updates

komrade/backend/crypt.py

@@ -49,7 +49,7 @@ class Crypt(Logger):
             super().log(*x)
         
     def hash(self,binary_data):
-        return hashlib.sha256(binary_data + self.secret).hexdigest()
+        return b64encode(hashlib.sha256(binary_data + self.secret).hexdigest().encode()).decode()
         # return zlib.adler32(binary_data)
 
     def force_binary(self,k_b):
@@ -66,15 +66,17 @@ class Crypt(Logger):
 
     def package_val(self,k):
         k_b = self.force_binary(k)
-        if self.cell is not None: k_b = self.cell.encrypt(k_b)
+        if self.cell is not None:
-        return k_b
+            k_b = self.cell.encrypt(k_b)
+        return b64encode(k_b)
 
     def unpackage_val(self,k_b):
         try:
-            if self.cell is not None: k_b = self.cell.decrypt(k_b)
+            if self.cell is not None:
+                k_b = self.cell.decrypt(k_b)
+            return b64decode(k_b)
         except ThemisError:
             pass
-        return k_b
 
     def has(self,k,prefix=''):
         k_b=self.package_key(k,prefix=prefix)
@@ -94,8 +96,19 @@ class Crypt(Logger):
         k_b=self.package_key(k,prefix=prefix)
         k_b_hash = self.hash(k_b)
         v_b=self.package_val(v)
-        self.log(f'set(\n\t{prefix}{k},\n\t{k_b}\n\t{k_b_hash}\n\t\n\t{v_b}\n)\n')
+        self.log(f'''
-
+Crypt.set(
+    prefix = {prefix},
+    
+    k = {k},
+    
+    k_b = {k_b},
+    
+    k_hash = {k_b_hash},
+    
+    val={v_b}
+)')
+        ''')
         # store
         self.store.put(k_b_hash,v_b)
         return True

komrade/backend/keymaker.py

@@ -273,36 +273,41 @@ class Keymaker(Logger):
                         keys_to_return = KEYMAKER_DEFAULT_KEYS_TO_SAVE_ON_CLIENT,
                         keys_to_gen = KEYMAKER_DEFAULT_KEYS_TO_GEN,
                         key_types = KEYMAKER_DEFAULT_KEY_TYPES):
-        self.log('forging new keys...',name,self.name)
+        # setup
-        self.log('keys_to_save:',keys_to_save)
-        self.log('keys_to_return',keys_to_return)
-        
-        # name
-        if not name: name=self.name
-
         keys_to_gen = set(keys_to_gen) | set(keys_to_save) | set(keys_to_return)
         keys_to_gen = sorted(list(keys_to_gen),key=lambda x: x.count('_'))
-        self.log('keys_to_gen =',keys_to_gen)
         key_types = dict([(k,key_types[k]) for k in keys_to_gen])
-        self.log('key_types =',key_types)
+        if not name: name=self.name
+
+        # show user what's happening
+        self.log(f'''
+Keymaker ({self}) is forging new keys for {name}
+    I will save these keys in this crypt:
+        {keys_to_save}
+    I will also save this user's pubkey (as b64 URI) to:
+        {self.get_path_qrcode(name=name)}
+    I will return these keys to you:
+        {keys_to_return}
+    which means I will end up generating these keys:
+        {keys_to_gen}
+    I will also be using these key types to do so:
+        {dict_format(key_types,tab=4)}
+        ''')
+        
 
         # get decryptor keys!
         keychain = self.gen_keys_from_types(key_types,passphrase=passphrase)
-        self.log('keychain 1 =',keychain)
+        self.log('I built this keychain!',dict_format(keychain,tab=2))
-        
-        # gen encrypted keys!
-        keychain = self.gen_encr_keys(keychain,keys_to_gen,passphrase=passphrase)
-        self.log('keychain 2 =',keychain)
         
         # save keys!
         # get URI id to save under (except for pubkeys, accessible by name)
