updates

komrade/backend/callers.py

@@ -12,12 +12,13 @@ class Caller(Operator):
     Variant of an Operator which handles local keys and keymaking.
     """
 
-    def ring_ring(self,msg):
+    def ring_ring(self,msg,**y):
         # stop
         return super().ring_ring(
             msg,
             to_whom=self.op,
-            get_resp_from=self.phone.ring_ring
+            get_resp_from=self.phone.ring_ring,
+            **y
         )
 
 

komrade/backend/crypt.py

@@ -49,7 +49,8 @@ class Crypt(Logger):
             super().log(*x)
         
     def hash(self,binary_data):
-        return b64encode(hashlib.sha256(binary_data + self.secret).hexdigest().encode()).decode()
+        return hasher(binary_data,self.secret)
+        # return b64encode(hashlib.sha256(binary_data + self.secret).hexdigest().encode()).decode()
         # return zlib.adler32(binary_data)
 
     def force_binary(self,k_b):

komrade/backend/keymaker.py

@@ -37,9 +37,12 @@ class KomradeSymmetricKey(KomradeKey):
                 self._cell = SCellSeal(key=self.key)
         return self._cell
     def encrypt(self,msg,**kwargs):
-        if issubclass(type(msg), KomradeKey): msg=msg.data
+        if issubclass(type(msg), KomradeKey) or issubclass(type(msg),KomradeEncryptedKey):
+            msg=msg.data
         return self.cell.encrypt(msg,**kwargs)
     def decrypt(self,msg,**kwargs):
+        if issubclass(type(msg), KomradeKey) or issubclass(type(msg),KomradeEncryptedKey):
+            msg=msg.data
         return self.cell.decrypt(msg,**kwargs)
 
 
@@ -56,11 +59,14 @@ def getpass_status(passphrase=None):
 from getpass import getpass
         
 class KomradeSymmetricKeyWithPassphrase(KomradeSymmetricKey):
+    def hash(self,x): return self.crypt_keys.hash(x)
+
     def __init__(self,passphrase=DEBUG_DEFAULT_PASSPHRASE, why=WHY_MSG):
-        self.passphrase=passphrase
-        if not self.passphrase:
-            self.passphrase=getpass(why)
-        #return self.passphrase
+        if not passphrase:
+            self.passphrase=hasher(getpass(why))
+        else:
+            self.passphrase=hasher(passphrase)
+
     @property
     def data(self): return KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE.encode('utf-8')
     def __repr__(self): return f'[Symmetric Key] (generated by password)'
@@ -158,21 +164,48 @@ class KomradeEncryptedAsymmetricPublicKey(KomradeEncryptedKey):
 class KomradeEncryptedSymmetricKey(KomradeEncryptedKey):
     def __repr__(self): return f'[Encrypted Symmetric Key]\n    ({self.discreet})'
 
-def get_encrypted_key_obj(data,name_of_encrypted_key):
-    if name_of_encrypted_key.startswith('privkey'):
-        return KomradeEncryptedAsymmetricPrivateKey(data)
-    elif name_of_encrypted_key.startswith('pubkey'):
-        return KomradeEncryptedAsymmetricPublicKey(data)
-    else:
-        return KomradeEncryptedSymmetricKey(data)
+
+
+KEYMAKER_DEFAULT_KEY_TYPES = {
+    'pubkey':KomradeAsymmetricPublicKey,
+    'privkey':KomradeAsymmetricPrivateKey,
+    'adminkey':KomradeSymmetricKeyWithoutPassphrase,
     
+    'pubkey_decr':KomradeSymmetricKeyWithoutPassphrase,
+    'privkey_decr':KomradeSymmetricKeyWithPassphrase,
+    'adminkey_decr':KomradeSymmetricKeyWithPassphrase,
+
+    'pubkey_decr_decr':KomradeSymmetricKeyWithoutPassphrase,
+    'privkey_decr_decr':KomradeSymmetricKeyWithPassphrase,
+    'adminkey_decr_decr':KomradeSymmetricKeyWithPassphrase,
+
+    'pubkey_encr_decr':KomradeSymmetricKeyWithoutPassphrase,
+    'privkey_encr_decr':KomradeSymmetricKeyWithPassphrase,
+    'adminkey_encr_decr':KomradeSymmetricKeyWithPassphrase,
 
 
+    # encrypted keys
+    'pubkey_encr':KomradeEncryptedAsymmetricPublicKey,
+    'privkey_encr':KomradeEncryptedAsymmetricPrivateKey,
+    'adminkey_encr':KomradeEncryptedSymmetricKey,
+    'pubkey_encr_encr':KomradeEncryptedSymmetricKey,
+    'privkey_encr_encr':KomradeEncryptedSymmetricKey,
+    'adminkey_encr_encr':KomradeEncryptedSymmetricKey,
+    'pubkey_decr_encr':KomradeEncryptedSymmetricKey,
+    'privkey_decr_encr':KomradeEncryptedSymmetricKey,
+    'adminkey_decr_encr':KomradeEncryptedSymmetricKey
+}
 
 
 
 
 
+def get_key_obj(keyname,data,passphrase=None,key_types=KEYMAKER_DEFAULT_KEY_TYPES):
+    return key_types[keyname](data)
+
+
+
+
 
 
 
@@ -222,6 +255,11 @@ class Keymaker(Logger):
     def top_keys(self):
         return [k for k in self.keys if k.count('_')==0]
 
+    def load_keychain_from_bytes(self,keychain):
+        for keyname,keyval in keychain.items():
+            keychain[keyname] = get_key_obj(keyname,keyval)
+        return keychain
+
     def keychain(self,look_for=KEYMAKER_DEFAULT_ALL_KEY_NAMES):
         # load existing keychain
         keys = self._keychain #self._keychain = keys = {**self._keychain}
@@ -231,16 +269,16 @@ class Keymaker(Logger):
         pubkey=self._keychain['pubkey']
 
         # get uri
-        uri = b64encode(pubkey)
+        uri = b64encode(pubkey) if type(pubkey)==bytes else b64encode(pubkey.data)
 
         # get from cache
         for keyname in look_for:
             if keyname in keys and keys[keyname]: continue
             key = self.crypt_keys.get(uri,prefix=f'/{keyname}/')
-            if key: keys[keyname]=key #get_encrypted_key_obj(key,keyname)
+            if key: keys[keyname]=get_key_obj(keyname,key) #get_encrypted_key_obj(key,keyname)
         
         # try to assemble
-        keys = self.assemble(self.assemble(keys))
+        keys = self.assemble(keys)
         
         #store to existing set
         self._keychain = keys
@@ -248,11 +286,6 @@ class Keymaker(Logger):
         #return
         return keys
 
-    def keychain_obj(self,look_for=KEYMAKER_DEFAULT_ALL_KEY_NAMES):
-        keychain = self.keychain()
-        for keyname,key_b in keychain.items():
-            keychain[keyname] = get_encrypted_key_obj(key_b,keyname)
-        return keychain
 
     @property
     def pubkey(self): return self.keychain().get('pubkey')
@@ -328,7 +361,6 @@ class Keymaker(Logger):
 
 
 
-
     def gen_keys_from_types(self,key_types=KEYMAKER_DEFAULT_KEY_TYPES,passphrase=DEBUG_DEFAULT_PASSPHRASE):
         """
         Get new asymmetric/symmetric keys, given a dictionary of constants describing their type
