open.source/magic-wormhole
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename send_data/get_data to just send/get

Browse Source
This commit is contained in:
Brian Warner 2016-05-12 15:52:22 -07:00
parent 49785008bb
commit 501af4b4ec
4 changed files with 52 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/wormhole/cli/cmd_receive.py
View File

@ -90,7 +90,7 @@ class TwistedReceiver:
raise RespondError("unknown offer type") raise RespondError("unknown offer type")
except RespondError as r: except RespondError as r:
data = json.dumps({"error": r.response}).encode("utf-8") data = json.dumps({"error": r.response}).encode("utf-8")
yield w.send_data(data) yield w.send(data)
raise TransferError(r.response) raise TransferError(r.response)
returnValue(None) returnValue(None)
@ -113,7 +113,7 @@ class TwistedReceiver:
@inlineCallbacks @inlineCallbacks
def get_data(self, w): def get_data(self, w):
# this may raise WrongPasswordError # this may raise WrongPasswordError
them_bytes = yield w.get_data() them_bytes = yield w.get()
them_d = json.loads(them_bytes.decode("utf-8")) them_d = json.loads(them_bytes.decode("utf-8"))
if "error" in them_d: if "error" in them_d:
raise TransferError(them_d["error"]) raise TransferError(them_d["error"])
@ -124,7 +124,7 @@ class TwistedReceiver:
# we're receiving a text message # we're receiving a text message
self.msg(them_d["message"]) self.msg(them_d["message"])
data = json.dumps({"message_ack": "ok"}).encode("utf-8") data = json.dumps({"message_ack": "ok"}).encode("utf-8")
yield w.send_data(data, wait=True) yield w.send(data, wait=True)
def handle_file(self, them_d): def handle_file(self, them_d):
file_data = them_d["file"] file_data = them_d["file"]
@ -199,7 +199,7 @@ class TwistedReceiver:
"relay_connection_hints": relay_hints, "relay_connection_hints": relay_hints,
}, },
}).encode("utf-8") }).encode("utf-8")
yield w.send_data(data) yield w.send(data)
# now receive the rest of the owl # now receive the rest of the owl
tdata = them_d["transit"] tdata = them_d["transit"]

6
src/wormhole/cli/cmd_send.py
View File

@ -94,17 +94,17 @@ def _send(reactor, w, args, phase1, fd_to_send, tor_manager):
if ok.lower() == "no": if ok.lower() == "no":
err = "sender rejected verification check, abandoned transfer" err = "sender rejected verification check, abandoned transfer"
reject_data = json.dumps({"error": err}).encode("utf-8") reject_data = json.dumps({"error": err}).encode("utf-8")
yield w.send_data(reject_data) yield w.send(reject_data)
raise TransferError(err) raise TransferError(err)
if fd_to_send is not None: if fd_to_send is not None:
transit_key = w.derive_key(APPID+"/transit-key") transit_key = w.derive_key(APPID+"/transit-key")
transit_sender.set_transit_key(transit_key) transit_sender.set_transit_key(transit_key)
my_phase1_bytes = json.dumps(phase1).encode("utf-8") my_phase1_bytes = json.dumps(phase1).encode("utf-8")
yield w.send_data(my_phase1_bytes) yield w.send(my_phase1_bytes)
# this may raise WrongPasswordError # this may raise WrongPasswordError
them_phase1_bytes = yield w.get_data() them_phase1_bytes = yield w.get()
them_phase1 = json.loads(them_phase1_bytes.decode("utf-8")) them_phase1 = json.loads(them_phase1_bytes.decode("utf-8"))

84
src/wormhole/test/test_twisted.py
View File