-        uri_id,keys_saved,keychain = self.save_keychain(name,keychain,keys_to_save)
+        uri_id,keys_saved_d,keychain = self.save_keychain(name,keychain,keys_to_save)
-        self.log('uri_id =',uri_id)
+        self.log('I saved this keychain:',dict_format(keys_saved_d,tab=2),'using the generated-from-pubkey URI ID',uri_id)
-        self.log('keys_saved =',keys_saved)
-        self.log('keychain =',keychain)
 
         # return keys!
         keys_returned = self.return_keychain(keychain,keys_to_return)
+        self.log('I am returning this keychain:',dict_format(keys_returned,tab=2))
+
         return (uri_id,keys_returned)
         
                 
@@ -314,23 +319,28 @@ class Keymaker(Logger):
                 keychain_toreturn[key]=keychain[key]
         return keychain_toreturn
 
-    def save_uri_as_qrcode(self,name=None,uri_id=None,odir=None):
+    def get_path_qrcode(self,name=None,dir=None,ext='.png'):
-        if not uri_id: uri_id = get_random_id() + get_random_id()
+        if not name: name=self.name
-        uri_id = self.uri_id
+        if not dir: dir = PATH_QRCODES
+        fnfn = os.path.join(dir,name+ext)
+        return fnfn
+
+    def save_uri_as_qrcode(self,uri_id=None,name=None):
+        if not uri_id: uri_id = self.uri_id
         if not uri_id and not self.uri_id: raise KomradeException('Need URI id to save!')
+        if not name: name=self.name
 
         # gen
         import pyqrcode
         qr = pyqrcode.create(uri_id)
-        if not odir: odir = PATH_QRCODES
+        ofnfn = self.get_path_qrcode(name=name)
-        ofnfn = os.path.join(odir,self.name+'.png')
         qr.png(ofnfn,scale=5)
         self.log('>> saved:',ofnfn)
 
     def save_keychain(self,name,keychain,keys_to_save=None,uri_id=None):
         if not keys_to_save: keys_to_save = list(keychain.keys())
         if not uri_id: uri_id = b64encode(keychain['pubkey'].data).decode() #uri_id = get_random_id() + get_random_id()
-        self.log(f'SAVING KEYCHAIN FOR {name} under URI {uri_id}')
+        # self.log(f'SAVING KEYCHAIN FOR {name} under URI {uri_id}')
         self._uri_id = uri_id
         # filter for transfer
         for k,v in keychain.items():
@@ -352,7 +362,10 @@ class Keymaker(Logger):
         # save pubkey as QR
         if not 'pubkey' in keys_saved_d:
             self.log('did not save pubkey in crypt, storing as QR...')
-            self.save_uri_as_qrcode(name=name, uri_id=uri_id, odir=PATH_QRCODES)
+            self.save_uri_as_qrcode(name=name, uri_id=uri_id)
+
+        # set to my keychain right away
+        self._keychain = keychain
 
         return (uri_id,keys_saved_d,keychain)
 

komrade/backend/messages.py

@@ -89,7 +89,7 @@ class Message(Logger):
             return (self._from_whom,self._to_whom) 
         alleged_from_whom = self.get_whom(self.from_name)
         alleged_to_whom = self.get_whom(self.to_name)
-        if not self.whom_records_match(alleged_from_whom,alleged_to_whom):
+        if alleged_to_whom and not self.whom_records_match(alleged_from_whom,alleged_to_whom):
             raise KomradeException('Records of from_whoms on The Operator and the from_whom do not match. Something fishy going on?')
         else:
             self._from_whom = alleged_from_whom

komrade/backend/operators.py

@@ -121,7 +121,7 @@ class Operator(Keymaker):
         # unpackage from transmission
         msg_d = pickle.loads(msg_b)
         # get message obj
-        print('unsealed msg:',msg_d)
+        # print('unsealed msg:',msg_d)
         from komrade.backend.messages import Message
         msg_obj = Message(msg_d,from_whom=from_whom,to_whom=to_whom)
         # decrypt msg