@@ -338,30 +370,26 @@ class Keymaker(Logger):
         asymmetric_pubkey=None
         asymmetric_privkey=None
         keychain = {}
-        # print('hello?')
-        for key_name,key_type_desc in key_types.items():
-            # print(key_name,key_type_desc)
-            if key_type_desc in {KEY_TYPE_ASYMMETRIC_PUBKEY,KEY_TYPE_ASYMMETRIC_PRIVKEY}:
+        
+        # gen keys requested
+        for key_name,key_class in key_types.items():
+            ## asymmetric?
+            if issubclass(key_class,KomradeAsymmetricKey):
+                if not asymmetric_privkey or asymmetric_pubkey:
+                    asymmetric_keys = KomradeAsymmetricKey()
+                    asymmetric_pubkey = asymmetric_keys.pubkey_obj
+                    asymmetric_privkey = asymmetric_keys.privkey_obj
                 
-                if not asymmetric_privkey or not asymmetric_pubkey:
-                    keypair = GenerateKeyPair(KEY_PAIR_TYPE.EC)
-                    asymmetric_privkey = keypair.export_private_key()
-                    asymmetric_pubkey = keypair.export_public_key()
+                if key_class == KomradeAsymmetricPublicKey:
+                    keychain[key_name]=asymmetric_pubkey
+                elif key_class == KomradeAsymmetricPrivateKey:
+                    keychain[key_name]=asymmetric_privkey
 
