August 2018 - tor-commits - lists.torproject.org

[stem/master] Update stem.client.cell docstrings for style, consistency, and clarity
by atagar＠torproject.org 26 Aug '18

26 Aug '18

commit 1163efbefe66b10315197d375e3bdf392e8b18fb Author: Dave Rolek <dmr-x(a)riseup.net> Date: Fri Aug 17 20:51:00 2018 +0000 Update stem.client.cell docstrings for style, consistency, and clarity Much of the updates here is to reduce the line length. --- stem/client/cell.py | 42 +++++++++++++++++++++++++----------------- 1 file changed, 25 insertions(+), 17 deletions(-) diff --git a/stem/client/cell.py b/stem/client/cell.py index fec8bb1b..d1265c10 100644 --- a/stem/client/cell.py +++ b/stem/client/cell.py @@ -369,7 +369,8 @@ class RelayCell(CircuitCell): :var stem.client.datatype.RelayCommand command: command to be issued :var int command_int: integer value of our command :var bytes data: payload of the cell - :var int recognized: zero if cell is decrypted, otherwise mostly non-zero (can rarely be zero) + :var int recognized: zero if cell is decrypted, otherwise mostly non-zero + (can rarely be zero) :var int digest: running digest held with the relay :var int stream_id: specific stream this concerns """ @@ -458,22 +459,26 @@ class RelayCell(CircuitCell): def apply_digest(self, digest, prep_cell = True): """ - Calculates, updates, and applies the digest to the cell payload, returning a new (cell, digest) tuple. + Calculates, updates, and applies the digest to the cell payload, + returning a new (cell, digest) tuple. :param HASH digest: running digest held with the relay - :param bool prep_cell: preps the cell payload according to the spec, if **True** (default) + :param bool prep_cell: preps the cell payload according to the spec, if + **True** (default) if **False**, the digest will be calculated as-is, namely: - the 'recognized' field will not be set to 0, - the digest field will not be set to 0, - and any 'unused' padding will be taken as-is. - Use with caution. - - :returns: (:class:`~stem.client.cell.RelayCell`, HASH) tuple updated as follows: - digest: updated via digest.update(payload) - RelayCell: a copy of self, with the following updates: - RelayCell.recognized: set to 0, if prep_cell is **True** - RelayCell.digest: updated with the calculated digest - RelayCell.unused: treated as padding and overwritten, if prep_cell is **True** + * the 'recognized' field will not be set to 0, + * the digest field will not be set to 0, + * and any 'unused' padding will be taken as-is. + Use **False** with caution. + + :returns: (:class:`~stem.client.cell.RelayCell`, HASH) tuple of object + copies updated as follows: + * digest: updated via digest.update(payload) + * RelayCell: a copy of self, with the following updates: + * RelayCell.recognized: set to 0, if prep_cell is **True** + * RelayCell.digest: updated with the calculated digest + * RelayCell.unused: treated as padding and overwritten, if prep_cell + is **True** """ if prep_cell: @@ -496,9 +501,11 @@ class RelayCell(CircuitCell): def pack_payload(self, **kwargs): """ - Convenience method for running _pack_payload on self. + Convenience method for running + :func:`~stem.client.cell.RelayCell._pack_payload` on self. - :param bool pad_remaining: (optional, defaults to **True**) pads up to payload size if **True** + :param bool pad_remaining: (optional, defaults to **True**) pads up to + payload size if **True** :returns: **bytes** with the packed payload """ @@ -511,7 +518,8 @@ class RelayCell(CircuitCell): Directly pack the payload without any validation beyond Size constraints. :param int command_int: integer value of our command - :param int recognized: zero if cell is decrypted, otherwise mostly non-zero (can rarely be zero) + :param int recognized: zero if cell is decrypted, otherwise mostly non-zero + (can rarely be zero) :param int stream_id: specific stream this concerns :param HASH,str,int digest: running digest held with the relay :param int data_len: length of body data

1 0

[stem/master] Add apply_digest instance method to RelayCell
by atagar＠torproject.org 26 Aug '18

26 Aug '18

commit 8023618ea74b4fb7b2cb1fca1694f6bff412b45a Author: Dave Rolek <dmr-x(a)riseup.net> Date: Fri Aug 10 20:59:04 2018 +0000 Add apply_digest instance method to RelayCell This method - currently unused - allows moving some of the digest-application logic into the Cell abstraction layer. It is a bit weird for it to have side-effects on a parameter (digest), but it's documented and works fairly logically. --- stem/client/cell.py | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/stem/client/cell.py b/stem/client/cell.py index 39a729f1..c1751ed6 100644 --- a/stem/client/cell.py +++ b/stem/client/cell.py @@ -456,6 +456,35 @@ class RelayCell(CircuitCell): return command, recognized, stream_id, digest, data_len, data, unused + def apply_digest(self, digest, prep_cell = True): + """ + Calculates, updates, and applies the digest to the cell payload. + + :param HASH digest: running digest held with the relay + :param bool prep_cell: preps the cell payload according to the spec, if **True** (default) + if **False**, the digest will be calculated as-is, namely: + the 'recognized' field will not be set to 0, + the digest field will not be set to 0, + and any 'unused' padding will be taken as-is. + Use with caution. + + :sideeffect digest: this object will be updated via digest.update(payload) + :sideeffect self.recognized: this will be set to 0, if prep_cell is **True** + :sideeffect self.digest: this will be updated with the calculated digest + :sideeffect self.unused: this will be treated as padding and overwritten, if prep_cell is **True** + """ + + if prep_cell: + self.recognized = 0 + self.digest = 0 + self.unused = b'' + + payload_without_updated_digest = self.pack_payload() + digest.update(payload_without_updated_digest) + self.digest = RelayCell._coerce_digest(digest) + + return + def pack_payload(self, **kwargs): """ Convenience method for running _pack_payload on self.

