From e9bc6fa775501e3e936a45664c5766108c055f2b Mon Sep 17 00:00:00 2001 From: quadrismegistus Date: Sat, 12 Sep 2020 21:19:53 +0100 Subject: [PATCH] updates --- komrade/backend/crypt.py | 11 +++++--- komrade/backend/keymaker.py | 45 ++++++++++++++++++++++++++----- komrade/backend/messages.py | 13 ++++++--- komrade/backend/operators.py | 51 ++++++++++++++++++++++------------- komrade/backend/phonelines.py | 3 +++ 5 files changed, 92 insertions(+), 31 deletions(-) diff --git a/komrade/backend/crypt.py b/komrade/backend/crypt.py index 3cffb8a..5967e1f 100644 --- a/komrade/backend/crypt.py +++ b/komrade/backend/crypt.py @@ -70,15 +70,18 @@ class Crypt(Logger): k_b = self.force_binary(k) if self.cell is not None: k_b = self.cell.encrypt(k_b) - return b64encode(k_b) + if not isBase64(k_b): k_b = b64encode(k_b) + return k_b def unpackage_val(self,k_b): try: if self.cell is not None: k_b = self.cell.decrypt(k_b) - return b64decode(k_b) - except ThemisError: - pass + except ThemisError as e: + self.log('error decrypting!',e,k_b) + return + if isBase64(k_b): k_b = b64decode(k_b) + return k_b def has(self,k,prefix=''): k_b=self.package_key(k,prefix=prefix) diff --git a/komrade/backend/keymaker.py b/komrade/backend/keymaker.py index a5d6bf4..573675c 100644 --- a/komrade/backend/keymaker.py +++ b/komrade/backend/keymaker.py @@ -22,6 +22,9 @@ class KomradeKey(ABC,Logger): @property def data_b64(self):return b64encode(self.data) if type(self.data)==bytes else self.data.data_b64 @property + def data_b64_s(self): + reeturn self.data_b64.decode() + @property def discreet(self): return make_key_discreet(self.data) def __str__(self): return repr(self) @@ -236,7 +239,8 @@ class Keymaker(Logger): self.path_crypt_data=path_crypt_data - def find_pubkey(self): + def find_pubkey(self,name=None): + if not name: name=self.name if 'pubkey' in self._keychain and self._keychain['pubkey']: return self._keychain['pubkey'] @@ -251,6 +255,11 @@ class Keymaker(Logger): # raise KomradeException(f'I don\'t know my public key!\n{self}\n{self._keychain}') return None + def find_name(self,pubkey_b64): + res = self.crypt_keys.get(pubkey_b64.decode(), prefix='/name/') + self.log('result from crypt for name:',res) + return res + @property def keys(self): @@ -265,13 +274,38 @@ class Keymaker(Logger): keychain[keyname] = get_key_obj(keyname,keyval) return keychain + def find_pubkey_and_name(self,name=None,pubkey=None): + if not pubkey: pubkey = self._keychain.get('pubkey') + if not name: name = self.name + + if pubkey: + if hasattr(pubkey,'data'): + pubkey=pubkey.data_b64 + else: + pubkey=b64encode(pubkey) if not isBase64(pubkey) else pubkey + + if name and pubkey: + # make sure they match + assert self.find_pubkey(name) == self.find_name(pubkey) + elif name and not pubkey: + pubkey = self.find_pubkey(name) + elif pubkey and not name: + self.name = self.find_name(pubkey) + else: + self.log('error! Neither name nor pubkey! Who am I?') + return (None,None) + + self._keychain['pubkey'] = pubkey + self.name = name + + return (name,pubkey) + def keychain(self,look_for=KEYMAKER_DEFAULT_ALL_KEY_NAMES): # load existing keychain - keys = self._keychain #self._keychain = keys = {**self._keychain} + keys = self._keychain # make sure we have the pubkey - if not 'pubkey' in self._keychain: self._keychain['pubkey']=self.find_pubkey() - pubkey=self._keychain['pubkey'] + name,pubkey = self.find_pubkey_and_name # get uri uri = b64encode(pubkey) if type(pubkey)==bytes else b64encode(pubkey.data) @@ -280,7 +314,6 @@ class Keymaker(Logger): 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]=get_key_obj(keyname,key) #get_encrypted_key_obj(key,keyname) # try to assemble keys = self.assemble(self.assemble(keys)) @@ -329,7 +362,7 @@ class Keymaker(Logger): @property def uri_id(self): if not self._uri_id: - pubkey = self.find_pubkey() + pubkey = self.pubkey #find_pubkey() self._uri_id = b64encode(pubkey) return self._uri_id diff --git a/komrade/backend/messages.py b/komrade/backend/messages.py index 8e12f73..4a8982b 100644 --- a/komrade/backend/messages.py +++ b/komrade/backend/messages.py @@ -73,9 +73,9 @@ class Message(Logger): if new_msg: self.msg=self.msg_d['msg']=new_msg - def get_whom(self,name): + def get_whom(self,name=None,pubkey=None): from komrade.backend.operators import locate_an_operator - return locate_an_operator(name) + return locate_an_operator(name=None,pubkey=None) @property def from_whom(self): @@ -89,8 +89,15 @@ class Message(Logger): self._from_whom,self._to_whom = self.get_from_whoms() return self._to_whom - ## loading messages def get_whoms(self): + if self._from_whom is None or self._to_whom is None: + self._from_whom = locate_an_operator(self.from_name,self.from_pub) + self._to_whom = locate_an_operator(self.to_name,self.to_pub) + return self._from_whom,self._to_whom + + + ## loading messages + def get_whoms1(self): if self._from_whom is not None and self._to_whom is not None: return (self._from_whom,self._to_whom) alleged_from_whom = self.get_whom(self.from_name) diff --git a/komrade/backend/operators.py b/komrade/backend/operators.py index a4f3b0d..477c4ce 100644 --- a/komrade/backend/operators.py +++ b/komrade/backend/operators.py @@ -8,34 +8,54 @@ from komrade import * from komrade.backend import * -def locate_an_operator(name): +def locate_an_operator(name=None,pubkey=None): global OPERATOR,TELEPHONE from komrade.backend.the_operator import TheOperator from komrade.backend.the_telephone import TheTelephone from komrade.backend.callers import Caller + if not OPERATOR: OPERATOR = TheOperator() + if not TELEPHONE: TELEPHONE = TheTelephone() + + if pubkey: + assert type(pubkey)==bytes + if not isBase64(pubkey): pubkey=b64encode(pubkey) if name == OPERATOR_NAME: - return OPERATOR if OPERATOR else TheOperator() - if name == TELEPHONE_NAME: - return TELEPHONE if TELEPHONE else TheTelephone() - return Caller(name) + return OPERATOR + if pubkey and pubkey == OPERATOR.pubkey.data_b64: + return OPERATOR + if name==TELEPHONE_NAME: + return TELEPHONE + if pubkey and pubkey == TELEPHONE.pubkey.data_b64 + return TELEPHONE + + return Caller(name=name,pubkey=pubkey) from komrade.constants import OPERATOR_ROUTES class Operator(Keymaker): ROUTES = OPERATOR_ROUTES - def __init__(self, name, passphrase=DEBUG_DEFAULT_PASSPHRASE, keychain = {}, path_crypt_keys=PATH_CRYPT_CA_KEYS, path_crypt_data=PATH_CRYPT_CA_DATA): + def __init__(self, name=None, pubkey=None, passphrase=DEBUG_DEFAULT_PASSPHRASE, keychain = {}, path_crypt_keys=PATH_CRYPT_CA_KEYS, path_crypt_data=PATH_CRYPT_CA_DATA): + if pubkey: + assert type(pubkey)==bytes + if isBase64(pubkey): pubkey = b64decode(pubkey) + if keychain.get('pubkey'): + assert keychain.get('pubkey').data == pubkey: + else: + keychain['pubkey']=KomradeAsymmetricPublicKey(pubkey) + super().__init__(name=name,passphrase=passphrase, keychain=keychain, path_crypt_keys=path_crypt_keys, path_crypt_data=path_crypt_data) - # self.boot(create=False) - from komrade.backend.phonelines import check_phonelines - check_phonelines() - - # print(self.crypt_keys.get(OPERATOR_NAME,prefix='/pubkey/')) - # stop + + def boot(self): + ## get both name and pubkey somehow + if not self.pubkey and self.name: + self._keychain['pubkey'] = self.find_pubkey() + elif self.pubkey and not self.name: + # def boot(self,create=False): # # Do I have my keys? @@ -149,12 +169,7 @@ class Operator(Keymaker): pubk = '' return f'{name}' #' ({keystr})' - def locate_an_operator(self,name): - if name == OPERATOR_NAME: - return TheOperator() - if name == TELEPHONE_NAME: - return TheTelephone() - return Caller(name) + def route_msg(self,msg_obj,reencrypt=True): diff --git a/komrade/backend/phonelines.py b/komrade/backend/phonelines.py index ad8a5e5..b364bf0 100644 --- a/komrade/backend/phonelines.py +++ b/komrade/backend/phonelines.py @@ -19,6 +19,7 @@ def create_phonelines(): # save pub and priv op_uri = op_pubkey.data_b64 keycrypt.set(OPERATOR_NAME,op_pubkey.data,prefix='/pubkey/') + keycrypt.set(op_pubkey.data_b64_s,OPERATOR_NAME,prefix='/name/') keycrypt.set(op_uri,op_privkey_encr.data,prefix='/privkey_encr/') @@ -32,6 +33,7 @@ def create_phonelines(): # save pub and priv keycrypt.set(TELEPHONE_NAME,phone_pubkey.data,prefix='/pubkey/') + keycrypt.set(phone_pubkey.data_b64_s,TELEPHONE_NAME,prefix='/name/') ## world world_keypair = KomradeAsymmetricKey() @@ -43,6 +45,7 @@ def create_phonelines(): # save pub and priv world_uri = world_pubkey.data_b64 keycrypt.set(WORLD_NAME,world_pubkey.data,prefix='/pubkey/') + keycrypt.set(world_pubkey.data_b64_s,WORLD_NAME,prefix='/name/') keycrypt.set(world_uri,world_privkey_encr.data,prefix='/privkey_encr/')