-            if key_type_desc==KEY_TYPE_ASYMMETRIC_PRIVKEY:
-                keychain[key_name] = KomradeAsymmetricPrivateKey(asymmetric_pubkey,asymmetric_privkey)
-            
-            elif key_type_desc==KEY_TYPE_ASYMMETRIC_PUBKEY:
-                keychain[key_name] = KomradeAsymmetricPublicKey(asymmetric_pubkey,asymmetric_privkey)
-            
+            ## otherwise, just gen?
             elif key_type_desc==KEY_TYPE_SYMMETRIC_WITHOUT_PASSPHRASE:
                 keychain[key_name]=KomradeSymmetricKeyWithoutPassphrase()
             
             elif key_type_desc==KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE:
-                if not passphrase and not self.passphrase:
-                    self.passphrase=getpass(WHY_MSG)
-
-                passphrase=passphrase if passphrase else self.passphrase
                 keychain[key_name]=KomradeSymmetricKeyWithPassphrase(passphrase=passphrase)
         
         return keychain
@@ -375,21 +403,17 @@ class Keymaker(Logger):
         # generate encrypted keys too
         for key_name in keys_to_gen:
             if key_name.endswith('_encr') and key_name not in keychain:
-                # encrypt it with the associated decr
-                # self.log(f'let\'s encrypt {key_name}!')
+
+                # get data to encrypt
                 name_of_what_to_encrypt = key_name[:-len('_encr')]
                 the_key_to_encrypt_it_with = name_of_what_to_encrypt + '_decr'
+                
                 if the_key_to_encrypt_it_with in keychain and name_of_what_to_encrypt in keychain:
-                    _key_decr = keychain[the_key_to_encrypt_it_with]
+                    _key_decr_obj = keychain[the_key_to_encrypt_it_with]
                     _key = keychain[name_of_what_to_encrypt]
-                    # self.log(f'about to encrypt key {name_of_what_to_encrypt}, using {the_key_to_encrypt_it_with}, which is a type {KEYMAKER_DEFAULT_KEY_TYPES[the_key_to_encrypt_it_with]} and has value {keychain[the_key_to_encrypt_it_with]}')
-                    _key_encr = _key_decr.encrypt(_key)
-
-
+                    _key_encr = _key_decr.encrypt(_key.data)
                     _key_encr_obj = get_encrypted_key_obj(_key_encr, name_of_what_to_encrypt)
 
-                    # self.log(f'{_key}\n-- encrypting ----->\n{_key_encr}')
-                    # keychain[key_name]=_key_encr
                     keychain[key_name]=_key_encr_obj
         return keychain
 
@@ -440,14 +464,14 @@ Keymaker ({self}) is forging new keys for {name}
         
         keychain = self.gen_encr_keys(keychain,keys_to_gen,passphrase=passphrase)
         # self.log('I built this keychain!',dict_format(keychain,tab=2))
-        # self.status('@Keymaker: I ended up building these keys:',keychain)
+        self.status('@Keymaker: I ended up building these keys:',keychain)
         
 
         # save keys!
         if save_keychain:
             # get URI id to save under (except for pubkeys, accessible by name)
             uri_id,keys_saved_d,keychain = self.save_keychain(name,keychain,keys_to_save)
-            # self.log('I saved this keychain:',dict_format(keys_saved_d,tab=2),'using the generated-from-pubkey 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)
 
         # return keys!
         if return_all_keys:
@@ -455,12 +479,10 @@ Keymaker ({self}) is forging new keys for {name}
 
         if return_keychain:
             keys_returned = self.return_keychain(keychain,keys_to_return)