1 0

[stem/master] Further simplify digest application
by atagar＠torproject.org 26 Aug '18

26 Aug '18

commit 22e18791388009cb2fafebdb47605b047a288250 Author: Dave Rolek <dmr-x(a)riseup.net> Date: Fri Aug 10 21:22:35 2018 +0000 Further simplify digest application The abstraction layers are starting to look better separated. --- stem/client/__init__.py | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/stem/client/__init__.py b/stem/client/__init__.py index b0500c4a..74b6d2bf 100644 --- a/stem/client/__init__.py +++ b/stem/client/__init__.py @@ -32,7 +32,6 @@ import threading import stem import stem.client.cell import stem.socket -from stem.util import str_tools import stem.util.connection from stem.client.datatype import ZERO, LinkProtocol, Address, KDF @@ -239,15 +238,9 @@ class Circuit(object): orig_key = copy.copy(self.forward_key) try: - # Digests and such are computed using the RELAY cell payload. - - _, command_int = stem.client.datatype.RelayCommand.get(command) - # coerce to bytes, just in case - data = str_tools._to_bytes(data) - - payload_without_digest = stem.client.cell.RelayCell._pack_payload(command_int, 0, stream_id, 0, len(data), data) - self.forward_digest.update(payload_without_digest) - payload_with_digest = stem.client.cell.RelayCell._pack_payload(command_int, 0, stream_id, self.forward_digest, len(data), data) + cell = stem.client.cell.RelayCell(self.id, command, data, stream_id = stream_id) + cell.apply_digest(self.forward_digest) + payload_with_digest = cell.pack_payload() encrypted_payload = self.forward_key.update(payload_with_digest) encrypted_cell = stem.client.cell.RawRelayCell(self.id, encrypted_payload)

1 0

[stem/master] Add check_digest instance method to BaseRelayCell
by atagar＠torproject.org 26 Aug '18

26 Aug '18