@ -18,8 +18,8 @@ class Basic(ServerBase, unittest.TestCase):
w2 = Wormhole(APPID, self.relayurl) w2 = Wormhole(APPID, self.relayurl)
code = yield w1.get_code() code = yield w1.get_code()
w2.set_code(code) w2.set_code(code)
yield self.doBoth(w1.send_data(b"data1"), w2.send_data(b"data2")) yield self.doBoth(w1.send(b"data1"), w2.send(b"data2"))
dl = yield self.doBoth(w1.get_data(), w2.get_data()) dl = yield self.doBoth(w1.get(), w2.get())
(dataX, dataY) = dl (dataX, dataY) = dl
self.assertEqual(dataX, b"data2") self.assertEqual(dataX, b"data2")
self.assertEqual(dataY, b"data1") self.assertEqual(dataY, b"data1")
@ -34,8 +34,8 @@ class Basic(ServerBase, unittest.TestCase):
w2 = Wormhole(APPID, self.relayurl) w2 = Wormhole(APPID, self.relayurl)
code = yield w1.get_code() code = yield w1.get_code()
w2.set_code(code) w2.set_code(code)
yield self.doBoth(w1.send_data(b"data"), w2.send_data(b"data")) yield self.doBoth(w1.send(b"data"), w2.send(b"data"))
dl = yield self.doBoth(w1.get_data(), w2.get_data()) dl = yield self.doBoth(w1.get(), w2.get())
(dataX, dataY) = dl (dataX, dataY) = dl
self.assertEqual(dataX, b"data") self.assertEqual(dataX, b"data")
self.assertEqual(dataY, b"data") self.assertEqual(dataY, b"data")
@ -47,10 +47,10 @@ class Basic(ServerBase, unittest.TestCase):
w2 = Wormhole(APPID, self.relayurl) w2 = Wormhole(APPID, self.relayurl)
code = yield w1.get_code() code = yield w1.get_code()
w2.set_code(code) w2.set_code(code)
res = yield self.doBoth(w1.send_data(b"data1"), w2.get_data()) res = yield self.doBoth(w1.send(b"data1"), w2.get())
(_, dataY) = res (_, dataY) = res
self.assertEqual(dataY, b"data1") self.assertEqual(dataY, b"data1")
dl = yield self.doBoth(w1.get_data(), w2.send_data(b"data2")) dl = yield self.doBoth(w1.get(), w2.send(b"data2"))
(dataX, _) = dl (dataX, _) = dl
self.assertEqual(dataX, b"data2") self.assertEqual(dataX, b"data2")
yield self.doBoth(w1.close(), w2.close()) yield self.doBoth(w1.close(), w2.close())
@ -61,8 +61,8 @@ class Basic(ServerBase, unittest.TestCase):
w2 = Wormhole(APPID, self.relayurl) w2 = Wormhole(APPID, self.relayurl)
w1.set_code(u"123-purple-elephant") w1.set_code(u"123-purple-elephant")
w2.set_code(u"123-purple-elephant") w2.set_code(u"123-purple-elephant")
yield self.doBoth(w1.send_data(b"data1"), w2.send_data(b"data2")) yield self.doBoth(w1.send(b"data1"), w2.send(b"data2"))
dl = yield self.doBoth(w1.get_data(), w2.get_data()) dl = yield self.doBoth(w1.get(), w2.get())
(dataX, dataY) = dl (dataX, dataY) = dl
self.assertEqual(dataX, b"data2") self.assertEqual(dataX, b"data2")
self.assertEqual(dataY, b"data1") self.assertEqual(dataY, b"data1")
@ -75,17 +75,13 @@ class Basic(ServerBase, unittest.TestCase):
w2 = Wormhole(APPID, self.relayurl) w2 = Wormhole(APPID, self.relayurl)
w1.set_code(u"123-purple-elephant") w1.set_code(u"123-purple-elephant")
w2.set_code(u"123-purple-elephant") w2.set_code(u"123-purple-elephant")
yield self.doBoth(w1.send_data(b"data1", u"p1"), yield self.doBoth(w1.send(b"data1", u"p1"), w2.send(b"data2", u"p1"))
w2.send_data(b"data2", u"p1")) yield self.doBoth(w1.send(b"data3", u"p2"), w2.send(b"data4", u"p2"))
yield self.doBoth(w1.send_data(b"data3", u"p2"), dl = yield self.doBoth(w1.get(u"p2"), w2.get(u"p1"))
w2.send_data(b"data4", u"p2"))
dl = yield self.doBoth(w1.get_data(u"p2"),
w2.get_data(u"p1"))
(dataX, dataY) = dl (dataX, dataY) = dl
self.assertEqual(dataX, b"data4") self.assertEqual(dataX, b"data4")
self.assertEqual(dataY, b"data1") self.assertEqual(dataY, b"data1")
dl = yield self.doBoth(w1.get_data(u"p1"), dl = yield self.doBoth(w1.get(u"p1"), w2.get(u"p2"))
w2.get_data(u"p2"))
(dataX, dataY) = dl (dataX, dataY) = dl
self.assertEqual(dataX, b"data2") self.assertEqual(dataX, b"data2")
self.assertEqual(dataY, b"data3") self.assertEqual(dataY, b"data3")
@ -100,21 +96,21 @@ class Basic(ServerBase, unittest.TestCase):
# w2 can't throw WrongPasswordError until it sees a CONFIRM message, # w2 can't throw WrongPasswordError until it sees a CONFIRM message,
# and w1 won't send CONFIRM until it sees a PAKE message, which w2 # and w1 won't send CONFIRM until it sees a PAKE message, which w2
# won't send until we call get_data. So we need both sides to be # won't send until we call get. So we need both sides to be
# running at the same time for this test. # running at the same time for this test.
d1 = w1.send_data(b"data1") d1 = w1.send(b"data1")
# at this point, w1 should be waiting for w2.PAKE # at this point, w1 should be waiting for w2.PAKE
yield self.assertFailure(w2.get_data(), WrongPasswordError) yield self.assertFailure(w2.get(), WrongPasswordError)
# * w2 will send w2.PAKE, wait for (and get) w1.PAKE, compute a key, # * w2 will send w2.PAKE, wait for (and get) w1.PAKE, compute a key,
# send w2.CONFIRM, then wait for w1.DATA. # send w2.CONFIRM, then wait for w1.DATA.
# * w1 will get w2.PAKE, compute a key, send w1.CONFIRM. # * w1 will get w2.PAKE, compute a key, send w1.CONFIRM.
# * w1 might also get w2.CONFIRM, and may notice the error before it # * w1 might also get w2.CONFIRM, and may notice the error before it
# sends w1.CONFIRM, in which case the wait=True will signal an # sends w1.CONFIRM, in which case the wait=True will signal an
# error inside _get_master_key() (inside send_data), and d1 will # error inside _get_master_key() (inside send), and d1 will
# errback. # errback.
# * but w1 might not see w2.CONFIRM yet, in which case it won't # * but w1 might not see w2.CONFIRM yet, in which case it won't
# errback until we do w1.get_data() # errback until we do w1.get()
# * w2 gets w1.CONFIRM, notices the error, records it. # * w2 gets w1.CONFIRM, notices the error, records it.
# * w2 (waiting for w1.DATA) wakes up, sees the error, throws # * w2 (waiting for w1.DATA) wakes up, sees the error, throws
# * meanwhile w1 finishes sending its data. w2.CONFIRM may or may not # * meanwhile w1 finishes sending its data. w2.CONFIRM may or may not
@ -124,20 +120,20 @@ class Basic(ServerBase, unittest.TestCase):
except WrongPasswordError: except WrongPasswordError:
pass pass
# When we ask w1 to get_data(), one of two things might happen: # When we ask w1 to get(), one of two things might happen:
# * if w2.CONFIRM arrived already, it will have recorded the error. # * if w2.CONFIRM arrived already, it will have recorded the error.
# When w1.get_data() sleeps (waiting for w2.DATA), we'll notice the # When w1.get() sleeps (waiting for w2.DATA), we'll notice the
# error before sleeping, and throw WrongPasswordError # error before sleeping, and throw WrongPasswordError
# * if w2.CONFIRM hasn't arrived yet, we'll sleep. When w2.CONFIRM # * if w2.CONFIRM hasn't arrived yet, we'll sleep. When w2.CONFIRM
# arrives, we notice and record the error, and wake up, and throw # arrives, we notice and record the error, and wake up, and throw
# Note that we didn't do w2.send_data(), so we're hoping that w1 will # Note that we didn't do w2.send(), so we're hoping that w1 will
# have enough information to detect the error before it sleeps # have enough information to detect the error before it sleeps
# (waiting for w2.DATA). Checking for the error both before sleeping # (waiting for w2.DATA). Checking for the error both before sleeping
# and after waking up makes this happen. # and after waking up makes this happen.
# so now w1 should have enough information to throw too # so now w1 should have enough information to throw too
yield self.assertFailure(w1.get_data(), WrongPasswordError) yield self.assertFailure(w1.get(), WrongPasswordError)
# both sides are closed automatically upon error, but it's still # both sides are closed automatically upon error, but it's still
# legal to call .close(), and should be idempotent # legal to call .close(), and should be idempotent
@ -153,9 +149,9 @@ class Basic(ServerBase, unittest.TestCase):
code = yield w1.get_code() code = yield w1.get_code()
w2.set_code(code) w2.set_code(code)
dl = yield self.doBoth(w1.send_data(b"data1"), w2.get_data()) dl = yield self.doBoth(w1.send(b"data1"), w2.get())
self.assertEqual(dl[1], b"data1") self.assertEqual(dl[1], b"data1")
dl = yield self.doBoth(w1.get_data(), w2.send_data(b"data2")) dl = yield self.doBoth(w1.get(), w2.send(b"data2"))
self.assertEqual(dl[0], b"data2") self.assertEqual(dl[0], b"data2")
yield self.doBoth(w1.close(), w2.close()) yield self.doBoth(w1.close(), w2.close())
@ -169,8 +165,8 @@ class Basic(ServerBase, unittest.TestCase):
v1, v2 = res v1, v2 = res
self.failUnlessEqual(type(v1), type(b"")) self.failUnlessEqual(type(v1), type(b""))
self.failUnlessEqual(v1, v2) self.failUnlessEqual(v1, v2)
yield self.doBoth(w1.send_data(b"data1"), w2.send_data(b"data2")) yield self.doBoth(w1.send(b"data1"), w2.send(b"data2"))
dl = yield self.doBoth(w1.get_data(), w2.get_data()) dl = yield self.doBoth(w1.get(), w2.get())
(dataX, dataY) = dl (dataX, dataY) = dl
self.assertEqual(dataX, b"data2") self.assertEqual(dataX, b"data2")
self.assertEqual(dataY, b"data1") self.assertEqual(dataY, b"data1")
@ -180,8 +176,8 @@ class Basic(ServerBase, unittest.TestCase):
def test_errors(self): def test_errors(self):
w1 = Wormhole(APPID, self.relayurl) w1 = Wormhole(APPID, self.relayurl)
yield self.assertFailure(w1.get_verifier(), UsageError) yield self.assertFailure(w1.get_verifier(), UsageError)
yield self.assertFailure(w1.send_data(b"data"), UsageError) yield self.assertFailure(w1.send(b"data"), UsageError)
yield self.assertFailure(w1.get_data(), UsageError) yield self.assertFailure(w1.get(), UsageError)
w1.set_code(u"123-purple-elephant") w1.set_code(u"123-purple-elephant")
yield self.assertRaises(UsageError, w1.set_code, u"123-nope") yield self.assertRaises(UsageError, w1.set_code, u"123-nope")
yield self.assertFailure(w1.get_code(), UsageError) yield self.assertFailure(w1.get_code(), UsageError)
@ -198,22 +194,20 @@ class Basic(ServerBase, unittest.TestCase):
w2.set_code(u"123-purple-elephant") w2.set_code(u"123-purple-elephant")
# we must let them establish a key before we can send data # we must let them establish a key before we can send data
yield self.doBoth(w1.get_verifier(), w2.get_verifier()) yield self.doBoth(w1.get_verifier(), w2.get_verifier())
yield w1.send_data(b"data1", phase=u"1") yield w1.send(b"data1", phase=u"1")
# underscore-prefixed phases are reserved # underscore-prefixed phases are reserved
yield self.assertFailure(w1.send_data(b"data1", phase=u"_1"), yield self.assertFailure(w1.send(b"data1", phase=u"_1"), UsageError)
UsageError) yield self.assertFailure(w1.get(phase=u"_1"), UsageError)
yield self.assertFailure(w1.get_data(phase=u"_1"), UsageError)
# you can't send twice to the same phase # you can't send twice to the same phase
yield self.assertFailure(w1.send_data(b"data1", phase=u"1"), yield self.assertFailure(w1.send(b"data1", phase=u"1"), UsageError)
UsageError)
# but you can send to a different one # but you can send to a different one
yield w1.send_data(b"data2", phase=u"2") yield w1.send(b"data2", phase=u"2")
res = yield w2.get_data(phase=u"1") res = yield w2.get(phase=u"1")
self.failUnlessEqual(res, b"data1") self.failUnlessEqual(res, b"data1")
# and you can't read twice from the same phase # and you can't read twice from the same phase
yield self.assertFailure(w2.get_data(phase=u"1"), UsageError) yield self.assertFailure(w2.get(phase=u"1"), UsageError)
# but you can read from a different one # but you can read from a different one
res = yield w2.get_data(phase=u"2") res = yield w2.get(phase=u"2")
self.failUnlessEqual(res, b"data2") self.failUnlessEqual(res, b"data2")
yield self.doBoth(w1.close(), w2.close()) yield self.doBoth(w1.close(), w2.close())
@ -232,12 +226,10 @@ class Basic(ServerBase, unittest.TestCase):
self.assertEqual(type(unpacked), dict) self.assertEqual(type(unpacked), dict)
self.new_w1 = Wormhole.from_serialized(s) self.new_w1 = Wormhole.from_serialized(s)
yield self.doBoth(self.new_w1.send_data(b"data1"), yield self.doBoth(self.new_w1.send(b"data1"), w2.send(b"data2"))
w2.send_data(b"data2")) dl = yield self.doBoth(self.new_w1.get(), w2.get())
dl = yield self.doBoth(self.new_w1.get_data(), w2.get_data())
(dataX, dataY) = dl (dataX, dataY) = dl
self.assertEqual((dataX, dataY), (b"data2", b"data1")) self.assertEqual((dataX, dataY), (b"data2", b"data1"))
self.assertRaises(UsageError, w2.serialize) # too late self.assertRaises(UsageError, w2.serialize) # too late
yield gatherResults([w1.close(), w2.close(), self.new_w1.close()], yield gatherResults([w1.close(), w2.close(), self.new_w1.close()], True)
True)

