Merge lp:~cmiller/desktopcouch/pair-with-oauth into lp:desktopcouch
- pair-with-oauth
- Merge into trunk
Proposed by
Chad Miller
| Status: | Merged |
|---|---|
| Approved by: | Chad Miller |
| Approved revision: | 63 |
| Merged at revision: | not available |
| Proposed branch: | lp:~cmiller/desktopcouch/pair-with-oauth |
| Merge into: | lp:desktopcouch |
| Diff against target: | None lines |
| To merge this branch: | bzr merge lp:~cmiller/desktopcouch/pair-with-oauth |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Stuart Langridge (community) | Approve | ||
| Vincenzo Di Somma (community) | Approve | ||
|
Review via email:
|
|||
Commit message
Assume the couchdb is secure. Big change, that.
Finally, remove pairings when asked to.
Transmit hostid and oauth information to paired devices.
Description of the change
To post a comment you must log in.
Revision history for this message
| Chad Miller (cmiller) wrote : | # |
> Starting up the pairing tool and then clicking "Listen for invitations" throws
> the following traceback;
>
> Traceback (most recent call last):
> File "bin/desktopcou
> listening = Listening(
> File "bin/desktopcou
> hostid, userid, listen_port = self.make_
> File "bin/desktopcou
> couchdb_
> TypeError: get_my_
yeah, this relies on other code ("replicate-to-u1") landing first.
Revision history for this message
| Vincenzo Di Somma (vds) wrote : | # |
What ln 228 of the diff means? In any case I'm not a gtk expert but the code looks good and all the tests pass.
review:
Approve
- 58. By Chad Miller
-
Merge from trunk.
- 59. By Chad Miller
-
Do not use the host id as the record id for couchdb, as there may be "deleted"
records with this id.Make URI parameter optional in get_my_
host_unique_ id() . - 60. By Chad Miller
-
Finish work on making pairing us oauth.
Rearrange the main widgets so they make more sense.
Revision history for this message
| Stuart Langridge (sil) wrote : | # |
Pulled and re-tested. Looks OK. Doesn't show existing paired local servers (should it? or is that in another branch?)
Revision history for this message
| Chad Miller (cmiller) wrote : | # |
> What ln 228 of the diff means? In any case I'm not a gtk expert but the code
> looks good and all the tests pass.
If you mean 'Narriative 'Alice'", it refers to a large comment near the top that describes the two roles that the single program plays.
- 61. By Chad Miller
-
Use the records API to get the server but do it left-handed, by getting a
database and then accessising the db object's private _server member.Fix failing tests: Import the file that mutates the environment so that a
separate couchdb server is used for testing. Update put_dynamic_paired_ host()
test to take its new hostname parameter. - 62. By Chad Miller
-
Add a column for hostname in listening section, so a populated already-
paired section doesn't look so weird.Add tests for unpairing.
Combine views of pairings.
Revision history for this message
| Stuart Langridge (sil) wrote : | # |
> Pulled and re-tested. Looks OK. Doesn't show existing paired local servers
> (should it? or is that in another branch?)
I am now ecstatically happy, yes I am.
review:
Approve
- 63. By Chad Miller
-
Save a create-time value in pairing records, so we have something
useful to give to the user. Put this time in the second column of
the already-paired list.
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === modified file 'bin/desktopcouch-pair' | |||
| 2 | --- bin/desktopcouch-pair 2009-09-04 14:44:20 +0000 | |||
| 3 | +++ bin/desktopcouch-pair 2009-09-11 03:23:30 +0000 | |||
| 4 | @@ -64,9 +64,11 @@ | |||
| 5 | 64 | import gobject | 64 | import gobject |
| 6 | 65 | import pango | 65 | import pango |
| 7 | 66 | 66 | ||
| 8 | 67 | from desktopcouch.pair.couchdb_pairing import couchdb_io | ||
| 9 | 67 | from desktopcouch.pair.couchdb_pairing import network_io | 68 | from desktopcouch.pair.couchdb_pairing import network_io |
| 10 | 68 | from desktopcouch.pair.couchdb_pairing import dbus_io | 69 | from desktopcouch.pair.couchdb_pairing import dbus_io |
| 11 | 69 | from desktopcouch.pair import pairing_record_type | 70 | from desktopcouch.pair import pairing_record_type |
| 12 | 71 | from desktopcouch import local_files | ||
| 13 | 70 | 72 | ||
| 14 | 71 | discovery_tool_version = "1" | 73 | discovery_tool_version = "1" |
| 15 | 72 | 74 | ||
| 16 | @@ -133,9 +135,9 @@ | |||
| 17 | 133 | """The window is destroyed.""" | 135 | """The window is destroyed.""" |
| 18 | 134 | self.inviter.close() | 136 | self.inviter.close() |
| 19 | 135 | 137 | ||
| 21 | 136 | def auth_completed(self, remote_host, remote_port, remote_info): | 138 | def auth_completed(self, remote_host, remote_id, remote_oauth): |
| 22 | 137 | """The auth stage is finished. Now pair with the remote host.""" | 139 | """The auth stage is finished. Now pair with the remote host.""" |
| 24 | 138 | pair_with_host(remote_host, remote_port, remote_info) | 140 | pair_with_host(remote_host, remote_id, remote_oauth) |
| 25 | 139 | self.window.destroy() | 141 | self.window.destroy() |
| 26 | 140 | 142 | ||
| 27 | 141 | def on_close(self): | 143 | def on_close(self): |
| 28 | @@ -162,7 +164,7 @@ | |||
| 29 | 162 | 164 | ||
| 30 | 163 | self.inviter = network_io.start_send_invitation(hostname, port, | 165 | self.inviter = network_io.start_send_invitation(hostname, port, |
| 31 | 164 | self.auth_completed, self.secret_message, self.public_seed, | 166 | self.auth_completed, self.secret_message, self.public_seed, |
| 33 | 165 | self.on_close) | 167 | self.on_close, local_hostid, local_oauth) |
| 34 | 166 | 168 | ||
| 35 | 167 | top_vbox = gtk.VBox() | 169 | top_vbox = gtk.VBox() |
| 36 | 168 | self.window.add(top_vbox) | 170 | self.window.add(top_vbox) |
| 37 | @@ -210,7 +212,8 @@ | |||
| 38 | 210 | # FIXME this is unimplemented and unused. | 212 | # FIXME this is unimplemented and unused. |
| 39 | 211 | self.destroy() | 213 | self.destroy() |
| 40 | 212 | 214 | ||
| 42 | 213 | def __init__(self, remote_host, is_secret_valid, send_valid_key): | 215 | def __init__(self, remote_host, is_secret_valid, send_valid_key, |
| 43 | 216 | remote_hostid, remote_oauth): | ||
| 44 | 214 | self.logging = logging.getLogger(self.__class__.__name__) | 217 | self.logging = logging.getLogger(self.__class__.__name__) |
| 45 | 215 | 218 | ||
| 46 | 216 | self.is_secret_valid = is_secret_valid | 219 | self.is_secret_valid = is_secret_valid |
| 47 | @@ -231,6 +234,8 @@ | |||
| 48 | 231 | self.window.add(top_vbox) | 234 | self.window.add(top_vbox) |
| 49 | 232 | 235 | ||
| 50 | 233 | self.remote_hostname = dbus_io.get_remote_hostname(remote_host) | 236 | self.remote_hostname = dbus_io.get_remote_hostname(remote_host) |
| 51 | 237 | self.remote_hostid = remote_hostid | ||
| 52 | 238 | self.remote_oauth = remote_oauth | ||
| 53 | 234 | 239 | ||
| 54 | 235 | description = gtk.Label( | 240 | description = gtk.Label( |
| 55 | 236 | _("To verify your pairing with %s, enter its secret.") % | 241 | _("To verify your pairing with %s, enter its secret.") % |
| 56 | @@ -279,7 +284,7 @@ | |||
| 57 | 279 | 284 | ||
| 58 | 280 | proposed_secret = unmap_easily_mistaken(self.entry_box.get_text()) | 285 | proposed_secret = unmap_easily_mistaken(self.entry_box.get_text()) |
| 59 | 281 | if self.is_secret_valid(proposed_secret): | 286 | if self.is_secret_valid(proposed_secret): |
| 61 | 282 | pair_with_host(self.remote_hostname, "(port)", "(info)") | 287 | pair_with_host(self.remote_hostname, remote_hostid, remote_oauth) |
| 62 | 283 | self.send_valid_key(proposed_secret) | 288 | self.send_valid_key(proposed_secret) |
| 63 | 284 | self.window.destroy() | 289 | self.window.destroy() |
| 64 | 285 | else: | 290 | else: |
| 65 | @@ -306,13 +311,13 @@ | |||
| 66 | 306 | self.listener.close() | 311 | self.listener.close() |
| 67 | 307 | 312 | ||
| 68 | 308 | def receive_invitation_challenge(self, remote_address, is_secret_valid, | 313 | def receive_invitation_challenge(self, remote_address, is_secret_valid, |
| 70 | 309 | send_secret): | 314 | send_secret, remote_hostid, remote_oauth): |
| 71 | 310 | """When we receive an invitation, check its validity and if | 315 | """When we receive an invitation, check its validity and if |
| 72 | 311 | it's what we expected, then continue and accept it.""" | 316 | it's what we expected, then continue and accept it.""" |
| 73 | 312 | 317 | ||
| 74 | 313 | self.logging.warn("received invitation from %s", remote_address) | 318 | self.logging.warn("received invitation from %s", remote_address) |
| 75 | 314 | self.acceptor = AcceptInvitation(remote_address, is_secret_valid, | 319 | self.acceptor = AcceptInvitation(remote_address, is_secret_valid, |
| 77 | 315 | send_secret) | 320 | send_secret, remote_hostid, remote_oauth) |
| 78 | 316 | self.acceptor.window.connect("destroy", | 321 | self.acceptor.window.connect("destroy", |
| 79 | 317 | lambda *args: setattr(self, "acceptor", None) and False) | 322 | lambda *args: setattr(self, "acceptor", None) and False) |
| 80 | 318 | 323 | ||
| 81 | @@ -326,7 +331,9 @@ | |||
| 82 | 326 | 331 | ||
| 83 | 327 | self.listener = network_io.ListenForInvitations( | 332 | self.listener = network_io.ListenForInvitations( |
| 84 | 328 | self.receive_invitation_challenge, | 333 | self.receive_invitation_challenge, |
| 86 | 329 | lambda: self.window.destroy()) | 334 | lambda: self.window.destroy(), |
| 87 | 335 | couchdb_io.get_my_host_unique_id(create=True), | ||
| 88 | 336 | local_files.get_oauth_tokens()) | ||
| 89 | 330 | 337 | ||
| 90 | 331 | listen_port = self.listener.get_local_port() | 338 | listen_port = self.listener.get_local_port() |
| 91 | 332 | 339 | ||
| 92 | @@ -522,19 +529,6 @@ | |||
| 93 | 522 | pair_with_cloud_service(service, hostname, port) | 529 | pair_with_cloud_service(service, hostname, port) |
| 94 | 523 | return | 530 | return |
| 95 | 524 | 531 | ||
| 96 | 525 | |||
| 97 | 526 | self.logging.error("Local pairing is not yet supported. Aborting.") | ||
| 98 | 527 | fail_note = gtk.MessageDialog( | ||
| 99 | 528 | parent=self.window, | ||
| 100 | 529 | flags=gtk.DIALOG_DESTROY_WITH_PARENT, | ||
| 101 | 530 | buttons=gtk.BUTTONS_OK, | ||
| 102 | 531 | type=gtk.MESSAGE_ERROR, | ||
| 103 | 532 | message_format =_("Sorry, couchdb authentication is not yet enabled, so local pairing is not supported")) | ||
| 104 | 533 | fail_note.run() | ||
| 105 | 534 | fail_note.destroy() | ||
| 106 | 535 | return False | ||
| 107 | 536 | |||
| 108 | 537 | |||
| 109 | 538 | self.logging.info("connecting to %s:%s tcp to invite", | 532 | self.logging.info("connecting to %s:%s tcp to invite", |
| 110 | 539 | hostname, port) | 533 | hostname, port) |
| 111 | 540 | if self.inviting != None: | 534 | if self.inviting != None: |
| 112 | @@ -608,19 +602,6 @@ | |||
| 113 | 608 | # assume local for this user. FIXME | 602 | # assume local for this user. FIXME |
| 114 | 609 | pass | 603 | pass |
| 115 | 610 | 604 | ||
| 116 | 611 | |||
| 117 | 612 | self.logging.error("Local pairing is not yet supported. Aborting.") | ||
| 118 | 613 | fail_note = gtk.MessageDialog( | ||
| 119 | 614 | parent=self.window, | ||
| 120 | 615 | flags=gtk.DIALOG_DESTROY_WITH_PARENT, | ||
| 121 | 616 | buttons=gtk.BUTTONS_OK, | ||
| 122 | 617 | type=gtk.MESSAGE_ERROR, | ||
| 123 | 618 | message_format =_("Sorry, couchdb authentication is not yet enabled, so local pairing is not supported")) | ||
| 124 | 619 | fail_note.run() | ||
| 125 | 620 | fail_note.destroy() | ||
| 126 | 621 | return False | ||
| 127 | 622 | |||
| 128 | 623 | |||
| 129 | 624 | btn.set_sensitive(False) | 605 | btn.set_sensitive(False) |
| 130 | 625 | listening = Listening(couchdb_instance) | 606 | listening = Listening(couchdb_instance) |
| 131 | 626 | listening.window.connect("destroy", | 607 | listening.window.connect("destroy", |
| 132 | @@ -682,14 +663,12 @@ | |||
| 133 | 682 | self.window.show() | 663 | self.window.show() |
| 134 | 683 | 664 | ||
| 135 | 684 | 665 | ||
| 137 | 685 | def pair_with_host(host, port, info): | 666 | def pair_with_host(hostname, hostid, oauth_data): |
| 138 | 686 | """We've verified all is correct and authorized, so now we pair | 667 | """We've verified all is correct and authorized, so now we pair |
| 139 | 687 | the databases.""" | 668 | the databases.""" |
| 141 | 688 | logging.info("verified host %s/%s/%s. Done!", host, port, info) | 669 | logging.info("verified host %s/%s/%s. Done!", host, hostid, oauth) |
| 142 | 689 | 670 | ||
| 146 | 690 | # Some kind of two-phase commit would be nice here, before we say | 671 | couchdb.put_dynamic_paired_host(hostname, hostid, oauth_data) |
| 144 | 691 | # successful. | ||
| 145 | 692 | #couchdb_io.replicate_to(...) | ||
| 147 | 693 | 672 | ||
| 148 | 694 | success_note = gtk.Dialog(title=_("Paired with %(host)s") % locals(), | 673 | success_note = gtk.Dialog(title=_("Paired with %(host)s") % locals(), |
| 149 | 695 | parent=pick_or_listen.window, | 674 | parent=pick_or_listen.window, |
| 150 | 696 | 675 | ||
| 151 | === modified file 'desktopcouch/pair/couchdb_pairing/dbus_io.py' | |||
| 152 | --- desktopcouch/pair/couchdb_pairing/dbus_io.py 2009-08-26 19:04:39 +0000 | |||
| 153 | +++ desktopcouch/pair/couchdb_pairing/dbus_io.py 2009-09-11 03:23:30 +0000 | |||
| 154 | @@ -210,7 +210,7 @@ | |||
| 155 | 210 | 210 | ||
| 156 | 211 | 211 | ||
| 157 | 212 | def discover_services(add_commport_name_cb, del_commport_name_cb, | 212 | def discover_services(add_commport_name_cb, del_commport_name_cb, |
| 159 | 213 | show_local=False): | 213 | show_local=True): |
| 160 | 214 | """Start looking for services. Use two callbacks to handle seeing | 214 | """Start looking for services. Use two callbacks to handle seeing |
| 161 | 215 | new services and seeing services disappear.""" | 215 | new services and seeing services disappear.""" |
| 162 | 216 | 216 | ||
| 163 | 217 | 217 | ||
| 164 | === modified file 'desktopcouch/pair/couchdb_pairing/network_io.py' | |||
| 165 | --- desktopcouch/pair/couchdb_pairing/network_io.py 2009-07-28 03:43:02 +0000 | |||
| 166 | +++ desktopcouch/pair/couchdb_pairing/network_io.py 2009-09-11 03:23:30 +0000 | |||
| 167 | @@ -35,18 +35,74 @@ | |||
| 168 | 35 | hash = hashlib.sha512 | 35 | hash = hashlib.sha512 |
| 169 | 36 | 36 | ||
| 170 | 37 | 37 | ||
| 171 | 38 | def dict_to_bytes(d): | ||
| 172 | 39 | """Convert a dictionary of string key/values into a string.""" | ||
| 173 | 40 | parts = list() | ||
| 174 | 41 | |||
| 175 | 42 | for k, v in d.iteritems(): | ||
| 176 | 43 | l = len(k) | ||
| 177 | 44 | parts.append(chr(l>>8)) | ||
| 178 | 45 | parts.append(chr(l&255)) | ||
| 179 | 46 | parts.append(k) | ||
| 180 | 47 | |||
| 181 | 48 | l = len(v) | ||
| 182 | 49 | parts.append(chr(l>>8)) | ||
| 183 | 50 | parts.append(chr(l&255)) | ||
| 184 | 51 | parts.append(v) | ||
| 185 | 52 | |||
| 186 | 53 | |||
| 187 | 54 | blob = "".join(parts) | ||
| 188 | 55 | l = len(blob) | ||
| 189 | 56 | blob_size = list() | ||
| 190 | 57 | blob_size.append(chr(l>>24)) | ||
| 191 | 58 | blob_size.append(chr(l>>16&255)) | ||
| 192 | 59 | blob_size.append(chr(l>>8&255)) | ||
| 193 | 60 | blob_size.append(chr(l&255)) | ||
| 194 | 61 | |||
| 195 | 62 | return "CMbydi0" + "".join(blob_size) + blob | ||
| 196 | 63 | |||
| 197 | 64 | |||
| 198 | 65 | def bytes_to_dict(b): | ||
| 199 | 66 | """Convert a string from C{dict_to_bytes} back into a dictionary.""" | ||
| 200 | 67 | if b[:7] != "CMbydi0": | ||
| 201 | 68 | raise ValueError("magic bytes missing. Invalid string. %r", b[:10]) | ||
| 202 | 69 | b = b[7:] | ||
| 203 | 70 | |||
| 204 | 71 | blob_size = 0 | ||
| 205 | 72 | for c in b[:4]: | ||
| 206 | 73 | blob_size = (blob_size << 8) + ord(c) | ||
| 207 | 74 | |||
| 208 | 75 | blob = b[4:] | ||
| 209 | 76 | if blob_size != len(blob): | ||
| 210 | 77 | raise ValueError("bytes are corrupt; expected %d, got %d" % (blob_size, | ||
| 211 | 78 | len(blob))) | ||
| 212 | 79 | |||
| 213 | 80 | d = {} | ||
| 214 | 81 | blob_cursor = 0 | ||
| 215 | 82 | |||
| 216 | 83 | while blob_cursor < blob_size: | ||
| 217 | 84 | k_len = (ord(blob[blob_cursor+0])<<8) + ord(blob[blob_cursor+1]) | ||
| 218 | 85 | k = blob[blob_cursor+2:blob_cursor+2+k_len] | ||
| 219 | 86 | blob_cursor += k_len + 2 | ||
| 220 | 87 | v_len = (ord(blob[blob_cursor+0])<<8) + ord(blob[blob_cursor+1]) | ||
| 221 | 88 | v = blob[blob_cursor+2:blob_cursor+2+v_len] | ||
| 222 | 89 | blob_cursor += v_len + 2 | ||
| 223 | 90 | d[k] = v | ||
| 224 | 91 | return d | ||
| 225 | 92 | |||
| 226 | 93 | |||
| 227 | 38 | class ListenForInvitations(): | 94 | class ListenForInvitations(): |
| 228 | 39 | """Narrative "Alice". | 95 | """Narrative "Alice". |
| 229 | 40 | 96 | ||
| 230 | 41 | This is the first half of a TCP listening socket. We spawn off | 97 | This is the first half of a TCP listening socket. We spawn off |
| 231 | 42 | processors when we accept invitation-connections.""" | 98 | processors when we accept invitation-connections.""" |
| 232 | 43 | 99 | ||
| 234 | 44 | def __init__(self, get_secret_from_user, on_close): | 100 | def __init__(self, get_secret_from_user, on_close, hostid, oauth_data): |
| 235 | 45 | """Initialize.""" | 101 | """Initialize.""" |
| 236 | 46 | self.logging = logging.getLogger(self.__class__.__name__) | 102 | self.logging = logging.getLogger(self.__class__.__name__) |
| 237 | 47 | 103 | ||
| 238 | 48 | self.factory = ProcessAnInvitationFactory(get_secret_from_user, | 104 | self.factory = ProcessAnInvitationFactory(get_secret_from_user, |
| 240 | 49 | on_close) | 105 | on_close, hostid, oauth_data) |
| 241 | 50 | self.listening_port = reactor.listenTCP(0, self.factory) | 106 | self.listening_port = reactor.listenTCP(0, self.factory) |
| 242 | 51 | 107 | ||
| 243 | 52 | def get_local_port(self): | 108 | def get_local_port(self): |
| 244 | @@ -84,15 +140,19 @@ | |||
| 245 | 84 | self.logging.debug("connection lost") | 140 | self.logging.debug("connection lost") |
| 246 | 85 | basic.LineReceiver.connectionLost(self, reason) | 141 | basic.LineReceiver.connectionLost(self, reason) |
| 247 | 86 | 142 | ||
| 249 | 87 | def lineReceived(self, message): | 143 | def lineReceived(self, rich_message): |
| 250 | 88 | """Handler for receipt of a message from the Bob end.""" | 144 | """Handler for receipt of a message from the Bob end.""" |
| 255 | 89 | h = hash() | 145 | d = bytes_to_dict(rich_message) |
| 256 | 90 | digest_nybble_count = h.digest_size * 2 | 146 | |
| 257 | 91 | self.expected_hash = message[0:digest_nybble_count] | 147 | self.expected_hash = d.pop("secret_message") |
| 258 | 92 | self.public_seed = message[digest_nybble_count:] | 148 | self.public_seed = d.pop("public_seed") |
| 259 | 149 | remote_hostid = d.pop("hostid") | ||
| 260 | 150 | remote_oauth = d | ||
| 261 | 151 | |||
| 262 | 93 | self.factory.get_secret_from_user(self.transport.getPeer().host, | 152 | self.factory.get_secret_from_user(self.transport.getPeer().host, |
| 263 | 94 | self.check_secret_from_user, | 153 | self.check_secret_from_user, |
| 265 | 95 | self.send_secret_to_remote) | 154 | self.send_secret_to_remote, |
| 266 | 155 | remote_hostid, remote_oauth) | ||
| 267 | 96 | 156 | ||
| 268 | 97 | def send_secret_to_remote(self, secret_message): | 157 | def send_secret_to_remote(self, secret_message): |
| 269 | 98 | """A callback for the invitation protocol to start a new phase | 158 | """A callback for the invitation protocol to start a new phase |
| 270 | @@ -101,12 +161,17 @@ | |||
| 271 | 101 | h = hash() | 161 | h = hash() |
| 272 | 102 | h.update(self.public_seed) | 162 | h.update(self.public_seed) |
| 273 | 103 | h.update(secret_message) | 163 | h.update(secret_message) |
| 275 | 104 | self.sendLine(h.hexdigest()) | 164 | all_dict = dict() |
| 276 | 165 | all_dict.update(self.factory.oauth_info) | ||
| 277 | 166 | all_dict["hostid"] = self.factory.hostid | ||
| 278 | 167 | all_dict["secret_message"] = h.hexdigest() | ||
| 279 | 168 | self.sendLine(dict_to_bytes(all_dict)) | ||
| 280 | 105 | 169 | ||
| 281 | 106 | def check_secret_from_user(self, secret_message): | 170 | def check_secret_from_user(self, secret_message): |
| 282 | 107 | """A callback for the invitation protocol to verify the secret | 171 | """A callback for the invitation protocol to verify the secret |
| 283 | 108 | that the user gives, against the hash we received over the | 172 | that the user gives, against the hash we received over the |
| 284 | 109 | network.""" | 173 | network.""" |
| 285 | 174 | |||
| 286 | 110 | h = hash() | 175 | h = hash() |
| 287 | 111 | h.update(secret_message) | 176 | h.update(secret_message) |
| 288 | 112 | digest = h.hexdigest() | 177 | digest = h.hexdigest() |
| 289 | @@ -115,7 +180,11 @@ | |||
| 290 | 115 | h = hash() | 180 | h = hash() |
| 291 | 116 | h.update(self.public_seed) | 181 | h.update(self.public_seed) |
| 292 | 117 | h.update(secret_message) | 182 | h.update(secret_message) |
| 294 | 118 | self.sendLine(h.hexdigest()) | 183 | all_dict = dict() |
| 295 | 184 | all_dict.update(self.factory.oauth_info) | ||
| 296 | 185 | all_dict["hostid"] = self.factory.hostid | ||
| 297 | 186 | all_dict["secret_message"] = h.hexdigest() | ||
| 298 | 187 | self.sendLine(dict_to_bytes(all_dict)) | ||
| 299 | 119 | 188 | ||
| 300 | 120 | self.logging.debug("User knew secret!") | 189 | self.logging.debug("User knew secret!") |
| 301 | 121 | 190 | ||
| 302 | @@ -132,10 +201,12 @@ | |||
| 303 | 132 | 201 | ||
| 304 | 133 | protocol = ProcessAnInvitationProtocol | 202 | protocol = ProcessAnInvitationProtocol |
| 305 | 134 | 203 | ||
| 307 | 135 | def __init__(self, get_secret_from_user, on_close): | 204 | def __init__(self, get_secret_from_user, on_close, hostid, oauth_info): |
| 308 | 136 | self.logging = logging.getLogger(self.__class__.__name__) | 205 | self.logging = logging.getLogger(self.__class__.__name__) |
| 309 | 137 | self.get_secret_from_user = get_secret_from_user | 206 | self.get_secret_from_user = get_secret_from_user |
| 310 | 138 | self.on_close = on_close | 207 | self.on_close = on_close |
| 311 | 208 | self.hostid = hostid | ||
| 312 | 209 | self.oauth_info = oauth_info | ||
| 313 | 139 | 210 | ||
| 314 | 140 | 211 | ||
| 315 | 141 | class SendInvitationProtocol(basic.LineReceiver): | 212 | class SendInvitationProtocol(basic.LineReceiver): |
| 316 | @@ -153,7 +224,11 @@ | |||
| 317 | 153 | 224 | ||
| 318 | 154 | h = hash() | 225 | h = hash() |
| 319 | 155 | h.update(self.factory.secret_message) | 226 | h.update(self.factory.secret_message) |
| 321 | 156 | self.sendLine(h.hexdigest() + self.factory.public_seed) | 227 | d = dict(secret_message=h.hexdigest(), |
| 322 | 228 | public_seed=self.factory.public_seed, | ||
| 323 | 229 | hostid=self.factory.local_hostid) | ||
| 324 | 230 | d.update(self.factory.local_oauth_info) | ||
| 325 | 231 | self.sendLine(dict_to_bytes(d)) | ||
| 326 | 157 | 232 | ||
| 327 | 158 | h = hash() | 233 | h = hash() |
| 328 | 159 | h.update(self.factory.public_seed) | 234 | h.update(self.factory.public_seed) |
| 329 | @@ -161,15 +236,19 @@ | |||
| 330 | 161 | self.expected_hash_of_secret = h.hexdigest() | 236 | self.expected_hash_of_secret = h.hexdigest() |
| 331 | 162 | 237 | ||
| 332 | 163 | 238 | ||
| 334 | 164 | def lineReceived(self, message): | 239 | def lineReceived(self, rich_message): |
| 335 | 165 | """Handler for receipt of a message from the Alice end.""" | 240 | """Handler for receipt of a message from the Alice end.""" |
| 336 | 241 | d = bytes_to_dict(rich_message) | ||
| 337 | 242 | message = d.pop("secret_message") | ||
| 338 | 243 | |||
| 339 | 166 | if message == self.expected_hash_of_secret: | 244 | if message == self.expected_hash_of_secret: |
| 340 | 167 | remote_host = self.transport.getPeer().host | 245 | remote_host = self.transport.getPeer().host |
| 341 | 168 | try: | 246 | try: |
| 342 | 169 | remote_hostname = get_remote_hostname(remote_host) | 247 | remote_hostname = get_remote_hostname(remote_host) |
| 343 | 170 | except dbus.exceptions.DBusException: | 248 | except dbus.exceptions.DBusException: |
| 344 | 171 | remote_hostname = None | 249 | remote_hostname = None |
| 346 | 172 | self.factory.auth_complete_cb(remote_hostname, "(port)", "(info)") | 250 | remote_hostid = d.pop("hostid") |
| 347 | 251 | self.factory.auth_complete_cb(remote_hostname, remote_hostid, d) | ||
| 348 | 173 | self.transport.loseConnection() | 252 | self.transport.loseConnection() |
| 349 | 174 | else: | 253 | else: |
| 350 | 175 | self.logging.warn("Expected %r from invitation.", | 254 | self.logging.warn("Expected %r from invitation.", |
| 351 | @@ -188,12 +267,14 @@ | |||
| 352 | 188 | protocol = SendInvitationProtocol | 267 | protocol = SendInvitationProtocol |
| 353 | 189 | 268 | ||
| 354 | 190 | def __init__(self, auth_complete_cb, secret_message, public_seed, | 269 | def __init__(self, auth_complete_cb, secret_message, public_seed, |
| 356 | 191 | on_close): | 270 | on_close, local_hostid, local_oauth_info): |
| 357 | 192 | self.logging = logging.getLogger(self.__class__.__name__) | 271 | self.logging = logging.getLogger(self.__class__.__name__) |
| 358 | 193 | self.auth_complete_cb = auth_complete_cb | 272 | self.auth_complete_cb = auth_complete_cb |
| 359 | 194 | self.secret_message = secret_message | 273 | self.secret_message = secret_message |
| 360 | 195 | self.public_seed = public_seed | 274 | self.public_seed = public_seed |
| 361 | 196 | self.on_close = on_close | 275 | self.on_close = on_close |
| 362 | 276 | self.local_hostid = local_hostid | ||
| 363 | 277 | self.local_oauth_info = local_oauth_info | ||
| 364 | 197 | self.logging.debug("initialized") | 278 | self.logging.debug("initialized") |
| 365 | 198 | 279 | ||
| 366 | 199 | def close(self): | 280 | def close(self): |
| 367 | @@ -214,12 +295,12 @@ | |||
| 368 | 214 | 295 | ||
| 369 | 215 | 296 | ||
| 370 | 216 | def start_send_invitation(host, port, auth_complete_cb, secret_message, | 297 | def start_send_invitation(host, port, auth_complete_cb, secret_message, |
| 372 | 217 | public_seed, on_close): | 298 | public_seed, on_close, local_hostid, local_oauth): |
| 373 | 218 | """Instantiate the factory to hold configuration data about sending an | 299 | """Instantiate the factory to hold configuration data about sending an |
| 374 | 219 | invitation and let the reactor add it to its event-handling loop by way of | 300 | invitation and let the reactor add it to its event-handling loop by way of |
| 375 | 220 | starting a TCP connection.""" | 301 | starting a TCP connection.""" |
| 376 | 221 | factory = SendInvitationFactory(auth_complete_cb, secret_message, | 302 | factory = SendInvitationFactory(auth_complete_cb, secret_message, |
| 378 | 222 | public_seed, on_close) | 303 | public_seed, on_close, local_hostid, local_oauth) |
| 379 | 223 | reactor.connectTCP(host, port, factory) | 304 | reactor.connectTCP(host, port, factory) |
| 380 | 224 | 305 | ||
| 381 | 225 | return factory | 306 | return factory |
| 382 | 226 | 307 | ||
| 383 | === modified file 'desktopcouch/pair/tests/test_network_io.py' | |||
| 384 | --- desktopcouch/pair/tests/test_network_io.py 2009-08-22 13:18:00 +0000 | |||
| 385 | +++ desktopcouch/pair/tests/test_network_io.py 2009-09-11 03:23:30 +0000 | |||
| 386 | @@ -26,10 +26,19 @@ | |||
| 387 | 26 | start_send_invitation, ListenForInvitations) | 26 | start_send_invitation, ListenForInvitations) |
| 388 | 27 | from desktopcouch.pair.couchdb_pairing.dbus_io import get_local_hostname | 27 | from desktopcouch.pair.couchdb_pairing.dbus_io import get_local_hostname |
| 389 | 28 | 28 | ||
| 390 | 29 | import os | ||
| 391 | 29 | import unittest | 30 | import unittest |
| 392 | 30 | 31 | ||
| 393 | 31 | local_hostname = ".".join(get_local_hostname()) | 32 | local_hostname = ".".join(get_local_hostname()) |
| 394 | 32 | 33 | ||
| 395 | 34 | a_hostid = "hostid a" | ||
| 396 | 35 | a_oauth_data = dict(token="atoken", token_secret="atokensecret", | ||
| 397 | 36 | consumer="aconsumer", consumer_secret="aconsumersecret") | ||
| 398 | 37 | |||
| 399 | 38 | b_hostid = "hostid b" | ||
| 400 | 39 | b_oauth_data = dict(token="btoken", token_secret="btokensecret", | ||
| 401 | 40 | consumer="bconsumer", consumer_secret="bconsumersecret") | ||
| 402 | 41 | |||
| 403 | 33 | 42 | ||
| 404 | 34 | class TestNetworkIO(unittest.TestCase): | 43 | class TestNetworkIO(unittest.TestCase): |
| 405 | 35 | 44 | ||
| 406 | @@ -43,8 +52,13 @@ | |||
| 407 | 43 | 52 | ||
| 408 | 44 | secret = "sekrit" | 53 | secret = "sekrit" |
| 409 | 45 | 54 | ||
| 411 | 46 | def listener_get_secret_from_user(sender, f, send_secret): | 55 | def listener_get_secret_from_user(sender, f, send_secret, hostid, |
| 412 | 56 | oauth_info): | ||
| 413 | 47 | """Get secret from user. Try several first.""" | 57 | """Get secret from user. Try several first.""" |
| 414 | 58 | |||
| 415 | 59 | self.assertEquals("hostid b", hostid) | ||
| 416 | 60 | self.assertTrue("token" in oauth_info) | ||
| 417 | 61 | |||
| 418 | 48 | self.assertFalse(f("sek")) | 62 | self.assertFalse(f("sek")) |
| 419 | 49 | self.assertFalse(f("")) | 63 | self.assertFalse(f("")) |
| 420 | 50 | self.assertFalse(f(" fs")) | 64 | self.assertFalse(f(" fs")) |
| 421 | @@ -60,15 +74,16 @@ | |||
| 422 | 60 | def inviter_close_socket(): | 74 | def inviter_close_socket(): |
| 423 | 61 | self._inviter_socket_state = "closed" | 75 | self._inviter_socket_state = "closed" |
| 424 | 62 | 76 | ||
| 426 | 63 | def inviter_complete_auth(a, b, c): | 77 | def inviter_complete_auth(hostname, hostid, oauth_info): |
| 427 | 78 | self.assertEquals("hostid a", hostid) | ||
| 428 | 79 | self.assertTrue("token" in oauth_info) | ||
| 429 | 64 | self._inviter_auth_completed = True | 80 | self._inviter_auth_completed = True |
| 430 | 65 | 81 | ||
| 431 | 66 | def listener_complete_auth(): | 82 | def listener_complete_auth(): |
| 432 | 67 | self._listener_auth_completed = True | 83 | self._listener_auth_completed = True |
| 433 | 68 | 84 | ||
| 434 | 69 | |||
| 435 | 70 | self.listener = ListenForInvitations(listener_get_secret_from_user, | 85 | self.listener = ListenForInvitations(listener_get_secret_from_user, |
| 437 | 71 | listener_close_socket) | 86 | listener_close_socket, a_hostid, a_oauth_data) |
| 438 | 72 | listener_port = self.listener.get_local_port() | 87 | listener_port = self.listener.get_local_port() |
| 439 | 73 | 88 | ||
| 440 | 74 | def inviter_display_message(*args): | 89 | def inviter_display_message(*args): |
| 441 | @@ -76,7 +91,8 @@ | |||
| 442 | 76 | logging.info("display message from inviter: %s", args) | 91 | logging.info("display message from inviter: %s", args) |
| 443 | 77 | 92 | ||
| 444 | 78 | self.inviter = start_send_invitation(local_hostname, listener_port, | 93 | self.inviter = start_send_invitation(local_hostname, listener_port, |
| 446 | 79 | inviter_complete_auth, secret, "seed", inviter_close_socket) | 94 | inviter_complete_auth, secret, "seed", inviter_close_socket, |
| 447 | 95 | b_hostid, b_oauth_data) | ||
| 448 | 80 | 96 | ||
| 449 | 81 | def exit_on_success(): | 97 | def exit_on_success(): |
| 450 | 82 | if self._listener_auth_completed and self._inviter_auth_completed: | 98 | if self._listener_auth_completed and self._inviter_auth_completed: |
Starting up the pairing tool and then clicking "Listen for invitations" throws the following traceback;
Traceback (most recent call last):
File "bin/desktopcou
listening = Listening(
File "bin/desktopcou
hostid, userid, listen_port = self.make_
File "bin/desktopcou
couchdb_
TypeError: get_my_