def init():
lg.out(4, "message_keeper.init")
message.AddIncomingMessageCallback(on_incoming_message)
message.AddOutgoingMessageCallback(on_outgoing_message)
if not my_keys.is_key_registered(messages_key_id()):
my_keys.generate_key(messages_key_id(),
key_size=settings.getPrivateKeySize())
def test():
lg.set_debug_level(24)
init()
my_keys.generate_key('[email protected]')
# copy [email protected]'s key to [email protected] in ~/.bitdust/keys/
open_queue('event-test123&[email protected]&[email protected]')
add_producer('*****@*****.**')
connect_producer('*****@*****.**',
'event-test123&[email protected]&[email protected]')
start_event_publisher('*****@*****.**', 'test123')
add_consumer('*****@*****.**')
add_callback_method('*****@*****.**', _test_callback_bob)
subscribe_consumer(
'*****@*****.**',
'event-test123&[email protected]&[email protected]')
add_consumer('*****@*****.**')
add_callback_method('*****@*****.**', _test_callback_dave)
subscribe_consumer(
'*****@*****.**',
'event-test123&[email protected]&[email protected]')
events.send('test123', data=dict(abc='abc', counter=0))
events.send('test123', data=dict(abc='abc', counter=2))
events.send('test123', data=dict(abc='abc', counter=4))
events.send('test123', data=dict(abc='abc', counter=1))
events.send('test123', data=dict(abc='abc', counter=6))
events.send('test123', data=dict(abc='abc', counter=23))
events.send('test123', data=dict(abc='abc', counter=620))
events.send('test123', data=dict(abc='abc', counter=20))
events.send('test123', data=dict(abc='abc', counter=30))
events.send('test123', data=dict(abc='abc', counter=40))
reactor.run()
def _on_my_keys_synchronized(self, evt):
from logs import lg
from main import settings
from storage import keys_synchronizer
from crypt import my_keys
from chat import message_keeper
if not my_keys.is_key_registered(message_keeper.messages_key_id(
)) and keys_synchronizer.is_synchronized():
lg.info(
'key to store messages was not found but we know that all my keys are in sync, generate a new key: %s'
% message_keeper.messages_key_id())
my_keys.generate_key(message_keeper.messages_key_id(),
key_size=settings.getPrivateKeySize())
def test_regression(self):
lg.set_debug_level(30)
for i in range(3):
key_id = 'test_key_%[email protected]_8084' % i
my_keys.erase_key(key_id, keys_folder='/tmp/')
my_keys.generate_key(key_id, key_size=1024, keys_folder='/tmp/')
is_valid = my_keys.validate_key(my_keys.key_obj(key_id))
if not is_valid:
print(key_id)
print(my_keys.get_private_key_raw(key_id))
else:
my_keys.erase_key(key_id, keys_folder='/tmp/')
self.assertTrue(is_valid)
def _on_my_keys_synchronized(self, evt):
from logs import lg
from main import settings
from storage import keys_synchronizer
from crypt import my_keys
from userid import my_id
customer_key_id = my_id.getGlobalID(key_alias='customer')
if not my_keys.is_key_registered(
customer_key_id) and keys_synchronizer.is_synchronized():
lg.info(
'customer key was not found but we know that all keys are in sync, generate new key: %s'
% customer_key_id)
my_keys.generate_key(customer_key_id,
key_size=settings.getPrivateKeySize())
def test_regression(self):
from logs import lg
from crypt import my_keys
lg.set_debug_level(30)
for i in range(3):
key_id = 'test_key_%d' % i
my_keys.erase_key(key_id, keys_folder='/tmp/')
my_keys.generate_key(key_id, key_size=1024, keys_folder='/tmp/')
is_valid = my_keys.validate_key(my_keys.key_obj(key_id))
if not is_valid:
print(key_id)
print(my_keys.get_private_key_raw(key_id))
else:
my_keys.erase_key(key_id, keys_folder='/tmp/')
self.assertTrue(is_valid)
def start(self):
from contacts import contactsdb
from crypt import my_keys
from customer import supplier_connector
from userid import my_id
from logs import lg
customer_key_id = my_id.getGlobalID(key_alias='customer')
if not my_keys.is_key_registered(customer_key_id):
lg.warn('customer key was not found, generate new key: %s' % customer_key_id)
my_keys.generate_key(customer_key_id)
for supplier_idurl in contactsdb.suppliers():
if supplier_idurl and not supplier_connector.by_idurl(supplier_idurl, customer_idurl=my_id.getLocalID()):
supplier_connector.create(supplier_idurl, customer_idurl=my_id.getLocalID())
# TODO: read from dht and connect to other suppliers - from other customers who shared data to me
return True
def generate_group_key(creator_id=None, label=None, key_size=4096):
group_key_id = None
group_alias = None
while True:
random_sample = os.urandom(24)
group_alias = 'group_%s' % strng.to_text(key.HashMD5(random_sample, hexdigest=True))
group_key_id = my_keys.make_key_id(alias=group_alias, creator_glob_id=creator_id)
if my_keys.is_key_registered(group_key_id):
continue
break
if not label:
label = 'group%s' % utime.make_timestamp()
my_keys.generate_key(key_id=group_key_id, label=label, key_size=key_size)
my_keys.sign_key(key_id=group_key_id)
if _Debug:
lg.args(_DebugLevel, group_key_id=group_key_id, group_alias=group_alias, creator_id=creator_id, label=label)
return group_key_id
