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'))