-            # self.log('I am returning this keychain:',dict_format(keys_returned,tab=2))
+            self.log('I am returning this keychain:',dict_format(keys_returned,tab=2))
             # return (uri_id,keys_returned)
             return keys_returned
 
-        
-
         raise KomradeException('What did you want me to do here?')
         
                 
@@ -537,74 +559,25 @@ Keymaker ({self}) is forging new keys for {name}
 
         return (uri_id,keys_saved_d,keychain)
 
-    def assemble(self,_keychain):
-        # last minute assemblies?
-        encr_keys = [k for k in _keychain if k.endswith('_encr')]
-        for ekey in encr_keys:
-            eval=_keychain[ekey]
-            if not eval: continue
-
-            unencrkey = ekey[:-len('_encr')]
-            if unencrkey in _keychain: continue
-            
-            decrkey = unencrkey+'_decr'
-            if decrkey not in _keychain: continue
-            
-            dval=_keychain[decrkey]
-            if not dval: continue
-
-            # self.log(ekey,decrkey,'??')
-            # self.log(eval,dval,'????')
-            
-            new_val = self.assemble_key(eval,dval)
-            # self.log('!!#!',new_val)
-            if new_val:
-                _keychain[unencrkey] = new_val
-        return _keychain
-
-    def assemble_key(self, key_encr, key_decr, key_encr_name=None, key_decr_name=None):
-        # self.log(f'assembling key: {key_decr} decrypting {key_encr}')
-
-        # need the encrypted half
-        if not key_encr:
-            # self.log('!! encrypted half not given')
-            return
-        if not key_decr:
-            if self.passphrase:
-                key_decr = self.passphrase
-            else:
-                # self.log('!! decryptor half not given')
-                return
-
-        # need some way to regenerate the decryptor
-        decr_cell = self.get_cell(key_decr)
-
-        # need the decryptor half
-        if not decr_cell:
-            # self.log('!! decryptor cell not regenerable')
-            return
-
-        # decrypt!
-        try:
-            # self.log(f'>> decrypting {key_encr_name} with {key_decr_name}\n({key_encr} with cell {decr_cell}')
-            key = decr_cell.decrypt(key_encr)
-            # self.log('assembled_key built:',key)
-            return key
-        except ThemisError as e:
-            self.log('!! decryption failed:',e)
-            return
-
-    def get_cell(self, str_or_key_or_cell):
-        # self.log('getting decr cell for',str_or_key_or_cell)
-
-        if type(str_or_key_or_cell)==SCellSeal:
-            return str_or_key_or_cell
-        elif type(str_or_key_or_cell)==str:
-            return SCellSeal(passphrase=str_or_key_or_cell)
-        elif type(str_or_key_or_cell)==bytes:
-            return SCellSeal(key=str_or_key_or_cell)
-        elif issubclass(type(str_or_key_or_cell),KomradeSymmetricKey):
-            return str_or_key_or_cell.cell
+    def assemble(self,keychain,passphrase=None,key_types=KEYMAKER_DEFAULT_KEY_TYPES):
+        encr_keys = [k for k in keychain.keys() if k.endswith('_encr')]
+        for encr_key_name in encr_keys:
+            decr_key_name = encr_key_name[:-5] + '_decr'
+            unencr_key_name = encr_key_name[:-5]
+            if unencr_key_name in keychain: continue
+            if not decr_key_name in keychain:
+                if type(key_types[decr_key_name])==KomradeSymmetricKeyWithPassphrase:
+                    keychain[decr_key_name] = KomradeSymmetricKeyWithPassphrase(
+                        passphrase if passphrase else self.passphrase
+                    )
+                else:
+                    continue
+            decr_key = keychain.get(decr_key_name)
+            encr_key = keychain.get(encr_key_name)
+            # self.log('?',decr_key,decr_key_name,encr_key_name,keychain[encr_key_name])
+            unencr_key = decr_key.decrypt(encr_key)
+            keychain[unencr_key_name] = get_key_obj(unencr_key_name,unencr_key)
+        return keychain
 
 
 if __name__ == '__main__':

komrade/backend/operators.py

@@ -76,7 +76,7 @@ class Operator(Keymaker):
         return OPERATOR
 
 
