def test_queue_file_normal(self):
# Setup
packet_list = split_to_assembly_packets(os.urandom(200), FILE)
# Test
self.assertIsNone(
queue_packets(packet_list,
FILE,
self.settings,
self.queue,
self.window,
log_as_ph=True))
time.sleep(0.1)
self.assertEqual(self.queue.qsize(), 1)
packet, settings, rx_account, tx_account, log_setting, log_as_ph, window_uid = self.queue.get(
)
self.assertIsInstance(packet, bytes)
self.assertIsInstance(settings, Settings)
self.assertEqual(rx_account, '*****@*****.**')
self.assertEqual(tx_account, '*****@*****.**')
self.assertEqual(window_uid, '*****@*****.**')
self.assertTrue(log_setting)
self.assertTrue(log_as_ph)
def test_long_command(self):
packet_list = split_to_assembly_packets(os.urandom(800), COMMAND)
self.assertEqual(len(packet_list), 4)
self.assertTrue(packet_list[0].startswith(C_L_HEADER))
self.assertTrue(packet_list[1].startswith(C_A_HEADER))
self.assertTrue(packet_list[2].startswith(C_A_HEADER))
self.assertTrue(packet_list[3].startswith(C_E_HEADER))
def test_long_message(self):
packet_list = split_to_assembly_packets(os.urandom(800), MESSAGE)
self.assertEqual(len(packet_list), 4)
self.assertTrue(packet_list[0].startswith(M_L_HEADER))
self.assertTrue(packet_list[1].startswith(M_A_HEADER))
self.assertTrue(packet_list[2].startswith(M_A_HEADER))
self.assertTrue(packet_list[3].startswith(M_E_HEADER))
def test_disabled_file_reception_raises_fr_with_append_packet(self):
# Setup
packet = Packet('*****@*****.**', self.contact, ORIGIN_CONTACT_HEADER, FILE, self.settings)
packet.long_active = True
compressed = zlib.compress(os.urandom(10000), level=COMPRESSION_LEVEL)
file_key = os.urandom(KEY_LENGTH)
encrypted = encrypt_and_sign(compressed, key=file_key)
encrypted += file_key
encoded = base64.b85encode(encrypted)
file_data = int_to_bytes(1000) + int_to_bytes(10000)+ b'testfile.txt' + US_BYTE + encoded
packets = split_to_assembly_packets(file_data, FILE)
for p in packets[:2]:
self.assertIsNone(packet.add_packet(p))
packet.contact.file_reception = False
# Test
self.assertFR("Alert! File reception disabled mid-transfer.",
packet.add_packet, packets[2])
for p in packets[3:]:
self.assertFR("Missing start packet.", packet.add_packet, p)
self.assertEqual(packet.log_masking_ctr, len(packets))
def test_short_file_from_user_raises_fr(self):
# Setup
packet = Packet('*****@*****.**', self.contact, ORIGIN_USER_HEADER, FILE, self.settings)
packets = split_to_assembly_packets(self.short_f_data, FILE)
# Test
for p in packets:
self.assertFR("Ignored file from user.", packet.add_packet, p)
self.assertEqual(packet.log_masking_ctr, 1)
def test_long_file(self):
packet_list = split_to_assembly_packets(os.urandom(800), FILE)
self.assertEqual(len(packet_list), 4)
self.assertTrue(
packet_list[0].startswith(F_L_HEADER +
b'\x00\x00\x00\x00\x00\x00\x00\x04'))
self.assertTrue(packet_list[1].startswith(F_A_HEADER))
self.assertTrue(packet_list[2].startswith(F_A_HEADER))
self.assertTrue(packet_list[3].startswith(F_E_HEADER))
def queue_packet(key, hek, tx_harac, packet, rx_account=None):
if rx_account is None:
header = COMMAND_PACKET_HEADER
trailer = b''
queue = queues[COMMAND_PACKET_HEADER]
packet = split_to_assembly_packets(packet, COMMAND)[0]
else:
header = MESSAGE_PACKET_HEADER
trailer = ORIGIN_CONTACT_HEADER + rx_account
queue = queues[MESSAGE_PACKET_HEADER]
packet = split_to_assembly_packets(packet, MESSAGE)[0]
encrypted_harac = encrypt_and_sign(int_to_bytes(tx_harac), hek)
encrypted_message = encrypt_and_sign(packet, key)
encrypted_packet = header + encrypted_harac + encrypted_message + trailer
queue.put((datetime.datetime.now(), encrypted_packet))
time.sleep(0.1)
def test_invalid_assembly_packet_header_raises_fr(self):
# Setup
packet = Packet('*****@*****.**', self.contact, ORIGIN_USER_HEADER, MESSAGE, self.settings)
plaintext = "Lorem ipsum dolor sit amet, consectetur adipiscing elit".encode()
packets = split_to_assembly_packets(plaintext, MESSAGE)
# Test
self.assertFR("Error: Received packet had an invalid assembly packet header.",
packet.add_packet, b'i' + packets[0][1:])
self.assertEqual(packet.log_masking_ctr, 1)
def test_short_command(self):
# Setup
packet = Packet(LOCAL_ID, self.contact, ORIGIN_CONTACT_HEADER, COMMAND, self.settings)
packets = split_to_assembly_packets(b'testcommand', COMMAND)
for p in packets:
packet.add_packet(p)
# Test
self.assertEqual(packet.assemble_command_packet(), b'testcommand')
self.assertEqual(packet.log_masking_ctr, 0)
def test_short_message(self):
# Setup
packet = Packet('*****@*****.**', self.contact, ORIGIN_USER_HEADER, MESSAGE, self.settings)
plaintext = "Lorem ipsum dolor sit amet, consectetur adipiscing elit".encode()
packets = split_to_assembly_packets(plaintext, MESSAGE)
for p in packets:
packet.add_packet(p)
# Test
self.assertEqual(packet.assemble_message_packet(), plaintext)
def test_long_message(self):
# Setup
packet = Packet('*****@*****.**', self.contact, ORIGIN_USER_HEADER, MESSAGE, self.settings)
packets = split_to_assembly_packets(self.msg.encode(), MESSAGE)
for p in packets:
packet.add_packet(p)
# Test
message = packet.assemble_message_packet()
self.assertEqual(message.decode(), self.msg)
def test_unauthorized_file_from_contact_raises_fr(self):
# Setup
self.contact.file_reception = False
packet = Packet('*****@*****.**', self.contact, ORIGIN_CONTACT_HEADER, FILE, self.settings)
packets = split_to_assembly_packets(self.short_f_data, FILE)
# Test
for p in packets:
self.assertFR("Alert! File transmission from Alice but reception is disabled.", packet.add_packet, p)
self.assertEqual(packet.log_masking_ctr, 1)
def test_long_command(self):
# Setup
packet = Packet(LOCAL_ID, self.contact, ORIGIN_CONTACT_HEADER, COMMAND, self.settings)
command = os.urandom(500)
packets = split_to_assembly_packets(command, COMMAND)
for p in packets:
packet.add_packet(p)
# Test
self.assertEqual(packet.assemble_command_packet(), command)
self.assertEqual(packet.log_masking_ctr, 0)
def test_long_command_hash_mismatch_raises_fr(self):
# Setup
packet = Packet(LOCAL_ID, self.contact, ORIGIN_CONTACT_HEADER, COMMAND, self.settings)
command = os.urandom(500) + b'a'
packets = split_to_assembly_packets(command, COMMAND)
packets = [p.replace(b'a', b'c') for p in packets]
for p in packets:
packet.add_packet(p)
# Test
self.assertFR("Error: Received an invalid command.", packet.assemble_command_packet)
self.assertEqual(packet.log_masking_ctr, 0)
def assembly_packet_creator(p_type: str,
payload: bytes = b'',
origin: bytes = b'',
header: bytes = b'',
group_name: str = None,
encrypt: bool = False,
break_g_name: bool = False,
origin_acco: bytes = b'*****@*****.**'):
"""Create assembly packet list and optionally encrypt it."""
if p_type == MESSAGE:
if not header:
if group_name is not None:
group_msg_id = GROUP_MSG_ID_LEN * b'a'
group_name = binascii.unhexlify(
'a466c02c221cb135') if break_g_name else group_name.encode(
)
header = GROUP_MESSAGE_HEADER + group_msg_id + group_name + US_BYTE
else:
header = PRIVATE_MESSAGE_HEADER
payload = header + payload
if p_type == FILE:
if not payload:
compressed = zlib.compress(os.urandom(10000),
level=COMPRESSION_LEVEL)
file_key = os.urandom(KEY_LENGTH)
encrypted = encrypt_and_sign(compressed, key=file_key) + file_key
encoded = base64.b85encode(encrypted)
payload = int_to_bytes(1) + int_to_bytes(
2) + b'testfile.txt' + US_BYTE + encoded
packet_list = split_to_assembly_packets(payload, p_type)
if not encrypt:
return packet_list
if encrypt:
harac = 1
m_key = KEY_LENGTH * b'\x01'
m_hek = KEY_LENGTH * b'\x01'
assembly_ct_list = []
for p in packet_list:
harac_in_bytes = int_to_bytes(harac)
encrypted_harac = encrypt_and_sign(harac_in_bytes, m_hek)
encrypted_message = encrypt_and_sign(p, m_key)
encrypted_packet = MESSAGE_PACKET_HEADER + encrypted_harac + encrypted_message + origin + origin_acco
assembly_ct_list.append(encrypted_packet)
m_key = hash_chain(m_key)
harac += 1
return assembly_ct_list
def test_invalid_long_file_header_raises_fr(self):
# Setup
packet = Packet('*****@*****.**', self.contact, ORIGIN_CONTACT_HEADER, FILE, self.settings)
compressed = zlib.compress(os.urandom(10000), level=COMPRESSION_LEVEL)
file_key = os.urandom(KEY_LENGTH)
encrypted = encrypt_and_sign(compressed, key=file_key)
encrypted += file_key
encoded = base64.b85encode(encrypted)
file_data = int_to_bytes(1000) + int_to_bytes(10000) + binascii.unhexlify('3f264d4189d7a091') + US_BYTE + encoded
packets = split_to_assembly_packets(file_data, FILE)
# Test
self.assertFR("Error: Received file packet had an invalid header.", packet.add_packet, packets[0])
self.assertEqual(packet.log_masking_ctr, 1)
def test_long_file_from_user_raises_fr(self):
# Setup
packet = Packet('*****@*****.**', self.contact, ORIGIN_USER_HEADER, FILE, self.settings)
compressed = zlib.compress(os.urandom(10000), level=COMPRESSION_LEVEL)
file_key = os.urandom(KEY_LENGTH)
encrypted = encrypt_and_sign(compressed, key=file_key)
encrypted += file_key
encoded = base64.b85encode(encrypted)
file_data = int_to_bytes(1000) + int_to_bytes(10000) + b'testfile.txt' + US_BYTE + encoded
packets = split_to_assembly_packets(file_data, FILE)
# Test
self.assertFR("Ignored file from user.", packet.add_packet, packets[0])
self.assertEqual(packet.log_masking_ctr, 1)
def test_queue_command_traffic_masking(self):
# Setup
packet_list = split_to_assembly_packets(os.urandom(200), COMMAND)
self.settings.session_traffic_masking = True
# Test
self.assertIsNone(
queue_packets(packet_list, COMMAND, self.settings, self.queue,
self.window))
time.sleep(0.1)
self.assertEqual(self.queue.qsize(), 1)
data, log_messages = self.queue.get()
self.assertIsInstance(data, bytes)
self.assertTrue(log_messages)
def test_queue_command_normal(self):
# Setup
packet_list = split_to_assembly_packets(os.urandom(200), COMMAND)
# Test
self.assertIsNone(
queue_packets(packet_list, COMMAND, self.settings, self.queue,
self.window))
time.sleep(0.1)
self.assertEqual(self.queue.qsize(), 1)
packet, settings = self.queue.get()
self.assertIsInstance(packet, bytes)
self.assertIsInstance(settings, Settings)
def test_unauthorized_long_file_raises_fr(self):
# Setup
self.contact.file_reception = False
packet = Packet('*****@*****.**', self.contact, ORIGIN_CONTACT_HEADER, FILE, self.settings)
compressed = zlib.compress(os.urandom(10000), level=COMPRESSION_LEVEL)
file_key = os.urandom(KEY_LENGTH)
encrypted = encrypt_and_sign(compressed, key=file_key)
encrypted += file_key
encoded = base64.b85encode(encrypted)
file_data = int_to_bytes(1000) + int_to_bytes(10000) + b'testfile.txt' + US_BYTE + encoded
packets = split_to_assembly_packets(file_data, FILE)
# Test
self.assertFR("Alert! File transmission from Alice but reception is disabled.", packet.add_packet, packets[0])
self.assertEqual(packet.log_masking_ctr, 1)
def test_queue_file_traffic_masking(self):
# Setup
packet_list = split_to_assembly_packets(os.urandom(200), FILE)
self.settings.session_traffic_masking = True
# Test
self.assertIsNone(
queue_packets(packet_list, FILE, self.settings, self.queue,
self.window))
time.sleep(0.1)
self.assertEqual(self.queue.qsize(), 1)
packet, log_messages, log_as_ph = self.queue.get()
self.assertIsInstance(packet, bytes)
self.assertTrue(log_messages)
self.assertFalse(log_as_ph)
def test_long_file(self):
# Setup
packet = Packet('*****@*****.**', self.contact, ORIGIN_CONTACT_HEADER, FILE, self.settings)
packet.long_active = True
compressed = zlib.compress(os.urandom(10000), level=COMPRESSION_LEVEL)
file_key = os.urandom(KEY_LENGTH)
encrypted = encrypt_and_sign(compressed, key=file_key)
encrypted += file_key
encoded = base64.b85encode(encrypted)
file_data = int_to_bytes(1000) + int_to_bytes(10000)+ b'testfile.txt' + US_BYTE + encoded
packets = split_to_assembly_packets(file_data, FILE)
for p in packets:
packet.add_packet(p)
# Test
self.assertIsNone(packet.assemble_and_store_file())
self.assertTrue(os.path.isfile(f'{DIR_RX_FILES}Alice/testfile.txt'))
self.assertEqual(os.path.getsize(f'{DIR_RX_FILES}Alice/testfile.txt'), 10000)
def test_noise_packet_interrupts_file(self):
# Setup
packet = Packet('*****@*****.**', self.contact, ORIGIN_CONTACT_HEADER, FILE, self.settings)
compressed = zlib.compress(os.urandom(10000), level=COMPRESSION_LEVEL)
file_key = os.urandom(KEY_LENGTH)
encrypted = encrypt_and_sign(compressed, key=file_key)
encrypted += file_key
encoded = base64.b85encode(encrypted)
file_data = int_to_bytes(1000) + int_to_bytes(10000) + b'testfile.txt' + US_BYTE + encoded
packets = split_to_assembly_packets(file_data, FILE)
packets = packets[:20]
packets.append(byte_padding(P_N_HEADER)) # Add cancel packet
for p in packets:
packet.add_packet(p)
# Test
self.assertEqual(len(packet.assembly_pt_list), 0) # Cancel packet empties packet list
self.assertFalse(packet.long_active)
self.assertFalse(packet.is_complete)
self.assertEqual(packet.log_masking_ctr, len(packets))
def test_short_file(self):
# Setup
packets = split_to_assembly_packets(self.short_f_data, FILE)
# Test
self.assertFalse(os.path.isfile(f'{DIR_RX_FILES}Alice/testfile.txt'))
self.assertFalse(os.path.isfile(f'{DIR_RX_FILES}Alice/testfile.txt.1'))
packet = Packet('*****@*****.**', self.contact, ORIGIN_CONTACT_HEADER, FILE, self.settings)
packet.long_active = True
for p in packets:
packet.add_packet(p)
self.assertIsNone(packet.assemble_and_store_file())
self.assertTrue(os.path.isfile(f'{DIR_RX_FILES}Alice/testfile.txt'))
for p in packets:
packet.add_packet(p)
self.assertIsNone(packet.assemble_and_store_file())
self.assertTrue(os.path.isfile(f'{DIR_RX_FILES}Alice/testfile.txt.1'))
# Teardown
shutil.rmtree(DIR_RX_FILES)
def test_short_file(self):
packet_list = split_to_assembly_packets(os.urandom(50), FILE)
self.assertEqual(len(packet_list), 1)
self.assertTrue(packet_list[0].startswith(F_S_HEADER))
def test_short_message(self):
packet_list = split_to_assembly_packets(b'Short message', MESSAGE)
self.assertEqual(len(packet_list), 1)
self.assertTrue(packet_list[0].startswith(M_S_HEADER))
def test_short_command(self):
packet_list = split_to_assembly_packets(os.urandom(50), COMMAND)
self.assertEqual(len(packet_list), 1)
self.assertTrue(packet_list[0].startswith(C_S_HEADER))