commit 69f293222f550978e603906a4b3e34cb371447b0 Author: Dave Rolek <dmr-x(a)riseup.net> Date: Sat Aug 18 02:40:01 2018 +0000 Add check_digest instance method to BaseRelayCell Similar to how apply_digest() is used by a RELAY cell sender, this collects the logic needed for a receiver to confirm that a cell is fully decrypted and that the cell's integrity is intact. This is new functionality. Prior to this change, stem.client had no facility to check the digest of a RELAY cell according to the spec. Not yet used. --- stem/client/cell.py | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/stem/client/cell.py b/stem/client/cell.py index 43dc076c..5235331e 100644 --- a/stem/client/cell.py +++ b/stem/client/cell.py @@ -354,6 +354,44 @@ class BaseRelayCell(CircuitCell): # unlike everywhere else, we actually want to use the subclass type, NOT *this* class return cls(circ_id, content) + def check_digest(self, digest): + """ + Calculates the running digest of the cell payload per the spec, returning + whether the cell's unpacked digest matched, along with the updated digest + if so. + + :param HASH digest: running digest held with the relay + + :returns: (digest_matches, digest) tuple of object copies updated as follows: + * digest_matches: **bool** indicating whether the digest matches + * digest: updated via digest.update(payload), if the digest matches; + otherwise a copy of the original + + :raises: **ValueError** if payload is the wrong size + """ + + command, recognized, stream_id, digest_from_cell, data_len, data, unused = RelayCell._unpack_payload(self.payload) + + # running digest is calculated using a zero'd digest field in the payload + prepared_payload = RelayCell._pack_payload(command, recognized, stream_id, 0, data_len, data, unused, pad_remainder = False) + + if len(prepared_payload) != FIXED_PAYLOAD_LEN: + # this should never fail + # if it did, it indicates a programming error either within stem.client.cell or a consumer + raise ValueError('Payload should be %i bytes, but was %i' % (FIXED_PAYLOAD_LEN, len(prepared_payload))) + + new_digest = digest.copy() + new_digest.update(prepared_payload) + + digest_matches = (RelayCell._coerce_digest(new_digest) == digest_from_cell) + + # only return the new_digest if the digest check passed + # even if not, return a copy of the original + # this allows a consumer to always assume the returned digest is a different object + digest_to_return = new_digest if digest_matches else digest.copy() + + return digest_matches, digest_to_return + def __hash__(self): return stem.util._hash_attr(self, 'circ_id', 'payload', cache = True)

1 0

[stem/master] Add check_recognized_field instance method to BaseRelayCell
by atagar＠torproject.org 26 Aug '18

26 Aug '18

commit f82d839704788a063135a2b32f7657b2f9167fda Author: Dave Rolek <dmr-x(a)riseup.net> Date: Sun Aug 19 03:48:05 2018 +0000 Add check_recognized_field instance method to BaseRelayCell This is new functionality. (Nothing in stem.client currently attempts to check the 'recognized' field.) Not yet used. This is arguably a very inefficient method, and it might even obscure its purpose by existing (it's extremely simple), but it seemed better to break it out and deal with the foreseeable performance hit than to trend towards premature optimization. (It also is a bit counterintuitive for a value of 0 to mean True, so breaking this out makes that clearer.) There are many ways this could be optimized, and - especially since so much of this unit is still in flux - it doesn't make sense yet to do so. --- stem/client/cell.py | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/stem/client/cell.py b/stem/client/cell.py index 5235331e..250d400a 100644 --- a/stem/client/cell.py +++ b/stem/client/cell.py @@ -354,6 +354,22 @@ class BaseRelayCell(CircuitCell): # unlike everywhere else, we actually want to use the subclass type, NOT *this* class return cls(circ_id, content) + def check_recognized_field(self): + """ + Checks the 'recognized' field of the cell payload, which indicates whether + it is **probably** fully decrypted. + + :returns: **bool** indicating whether the 'recognized' field indicates + likely decryption. Per the spec: + * **False** guarantees the cell *not* to be fully decrypted. + * **True** does *not* guarantee the cell to be fully decrypted, and it + must be checked further. See also + :func:`~stem.client.cell.BaseRelayCell.check_digest` + """ + + _, recognized_from_cell, _, _, _, _, _ = RelayCell._unpack_payload(self.payload) + return recognized_from_cell == 0 + def check_digest(self, digest): """ Calculates the running digest of the cell payload per the spec, returning

1 0

[stem/master] Refactor RELAY cell encryption into new encrypt instance method
by atagar＠torproject.org 26 Aug '18

26 Aug '18

commit 116eb4b3efd01a91093a81d9411582cd43c98584 Author: Dave Rolek <dmr-x(a)riseup.net> Date: Fri Aug 17 19:30:56 2018 +0000 Refactor RELAY cell encryption into new encrypt instance method This further tunes the abstraction layers such that consumers don't need to care at all what part of the Cell is encrypted. They are still responsible for managing the digest/encryption key states, but don't need to know the finer details of the encryption. --- stem/client/__init__.py | 6 +----- stem/client/cell.py | 35 +++++++++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 5 deletions(-) diff --git a/stem/client/__init__.py b/stem/client/__init__.py index b64956ff..a228bebc 100644 --- a/stem/client/__init__.py +++ b/stem/client/__init__.py @@ -239,11 +239,7 @@ class Circuit(object): try: cell = stem.client.cell.RelayCell(self.id, command, data, stream_id = stream_id) - cell_with_digest, self.forward_digest = cell.apply_digest(self.forward_digest) - payload_with_digest = cell_with_digest.pack_payload() - - encrypted_payload = self.forward_key.update(payload_with_digest) - encrypted_cell = stem.client.cell.RawRelayCell(self.id, encrypted_payload) + encrypted_cell, self.forward_digest, self.forward_key = cell.encrypt(self.forward_digest, self.forward_key) reply_cells = [] self.relay._orport.send(encrypted_cell.pack(self.relay.link_protocol)) diff --git a/stem/client/cell.py b/stem/client/cell.py index d1265c10..43dc076c 100644 --- a/stem/client/cell.py +++ b/stem/client/cell.py @@ -39,6 +39,7 @@ Messages communicated over a Tor relay's ORPort. +- pop - decodes cell with remainder """ +import copy import datetime import inspect import os @@ -499,6 +500,40 @@ class RelayCell(CircuitCell): return new_cell, new_digest + def encrypt(self, digest, encryptor, **kwargs): + """ + Preps a cell payload, including calculating digest, and encrypts it, + returning a new (RawRelayCell, digest, encryptor) tuple. + + The method name is technically a misnomer, as it also preps cell payload + and applies the digest, prior to encrypting. However, these operations + are defined per the spec as required for RELAY cells, and ... + (1) it is a natural mental extension to include them here; + (2) it would be a bit pointless to require method consumers to manually + call both, for pedantry. + + :param HASH digest: running digest held with the relay + :param cryptography.hazmat.primitives.ciphers.CipherContext encryptor: + running stream cipher encryptor held with the relay + + :param bool prep_cell: (optional, defaults to **True**) refer to + :func:`~stem.client.cell.RelayCell.apply_digest` + + :returns: (:class:`~stem.client.cell.RawRelayCell`, HASH, CipherContext) + tuple of object copies updated as follows: + * RawRelayCell: updated as specified in + :func:`~stem.client.cell.RelayCell.apply_digest`, then encrypted + * digest: updated via digest.update(payload) + * encryptor: updated via encryptor.update(payload_with_digest) + """ + + unencrypted_cell, new_digest = self.apply_digest(digest, **kwargs) + new_encryptor = copy.copy(encryptor) + encrypted_payload = new_encryptor.update(unencrypted_cell.pack_payload()) + encrypted_cell = RawRelayCell(unencrypted_cell.circ_id, encrypted_payload) + + return encrypted_cell, new_digest, new_encryptor + def pack_payload(self, **kwargs): """ Convenience method for running

1 0

[stem/master] Add interpret_cell instance method to BaseRelayCell
by atagar＠torproject.org 26 Aug '18

26 Aug '18

