def _pack(self) -> bytes: nodes_buffer: bytes = b'' for node in self.direct_path: nodes_buffer += pack_dynamic('V', node.pack()) return pack_dynamic('V', nodes_buffer)
def _pack(self) -> bytes: path_secret_buffer: bytes = b'' for entry in self.encrypted_path_secret: path_secret_buffer += pack_dynamic('V', entry.pack()) return pack_dynamic('32sV', self.public_key, path_secret_buffer)
def _packed_nodes(self) -> bytes: # packed_list: List[bytes] = [] packed_list: bytes = b'' for node in self.tree: if node is None: packed_list += pack_dynamic('V', b"NOTHING") else: packed_list += pack_dynamic('V', node.pack()) return packed_list
def test_stacked_payloads(): payload = b'' + pack_dynamic('V', b'a' * 32) + pack_dynamic('V', b'b' * 64) payload_payload = pack_dynamic('V', payload) unpacked_payload = unpack_dynamic('V', payload_payload)[0] assert payload == unpacked_payload payload_list = unpack_byte_list(unpacked_payload) assert len(payload_list) == 2 assert payload_list[0] == b'a' * 32 assert payload_list[1] == b'b' * 64
def test_normal_format_chars_pack(): cases: Dict = {'c': b'a', 'L': 1337, '2s': b'aa'} for fmt_char, value in cases.items(): assert pack_dynamic(fmt_char, value) == struct.pack(MP_BYTE_ORDERING + fmt_char, value)
def test_pack_unpack_combinations(): dyn_payload = b'a' * 10 cases: Dict[string, List] = { 'V': [dyn_payload], 'Vc': [dyn_payload, b'a'], 'LLV': [1337, 7331, dyn_payload], 'LVL': [1337, b'b' * 16, 7331], '32sV': [b'a' * 32, pack_dynamic('V', b'a' * 72)] } for fmt_string, arguments in cases.items(): packed_unpacked_values = unpack_dynamic( fmt_string, pack_dynamic(fmt_string, *arguments)) for i, arg in enumerate(arguments): assert arg == packed_unpacked_values[i]
def test_empty_vector(): packed = pack_dynamic('V', b'') assert len(packed) == struct.calcsize(MP_BYTE_ORDERING + 'L') assert struct.unpack(MP_BYTE_ORDERING + 'L', packed)[0] == 0 unpacked = unpack_dynamic('V', packed) assert len(unpacked) == 1 assert isinstance(unpacked[0], bytes) assert unpacked[0] == b''
def test_plain_vector(): cases: List[bytes] = [ b'\x30', b'hallo', b'@@@!#?<>-_---_+*-^', 'ÄÜÖß'.encode('utf-8') ] for some_byte_string in cases: out: bytes = pack_dynamic('V', some_byte_string) assert len(out) == MP_LENGTH_FIELD_SIZE + len(some_byte_string) assert struct.unpack( f'{MP_BYTE_ORDERING}L', out[0:MP_LENGTH_FIELD_SIZE])[0] == len(some_byte_string)
def test_combined_payloads(): dyn_payload = b'a' * 10 cases: Dict[string, List] = { 'Vc': [dyn_payload, b'a'], 'LLV': [1337, 7331, dyn_payload], '2LV': [1337, 7331, dyn_payload], '32sV': [b'a' * 32, dyn_payload], } for fmt_string, arguments in cases.items(): plain_fmt = fmt_string.replace('V', '') plain_size = struct.calcsize(MP_BYTE_ORDERING + plain_fmt) expected_size = plain_size + MP_LENGTH_FIELD_SIZE + len(dyn_payload) assert expected_size == len(pack_dynamic(fmt_string, *arguments))
def _pack(self) -> bytes: return pack_dynamic('VVV', self._public_key, self._private_key if self._private_key is not None else b'', self._credentials if self._credentials is not None else b'')
def _pack(self) -> bytes: return pack_dynamic('32sV', self.ephemeral_key, self.cipher_text)
def _pack(self) -> bytes: return pack_dynamic('VVIVVVVV', self.protocol_version, self.group_id, self.epoch, self._packed_nodes(), self.interim_transcript_hash, self.init_secret, self.key, self.nounce)
def _pack(self) -> bytes: return pack_dynamic('VIIBVV', self.group_id, self.epoch, self.sender, self.content_type.value, self.content.pack(), self.signature)
def _pack(self) -> bytes: return pack_dynamic('VIBVVV', self.group_id, self.epoch, self.content_type.value, self.sender_data_nounce, self.encrypted_sender_data, self.ciphertext)
def _pack(self) -> bytes: return pack_dynamic('V', self.application_data)
def _pack(self) -> bytes: return pack_dynamic('II', self.sender, self.generation)
def _pack(self) -> bytes: return pack_dynamic('BV', self.msg_type.value, self.operation.pack())
def _pack(self) -> bytes: return pack_dynamic('IV', self.confirmation, self.group_operation.pack())
def test_quantifier_untouched(): fmt = '2L' values = [1337, 7331] assert pack_dynamic(fmt, *values) == struct.pack(MP_BYTE_ORDERING + fmt, *values)
def _pack(self) -> bytes: return pack_dynamic('V', '\n'.join(self.user_names).encode('UTF-8'))
def _pack(self) -> bytes: return pack_dynamic('IVV', self.index, self.init_key, self.welcome_info_hash)
def _pack(self) -> bytes: return pack_dynamic('BV', self.msg_type.value, self.contents.pack())
def _pack(self) -> bytes: return pack_dynamic('V', self.message.encode('UTF-8'))