-    def compose_msg_to(self,msg,another):
+    def compose_msg_to(self,msg,another,route=None):
         if not self.privkey or not self.pubkey:
             raise KomradeException('why do I have no pub/privkey pair!?',self,self.name,self.pubkey,self.privkey,self.keychain())
         if not another.name or not another.pubkey:
@@ -89,6 +89,7 @@ class Operator(Keymaker):
             '_to_pub':another.pubkey,
             '_to_name':another.name,
             '_msg':msg,
+            ROUTE_KEYNAME:route
         }
         # self.log(f'I am {self} packaging a message to {another}: {msg_d}')
         from komrade.backend.messages import Message
@@ -189,22 +190,29 @@ class Operator(Keymaker):
         return msg_obj
 
 
-    def ring_ring(self,msg,to_whom,get_resp_from=None):
+    def ring_ring(self,msg,to_whom,from_whom=None,get_resp_from=None,route=None):
         # ring ring
         from komrade.cli.artcode import ART_PHONE_SM1
-        self.log(f'''ring ring! {ART_PHONE_SM1} ring ring!
+        import textwrap as tw
+        self.log(f'''
+
+{ART_PHONE_SM1} 
+ring ring ring!
+
 I am {self}.
 
-I have been told to pass onto {to_whom},
-by way of function {get_resp_from},
-the following msg:
-{dict_format(msg,tab=5)}
+I have been given a message by {from_whom}, and told to pass it onto {to_whom}, by way of the function {get_resp_from}.
+
+The message is:
+
+    {dict_format(msg)}
 ''')
         
         # get encr msg obj
         msg_obj = self.compose_msg_to(
             msg,
-            to_whom
+            to_whom,
+            route=route
         )
         self.log(f'ring ring! here is the message object I made, to send to {to_whom}: {msg_obj}')
         

komrade/backend/people.py

@@ -64,30 +64,32 @@ class Persona(Caller):
 
         ## 3) Have passphrase?
         if SHOW_STATUS and not passphrase:
-            passphrase = self.cli.status_keymaker_part2(name,passphrase,pubkey,privkey,self.crypt_keys.hash,self)
+            passphrase = self.cli.status_keymaker_part2(name,passphrase,pubkey,privkey,hasher,self)
         else:
             if not passphrase: passphrase=getpass('Enter a memorable password to encrypt your private key with: ')
 
         ## 4) Get hashed password
-        passhash = self.crypt_keys.hash(passphrase.encode())
+        passhash = hasher(passphrase)
         self.log(f'''Keymaker has created a symmetric encryption cell using the disguised password:\n\n\t(2A) [Symmetric Encryption Key]\n\t({make_key_discreet_str(passhash)})''')
 
         ## 5) Encrypt private key
-        privkey_decr = KomradeSymmetricKeyWithPassphrase(passhash)
+        privkey_decr = KomradeSymmetricKeyWithPassphrase(passphrase)
         privkey_encr = privkey_decr.encrypt(privkey.data)
         privkey_encr_obj = KomradeEncryptedAsymmetricPrivateKey(privkey_encr)
         self.log(f"This pass-generated key has now transformed the private key (2) into the following encrypted form (redacted):\n\n\t(2B) [Encrypted Private Key]\n\t({make_key_discreet_str(privkey_encr_obj.data_b64)})")
 
         ## 6) Test keychain works
-        privkey_decr2 = KomradeSymmetricKeyWithPassphrase(passhash)
+        privkey_decr2 = KomradeSymmetricKeyWithPassphrase(passphrase)
+        assert privkey_decr2.decrypt(privkey_encr) == privkey.data
         
-        self._keychain['pubkey']=pubkey.data
-        self._keychain['privkey_encr']=privkey_encr_obj.data
+        self._keychain['pubkey']=pubkey
+        self._keychain['privkey_encr']=privkey_encr_obj
         self._keychain['privkey_decr']=privkey_decr
+        # we should be able to reassemble privkey now?
+        assert 'privkey' in self.keychain()
 
         self.log('My keychain now looks like:',dict_format(self.keychain()))
 
-
         ## 6) More narration?
         if SHOW_STATUS:
             self.cli.status_keymaker_part3(privkey,privkey_decr,privkey_encr,passphrase)
@@ -95,8 +97,7 @@ class Persona(Caller):
         ## 7) Save data to server
         data = {
             'name':name, 
-            'pubkey': pubkey.data,
-            ROUTE_KEYNAME:'register_new_user'
+            'pubkey': pubkey
         }
         self.log('I will be sending this data to @TheOperator, on the remote server:',dict_format(data,tab=2))
         
@@ -104,13 +105,13 @@ class Persona(Caller):
         # call from phone since I don't have pubkey on record on Op yet
         # self.log('my keychain:',self._keychain,pubkey,self.op._keychain)
 
-        resp_msg_obj = self.ring_ring(data)
+        resp_msg_obj = self.ring_ring(data,route='register_new_user',from_whom=self)
         self.log('register got back from op:',dict_format(resp_msg_obj,tab=2))
 
 
 
-    def ring_ring(self,msg):
-        return super().ring_ring(msg)
+    def ring_ring(self,msg,**y):
+        return super().ring_ring(msg,**y)
 
     def send_msg_to(self,msg,to_whom):
         msg = self.compose_msg_to(msg,to_whom)
@@ -128,7 +129,7 @@ def test_register():
     botname=f'marx{str(num).zfill(3)}'
     marxbot = Persona(botname)
     # marxbot=Persona()
-    marxbot.register(passphrase='communise')
+    marxbot.register(passphrase='acc')
 
 if __name__=='__main__':
     test_register()

komrade/backend/phonelines.py

@@ -15,8 +15,7 @@ def create_phonelines():
     op_keys_to_keep_on_server = ['pubkey',   # stored under name
                                 'privkey_encr',
                                 'adminkey_encr',
-                                'adminkey_decr_encr',
-                                'adminkey_decr_decr']   # kept on op server
+                                'adminkey_decr']   # kept on op server
 
     ## create phone
     phone = Keymaker(name=TELEPHONE_NAME)
@@ -30,32 +29,47 @@ def create_phonelines():
     world_keys_to_keep_on_3rdparty = op_keys_to_keep_on_3rdparty
     world_keys_to_keep_on_server = op_keys_to_keep_on_server
 
+
+    # key types
+    key_types = {
+        'pubkey':KomradeAsymmetricPublicKey,
+        'privkey':KomradeAsymmetricPrivateKey,
+        'privkey_encr':KomradeEncryptedAsymmetricPrivateKey,
+        'privkey_decr':KomradeSymmetricKeyWithoutPassphrase,
+        'adminkey':KomradeSymmetricKeyWithoutPassphrase,
+        'adminkey_encr':KomradeEncryptedSymmetricKey,
+        'adminkey_decr':KomradeSymmetricKeyWithPassphrase,
+    }
+
     
 
     # create keys for Op
     op_uri,op_decr_keys = op.forge_new_keys(
+        key_types=key_types,
         keys_to_save=op_keys_to_keep_on_server,
         keys_to_return=op_keys_to_keep_on_client + op_keys_to_keep_on_3rdparty # on clients only
+        
     )
     #print('op!',op_uri)
     p#print(op_decr_keys)
 
     # create keys for phone
     phone_uri,phone_decr_keys = phone.forge_new_keys(
-        name=TELEPHONE_NAME,
+        key_types=key_types,
         keys_to_save=phone_keys_to_keep_on_server,  # on server only
         keys_to_return=phone_keys_to_keep_on_client + phone_keys_to_keep_on_3rdparty   # on clients only
     )
     #print('phone!',op_uri)
-    p#print(phone_decr_keys)
+    #print(phone_decr_keys)
 
     # create keys for world
     world_uri,world_decr_keys = world.forge_new_keys(
+        key_types=key_types,
         keys_to_save=world_keys_to_keep_on_server,
         keys_to_return=world_keys_to_keep_on_client + world_keys_to_keep_on_3rdparty # on clients only
     )
     #print('world!',op_uri)
-    p#print(world_decr_keys)
+    #print(world_decr_keys)
     ## store remote keys
     THIRD_PARTY_DICT = {OPERATOR_NAME:{}, TELEPHONE_NAME:{}, WORLD_NAME:{}}
     for key in op_keys_to_keep_on_3rdparty:

komrade/backend/the_operator.py

@@ -33,7 +33,7 @@ class TheOperator(Operator):
             path_crypt_keys=PATH_CRYPT_OP_KEYS,
             path_crypt_data=PATH_CRYPT_OP_DATA
         )
-        self._keychain = self.operator_keychain
+        self._keychain = self.load_keychain_from_bytes(self.operator_keychain)
         
     def ring(self,
         from_caller=None,

komrade/backend/the_telephone.py

@@ -12,7 +12,7 @@ class TheTelephone(Operator):
     def __init__(self, caller=None):
         super().__init__(name=TELEPHONE_NAME)
         self.caller=caller
-        self._keychain = self.telephone_keychain
+        self._keychain = self.load_keychain_from_bytes(self.telephone_keychain)
 
     def find_pubkey(self):
         return self.telephone_keychain.get('pubkey')
@@ -61,11 +61,12 @@ Please send this message along, would you: {msg_b64_str}
         # return self.pronto_pronto(resp_msg_obj)
 
 
-    def ring_ring(self,msg):
+    def ring_ring(self,msg,**y):
         return super().ring_ring(
             msg,
             to_whom=self.op,
-            get_resp_from=self.send_and_receive
+            get_resp_from=self.send_and_receive,
+            **y
         )
         
     

komrade/constants.py

@@ -99,39 +99,11 @@ KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE = 'symmetric_key_with_passphrase'
 ENCRYPTED_KEY = 'encrypted_key'
 
 
-KEYMAKER_DEFAULT_KEY_TYPES = {
-    'pubkey':KEY_TYPE_ASYMMETRIC_PUBKEY,
-    'privkey':KEY_TYPE_ASYMMETRIC_PRIVKEY,
-    'adminkey':KEY_TYPE_SYMMETRIC_WITHOUT_PASSPHRASE,
-    
-    'pubkey_decr':KEY_TYPE_SYMMETRIC_WITHOUT_PASSPHRASE,
-    'privkey_decr':KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE,
-    'adminkey_decr':KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE,
-
-    'pubkey_decr_decr':KEY_TYPE_SYMMETRIC_WITHOUT_PASSPHRASE,
-    'privkey_decr_decr':KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE,
-    'adminkey_decr_decr':KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE,
-
-    'pubkey_encr_decr':KEY_TYPE_SYMMETRIC_WITHOUT_PASSPHRASE,
-    'privkey_encr_decr':KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE,
-    'adminkey_encr_decr':KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE,
-
-
-    # encrypted keys
-    'pubkey_encr':ENCRYPTED_KEY,
-    'privkey_encr':ENCRYPTED_KEY,
-    'adminkey_encr':ENCRYPTED_KEY,
-    'pubkey_encr_encr':ENCRYPTED_KEY,
-    'privkey_encr_encr':ENCRYPTED_KEY,
-    'adminkey_encr_encr':ENCRYPTED_KEY,
-    'pubkey_decr_encr':ENCRYPTED_KEY,
-    'privkey_decr_encr':ENCRYPTED_KEY,
-    'adminkey_decr_encr':ENCRYPTED_KEY
-}
 
-KEYMAKER_DEFAULT_ALL_KEY_NAMES = sorted(list(KEYMAKER_DEFAULT_KEY_TYPES.keys()), key=lambda x: x.count('_'))
 
-WHY_MSG = 'Forge the password of memory: '
+KEYMAKER_DEFAULT_ALL_KEY_NAMES = KEYNAMES
+
+WHY_MSG = 'What is the password of memory for this account? '
 
 
 

komrade/utils.py

@@ -164,6 +164,17 @@ def hashish(binary_data):
     import hashlib
     return hashlib.sha256(binary_data).hexdigest()
 
+def hasher(dat,secret=None):
+    import hashlib
+    if not secret:
+        with open(PATH_CRYPT_SECRET,'rb') as f:
+            secret = f.read()
+    if type(dat)==str:
+        dat=dat.encode()
+
+    # print(dat,secret[:10])
+    return b64encode(hashlib.sha256(dat + secret).hexdigest().encode()).decode()
+
 
 from base64 import b64encode,b64decode
 import ujson as json