14
src/wormhole/twisted/transcribe.py
View File

@ -332,7 +332,7 @@ class Wormhole:
def serialize(self): def serialize(self):
# I can only be serialized after get_code/set_code and before # I can only be serialized after get_code/set_code and before
# get_verifier/get_data # get_verifier/get
if self._code is None: raise UsageError if self._code is None: raise UsageError
if self._key is not None: raise UsageError if self._key is not None: raise UsageError
if self._sent_phases: raise UsageError if self._sent_phases: raise UsageError
@ -448,7 +448,7 @@ class Wormhole:
def derive_key(self, purpose, length=SecretBox.KEY_SIZE): def derive_key(self, purpose, length=SecretBox.KEY_SIZE):
if not isinstance(purpose, type(u"")): raise TypeError(type(purpose)) if not isinstance(purpose, type(u"")): raise TypeError(type(purpose))
if self._key is None: if self._key is None:
# call after get_verifier() or get_data() # call after get_verifier() or get()
raise UsageError raise UsageError
return HKDF(self._key, length, CTXinfo=to_bytes(purpose)) return HKDF(self._key, length, CTXinfo=to_bytes(purpose))
@ -469,17 +469,17 @@ class Wormhole:
return data return data
@inlineCallbacks @inlineCallbacks
def send_data(self, outbound_data, phase=u"data", wait=False): def send(self, outbound_data, phase=u"data", wait=False):
if not isinstance(outbound_data, type(b"")): if not isinstance(outbound_data, type(b"")):
raise TypeError(type(outbound_data)) raise TypeError(type(outbound_data))
if not isinstance(phase, type(u"")): raise TypeError(type(phase)) if not isinstance(phase, type(u"")): raise TypeError(type(phase))
if self._closed: raise UsageError if self._closed: raise UsageError
if self._code is None: if self._code is None:
raise UsageError("You must set_code() before send_data()") raise UsageError("You must set_code() before send()")
if phase.startswith(u"_"): raise UsageError # reserved for internals if phase.startswith(u"_"): raise UsageError # reserved for internals
if phase in self._sent_phases: raise UsageError # only call this once if phase in self._sent_phases: raise UsageError # only call this once
self._sent_phases.add(phase) self._sent_phases.add(phase)
with self._timing.add("API send_data", phase=phase, wait=wait): with self._timing.add("API send", phase=phase, wait=wait):
# Without predefined roles, we can't derive predictably unique # Without predefined roles, we can't derive predictably unique
# keys for each side, so we use the same key for both. We use # keys for each side, so we use the same key for both. We use
# random nonces to keep the messages distinct, and we # random nonces to keep the messages distinct, and we
@ -490,14 +490,14 @@ class Wormhole:
yield self._msg_send(phase, outbound_encrypted, wait) yield self._msg_send(phase, outbound_encrypted, wait)
@inlineCallbacks @inlineCallbacks
def get_data(self, phase=u"data"): def get(self, phase=u"data"):
if not isinstance(phase, type(u"")): raise TypeError(type(phase)) if not isinstance(phase, type(u"")): raise TypeError(type(phase))
if self._closed: raise UsageError if self._closed: raise UsageError
if self._code is None: raise UsageError if self._code is None: raise UsageError
if phase.startswith(u"_"): raise UsageError # reserved for internals if phase.startswith(u"_"): raise UsageError # reserved for internals
if phase in self._got_phases: raise UsageError # only call this once if phase in self._got_phases: raise UsageError # only call this once
self._got_phases.add(phase) self._got_phases.add(phase)
with self._timing.add("API get_data", phase=phase): with self._timing.add("API get", phase=phase):
yield self._get_master_key() yield self._get_master_key()
body = yield self._msg_get(phase) # we can wait a long time here body = yield self._msg_get(phase) # we can wait a long time here
try: try: