def test_komlogsession_creation_privkey_modification_not_allowed(self): ''' username cannot be modified on la KomlogSession object ''' username = '******' privkey = crypto.generate_rsa_key() s = session.KomlogSession(username=username, privkey=privkey) with self.assertRaises(exceptions.BadParametersException) as cm: s.privkey = crypto.generate_rsa_key() self.assertEqual(cm.exception.msg, 'private key modification not allowed')
def test_validate_privkey_failure(self): ''' validate_privkey should raise a TypeError exception if value is not a private key ''' values = [ None, ' not valid ', '..not_valid', 'not..valid', 'ññ', 'uri\n', 'uri\t', 'uri\r', 121, 323.1231, decimal.Decimal('23'), ['a', 'list'], {'set'}, ('a', 'tuple'), { 'a': 'dict' }, crypto.generate_rsa_key(key_size=2048) #min valid size is 4096 ] for value in values: with self.assertRaises(TypeError) as cm: validation.validate_privkey(value) self.assertEqual(str(cm.exception), 'Invalid private key')
def test_encrypt_failure_invalid_plaintext(self): ''' encrypt should fail if pubkey is not valid bytes encoded text ''' privkey = crypto.generate_rsa_key() pubkey = privkey.public_key() plaintext = 'text to encrypt is a string' with self.assertRaises(TypeError) as cm: crypto.encrypt(pubkey, plaintext)
def test_sign_message_success(self): ''' sign_message should return the message signed ''' privkey = crypto.generate_rsa_key() message = b64encode('message'.encode()).decode() signed = crypto.sign_message(privkey, message) self.assertIsNotNone(signed) self.assertTrue(isinstance(signed, str))
def test_komlogsession_creation_failure_invalid_username(self): ''' creating a KomlogSession object should fail if user is invalid ''' username = '******' privkey = crypto.generate_rsa_key() with self.assertRaises(exceptions.BadParametersException) as cm: session.KomlogSession(username=username, privkey=privkey) self.assertEqual(cm.exception.msg, 'Invalid username {}'.format(str(username)))
def test_unregister_session(self): ''' unregistering a session should add the session to the session list ''' username = '******' privkey = crypto.generate_rsa_key() s = session.KomlogSession(username, privkey) self.assertTrue(s in sessionIndex.sessions) self.assertTrue(sessionIndex.unregister_session(s.sid)) self.assertFalse(s in sessionIndex.sessions)
def test_decrypt_success(self): ''' decrypt should succeed ''' privkey = crypto.generate_rsa_key() pubkey = privkey.public_key() text = 'text to encrypt'.encode() ciphertext = crypto.encrypt(pubkey, text) self.assertEqual( crypto.decrypt(privkey=privkey, ciphertext=ciphertext), text)
def test_store_keys_failure_no_permission_to_create_public_file(self): ''' store_keys should fail if process has no permission to create public file ''' privkey = crypto.generate_rsa_key() privkey_file = '/tmp/test_store_keys_failure_permission_to_create_public_file.priv' pubkey_file = '/root/test_store_keys_failure_permission_to_create_public_file.pub' with self.assertRaises(OSError) as cm: crypto.store_keys(privkey, privkey_file, pubkey_file) self.assertEqual(cm.exception.errno, 13) self.assertFalse(os.path.isfile(privkey_file)) self.assertFalse(os.path.isfile(pubkey_file))
def test_get_session_sid_None(self): ''' get_session should return the first session if sid is None ''' username = '******' privkey = crypto.generate_rsa_key() sessionIndex.sessions = [] s1 = session.KomlogSession(username, privkey) self.assertTrue(s1 in sessionIndex.sessions) s2 = session.KomlogSession(username, privkey) self.assertTrue(s2 in sessionIndex.sessions) ss = sessionIndex.get_session() self.assertEqual(s1,ss)
def test_register_session_only_add_the_session_once(self): ''' creating a session should add it to the sessionIndex automatically ''' username = '******' privkey = crypto.generate_rsa_key() sessionIndex.sessions = [] s = session.KomlogSession(username, privkey) self.assertTrue(s in sessionIndex.sessions) self.assertEqual(len(sessionIndex.sessions),1) self.assertTrue(sessionIndex.register_session(s)) self.assertTrue(s in sessionIndex.sessions) self.assertEqual(len(sessionIndex.sessions),1)
async def test_hook_to_metric_failure_invalid_response(self): ''' hook_to_metric should fail if we receive and unknown response ''' username1 = 'username1' privkey1 = crypto.generate_rsa_key() session1 = KomlogSession(username=username1, privkey=privkey1) session1.send_message = test.AsyncMock(return_value=None) metric = Datasource('my_ds', session=session1) response = await prproc.hook_to_metric(metric) self.assertEqual(session1.send_message.call_count, 1) self.assertEqual(response['hooked'], False) self.assertEqual(response['exists'], False) sessionIndex.unregister_session(session1.sid)
def test_get_session_sid(self): ''' get_session should return the session with sid ''' username = '******' privkey = crypto.generate_rsa_key() s1 = session.KomlogSession(username, privkey) self.assertTrue(s1 in sessionIndex.sessions) s2 = session.KomlogSession(username, privkey) self.assertTrue(s2 in sessionIndex.sessions) ss = sessionIndex.get_session(s1.sid) self.assertEqual(ss,s1) ss = sessionIndex.get_session(s2.sid) self.assertEqual(ss,s2)
async def test_request_data_failure_unknown_response(self): ''' request_data should fail if we receive and unknown response ''' username1 = 'username1' privkey1 = crypto.generate_rsa_key() session1 = KomlogSession(username=username1, privkey=privkey1) session1.send_message = test.AsyncMock(return_value=None) start = TimeUUID(100) end = TimeUUID(300) count = 10 metric = Datasource('my_ds', session=session1) response = await prproc.request_data(metric, start, end, count) self.assertEqual(session1.send_message.call_count, 1) self.assertEqual(response['success'], False) self.assertEqual(response['error'], 'Unknown response') sessionIndex.unregister_session(session1.sid)
def get_private_key(): privkey_file = config.config.key if not os.path.isfile(privkey_file): logging.logger.debug('Generating RSA keys...') key_dir=os.path.dirname(privkey_file) pubkey_file=os.path.join(key_dir,defaults.RSA_PUB_KEY) privkey=crypto.generate_rsa_key() crypto.store_keys(privkey=privkey, privkey_file=privkey_file, pubkey_file=pubkey_file) logging.logger.debug('Keys stored successfully on disk') pubkey=privkey.public_key() key_str=crypto.get_printable_pubkey(pubkey) logging.logger.info('This is the public key, add it to your Komlog account:\n'+key_str) return privkey else: privkey=crypto.load_private_key(privkey_file) return privkey
def test_load_private_key_failure_public_key_filename_passed(self): ''' load_private_key should fail if we pass the public key file instead of the private one ''' random_string = ''.join( random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(10)) privkey_file = os.path.join('/tmp/', random_string + '.priv') pubkey_file = os.path.join('/tmp/', random_string + '.pub') privkey = crypto.generate_rsa_key() pubkey_generated = privkey.public_key() crypto.store_keys(privkey=privkey, privkey_file=privkey_file, pubkey_file=pubkey_file) with self.assertRaises(ValueError) as cm: loadedkey = crypto.load_private_key(pubkey_file) os.remove(privkey_file) os.remove(pubkey_file)
async def test_process_message_send_data_interval_success_dp_data(self): ''' process_message_send_data_interval should store contents in session store ''' username = '******' privkey = crypto.generate_rsa_key() uri = 'my_datapoint' m_type = Metrics.DATAPOINT start = TimeUUID(1) end = TimeUUID(3000) data_json = json.dumps([(TimeUUID(i).hex, i) for i in range(1, 100)]) data = json.loads(data_json) session = KomlogSession(username=username, privkey=privkey) msg = messages.SendDataInterval(uri, m_type, start, end, data) self.assertIsNone( prmsg.process_message_send_data_interval(msg, session)) for d in data: smp = Sample(Datapoint(uri, session), TimeUUID(s=d[0]), d[1]) self.assertTrue(session.store.is_in(smp.metric, smp.t, smp.value)) sessionIndex.unregister_session(session.sid)
def test_load_public_key_success(self): ''' load_public_key should succeed and return the public key ''' random_string = ''.join( random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(10)) privkey_file = os.path.join('/tmp/', random_string + '.priv') pubkey_file = os.path.join('/tmp/', random_string + '.pub') privkey = crypto.generate_rsa_key() pubkey_generated = privkey.public_key() crypto.store_keys(privkey=privkey, privkey_file=privkey_file, pubkey_file=pubkey_file) pubkey_loaded = crypto.load_public_key(pubkey_file) os.remove(privkey_file) os.remove(pubkey_file) self.assertIsNotNone(pubkey_loaded) self.assertEqual(crypto.serialize_public_key(pubkey_generated), crypto.serialize_public_key(pubkey_loaded))
def test_komlogsession_creation_success(self): username = '******' privkey = crypto.generate_rsa_key() s = session.KomlogSession(username=username, privkey=privkey) s2 = sessionIndex.get_session(sid=s.sid) self.assertEqual(s, s2)
def test_get_printable_pubkey_success(self): ''' get_printable_pubkey should return the string serialization of the public key ''' privkey = crypto.generate_rsa_key() pubkey = privkey.public_key() self.assertIsNotNone(crypto.get_printable_pubkey(pubkey))
def test_register_session_automatically_when_session_is_created(self): ''' creating a session should add it to the sessionIndex automatically ''' username = '******' privkey = crypto.generate_rsa_key() s = session.KomlogSession(username, privkey) self.assertTrue(s in sessionIndex.sessions)
def test_generate_rsa_key_success(self): ''' generate_rsa_key should return a RSAPrivateKey object with size 4096 ''' privkey = crypto.generate_rsa_key() self.assertTrue(isinstance(privkey, rsa.RSAPrivateKey)) self.assertEqual(privkey.key_size, 4096)
def test_process_challenge_failure_invalid_challenge(self): ''' process_challenge should return None if challenge received cannot be decrypted ''' privkey = crypto.generate_rsa_key() challenge = b64encode('challenge'.encode()).decode() with self.assertRaises(ValueError) as cm: crypto.process_challenge(privkey, challenge)
async def test_send_samples_success(self): ''' send_samples should create messages and send through the sessions to Komlog ''' username1 = 'username1' privkey1 = crypto.generate_rsa_key() username2 = 'username2' privkey2 = crypto.generate_rsa_key() session1 = KomlogSession(username=username1, privkey=privkey1) session2 = KomlogSession(username=username2, privkey=privkey2) session1.send_message = test.AsyncMock(return_value=None) session2.send_message = test.AsyncMock(return_value=None) t_common = TimeUUID() t1 = TimeUUID() t2 = TimeUUID() samples_s1 = [ Sample(Datasource('datasource1', session=session1), t_common, 'value'), Sample(Datasource('datasource2', session=session1), t_common, 'value'), Sample(Datasource('datasource3', session=session1), t_common, 'value'), Sample(Datasource('datasource4', session=session1), t_common, 'value'), Sample(Datapoint('datapoint1', session=session1), t_common, 1), Sample(Datapoint('datapoint2', session=session1), t_common, 1), Sample(Datapoint('datapoint3', session=session1), t_common, 1), Sample(Datapoint('datapoint4', session=session1), t_common, 1), Sample(Datasource('datasource5', session=session1), t1, 'value'), Sample(Datapoint('datapoint5', session=session1), t2, 1), ] samples_s2 = [ Sample(Datasource('datasource1', session=session2), t_common, 'value'), Sample(Datasource('datasource2', session=session2), t_common, 'value'), Sample(Datasource('datasource3', session=session2), t_common, 'value'), Sample(Datasource('datasource4', session=session2), t_common, 'value'), Sample(Datapoint('datapoint1', session=session2), t_common, 1), Sample(Datapoint('datapoint2', session=session2), t_common, 1), Sample(Datapoint('datapoint3', session=session2), t_common, 1), Sample(Datapoint('datapoint4', session=session2), t_common, 1), Sample(Datasource('datasource5', session=session2), t1, 'value'), Sample(Datapoint('datapoint5', session=session2), t2, 1), ] total_samples = [] for smp in samples_s1: total_samples.append(smp) for smp in samples_s2: total_samples.append(smp) response = await prproc.send_samples(total_samples) self.assertEqual(session1.send_message.call_count, 3) self.assertEqual(session2.send_message.call_count, 3) self.assertEqual(response['success'], False) self.assertEqual(len(response['errors']), 6) for i, m in enumerate(response['errors']): self.assertEqual(m['success'], False) self.assertEqual(m['error'], 'Unexpected message type') msg = m['msg'] if i == 0: self.assertTrue(isinstance(msg, messages.SendMultiData)) self.assertEqual(msg.t, t_common) self.assertEqual(msg.uris, [{ 'uri': s.metric.uri, 'type': s.metric._m_type_, 'content': s.value } for s in samples_s1[:-2]]) elif i == 1: self.assertTrue(isinstance(msg, messages.SendDsData)) self.assertEqual(msg.uri, samples_s1[-2].metric.uri) self.assertEqual(msg.t, samples_s1[-2].t) self.assertEqual(msg.content, samples_s1[-2].value) elif i == 2: self.assertTrue(isinstance(msg, messages.SendDpData)) self.assertEqual(msg.uri, samples_s1[-1].metric.uri) self.assertEqual(msg.t, samples_s1[-1].t) self.assertEqual(msg.content, samples_s1[-1].value) elif i == 3: self.assertTrue(isinstance(msg, messages.SendMultiData)) self.assertEqual(msg.t, t_common) self.assertEqual(msg.uris, [{ 'uri': s.metric.uri, 'type': s.metric._m_type_, 'content': s.value } for s in samples_s2[:-2]]) elif i == 4: self.assertTrue(isinstance(msg, messages.SendDsData)) self.assertEqual(msg.uri, samples_s2[-2].metric.uri) self.assertEqual(msg.t, samples_s2[-2].t) self.assertEqual(msg.content, samples_s2[-2].value) elif i == 5: self.assertTrue(isinstance(msg, messages.SendDpData)) self.assertEqual(msg.uri, samples_s2[-1].metric.uri) self.assertEqual(msg.t, samples_s2[-1].t) self.assertEqual(msg.content, samples_s2[-1].value) sessionIndex.unregister_session(session1.sid) sessionIndex.unregister_session(session2.sid)
def test_sign_message_failure_invalid_message(self): ''' sign_message should return None if message is not a string ''' privkey = crypto.generate_rsa_key() message = 234234234234 with self.assertRaises(AttributeError) as cm: crypto.sign_message(privkey, message)
def test_encrypt_success(self): ''' encrypt should succeed ''' privkey = crypto.generate_rsa_key() pubkey = privkey.public_key() plaintext = 'text to encrypt is bytes encoded'.encode() self.assertIsNotNone(crypto.encrypt(pubkey, plaintext))
def test_validate_privkey_success(self): ''' validate_privkey should raise a TypeError exception if value is a valid private key ''' privkey = crypto.generate_rsa_key() self.assertTrue(validation.validate_privkey(privkey))
def test_decrypt_failure_invalid_ciphertext(self): ''' decrypt should fail if ciphertext is not of type bytes ''' privkey = crypto.generate_rsa_key() ciphertext = 'string type' with self.assertRaises(ValueError) as cm: crypto.decrypt(privkey=privkey, ciphertext=ciphertext)
def test_serialize_private_key_success(self): ''' serialize_private_key should succeed if we pass a valid private key ''' privkey = crypto.generate_rsa_key() self.assertIsNotNone(crypto.serialize_private_key(privkey))
def test_serialize_private_key_failure_public_key_passed(self): ''' serialize_private_key should fail if key parameter is not the private key but the public one ''' privkey = crypto.generate_rsa_key() pubkey = privkey.public_key() with self.assertRaises(AttributeError) as cm: crypto.serialize_private_key(pubkey)
async def test_process_message_send_multi_data_success_no_notify_already_stored_values( self): ''' process_message_send_multi_data should store contents and notify tmIndex ''' try: username = '******' privkey = crypto.generate_rsa_key() t = TimeUUID() uris = [{ 'uri': 'datasource1', 'type': Metrics.DATASOURCE.value, 'content': 'ds data' }, { 'uri': 'datasource2', 'type': Metrics.DATASOURCE.value, 'content': 'ds data' }, { 'uri': 'datasource3', 'type': Metrics.DATASOURCE.value, 'content': 'ds data' }, { 'uri': 'datasource4', 'type': Metrics.DATASOURCE.value, 'content': 'ds data' }, { 'uri': 'datapoint1', 'type': Metrics.DATAPOINT.value, 'content': '1232' }, { 'uri': 'datapoint2', 'type': Metrics.DATAPOINT.value, 'content': '1233' }, { 'uri': 'datapoint3', 'type': Metrics.DATAPOINT.value, 'content': '1234' }, { 'uri': 'datapoint4', 'type': Metrics.DATAPOINT.value, 'content': '1235' }] msg = messages.SendMultiData(t, uris) session = KomlogSession(username=username, privkey=privkey) bck = tmIndex.metrics_updated tmIndex.metrics_updated = Mock(return_value=None) self.assertIsNone( prmsg.process_message_send_multi_data(msg, session)) metrics = [ Datasource('datasource1', session=session), Datasource('datasource2', session=session), Datasource('datasource3', session=session), Datasource('datasource4', session=session), Datapoint('datapoint1', session=session), Datapoint('datapoint2', session=session), Datapoint('datapoint3', session=session), Datapoint('datapoint4', session=session) ] for uri in uris: if uri['type'] == Metrics.DATASOURCE.value: smp = Sample(Datasource(uri['uri'], session=session), t, uri['content']) else: smp = Sample(Datapoint(uri['uri'], session=session), t, uri['content']) self.assertTrue( session.store.is_in(smp.metric, smp.t, smp.value)) self.assertEqual(tmIndex.metrics_updated.call_args[1]['t'], t) self.assertEqual(tmIndex.metrics_updated.call_args[1]['metrics'], metrics) updated_uris = [{ 'uri': 'datasource1', 'type': Metrics.DATASOURCE.value, 'content': 'ds data' }, { 'uri': 'datasource2', 'type': Metrics.DATASOURCE.value, 'content': 'ds data2' }, { 'uri': 'datasource3', 'type': Metrics.DATASOURCE.value, 'content': 'ds data' }, { 'uri': 'datasource4', 'type': Metrics.DATASOURCE.value, 'content': 'ds data' }, { 'uri': 'datasource5', 'type': Metrics.DATASOURCE.value, 'content': 'ds data' }, { 'uri': 'datapoint1', 'type': Metrics.DATAPOINT.value, 'content': '1233' }, { 'uri': 'datapoint2', 'type': Metrics.DATAPOINT.value, 'content': '1234' }, { 'uri': 'datapoint3', 'type': Metrics.DATAPOINT.value, 'content': '1234' }, { 'uri': 'datapoint4', 'type': Metrics.DATAPOINT.value, 'content': '1235' }, { 'uri': 'datapoint5', 'type': Metrics.DATAPOINT.value, 'content': '1235' }] msg = messages.SendMultiData(t, updated_uris) updated_metrics = [ Datasource('datasource2', session=session), Datasource('datasource5', session=session), Datapoint('datapoint1', session=session), Datapoint('datapoint2', session=session), Datapoint('datapoint5', session=session) ] self.assertIsNone( prmsg.process_message_send_multi_data(msg, session)) for uri in updated_uris: if uri['type'] == Metrics.DATASOURCE.value: smp = Sample(Datasource(uri['uri']), t, uri['content']) else: smp = Sample(Datapoint(uri['uri']), t, uri['content']) self.assertTrue( session.store.is_in(smp.metric, smp.t, smp.value)) self.assertEqual(tmIndex.metrics_updated.call_args[1]['t'], t) self.assertEqual(tmIndex.metrics_updated.call_args[1]['metrics'], updated_metrics) sessionIndex.unregister_session(session.sid) tmIndex.metrics_updated = bck except: tmIndex.metrics_updated = bck raise