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
