updates

komrade/backend/keymaker.py

@@ -8,7 +8,6 @@ class KomradeKey(ABC):
     def encrypt(self,msg,**kwargs): pass
     @abstractmethod
     def decrypt(self,msg,**kwargs): pass
-
     @abstractmethod
     def data(self): pass
 
@@ -142,7 +141,18 @@ class Keymaker(Logger):
     def privkey(self): return self.keychain().get('privkey')
     @property
     def adminkey(self): return self.keychain().get('adminkey')
-
+    @property
+    def pubkey_encr(self): return self.keychain().get('pubkey_encr')
+    @property
+    def privkey_encr(self): return self.keychain().get('privkey_encr')
+    @property
+    def adminkey_encr(self): return self.keychain().get('adminkey_encr')
+    @property
+    def pubkey_decr(self): return self.keychain().get('pubkey_decr')
+    @property
+    def privkey_decr(self): return self.keychain().get('privkey_decr')
+    @property
+    def adminkey_decr(self): return self.keychain().get('adminkey_decr')
 
 
     def load_qr(self,name):
@@ -185,8 +195,11 @@ class Keymaker(Logger):
             self._crypt_data = Crypt(fn=self.path_crypt_data)
         return self._crypt_data
 
-    def exists(self):
-        return self.crypt_keys.exists(self.name,prefix='/pubkey_encr/') or self.crypt_keys.exists(self.name,prefix='/pubkey_decr/') or self.crypt_keys.exists(self.name,prefix='/pubkey/')
+    def can_log_in(self):
+        if not self.pubkey: return False
+        if not (self.privkey or self.privkey_encr): return False
+        return True
+    
 
     ### CREATING KEYS
     

komrade/backend/operators.py

@@ -14,19 +14,19 @@ class Operator(Keymaker):
     def __init__(self, name, passphrase=DEBUG_DEFAULT_PASSPHRASE, keychain = {}, path_crypt_keys=PATH_CRYPT_CA_KEYS, path_crypt_data=PATH_CRYPT_CA_DATA):
         super().__init__(name=name,passphrase=passphrase, keychain=keychain,
                          path_crypt_keys=path_crypt_keys, path_crypt_data=path_crypt_data)
-        self.boot(create=False)
+        # self.boot(create=False)
 
         # connect phonelines?
         from komrade.backend.phonelines import connect_phonelines
         self.operator_keychain,self.telephone_keychain,self.omega_key = connect_phonelines()
 
-    def boot(self,create=False):
-         # Do I have my keys?
-        have_keys = self.exists()
+    # def boot(self,create=False):
+    #      # Do I have my keys?
+    #     have_keys = self.exists()
         
-        # If not, forge them -- only once!
-        if not have_keys and create:
-            self.get_new_keys()
+    #     # If not, forge them -- only once!
+    #     if not have_keys and create:
+    #         self.get_new_keys()
         
     
     @property
@@ -102,22 +102,6 @@ class Operator(Keymaker):
         msg_obj.decrypt()
         return msg_obj
 
-    # def package_msg_to(self,msg,another):
-    #     # otherwise send msg
-    #     return self.compose_msg_to(msg,another)
-
-    
-    # def unpackage_msg_from(self,msg_encr_b,another):
-    #     return self.decrypt_from_send(
-    #         msg_encr_b,
-    #         from_pubkey=another.pubkey,
-    #         to_privkey=self.privkey
-    #     )
-
-    
-    # self = caller
-    # towhom = phone
-    # bywayof = op
     def ring_ring(self,msg,to_whom,get_resp_from=None):
         # get encr msg obj
         msg_obj = self.compose_msg_to(msg, to_whom)

komrade/backend/people.py

@@ -3,76 +3,42 @@ from komrade import *
 from komrade.backend import *
 
 
-class Person(Caller):
+class Persona(Caller):
 
-    # def ring_ring(self,msg,to_whom = None):
-    #     # if no one intended, call the operator
-    #     #return super().ring_ring(with_msg,to_phone=self.op)
-    #     if not to_whom: to_whom = self.op
+    def __init__(self, name, passphrase=DEBUG_DEFAULT_PASSPHRASE):
+        super().__init__(name=name,passphrase=passphrase)
+        self.boot(create=False)
 
