From 4143fd9872d34d51a74513ad0e552dd1c0d5ab2d Mon Sep 17 00:00:00 2001 From: quadrismegistus Date: Sat, 12 Sep 2020 15:32:03 +0100 Subject: [PATCH] updates --- komrade/backend/callers.py | 5 +- komrade/backend/crypt.py | 3 +- komrade/backend/keymaker.py | 215 ++++++++++++++----------------- komrade/backend/operators.py | 24 ++-- komrade/backend/people.py | 27 ++-- komrade/backend/phonelines.py | 24 +++- komrade/backend/the_operator.py | 2 +- komrade/backend/the_telephone.py | 7 +- komrade/constants.py | 34 +---- komrade/utils.py | 11 ++ 10 files changed, 167 insertions(+), 185 deletions(-) diff --git a/komrade/backend/callers.py b/komrade/backend/callers.py index 6f7da60..4abd646 100644 --- a/komrade/backend/callers.py +++ b/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 ) diff --git a/komrade/backend/crypt.py b/komrade/backend/crypt.py index 8a75d75..3f39149 100644 --- a/komrade/backend/crypt.py +++ b/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): diff --git a/komrade/backend/keymaker.py b/komrade/backend/keymaker.py index b8bde93..53da8ac 100644 --- a/komrade/backend/keymaker.py +++ 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__': diff --git a/komrade/backend/operators.py b/komrade/backend/operators.py index 78cd98c..37aa790 100644 --- a/komrade/backend/operators.py +++ b/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}') diff --git a/komrade/backend/people.py b/komrade/backend/people.py index 86bd985..15377ac 100644 --- a/komrade/backend/people.py +++ b/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() diff --git a/komrade/backend/phonelines.py b/komrade/backend/phonelines.py index 1ea3a37..ff1c137 100644 --- a/komrade/backend/phonelines.py +++ b/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: diff --git a/komrade/backend/the_operator.py b/komrade/backend/the_operator.py index ba9cb24..3760dcd 100644 --- a/komrade/backend/the_operator.py +++ b/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, diff --git a/komrade/backend/the_telephone.py b/komrade/backend/the_telephone.py index ad84e94..7f06af2 100644 --- a/komrade/backend/the_telephone.py +++ b/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 ) diff --git a/komrade/constants.py b/komrade/constants.py index 97901f9..7bd592c 100644 --- a/komrade/constants.py +++ b/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? ' diff --git a/komrade/utils.py b/komrade/utils.py index 0033ac3..4845822 100644 --- a/komrade/utils.py +++ b/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