From ade3e418a9684f26f59b915bbc2d32c53b1ec126 Mon Sep 17 00:00:00 2001 From: quadrismegistus Date: Sun, 6 Sep 2020 15:45:40 +0100 Subject: [PATCH] updates --- ...be4a6ad79ce21fd86bc33da14af3c83df51cc8f9e3 | 1 + ...41f1f981d6122dada7d207165a8068ec7388593d30 | 1 + ...0e3d8bd574fa1f91b3468139bbfb7f9c47811fede6 | 1 + ...29bff97745b97e8c05512a5d9955dd9423897f090b | 1 + ...b6f09bd241a10139464d1413271b5adb1ca8dfee68 | 1 + ...ecf9af19df3934bb68990648f2eab900f7f0dba366 | 1 + ...4e6e1760647747f3262ee0acbc306323771465ff61 | 1 + ...2a2d04adbbae22b0002acb5223d07f203a9c1e2cb8 | 1 + komrade/backend/crypt.py | 4 +- komrade/backend/keymaker.py | 239 +++++++++++++----- komrade/backend/the_operator.py | 22 +- komrade/constants.py | 13 +- 12 files changed, 202 insertions(+), 84 deletions(-) create mode 100644 None/0255ebc2059eedf0d6cf1bbe4a6ad79ce21fd86bc33da14af3c83df51cc8f9e3 create mode 100644 None/137bc6f03f1fc6cedf83cf41f1f981d6122dada7d207165a8068ec7388593d30 create mode 100644 None/63105e8321745c0496430e0e3d8bd574fa1f91b3468139bbfb7f9c47811fede6 create mode 100644 None/71c13c3c997b30c87e622b29bff97745b97e8c05512a5d9955dd9423897f090b create mode 100644 None/7f8ea89019a71f04748f23b6f09bd241a10139464d1413271b5adb1ca8dfee68 create mode 100644 None/945e8c1b53ba095abcb719ecf9af19df3934bb68990648f2eab900f7f0dba366 create mode 100644 None/9e41bf22d67901991166274e6e1760647747f3262ee0acbc306323771465ff61 create mode 100644 None/e41087f8857fcbfd4e3d0e2a2d04adbbae22b0002acb5223d07f203a9c1e2cb8 diff --git a/None/0255ebc2059eedf0d6cf1bbe4a6ad79ce21fd86bc33da14af3c83df51cc8f9e3 b/None/0255ebc2059eedf0d6cf1bbe4a6ad79ce21fd86bc33da14af3c83df51cc8f9e3 new file mode 100644 index 0000000..f2c23c2 --- /dev/null +++ b/None/0255ebc2059eedf0d6cf1bbe4a6ad79ce21fd86bc33da14af3c83df51cc8f9e3 @@ -0,0 +1 @@ +AAEBQQwAAAAQAAAAHQAAABYAAABC4JMHDsMWv3i/l5rmUgS5P5vejNzshcm4QtCeQA0DABAAMelPtEYSmoGMNE+o5ZrzguZ78+wJQP2ntDTMpfbzd/qOFCGwteMPqHS50Bff \ No newline at end of file diff --git a/None/137bc6f03f1fc6cedf83cf41f1f981d6122dada7d207165a8068ec7388593d30 b/None/137bc6f03f1fc6cedf83cf41f1f981d6122dada7d207165a8068ec7388593d30 new file mode 100644 index 0000000..2dd3d64 --- /dev/null +++ b/None/137bc6f03f1fc6cedf83cf41f1f981d6122dada7d207165a8068ec7388593d30 @@ -0,0 +1 @@ +AAEBQAwAAAAQAAAALQAAACmm136MajOfg75ANfkf1QeUSAm5WrKDBPdfgSAhkXV9fKMYjkUmGbqXnf7/xYiwD0X0oXfligYTKTZzbe59/R34h1GTVQi62cM= \ No newline at end of file diff --git a/None/63105e8321745c0496430e0e3d8bd574fa1f91b3468139bbfb7f9c47811fede6 b/None/63105e8321745c0496430e0e3d8bd574fa1f91b3468139bbfb7f9c47811fede6 new file mode 100644 index 0000000..b481919 --- /dev/null +++ b/None/63105e8321745c0496430e0e3d8bd574fa1f91b3468139bbfb7f9c47811fede6 @@ -0,0 +1 @@ +AAEBQAwAAAAQAAAALQAAAD7QTJ0mwcKbPCTpwjR64Ls6fxYRTaihT6BgTGVJvV7IGqlLOe/5VPg6AHzDb8SNwvpk5O1TNI8zXEwtSYizKj2JWbPP68rXHtI= \ No newline at end of file diff --git a/None/71c13c3c997b30c87e622b29bff97745b97e8c05512a5d9955dd9423897f090b b/None/71c13c3c997b30c87e622b29bff97745b97e8c05512a5d9955dd9423897f090b new file mode 100644 index 0000000..c338fe9 --- /dev/null +++ b/None/71c13c3c997b30c87e622b29bff97745b97e8c05512a5d9955dd9423897f090b @@ -0,0 +1 @@ +AAEBQAwAAAAQAAAALQAAAL7ZufZEfG+BI05y8vtCoKssFKSrwGZ6vcY/XzgJzR9f5YRb5OXCiqDWoV954X/nox1KgHjX6Uwuv23VnOORI8BlX9XQZpMUVLQ= \ No newline at end of file diff --git a/None/7f8ea89019a71f04748f23b6f09bd241a10139464d1413271b5adb1ca8dfee68 b/None/7f8ea89019a71f04748f23b6f09bd241a10139464d1413271b5adb1ca8dfee68 new file mode 100644 index 0000000..074bf7d --- /dev/null +++ b/None/7f8ea89019a71f04748f23b6f09bd241a10139464d1413271b5adb1ca8dfee68 @@ -0,0 +1 @@ +AAEBQQwAAAAQAAAAHQAAABYAAADZSSgVHoOdHsCTRJUh6QK27eoRmsD4qihqqqJFQA0DABAAdi9kbiachwmqGsxRi3THw+o4ELp3L3Fx7lVzIWFGM1kWQUm4egQNKmYPozWU \ No newline at end of file diff --git a/None/945e8c1b53ba095abcb719ecf9af19df3934bb68990648f2eab900f7f0dba366 b/None/945e8c1b53ba095abcb719ecf9af19df3934bb68990648f2eab900f7f0dba366 new file mode 100644 index 0000000..a7fa9f3 --- /dev/null +++ b/None/945e8c1b53ba095abcb719ecf9af19df3934bb68990648f2eab900f7f0dba366 @@ -0,0 +1 @@ +AAEBQAwAAAAQAAAALQAAAMAPieX8VPk7FpATBIlBv8Jnmn2YZOYdMOza5ohYScD6o+bPQWyr1aa+Q7LUHaiDt1OVRGrYB3YhpL45eVV3pMy43fR+kEf4hWo= \ No newline at end of file diff --git a/None/9e41bf22d67901991166274e6e1760647747f3262ee0acbc306323771465ff61 b/None/9e41bf22d67901991166274e6e1760647747f3262ee0acbc306323771465ff61 new file mode 100644 index 0000000..dc59ca1 --- /dev/null +++ b/None/9e41bf22d67901991166274e6e1760647747f3262ee0acbc306323771465ff61 @@ -0,0 +1 @@ +AAEBQAwAAAAQAAAALQAAACYNHQ4rRWUk9LCyYnKST/yw2nv/7oP+dMtD9YUhuTdbhk4RyVn7/QN2AYQRUU7wDdECODdRYbJd7KfVHtKzSHMn6gVVLq0tUxY= \ No newline at end of file diff --git a/None/e41087f8857fcbfd4e3d0e2a2d04adbbae22b0002acb5223d07f203a9c1e2cb8 b/None/e41087f8857fcbfd4e3d0e2a2d04adbbae22b0002acb5223d07f203a9c1e2cb8 new file mode 100644 index 0000000..6c18ce7 --- /dev/null +++ b/None/e41087f8857fcbfd4e3d0e2a2d04adbbae22b0002acb5223d07f203a9c1e2cb8 @@ -0,0 +1 @@ +AAEBQQwAAAAQAAAAHQAAABYAAADasH1b42yDC1v5Hm9tyHe8Nm3M6FyuW/yQmbebQA0DABAA89tLLiYHN4wubd7aQe7Ii9eirO3VCc3cAHZa87jzXQ4vNhfvz2jntnTCNN+w \ No newline at end of file diff --git a/komrade/backend/crypt.py b/komrade/backend/crypt.py index afe346e..8be947c 100644 --- a/komrade/backend/crypt.py +++ b/komrade/backend/crypt.py @@ -36,7 +36,7 @@ class Crypt(Logger): def force_binary(self,k_b): if type(k_b)==str: k_b=k_b.encode() - if type(k_b)!=bytes: k_b=str(k_b).encode() + if type(k_b)!=bytes: k_b=k_b.decode() return k_b def package_key(self,k,prefix=''): @@ -67,7 +67,7 @@ class Crypt(Logger): # self.log('set() v -->',v) v_b=self.package_val(v) - self.log(f'set(\n\t{prefix}{k},\n\t\n\t{v_b}\n)\n') + self.log(f'set(\n\t{prefix}{k},\n\t{k_b}\n\t\n\t{v_b}\n)\n') return self.store.put(k_b,v_b) diff --git a/komrade/backend/keymaker.py b/komrade/backend/keymaker.py index 8ff778b..82cb0a7 100644 --- a/komrade/backend/keymaker.py +++ b/komrade/backend/keymaker.py @@ -1,28 +1,76 @@ import os,sys; sys.path.append(os.path.abspath(os.path.join(os.path.abspath(os.path.join(os.path.dirname(__file__),'..')),'..'))) from komrade import * from komrade.backend.crypt import * +from abc import ABC, abstractmethod + +class KomradeKey(ABC): + @abstractmethod + def encrypt(self,msg,**kwargs): pass + @abstractmethod + def decrypt(self,msg,**kwargs): pass + @abstractmethod + def data(self): pass -class KomradeSymmetric(SCellSeal): +class KomradeSymmetricKey(KomradeKey): @property def cell(self): if not hasattr(self,'_cell'): if hasattr(self,'passphrase') and self.passphrase: - self._cell = SCellSeal(passphrase=passphrase) + self._cell = SCellSeal(passphrase=self.passphrase) elif hasattr(self,'key') and self.key: - self._cell = SCellSeal(key=key) + self._cell = SCellSeal(key=self.key) + return self._cell + def encrypt(self,msg,**kwargs): + if issubclass(type(msg), KomradeKey): msg=msg.data + return self.cell.encrypt(msg,**kwargs) + def decrypt(self,msg,**kwargs): + return self.cell.decrypt(msg,**kwargs) + + + + -class KomradeSymmetricPass(KomradeSymmetric): +class KomradeSymmetricKeyWithPassphrase(KomradeSymmetricKey): def __init__(self,passphrase=None, why=WHY_MSG): self.passphrase=passphrase if not self.passphrase: self.passphrase=getpass.getpass(why) - return self.passphrase + #return self.passphrase + @property + def data(self): return KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE.encode('utf-8') -class KomradeSymmetricKey(SCellSeal): +class KomradeSymmetricKeyWithoutPassphrase(KomradeSymmetricKey): def __init__(self): self.key = GenerateSymmetricKey() + @property + def data(self): return self.key + + + +class KomradeAsymmetricKey(KomradeKey): + def __init__(self,pubkey,privkey): + self.pubkey=pubkey + self.privkey=privkey + def encrypt(self,msg,pubkey=None,privkey=None): + if issubclass(type(msg), KomradeKey): msg=msg.data + pubkey=pubkey if pubkey else self.pubkey + privkey=privkey if privkey else self.privkey + return SMessage(privkey,pubkey).wrap(msg) + def decrypt(self,msg,pubkey=None,privkey=None): + pubkey=pubkey if pubkey else self.pubkey + privkey=privkey if privkey else self.privkey + return SMessage(privkey,pubkey).unwrap(msg) + @property + def data(self): return self.key + +class KomradeAsymmetricPublicKey(KomradeAsymmetricKey): + @property + def key(self): return self.pubkey +class KomradeAsymmetricPrivateKey(KomradeAsymmetricKey): + @property + def key(self): return self.privkey class Keymaker(Logger): @@ -272,85 +320,135 @@ class Keymaker(Logger): asymmetric_pubkey=None asymmetric_privkey=None keychain = defaultdict(None) - for key_name,key_type_descr in key_types.items(): - if key_type_descr in {KEY_TYPE_ASYMMETRIC_PRIVKEY,KEY_TYPE_ASYMMETRIC_PRIVKEY}: + for key_name,key_type_desc in key_types.items(): + if key_type_desc in {KEY_TYPE_ASYMMETRIC_PUBKEY,KEY_TYPE_ASYMMETRIC_PRIVKEY}: 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_type_descr==KEY_TYPE_ASYMMETRIC_PRIVKEY: - keychain[key_name] = asymmetric_privkey - elif key_type_descr==KEY_TYPE_ASYMMETRIC_PUBKEY: - keychain[key_name] = asymmetric_pubkey + 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) elif key_type_desc==KEY_TYPE_SYMMETRIC_WITHOUT_PASSPHRASE: - keychain[key_name]=KomradeSymmetricKey() + keychain[key_name]=KomradeSymmetricKeyWithoutPassphrase() elif key_type_desc==KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE: - if not passphrase and not self.passphrase: - self.passphrase=getpass.getpass(WHY_MSG) - keychain[key_name]=KomradeSymmetricPass(passphrase=passphrase if passphrase else self.passphrase) + if not passphrase and not self.passphrase: self.passphrase=getpass.getpass(WHY_MSG) + passphrase=passphrase if passphrase else self.passphrase + keychain[key_name]=KomradeSymmetricKeyWithPassphrase(passphrase=passphrase) + return keychain def forge_new_keys(self, - name, + name=None, keys_to_save = KEYMAKER_DEFAULT_KEYS_TO_SAVE, keys_to_return = KEYMAKER_DEFAULT_KEYS_TO_RETURN, + keys_to_gen = KEYMAKER_DEFAULT_KEYS_TO_GEN, key_types = KEYMAKER_DEFAULT_KEY_TYPES): self.log('forging new keys...') + 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) + + keychain = self.gen_keys_from_types(key_types) + self.log('keychain =',keychain) + + self.log('!!!!',keychain) + # stop + #keychain_tosave = defaultdict(None) + #keychain_toreturn = defaultdict(None) + self.log('keys_to_save =',keys_to_save) + self.log('keys_to_return =',keys_to_return) + + for key_name in keys_to_gen: + if key_name.endswith('_encr') and key_name not in keychain: + # encrypt it with the associated decr + 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 = 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 {key_types[the_key_to_encrypt_it_with]} and has value {keychain[the_key_to_encrypt_it_with]}') + _key_encr = _key_decr.encrypt(_key) + self.log(f'{_key}\n-- encrypting ----->\n{_key_encr}') + keychain[key_name]=_key_encr + + self.log('once more, with encryption!',keychain) + + # filter for transfer + for k,v in keychain.items(): + if issubclass(type(v),KomradeKey): + v=v.data + v=b64encode(v) + keychain[k]=v + self.log('-->',v) + # stop + + # keychain_tosave = dict([(k,keychain[k]) for k in keys_to_save if k in keychain]) + - # Create public and private keys - keychain = {} - keypair = GenerateKeyPair(KEY_PAIR_TYPE.EC) - keychain['privkey'] = keypair.export_private_key() - keychain['pubkey'] = keypair.export_public_key() - keychain['adminkey'] = GenerateSymmetricKey() - - # # Create decryption/permission keys - # keychain['pubkey_decr'] = GenerateSymmetricKey() - # keychain['privkey_decr'] = GenerateSymmetricKey() - # keychain['adminkey_decr'] = GenerateSymmetricKey() #SCellSeal(passphrase=passphrase) + # for k,v in keychain_tosave.items(): + if 'pubkey' in keys_to_save or 'privkey' in keys_to_save or 'adminkey' in keys_to_save: + raise KomradeException('there is no private property in a socialist network! all keys must be split between komrades') + + ### SAVE ENCRYPTED KEYS? + if 'pubkey_encr' in keys_to_save: + self.crypt_keys.set(name,keychain['pubkey_encr'],prefix='/pubkey_encr/') + if 'privkey_encr' in keys_to_save: + self.crypt_keys.set(keychain['pubkey'],keychain['privkey_encr'],prefix='/privkey_encr/') + if 'adminkey_encr' in keys_to_save: + self.crypt_keys.set(keychain['privkey'],keychain['adminkey_encr'],prefix='/adminkey_encr/') + if 'pubkey_encr_encr' in keys_to_save: + self.crypt_keys.set(self.name,keychain['pubkey_decr_encr'],prefix='/pubkey_decr_encr/') + if 'privkey_encr_encr' in keys_to_save: + self.crypt_keys.set(keychain['pubkey_decr'],keychain['privkey_decr_encr'],prefix='/privkey_decr_encr/') + if 'adminkey_encr_encr' in keys_to_save: + self.crypt_keys.set(keychain['privkey_decr'],keychain['adminkey_decr_encr'],prefix='/adminkey_decr_encr/') + if 'pubkey_decr_encr' in keys_to_save: + self.crypt_keys.set(self.name,keychain['pubkey_decr_encr'],prefix='/pubkey_decr_encr/') + if 'privkey_decr_encr' in keys_to_save: + self.crypt_keys.set(keychain['pubkey_decr'],keychain['privkey_decr_encr'],prefix='/privkey_decr_encr/') + if 'adminkey_decr_encr' in keys_to_save: + self.crypt_keys.set(keychain['privkey_decr'],keychain['adminkey_decr_encr'],prefix='/adminkey_decr_encr/') - # # Encrypt original keys - # keychain['pubkey_encr'] = SCellSeal(key=pubkey_decr).encrypt(pubkey) - # keychain['privkey_encr'] = SCellSeal(key=privkey_decr).encrypt(privkey) - # keychain['adminkey_encr'] = SCellSeal(key=adminkey_decr).encrypt(adminkey) - - double_enc = ['pubkey_decr_encr','pubkey_encr_encr','pubkey_decr_encr','pubkey_encr_encr','pubkey_decr_encr','pubkey_encr_encr'] - for xkey in double_encr: - if xkey in to_return or xkey in to_save: - xkey_orig = xkey[:-len('_encr')] - keychain[xkey] = self.cell_dblencr.encrypt(**) - - # store encrypted on my hardware - if save_encrypted: - self.crypt_keys.set(name,pubkey_encr,prefix='/pubkey_encr/') - self.crypt_keys.set(pubkey,privkey_encr,prefix='/privkey_encr/') - self.crypt_keys.set(privkey,adminkey_encr,prefix='/adminkey_encr/') + if 'pubkey_decr' in keys_to_save: + self.crypt_keys.set(name,keychain['pubkey_decr'],prefix='/pubkey_decr/') + if 'privkey_decr' in keys_to_save: + self.crypt_keys.set(pubkey,keychain['privkey_decr'],prefix='/privkey_decr/') + if 'adminkey_decr' in keys_to_save: + self.crypt_keys.set(privkey,keychain['adminkey_decr'],prefix='/adminkey_decr/') + if 'pubkey_decr_decr' in keys_to_save: + self.crypt_keys.set(self.name,keychain['pubkey_decr_decr'],prefix='/pubkey_decr_decr/') + if 'privkey_decr_decr' in keys_to_save: + self.crypt_keys.set(keychain['pubkey_decr'],keychain['privkey_decr_decr'],prefix='/privkey_decr_decr/') + if 'adminkey_decr_decr' in keys_to_save: + self.crypt_keys.set(keychain['privkey_decr'],keychain['adminkey_decr_decr'],prefix='/adminkey_decr_decr/') + if 'pubkey_decr_decr' in keys_to_save: + self.crypt_keys.set(self.name,keychain['pubkey_decr_decr'],prefix='/pubkey_decr_decr/') + if 'privkey_decr_decr' in keys_to_save: + self.crypt_keys.set(keychain['pubkey_decr'],keychain['privkey_decr_decr'],prefix='/privkey_decr_decr/') + if 'adminkey_decr_decr' in keys_to_save: + self.crypt_keys.set(keychain['privkey_decr'],keychain['adminkey_decr_decr'],prefix='/adminkey_decr_decr/') + # store permissions file? - secret_admin_val = pubkey_encr + BSEP + b'find,read,admin' - if pubkey_is_public: secret_admin_val += b'*'+BSEP+b'find' - secret_admin_val_encr = SCellSeal(key=adminkey).encrypt(secret_admin_val) - if save_encrypted: - self.crypt_keys.set(adminkey,secret_admin_val_encr,prefix='/permkey_encr/') - - # keep public key? - if pubkey_is_public: - self.crypt_keys.set(name,pubkey_decr,prefix='/pubkey_decr/') - - # send back decryption keys to client - toreturn={} - if return_decrypted: - toreturn['pubkey_decr']=pubkey_decr - toreturn['privkey_decr']=privkey_decr - toreturn['adminkey_decr']=adminkey_decr + # if 'permkey_encr' in keys_to_save: + # secret_admin_val = keychain['pubkey_encr'] + BSEP + b'find,read,admin' + # secret_admin_val_encr = SCellSeal(key=keychain['adminkey']).encrypt(secret_admin_val) + # self.crypt_keys.set(adminkey,secret_admin_val_encr,prefix='/permkey_encr/') - if return_encrypted: - toreturn['pubkey_encr']=pubkey_encr - toreturn['privkey_encr']=privkey_encr - toreturn['adminkey_encr']=adminkey_encr - - return toreturn + + keychain_toreturn = defaultdict(None) + for k in keys_to_return: + if k in keychain: + keychain_toreturn[k] = keychain[k] + + return keychain_toreturn @property def cell_dblencr(self): @@ -437,4 +535,11 @@ class Keymaker(Logger): if res: _keychain[keyname]=res return _keychain - \ No newline at end of file + + + +if __name__ == '__main__': + keymaker = Keymaker('marx69') + keychain = keymaker.forge_new_keys() + + print(keychain) \ No newline at end of file diff --git a/komrade/backend/the_operator.py b/komrade/backend/the_operator.py index b824de6..76bb4e8 100644 --- a/komrade/backend/the_operator.py +++ b/komrade/backend/the_operator.py @@ -65,25 +65,25 @@ def init_operators(): phone = Operator( name=TELEPHONE_NAME, - path_crypt_keys=PATH_CRYPT_CA_KEYS, - path_crypt_data=PATH_CRYPT_CA_DATA + path_crypt_keys=PATH_CRYPT_OP_KEYS, + path_crypt_data=PATH_CRYPT_OP_KEYS ) op_decr_keys = op.get_new_keys( - adminkey_pass=True, pubkey_pass=None, privkey_pass=None, - save_encrypted=True, return_encrypted=False, - save_decrypted=False, return_decrypted=True + keys_to_save = ['pubkey_encr', 'privkey_encr', 'adminkey_encr'], + keys_to_return = ['pubkey_decr', 'privkey_decr', 'adminkey_decr'] + ) ) phone_decr_keys = phone.get_new_keys( - adminkey_pass=True, pubkey_pass=None, privkey_pass=None, - save_encrypted=True, return_encrypted=False, - save_decrypted=False, return_decrypted=True - ) + keys_to_save = ['pubkey_encr', 'privkey_encr', 'adminkey_encr'], + keys_to_return = ['pubkey_decr', 'privkey_decr', 'adminkey_decr'] + ) + + self.log('OPERATOR_KEYCHAIN =',op_decr_keys) - print('op_decr_keys',op_decr_keys) + self.log('TELEPHONE_KEYCHAIN =',phone_decr_keys) - print('phone_decr_keys',phone_decr_keys) # op_pub = op.pubkey_decr_ # phone_pub = phone.pubkey_decr_ diff --git a/komrade/constants.py b/komrade/constants.py index 43d1746..ec4fba9 100644 --- a/komrade/constants.py +++ b/komrade/constants.py @@ -49,8 +49,13 @@ OPERATOR_INTERCEPT_MESSAGE = "If you'd like to make a call, please hang up and t -KEYMAKER_DEFAULT_KEYS_TO_SAVE = ['pubkey_encr', 'privkey_encr', 'adminkey_encr'], -KEYMAKER_DEFAULT_KEYS_TO_RETURN = ['pubkey_decr', 'privkey_decr', 'adminkey_decr'], +KEYMAKER_DEFAULT_KEYS_TO_SAVE = ['pubkey_encr', 'privkey_encr', 'adminkey_encr'] +KEYMAKER_DEFAULT_KEYS_TO_RETURN = ['pubkey_decr_decr','pubkey_decr_encr', + 'privkey_decr_decr','privkey_decr_encr', + 'adminkey_decr_decr','adminkey_decr_encr' + ] +KEYMAKER_DEFAULT_KEYS_TO_GEN = ['pubkey','privkey','adminkey','pubkey_decr', 'privkey_decr', 'adminkey_decr'] + KEYMAKER_DEFAULT_KEYS_TO_SAVE + KEYMAKER_DEFAULT_KEYS_TO_RETURN + KEY_TYPE_ASYMMETRIC_PUBKEY = 'asymmetric_pubkey' KEY_TYPE_ASYMMETRIC_PRIVKEY = 'asymmetric_privkey' @@ -61,7 +66,7 @@ ENCRYPTED_KEY = 'encrypted_key' KEYMAKER_DEFAULT_KEY_TYPES = { 'pubkey':KEY_TYPE_ASYMMETRIC_PUBKEY, - 'privkey':KEY_TYPE_ASYMMETRIC_PRIVKEY + 'privkey':KEY_TYPE_ASYMMETRIC_PRIVKEY, 'adminkey':KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE, 'pubkey_decr':KEY_TYPE_SYMMETRIC_WITHOUT_PASSPHRASE, @@ -70,7 +75,7 @@ KEYMAKER_DEFAULT_KEY_TYPES = { 'pubkey_decr_decr':KEY_TYPE_SYMMETRIC_WITHOUT_PASSPHRASE, 'privkey_decr_decr':KEY_TYPE_SYMMETRIC_WITH_PASSPHRASE, - 'adminkey_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,