def test_get_list_of_member_pub_keys(self):
self.assertEqual(first=self.group.get_list_of_member_pub_keys(),
second=[
nick_to_pub_key('Alice'),
nick_to_pub_key('Bob'),
nick_to_pub_key('Charlie')
])
def test_has_rx_mk(self):
self.assertTrue(self.keylist.has_rx_mk(nick_to_pub_key('Bob')))
self.keylist.get_keyset(
nick_to_pub_key('Bob')).rx_mk = bytes(SYMMETRIC_KEY_LENGTH)
self.keylist.get_keyset(
nick_to_pub_key('Bob')).rx_hk = bytes(SYMMETRIC_KEY_LENGTH)
self.assertFalse(self.keylist.has_rx_mk(nick_to_pub_key('Bob')))
def setUp(self) -> None:
"""Pre-test actions."""
self.window_list = WindowList()
self.window_list.windows = [
RxWindow(uid=nick_to_pub_key("Alice"), name='Alice'),
RxWindow(uid=nick_to_pub_key("Bob"), name='Bob')
]
def test_manage(self) -> None:
# Setup
queues = gen_queue_dict()
# Test that the KeySet for David does not exist
self.assertFalse(self.keylist.has_keyset(nick_to_pub_key('David')))
# Test adding the KeySet for David
self.assertIsNone(self.keylist.manage(queues, KDB_ADD_ENTRY_HEADER, nick_to_pub_key('David'),
bytes(SYMMETRIC_KEY_LENGTH), bytes(SYMMETRIC_KEY_LENGTH),
bytes(SYMMETRIC_KEY_LENGTH), bytes(SYMMETRIC_KEY_LENGTH)))
self.assertTrue(self.keylist.has_keyset(nick_to_pub_key('David')))
# Test removing David's KeySet
self.assertIsNone(self.keylist.manage(queues, KDB_REMOVE_ENTRY_HEADER, nick_to_pub_key('David')))
self.assertFalse(self.keylist.has_keyset(nick_to_pub_key('David')))
# Test changing the master key
new_key = SYMMETRIC_KEY_LENGTH * b'\x01'
self.assertNotEqual(self.master_key.master_key, new_key)
queues[KEY_MANAGEMENT_QUEUE].put(new_key)
self.assertIsNone(self.keylist.manage(queues, KDB_M_KEY_CHANGE_HALT_HEADER))
self.assertEqual(self.keylist.master_key.master_key, new_key)
self.assertEqual(self.keylist.database.database_key, new_key)
# Test an invalid KeyList management command raises CriticalError
with self.assertRaises(SystemExit):
self.keylist.manage(queues, 'invalid_key', None)
def setUp(self):
self.cmd_data = nick_to_pub_key("Alice")
self.window_list = WindowList()
self.window_list.windows = [RxWindow(uid=nick_to_pub_key("Alice"), name='Alice'),
RxWindow(uid=nick_to_pub_key("Bob"), name='Bob')]
self.window = self.window_list.get_window(nick_to_pub_key("Alice"))
self.window.message_log = [(datetime.now(), 'Hi Bob', nick_to_pub_key("Alice"), ORIGIN_CONTACT_HEADER)]
def test_add_contact(self) -> None:
command = (ONION_SERVICE_PRIVATE_KEY_LENGTH * b'a' + b'b' + b'\x01' +
int_to_bytes(1) + nick_to_pub_key('Alice') +
nick_to_pub_key('Bob'))
self.assertIsNone(add_onion_data(command, self.queues))
self.assertEqual(self.queues[ONION_KEY_QUEUE].qsize(), 1)
self.assertEqual(self.queues[ONION_KEY_QUEUE].get(),
(ONION_SERVICE_PRIVATE_KEY_LENGTH * b'a', b'b'))
def test_nick_change(self):
# Setup
cmd_data = nick_to_pub_key("Alice") + b'Alice_'
# Test
self.assertIsNone(ch_nick(cmd_data, *self.args))
self.assertEqual(self.contact_list.get_contact_by_pub_key(nick_to_pub_key("Alice")).nick, 'Alice_')
self.assertEqual(self.window.name, 'Alice_')
def test_remove_keyset(self):
# Test KeySet for Bob exists
self.assertTrue(self.keylist.has_keyset(nick_to_pub_key('Bob')))
# Remove KeySet for Bob
self.assertIsNone(self.keylist.remove_keyset(nick_to_pub_key('Bob')))
# Test KeySet was removed
self.assertFalse(self.keylist.has_keyset(nick_to_pub_key('Bob')))
def test_window_selection(self):
self.assertIsNone(win_select(nick_to_pub_key("Alice"), self.window_list))
self.assertEqual(self.window_list.active_win.name, 'Alice')
self.assertIsNone(win_select(nick_to_pub_key("Bob"), self.window_list))
self.assertEqual(self.window_list.active_win.name, 'Bob')
self.assertIsNone(win_select(WIN_UID_FILE, self.window_list))
self.assertEqual(self.window_list.active_win.uid, WIN_UID_FILE)
def test_file_datagram(self) -> None:
# Setup
packet = self.create_packet(FILE_DATAGRAM_HEADER + int_to_bytes(2) +
nick_to_pub_key('Alice') +
nick_to_pub_key('Bob') + 200 * b'a')
self.queues[GATEWAY_QUEUE].put((self.ts, packet))
# Test
self.assertIsNone(src_incoming(*self.args, unit_test=True))
self.assertEqual(self.queues[DST_MESSAGE_QUEUE].qsize(), 0)
def test_group_exit_datagram(self) -> None:
# Setup
packet = self.create_packet(GROUP_MSG_EXIT_GROUP_HEADER +
bytes(GROUP_ID_LENGTH) +
nick_to_pub_key('Alice') +
nick_to_pub_key('Bob'))
self.queues[GATEWAY_QUEUE].put((self.ts, packet))
# Test
self.assertIsNone(src_incoming(*self.args, unit_test=True))
self.assertEqual(self.queues[DST_MESSAGE_QUEUE].qsize(), 0)
def test_add_contact(self):
command = b''.join([nick_to_pub_key('Alice'), nick_to_pub_key('Bob')])
self.assertIsNone(add_contact(command, True, self.queues))
self.assertEqual(self.queues[CONTACT_KEY_QUEUE].qsize(), 1)
for q in [GROUP_MGMT_QUEUE, F_REQ_MGMT_QUEUE]:
command = self.queues[q].get()
self.assertEqual(command,
(RP_ADD_CONTACT_HEADER, b''.join([nick_to_pub_key('Alice'), nick_to_pub_key('Bob')])))
self.assertEqual(self.queues[CONTACT_KEY_QUEUE].get(),
(RP_ADD_CONTACT_HEADER, b''.join(list(map(nick_to_pub_key, ['Alice', 'Bob']))), True))
def test_group_remove_datagram(self):
# Setup
packet = self.create_packet(GROUP_MSG_MEMBER_REM_HEADER +
bytes(GROUP_ID_LENGTH) + int_to_bytes(2) +
nick_to_pub_key('Alice') +
nick_to_pub_key('Bob'))
self.queues[GATEWAY_QUEUE].put((self.ts, packet))
# Test
self.assertIsNone(src_incoming(*self.args, unittest=True))
self.assertEqual(self.queues[DST_MESSAGE_QUEUE].qsize(), 0)
self.assertEqual(self.queues[M_TO_FLASK_QUEUE].qsize(), 2)
def test_add_members(self) -> None:
# Test members to be added are not already in group
self.assertFalse(self.group.has_member(nick_to_pub_key('David')))
self.assertFalse(self.group.has_member(nick_to_pub_key('Eric')))
self.assertIsNone(self.group.add_members(list(map(create_contact, ['Alice', 'David', 'Eric']))))
# Test new members were added
self.assertTrue(self.group.has_member(nick_to_pub_key('David')))
self.assertTrue(self.group.has_member(nick_to_pub_key('Eric')))
# Test Alice was not added twice
self.assertEqual(len(self.group), len(['Alice', 'Bob', 'Charlie', 'David', 'Eric']))
def test_cancel_file_during_traffic_masking(self):
# Setup
user_input = UserInput('cf')
settings = Settings(traffic_masking=True)
window = TxWindow()
window.window_contacts = [create_contact('Alice')]
self.queues[TM_FILE_PACKET_QUEUE].put(('testfile1', {nick_to_pub_key("Alice"): False}))
self.queues[TM_FILE_PACKET_QUEUE].put(('testfile2', {nick_to_pub_key("Alice"): False}))
# Test
self.assertIsNone(cancel_packet(user_input, window, settings, self.queues))
self.assertEqual(self.queues[TM_FILE_PACKET_QUEUE].qsize(), 1)
def test_queue_message_normal(self):
# Setup
packet_list = split_to_assembly_packets(os.urandom(200), MESSAGE)
# Test
self.assertIsNone(queue_assembly_packets(packet_list, MESSAGE, *self.args))
self.assertEqual(self.queues[MESSAGE_PACKET_QUEUE].qsize(), 1)
packet, pub_key, log_setting, log_as_ph, win_uid = self.queues[MESSAGE_PACKET_QUEUE].get()
self.assertIsInstance(packet, bytes)
self.assertEqual(pub_key, nick_to_pub_key("Alice"))
self.assertEqual(win_uid, nick_to_pub_key("Alice"))
self.assertTrue(log_setting)
self.assertFalse(log_as_ph)
def test_successful_removal(self):
# Setup
contact_list = ContactList(nicks=['Alice', 'Bob'])
contact = contact_list.get_contact_by_address_or_nick("Bob")
group_list = GroupList(groups=['test_group', 'test_group2'])
key_list = KeyList(nicks=['Alice', 'Bob'])
self.window_list.windows = [RxWindow(type=WIN_TYPE_GROUP)]
# Test
self.assert_fr("No log database available.",
contact_rem, *self.args, contact_list, group_list, key_list, self.settings, self.master_key)
self.assertFalse(contact_list.has_pub_key(nick_to_pub_key("Bob")))
self.assertFalse(key_list.has_keyset(nick_to_pub_key("Bob")))
for g in group_list:
self.assertFalse(contact in g.members)
def queue_delayer():
"""Place datagrams into queue after delay."""
time.sleep(delay)
queue_command(b'test', settings, queues)
time.sleep(delay)
queue_to_nc(
PUBLIC_KEY_DATAGRAM_HEADER + TFC_PUBLIC_KEY_LENGTH * b'a' +
nick_to_pub_key('Alice'), # 1
queues[RELAY_PACKET_QUEUE])
time.sleep(delay)
queue_to_nc(UNENCRYPTED_DATAGRAM_HEADER + UNENCRYPTED_WIPE_COMMAND,
queues[RELAY_PACKET_QUEUE]) # 2
time.sleep(delay)
queue_to_nc(UNENCRYPTED_DATAGRAM_HEADER + UNENCRYPTED_EXIT_COMMAND,
queues[RELAY_PACKET_QUEUE]) # 3
time.sleep(delay)
queues[KEY_MANAGEMENT_QUEUE].put((
KDB_ADD_ENTRY_HEADER,
LOCAL_PUBKEY, # 4
SYMMETRIC_KEY_LENGTH * b'a',
SYMMETRIC_KEY_LENGTH * b'a',
SYMMETRIC_KEY_LENGTH * b'a',
SYMMETRIC_KEY_LENGTH * b'a'))
time.sleep(delay)
queue_message(user_input, window, settings, queues) # 5
time.sleep(delay)
queue_message(user_input, window, settings, queues) # 6
time.sleep(delay)
queues[KEY_MANAGEMENT_QUEUE].put(
(KDB_ADD_ENTRY_HEADER, nick_to_pub_key('Alice'),
SYMMETRIC_KEY_LENGTH * b'a', SYMMETRIC_KEY_LENGTH * b'a',
SYMMETRIC_KEY_LENGTH * b'a', SYMMETRIC_KEY_LENGTH * b'a'))
time.sleep(delay)
queue_message(user_input, window, settings, queues) # 7
time.sleep(delay)
queue_message(user_input, window, settings, queues) # 8
time.sleep(delay)
queues[SENDER_MODE_QUEUE].put(settings)
def test_setting_change_contact(self):
# Setup
self.window = self.window_list.get_window(nick_to_pub_key("Bob"))
self.window.type = WIN_TYPE_CONTACT
self.window.type_print = 'contact'
self.window.window_contacts = self.contact_list.contacts
bob = self.contact_list.get_contact_by_address_or_nick("Bob")
# Test
for attr, header in [('log_messages', CH_LOGGING),
('notifications', CH_NOTIFY),
('file_reception', CH_FILE_RECV)]:
for s in [ENABLE, ENABLE, DISABLE, DISABLE]:
cmd_data = s + nick_to_pub_key("Bob")
self.assertIsNone(ch_contact_s(cmd_data, *self.args, header))
self.assertEqual(bob.__getattribute__(attr), (s == ENABLE))
def test_buffering_of_unique_files(self) -> None:
# Setup
packet = 500 * b'a'
onion_pub_key = nick_to_pub_key('Alice')
ts = datetime.now()
header = MESSAGE_DATAGRAM_HEADER
buf_key = SYMMETRIC_KEY_LENGTH * b'a'
sub_dir = hashlib.blake2b(
onion_pub_key, key=buf_key,
digest_size=BLAKE2_DIGEST_LENGTH).hexdigest()
# Test
self.assertIsNone(
buffer_to_flask(packet, onion_pub_key, ts, header, buf_key, True))
self.assertIsNone(
buffer_to_flask(packet, onion_pub_key, ts, header, buf_key, True))
self.assertTrue(
os.path.isdir(f"{RELAY_BUFFER_OUTGOING_F_DIR}/{sub_dir}"))
self.assertTrue(
os.path.isfile(
f"{RELAY_BUFFER_OUTGOING_F_DIR}/{sub_dir}/{RELAY_BUFFER_OUTGOING_FILE}.0"
))
self.assertTrue(
os.path.isfile(
f"{RELAY_BUFFER_OUTGOING_F_DIR}/{sub_dir}/{RELAY_BUFFER_OUTGOING_FILE}.1"
))
def test_unknown_account_raises_fr(self):
# Setup
cmd_data = nick_to_pub_key("Bob") + b'Bob_'
# Test
trunc_addr = nick_to_short_address('Bob')
self.assert_fr(f"Error: Receiver has no contact '{trunc_addr}' to rename.", ch_nick, cmd_data, *self.args)
def setUp(self):
self.unittest_dir = cd_unittest()
self.win_name = nick_to_pub_key("Alice")
self.contact_list = ContactList()
self.group_list = GroupList()
self.settings = Settings()
self.master_key = MasterKey()
def test_setting_change_all(self) -> None:
# Setup
self.window = self.window_list.get_window(nick_to_pub_key("Bob"))
self.window.type = WIN_TYPE_CONTACT
self.window.type_print = 'contact'
self.window.window_contacts = self.contact_list.contacts
# Test
for attr, header in [('log_messages', CH_LOGGING),
('notifications', CH_NOTIFY),
('file_reception', CH_FILE_RECV)]:
for s in [ENABLE, ENABLE, DISABLE, DISABLE]:
cmd_data = s.upper() + US_BYTE
self.assertIsNone(ch_contact_s(cmd_data, *self.args, header))
if header in [CH_LOGGING, CH_NOTIFY]:
for c in self.contact_list.get_list_of_contacts():
self.assertEqual(c.__getattribute__(attr),
(s == ENABLE))
for g in self.group_list.groups:
self.assertEqual(g.__getattribute__(attr),
(s == ENABLE))
if header == CH_FILE_RECV:
for c in self.contact_list.get_list_of_contacts():
self.assertEqual(c.__getattribute__(attr),
(s == ENABLE))
def test_master_key_change(self, *_) -> None:
# Setup
write_log_entry(F_S_HEADER + bytes(PADDING_LENGTH), nick_to_pub_key("Alice"), self.tfc_log_database)
self.contact_list.file_name = f'{DIR_USER_DATA}{RX}_contacts'
self.group_list.file_name = f'{DIR_USER_DATA}{RX}_groups'
self.key_list.file_name = f'{DIR_USER_DATA}{RX}_keys'
self.settings.file_name = f'{DIR_USER_DATA}{RX}_settings'
self.contact_list.database = TFCDatabase(self.contact_list.file_name, self.contact_list.master_key)
self.group_list.database = TFCDatabase(self.group_list.file_name, self.group_list.master_key)
self.key_list.database = TFCDatabase(self.key_list.file_name, self.group_list.master_key)
self.settings.database = TFCDatabase(self.settings.file_name, self.settings.master_key)
orig_cl_rd = self.contact_list.database.replace_database
orig_gl_rd = self.group_list.database.replace_database
orig_kl_rd = self.key_list.database.replace_database
orig_st_rd = self.settings.database.replace_database
self.contact_list.database.replace_database = lambda: None
self.group_list.database.replace_database = lambda: None
self.key_list.database.replace_database = lambda: None
self.settings.database.replace_database = lambda: None
# Test
self.assertEqual(self.master_key.master_key, bytes(SYMMETRIC_KEY_LENGTH))
self.assertIsNone(ch_master_key(*self.args))
self.assertNotEqual(self.master_key.master_key, bytes(SYMMETRIC_KEY_LENGTH))
# Teardown
self.contact_list.database.replace_database = orig_cl_rd
self.group_list.database.replace_database = orig_gl_rd
self.key_list.database.replace_database = orig_kl_rd
self.settings.database.replace_database = orig_st_rd
def setUp(self):
self.settings = Settings()
self.queues = gen_queue_dict()
self.window = TxWindow(uid=nick_to_pub_key("Alice"),
log_messages=True)
self.window.window_contacts = [create_contact('Alice')]
self.args = self.settings, self.queues, self.window
def test_public_key_datagram(self) -> None:
# Setup
packet = self.create_packet(PUBLIC_KEY_DATAGRAM_HEADER + nick_to_pub_key('bob') + TFC_PUBLIC_KEY_LENGTH * b'a')
self.queues[GATEWAY_QUEUE].put((self.ts, packet))
# Test
self.assertIsNone(src_incoming(*self.args, unit_test=True))
def setUp(self):
self.unittest_dir = cd_unittest()
self.ts = datetime.now()
self.window_list = WindowList()
self.cmd_data = nick_to_pub_key("Bob")
self.settings = Settings()
self.master_key = MasterKey()
self.args = self.cmd_data, self.ts, self.window_list
def setUp(self):
self.ts = datetime.now()
self.contact_list = ContactList(nicks=['Alice'])
self.window_list = WindowList(contact_list=self.contact_list)
self.group_list = GroupList()
self.args = self.ts, self.window_list, self.contact_list
self.window = self.window_list.get_window(nick_to_pub_key("Alice"))
self.window.type = WIN_TYPE_CONTACT
def test_master_key_change(self, *_):
# Setup
write_log_entry(F_S_HEADER + bytes(PADDING_LENGTH), nick_to_pub_key("Alice"), self.settings, self.master_key)
# Test
self.assertEqual(self.master_key.master_key, bytes(SYMMETRIC_KEY_LENGTH))
self.assertIsNone(ch_master_key(*self.args))
self.assertNotEqual(self.master_key.master_key, bytes(SYMMETRIC_KEY_LENGTH))
def test_cancel_group_message_during_normal(self):
# Setup
user_input = UserInput('cm')
settings = Settings()
window = TxWindow(name='test_group',
type=WIN_TYPE_GROUP,
type_print='group',
uid='test_group')
window.window_contacts = [create_contact('Alice')]
self.queues[MESSAGE_PACKET_QUEUE].put(('test_message1', nick_to_pub_key("Alice"), False, False, 'test_group'))
self.queues[MESSAGE_PACKET_QUEUE].put(('test_message2', nick_to_pub_key("Alice"), False, False, 'test_group'))
# Test
self.assert_fr("Cancelled queued messages to group test_group.",
cancel_packet, user_input, window, settings, self.queues)
self.assertEqual(self.queues[MESSAGE_PACKET_QUEUE].qsize(), 1) # Cancel packet