commit 40ca0ca23f2f3fc3cab5ece39370ddb565029501 Author: Dave Rolek <dmr-x(a)riseup.net> Date: Sun Aug 19 04:32:52 2018 +0000 Add interpret_cell instance method to BaseRelayCell This method facilitates separating decryption / recognition of a cell from the interpretation of a cell. Many places in the spec indicate that cells should be dropped (ignored) under certain conditions, but that such cells should still be accounted for within the running decryption / digest. Furthermore, it may be useful in some cases to convert between raw cells and interpreted cells, without including the other steps of encryption / decryption. This additionally allows removing one of the interim TODOs in the RELAY cell unit tests. Arguably the tests need some rework with all these changes, but that can come a bit later. Not yet used, beyond the aforementioned unit tests. This method will probably evolve a decent amount, since the unit is still in a state of high flux. --- stem/client/cell.py | 35 +++++++++++++++++++++++++++++++++++ test/unit/client/cell.py | 4 ++-- 2 files changed, 37 insertions(+), 2 deletions(-) diff --git a/stem/client/cell.py b/stem/client/cell.py index 250d400a..a96b2f7b 100644 --- a/stem/client/cell.py +++ b/stem/client/cell.py @@ -408,6 +408,41 @@ class BaseRelayCell(CircuitCell): return digest_matches, digest_to_return + def interpret_cell(self): + """ + Interprets the cell payload, returning a new + :class:`~stem.client.cell.RelayCell` class or subclass according to its + contents. + + This method should only be used on fully decrypted cells, but that + responsibility is relegated to the caller. + + Furthermore, this interpretation may cause an exception for a NYI relay + command, a malformed cell, or some other reason. + + :returns: :class:`~stem.client.cell.RelayCell` class or subclass + """ + + # TODO: this mapping is quite hardcoded right now, but probably needs to be + # completely reworked once the Cell class hierarchy is better fleshed out. + # + # (It doesn't really make sense to have anything beyond this hack in the + # interim.) + # + # At that time, it would probably be modeled after Cell.by_value(), albeit + # specialized for the multiple types of RELAY / RELAY_EARLY cells. + + relay_cells_by_value = { + RawRelayCell.VALUE: RelayCell, + RelayEarlyCell.VALUE: RelayEarlyCell, + } + new_cls = relay_cells_by_value[self.VALUE] + + dummy_link_protocol = None + new_cell = new_cls._unpack(self.payload, self.circ_id, dummy_link_protocol) + + return new_cell + def __hash__(self): return stem.util._hash_attr(self, 'circ_id', 'payload', cache = True) diff --git a/test/unit/client/cell.py b/test/unit/client/cell.py index 3e091ee5..b4c0bd94 100644 --- a/test/unit/client/cell.py +++ b/test/unit/client/cell.py @@ -235,12 +235,12 @@ class TestCell(unittest.TestCase): self.assertEqual(cell_bytes, RelayCell(circ_id, command, data, digest, stream_id, unused = unused).pack(link_protocol)) self.assertEqual(cell_bytes, RelayCell(circ_id, command_int, data, digest, stream_id, unused = unused).pack(link_protocol)) - # TODO - temporarily, we hack the interim tests by unpacking info via RawRelayCell + # first unpack via RawRelayCell, then interpret into RelayCell raw_cell = Cell.pop(cell_bytes, link_protocol)[0] self.assertEqual(circ_id, raw_cell.circ_id) self.assertEqual(cell_bytes[-FIXED_PAYLOAD_LEN:], raw_cell.payload) - cell = RelayCell._unpack(raw_cell.payload, raw_cell.circ_id, link_protocol) + cell = raw_cell.interpret_cell() self.assertEqual(circ_id, cell.circ_id) self.assertEqual(command, cell.command) self.assertEqual(command_int, cell.command_int)

1 0

[stem/master] Refactor apply_digest to remove side effects
by atagar＠torproject.org 26 Aug '18

26 Aug '18