-    
+    def boot(self,create=False):
+        # Do I already have my keys?
+        # yes? -- login
 
-        # # create a message, caller 2 caller
-        # msg_obj = self.compose_msg_to(msg, to_whom)
+        keys = self.keychain()
+        if keys.get('pubkey') and keys.get('privkey'):
+            self.log('booted!')
+            return True
         
-        # # ring 2: use 'Caller' class to dial and get response
-        # resp_msg_obj = super().ring_ring(
-        #     msg_obj
-        # )
-        # self.log('resp_msg_encr_caller2caller',resp_msg_encr_caller2caller)
-
-        # # ring 3: decrypt and send back
-        # resp_msg_unencr = self.unpackage_msg_from(
-        #     msg_encr_caller2caller,
-        #     to_whom
-        # )
-        # self.log('resp_msg_unencr',resp_msg_encr_caller2caller)
-
-        # return resp_msg_unencr
-
-    # def ring_ring(self,with_msg,to_whom = None):
-    #     # if no one intended, call the operator
-    #     #return super().ring_ring(with_msg,to_phone=self.op)
-    #     if not to_whom: to_whom = self.op
-
-    #     # msg should be unencrypted
-    #     msg_unencr = with_msg
-    #     self.log('msg_unencr',msg_unencr)
-
-    #     # ring 1: encrypt caller2phone
-    #     msg_encr_caller2caller = self.package_msg_to(
-    #         msg_unencr,
-    #         to_whom
-    #     )
-    #     self.log('msg_encr_caller2caller!',msg_encr_caller2caller)
-
-    #     # ring 2: use 'Caller' class to dial and get response
-    #     resp_msg_encr_caller2caller = super().ring_ring(
-    #         msg_encr_caller2caller
-    #     )
-    #     self.log('resp_msg_encr_caller2caller',resp_msg_encr_caller2caller)
-
-    #     # ring 3: decrypt and send back
-    #     resp_msg_unencr = self.unpackage_msg_from(
-    #         msg_encr_caller2caller,
-    #         to_whom
-    #     )
-    #     self.log('resp_msg_unencr',resp_msg_encr_caller2caller)
-
-    #     return resp_msg_unencr
+        # If not, forge them -- only once!
+        if not have_keys and create:
+            self.get_new_keys()
 
-    def send_msg_to(self,msg,to_whom):
-        msg = {'_please':'deliver_to', 'msg':msg}
-        return self.ring_ring(msg,to_whom)
-
-    def ring_ring(self,msg,to_whom):
-        return super(Caller,self).ring_ring(
-            msg,
-            to_whom,
-            get_resp_from=super().ring_ring
+
+    def exists_locally_as_contact(self):
+        return self.pubkey and not self.privkey
+
+    def exists_locally_as_persona(self):
+        return self.pubkey and self.privkey
+
+    def exists_on_server(self):
+        answer = self.ring_ring(
+            msg={'_please':'does_username_exist','name':self.name}
         )
 
 
+    # login?
+    def login(self):
+        if keys.get('pubkey') and keys.get('privkey')
+
 
     def register(self, name = None, passphrase = DEBUG_DEFAULT_PASSPHRASE, is_group=None):
         # get needed metadata
@@ -94,9 +60,6 @@ class Person(Caller):
         # get message back
         msg_obj = self.phone.ring_ring(msg_to_op)
         phone_res = msg_obj.msg
-        
-        print('GOT BACK!!!',msg_obj)
-
 
         # URI id
         uri_id = phone_res.get('uri_id')
@@ -111,85 +74,27 @@ class Person(Caller):
         saved_keys = self.save_keychain(name,returned_keys,uri_id=uri_id)
         self.log('saved keys!',saved_keys)
 
-        # save my qr?
-
-        # better have the right keys
-        # assert set(KEYMAKER_DEFAULT_KEYS_TO_SAVE) == set(saved_keys.keys())
-
         # success!
         self.log('yay!!!!')
         return saved_keys
 
 
+    def ring_ring(self,msg):
+        return super().ring_ring(msg)
 
-    # def register(self,name=None,passphrase=DEBUG_DEFAULT_PASSPHRASE, is_group=None):
-    #     # get needed metadata
-    #     if not name: name=self.name
-    #     if name is None: 
-    #         name = input('\nWhat is the name for this account? ')
-    #     if passphrase is None:
-    #         passphrase = getpass.getpass('\nEnter a memborable password: ')
-    #     # if is_group is None:
-    #         # is_group = input('\nIs this a group account? [y/N]').strip().lower() == 'y'
-
-    #     # form request to operator
-    #     msg_to_op = {'_please':'forge_new_keys'}
-
-    #     msg_response = self.phone.ring_ring(
-    #         msg_to_op,
-    #         self.op
-    #     )
-
-    #     # call and ask operator to register us
+    def send_msg_to(self,msg,to_whom):
+        msg = self.compose_msg_to(msg,to_whom)
         
-    #     # for only this one! we skip straight to phone,
-    #     # since I don't have any public keys yet
-
-    #     resp = self.phone.ring_ring(msg_to_op)
-
-    #     return resp
-
-
-    # def get_new_keys(self, name = None, passphrase = DEBUG_DEFAULT_PASSPHRASE, is_group=None):
-    #     # get needed metadata
-    #     if not name: name=self.name
-    #     if name is None: 
-    #         name = input('\nWhat is the name for this account? ')
-    #     if passphrase is None:
-    #         passphrase = getpass.getpass('\nEnter a memborable password: ')
-    #     # if is_group is None:
-    #         # is_group = input('\nIs this a group account? [y/N]').strip().lower() == 'y'
-
+        {'_please':'deliver_to', 'msg':msg}
         
+        return self.ring_ring(msg)
 
-    #     phone_res = self.phone.ring(msg_to_op)
-        
-    #     # URI id
-    #     uri_id = phone_res.get('uri_id')
-    #     returned_keys = phone_res.get('_keychain')
-    #     self.log('got URI from Op:',uri_id)
-    #     self.log('got returnd keys from Op:',returned_keys)
-
-    #     stop
-
-    #     # better have the right keys
-    #     assert set(KEYMAKER_DEFAULT_KEYS_TO_SAVE_ON_CLIENT) == set(returned_keys.keys())
-
-    #     # now save these keys!
-    #     saved_keys = self.save_keychain(name,returned_keys,uri_id=uri_id)
-    #     self.log('saved keys!',saved_keys)
-
-    #     # better have the right keys
-    #     # assert set(KEYMAKER_DEFAULT_KEYS_TO_SAVE) == set(saved_keys.keys())
-
-    #     # success!
-    #     self.log('yay!!!!')
-    #     return saved_keys
+    
 
 
 if __name__=='__main__':
-    marx = Person('marx')
-    elon = Person('elon')
+    marx = Persona('marx')
+    elon = Persona('elon')
 
     # marx.register()
     # elon.register()
@@ -197,4 +102,4 @@ if __name__=='__main__':
     # print(person.pubkey)
 
     # elon.send_msg_to('youre dumb',marx)
-    Caller('elon').ring_ring({'_please':'say_hello',{'_msg':'my dumb message to operator'}})
+    Caller('elon').ring_ring({'_please':'say_hello','_msg':'my dumb message to operator'})

komrade/backend/the_operator.py

@@ -102,13 +102,20 @@ class TheOperator(Operator):
         if type(data)==dict and ROUTE_KEYNAME in data:
             del data[ROUTE_KEYNAME]
 
-        # hard code the acceptable routes
+        ## hard code the acceptable routes
         if route == 'forge_new_keys':
             return self.forge_new_keys(data)
+        elif route == 'does_user_exist':
+            return self.does_user_exist(data)
         
         # otherwise, hang up and try again
         return OPERATOR_INTERCEPT_MESSAGE
 
+
+
+
+
+    ### ROUTES
     def forge_new_keys(self,data):
         self.log('about to make some new keys!',data)
         # return {'_please':'well_hello_to_you_too'}
@@ -119,6 +126,11 @@ class TheOperator(Operator):
         # return to Telephone/Caller
         return forged_keys_plus_id
         
+    def does_user_exist(self,data):
+        assert type(data)==dict and 'name' in data and data['name']
+        # find pubkey?
+        return self.crypt_keys.get(data['name'],prefix='/pubkey/')
+