updates

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)

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
 

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)

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):

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/')