commit 1a151d445832df3fdecdb99aa1ecbbe0fee14563 Author: Dave Rolek <dmr-x(a)riseup.net> Date: Wed Aug 15 03:28:03 2018 +0000 Refactor apply_digest to remove side effects Per discussion with Damian over IRC, instances of our Cell classes are intended to be immutable objects. So instead of modifying the RelayCell and having an additional side effect on the digest, this provides a modified copy of each, in a tuple. That makes apply_digest() a pure function, currently with referential transparency (i.e. also deterministic). In the future, it may utilize randomness for cell padding, which would make it non-deterministic. Overall this now more generally follows a functional-programming paradigm. --- stem/client/__init__.py | 4 ++-- stem/client/cell.py | 33 +++++++++++++++++++++------------ 2 files changed, 23 insertions(+), 14 deletions(-) diff --git a/stem/client/__init__.py b/stem/client/__init__.py index 74b6d2bf..b64956ff 100644 --- a/stem/client/__init__.py +++ b/stem/client/__init__.py @@ -239,8 +239,8 @@ class Circuit(object): try: cell = stem.client.cell.RelayCell(self.id, command, data, stream_id = stream_id) - cell.apply_digest(self.forward_digest) - payload_with_digest = cell.pack_payload() + cell_with_digest, self.forward_digest = cell.apply_digest(self.forward_digest) + payload_with_digest = cell_with_digest.pack_payload() encrypted_payload = self.forward_key.update(payload_with_digest) encrypted_cell = stem.client.cell.RawRelayCell(self.id, encrypted_payload) diff --git a/stem/client/cell.py b/stem/client/cell.py index c1751ed6..fec8bb1b 100644 --- a/stem/client/cell.py +++ b/stem/client/cell.py @@ -458,7 +458,7 @@ class RelayCell(CircuitCell): def apply_digest(self, digest, prep_cell = True): """ - Calculates, updates, and applies the digest to the cell payload. + Calculates, updates, and applies the digest to the cell payload, returning a new (cell, digest) tuple. :param HASH digest: running digest held with the relay :param bool prep_cell: preps the cell payload according to the spec, if **True** (default) @@ -468,22 +468,31 @@ class RelayCell(CircuitCell): and any 'unused' padding will be taken as-is. Use with caution. - :sideeffect digest: this object will be updated via digest.update(payload) - :sideeffect self.recognized: this will be set to 0, if prep_cell is **True** - :sideeffect self.digest: this will be updated with the calculated digest - :sideeffect self.unused: this will be treated as padding and overwritten, if prep_cell is **True** + :returns: (:class:`~stem.client.cell.RelayCell`, HASH) tuple updated as follows: + digest: updated via digest.update(payload) + RelayCell: a copy of self, with the following updates: + RelayCell.recognized: set to 0, if prep_cell is **True** + RelayCell.digest: updated with the calculated digest + RelayCell.unused: treated as padding and overwritten, if prep_cell is **True** """ if prep_cell: - self.recognized = 0 - self.digest = 0 - self.unused = b'' + new_cell_recognized = 0 + new_cell_digest = 0 + new_cell_unused = b'' + else: + new_cell_recognized = self.recognized + new_cell_digest = self.digest + new_cell_unused = self.unused + + new_digest = digest.copy() + new_cell = RelayCell(self.circ_id, self.command, self.data, digest = new_cell_digest, stream_id = self.stream_id, recognized = new_cell_recognized, unused = new_cell_unused) - payload_without_updated_digest = self.pack_payload() - digest.update(payload_without_updated_digest) - self.digest = RelayCell._coerce_digest(digest) + payload_without_updated_digest = new_cell.pack_payload() + new_digest.update(payload_without_updated_digest) + new_cell.digest = RelayCell._coerce_digest(new_digest) - return + return new_cell, new_digest def pack_payload(self, **kwargs): """

1 0

[stem/master] Rearrange the digest/key copies to be a bit more spec-compliant
by atagar＠torproject.org 26 Aug '18

26 Aug '18

commit 13cc211070c2cf1d0d571461eed688ac1e69a735 Author: Dave Rolek <dmr-x(a)riseup.net> Date: Sat Aug 18 04:26:42 2018 +0000 Rearrange the digest/key copies to be a bit more spec-compliant This arrangement is better, as it better keeps track of the digest/key on a cell-by-cell basis, but it's still not spec-compliant in a number of ways, such as its potential to drop cells or get corrupted backward digest/key state in the case of an exception. That's ok - this is just an interim implementation, and this change is just to make things a bit better for illustrative purposes. --- stem/client/__init__.py | 33 +++++++++++++++++++-------------- 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/stem/client/__init__.py b/stem/client/__init__.py index 91e8c4ca..8c96b8c2 100644 --- a/stem/client/__init__.py +++ b/stem/client/__init__.py @@ -236,20 +236,27 @@ class Circuit(object): with self.relay._orport_lock: orig_forward_digest = self.forward_digest.copy() orig_forward_key = copy.copy(self.forward_key) - orig_backward_digest = self.backward_digest.copy() - orig_backward_key = copy.copy(self.backward_key) try: cell = stem.client.cell.RelayCell(self.id, command, data, stream_id = stream_id) encrypted_cell, self.forward_digest, self.forward_key = cell.encrypt(self.forward_digest, self.forward_key) - reply_cells = [] self.relay._orport.send(encrypted_cell.pack(self.relay.link_protocol)) - reply = self.relay._orport.recv() + except: + self.forward_digest = orig_forward_digest + self.forward_key = orig_forward_key + raise + + reply = self.relay._orport.recv() + reply_cells = [] - relay_cell_cmd = stem.client.cell.RelayCell.VALUE + relay_cell_cmd = stem.client.cell.RelayCell.VALUE - while reply: + while reply: + orig_backward_digest = self.backward_digest.copy() + orig_backward_key = copy.copy(self.backward_key) + + try: raw_cell, reply = stem.client.cell.Cell.pop(reply, self.relay.link_protocol) if raw_cell.VALUE != relay_cell_cmd: @@ -260,16 +267,14 @@ class Circuit(object): decrypted_cell, fully_decrypted, self.backward_digest, self.backward_key = raw_cell.decrypt(self.backward_digest, self.backward_key, interpret = True) if not fully_decrypted: raise stem.ProtocolError('Response for circuit id %i was not fully decrypted, when expected to be' % self.id) + except: + self.backward_digest = orig_backward_digest + self.backward_key = orig_backward_key + raise - reply_cells.append(decrypted_cell) + reply_cells.append(decrypted_cell) - return reply_cells - except: - self.forward_digest = orig_forward_digest - self.forward_key = orig_forward_key - self.backward_digest = orig_backward_digest - self.backward_key = orig_backward_key - raise + return reply_cells def close(self): with self.relay._orport_lock:

1 0

[stem/master] Now use the decrypt method in our Circuit class
by atagar＠torproject.org 26 Aug '18

26 Aug '18

commit eaa871fa08b3920baa9d24b3338c7c4b6973ee40 Author: Dave Rolek <dmr-x(a)riseup.net> Date: Sat Aug 18 04:12:35 2018 +0000 Now use the decrypt method in our Circuit class This also now actually checks the 'recognized' field and digest, unlike before. Keep in mind that this implementation is really meant for illustrative purposes, in the interim. (There are some limitations to it.) --- stem/client/__init__.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/stem/client/__init__.py b/stem/client/__init__.py index a228bebc..33ac0d8d 100644 --- a/stem/client/__init__.py +++ b/stem/client/__init__.py @@ -255,8 +255,11 @@ class Circuit(object): elif raw_cell.circ_id != self.id: raise stem.ProtocolError('Response should be for circuit id %i, not %i' % (self.id, raw_cell.circ_id)) - decrypted_payload = self.backward_key.update(raw_cell.payload) - reply_cells.append(stem.client.cell.RelayCell._unpack(decrypted_payload, self.id, self.relay.link_protocol)) + decrypted_cell, fully_decrypted, self.backward_digest, self.backward_key = raw_cell.decrypt(self.backward_digest, self.backward_key, interpret = True) + if not fully_decrypted: + raise stem.ProtocolError('Response for circuit id %i was not fully decrypted, when expected to be' % self.id) + + reply_cells.append(decrypted_cell) return reply_cells except:

1 0