@@ -182,7 +182,7 @@ class Operator(Keymaker):
         # are there instructions for us?
         if msg_obj.route:
             # get result from routing
-            self.log(f'routing msg to self.{msg_obj.route}(**{msg_obj.data})')
+            self.log(f'routing msg to self.{msg_obj.route}(**{dict_format(msg_obj.data)})')
             return self.route(msg_obj)
 
         # can we pass the buck on?

komrade/backend/people.py

@@ -62,7 +62,33 @@ class Persona(Caller):
         self.log(f'my new uri is {uri_id} and I got new keys!: {dict_format(keys_returned)}')
 
         # save the ones we should on server
+        data = { **{'name':name}, **keys_returned}
+        self.log('sending to server:',dict_format(data))
+        # msg_to_op = self.compose_msg_to(data, self.op)
+            
+
+        # ring operator
+        resp_msg_obj = self.ring_ring(data)
+        self.log('register got back from op:',resp_msg_obj)
         
+    #     phone_res = msg_obj.msg
+
+    #     # URI id
+    #     uri_id = phone_res.get('uri_id')
+    #     returned_keys = phone_res.get('_keychain')
+    #     self.log('got URI from Op:',uri_id)
+    #     self.log('got returnd keys from Op:',returned_keys)
+
+    #     # better have the right keys
+    #     assert set(KEYMAKER_DEFAULT_KEYS_TO_SAVE_ON_CLIENT) == set(returned_keys.keys())
+
+    #     # now save these keys!
+    #     saved_keys = self.save_keychain(name,returned_keys,uri_id=uri_id)
+    #     self.log('saved keys!',saved_keys)
+
+    #     # success!
+    #     self.log('yay!!!!')
+    #     return saved_keys
 
 
 
@@ -123,7 +149,7 @@ if __name__=='__main__':
     marx = Persona('marx')
     elon = Persona('elon')
 
-    # marx.register()
+    marx.register()
     # elon.register()
     # person.register()
     # print(person.pubkey)
@@ -131,4 +157,4 @@ if __name__=='__main__':
     # elon.send_msg_to('youre dumb',marx)
     #Caller('elon').ring_ring({'_route':'say_hello','_msg':'my dumb message to operator'})
 
-    print(marx.exists_on_server())
+    # print(marx.exists_on_server())

komrade/backend/the_operator.py

@@ -88,19 +88,22 @@ class TheOperator(Operator):
         return encr_data_b
 
     ### ROUTES
-    def forge_new_keys(self,**data):
+    
-        self.log('about to make some new keys!',data)
+    
-        # return {'_route':'well_hello_to_you_too'}
+    # @deprecated HAPPENS ON CLIENT NOW:
+    # def forge_new_keys(self,**data):
+    #     self.log('about to make some new keys!',data)
+    #     # return {'_route':'well_hello_to_you_too'}
         
-        # get keys
+    #     # get keys
-        forged_keys_plus_id = super().forge_new_keys(
+    #     forged_keys_plus_id = super().forge_new_keys(
-            name=data.get('name'),
+    #         name=data.get('name'),
-            passphrase=data.get('passphrase')
+    #         passphrase=data.get('passphrase')
-        )
+    #     )
-        self.log('<- forged keys',forged_keys_plus_id)
+    #     self.log('<- forged keys',forged_keys_plus_id)
-
+
-        # return to Telephone/Caller
+    #     # return to Telephone/Caller
-        return forged_keys_plus_id
+    #     return forged_keys_plus_id
         
     def does_username_exist(self,name,**data):
         pubkey=self.crypt_keys.get(name,prefix='/pubkey/')

komrade/utils.py

@@ -34,7 +34,7 @@ def pause():
 
 def dict_format(d, tab=0):
     s = ['{\n']
-    for k,v in d.items():
+    for k,v in sorted(d.items()):
         if isinstance(v, dict):
             v = dict_format(v, tab+1)
         else: