updates

komrade/backend/callers.py

@@ -12,6 +12,7 @@ class Caller(Operator):
     """
 
     def ring_ring(self,msg):
+        # stop
         return super().ring_ring(
             msg,
             to_whom=self.op,

komrade/backend/keymaker.py

@@ -107,7 +107,14 @@ class Keymaker(Logger):
         raise KomradeException(f'I don\'t know my public key!\n{self}\n{self._keychain}')
         #return None
 
-        
+
+    @property
+    def keys(self):
+        return sorted(list(self.keychain().keys()))
+    
+    @property
+    def top_keys(self):
+        return [k for k in self.keys if k.count('_')==0]
 
     def keychain(self,look_for=KEYMAKER_DEFAULT_ALL_KEY_NAMES):
         # load existing keychain
@@ -158,7 +165,6 @@ class Keymaker(Logger):
     def load_qr(self,name):
         # try to load?
         contact_fnfn = os.path.join(PATH_QRCODES,name+'.png')
-        print(contact_fnfn,os.path.exists(contact_fnfn))
         if not os.path.exists(contact_fnfn): return ''
         # with open(contact_fnfn,'rb') as f: dat=f.read()
         from pyzbar.pyzbar import decode

komrade/backend/messages.py

@@ -40,19 +40,12 @@ class Message(Logger):
     def __repr__(self):
         return f"""
     
-    <MESSAGE>
+    <MSG>
-        self.caller={self.callee}
+        self.caller={self.caller}
-        self.from_name={self.from_name}
+        self.callee={self.callee}
-        self.from_pubkey={self.from_pubkey}
-        
-        self.callee={self.caller}
-        self.to_name={self.to_name}
-        self.to_pubkey={self.to_pubkey}
-        
         self.msg={self.msg}
-        
+        self.route={self.route}
-        self._route={self.route}
+    </MSG>
-    </MESSAGE>
 
         """
 
@@ -110,7 +103,7 @@ class Message(Logger):
             return False
         return True
 
-    def decrypt(self,recursive=True):
+    def decrypt(self,recursive=False):
         # get callers
         caller,callee = self.get_callers()
         self.log(f'attempting to decrypt msg {self.msg} from {caller} to {callee}')
@@ -134,7 +127,7 @@ class Message(Logger):
         return decr_msg
 
 
-    def encrypt(self,recursive=True):
+    def encrypt(self,recursive=False):
         """
         Assuming that a recursive message looks like this:
         <MESSAGE>
@@ -163,7 +156,7 @@ class Message(Logger):
         </MESSAGE>
         """
         if self.is_encrypted: return
-        self.log(f'attempting to encrypt msg {self.msg} from {self.caller} to {self.callee}')
+        # self.log(f'attempting to encrypt msg {self.msg} from {self.caller} to {self.callee}')
         self.log(f'I now look like v1: {self}')
 
         if not self.has_embedded_msg:
@@ -180,7 +173,7 @@ class Message(Logger):
             self.caller.privkey,
             self.callee.pubkey
         )
-        self.log('created an encrypted msg:',encr_msg)
+        # self.log('created an encrypted msg:',encr_msg)
         self.msg_decr = self.msg
         self.msg = encr_msg
         self.msg_d['_msg'] = encr_msg
@@ -193,28 +186,21 @@ class Message(Logger):
 
     ## creating/encrypting/rolling up messages
     def encrypt_to_send(self,msg_json,from_privkey,to_pubkey):
-        self.log('msg_json',msg_json)
-        self.log('from_privkey',from_privkey)
-        self.log('to_pubkey',to_pubkey)
-        
-        
-        
         if not msg_json or not from_privkey or not to_pubkey:
-            self.log('not enough info!',msg_json,from_privkey,to_pubkey)
+            raise KomradeException(f'not enough info!')
-            whattttttt
+
-            return b''
+        # self.log('packing for transmission: msg_json',type(msg_json),msg_json)
-        self.log('packing for transmission: msg_json',type(msg_json),msg_json)
         msg_b = package_for_transmission(msg_json)
-        self.log('packing for transmission: msg_b',type(msg_b),msg_b)
+        # self.log('packing for transmission: msg_b',type(msg_b),msg_b)
         # try:
-        self.log('from privkey =',from_privkey)
+        # self.log('from privkey =',from_privkey)
-        self.log('to pubkey =',to_pubkey)
+        # self.log('to pubkey =',to_pubkey)
 
         msg_encr = SMessage(
             from_privkey,
             to_pubkey,
         ).wrap(msg_b)
-        self.log('msg_encr',msg_encr)
+        # self.log('msg_encr',msg_encr)
         # stop
         return msg_encr
         # except ThemisError as e:
@@ -281,7 +267,7 @@ def test_msg():
     print('?keychains?')
     pprint(phone.pubkey)
     
-    msg={'_please':'forge_new_keys'}
+    msg={'_route':'forge_new_keys'}
 
 
     resp_msp_obj = phone.ring_ring(msg)

komrade/backend/operators.py

@@ -72,20 +72,22 @@ class Operator(Keymaker):
             '_to_name':another.name,
             '_msg':msg,
         }
-        self.log(f'I am a {type(self)} packaging a message to {another}: {msg_d}')
+        # self.log(f'I am {self} packaging a message to {another}: {msg_d}')
         
         from komrade.backend.messages import Message
         msg_obj = Message(msg_d,caller=self,callee=another)
-        self.log('created msg obj:',msg_obj)
+        # self.log('created msg obj:',msg_obj)
+        
+        
 
         return msg_obj
 
     def seal_msg(self,msg_obj):
         # make sure encrypted
-        msg_obj.encrypt()
+        # msg_obj.encrypt()
         # return pure binary version of self's entire msg_d
         msg_b = package_for_transmission(msg_obj.msg_d)
-        # encrypte by omega key
+        # encrypt by omega key
         msg_b_encr = self.omega_key.encrypt(msg_b)
         return msg_b_encr
 
@@ -99,23 +101,39 @@ class Operator(Keymaker):
         from komrade.backend.messages import Message
         msg_obj = Message(msg_d)
         # decrypt msg
-        msg_obj.decrypt()
+        # msg_obj.decrypt()
         return msg_obj
 
+
+    def __repr__(self):
+        clsname=(type(self)).__name__
+        keystr='+'.join(self.top_keys)
+        return f'[{clsname}] {self.name} ({keystr})'
+
     def ring_ring(self,msg,to_whom,get_resp_from=None):
+        # ring ring
+        self.log(f'ring ring! I, {self}, have been told to pass a message {msg} onto {to_whom}, by way of function {get_resp_from}')
+        
         # get encr msg obj
         msg_obj = self.compose_msg_to(msg, to_whom)
-        # pass onto next person
+        self.log(f'here is the message object I made, to send to {to_whom}: {msg_obj}')
-
+        
+        # encrypting
+        msg_obj.encrypt()
+        # self.log(f'now I look like: {msg_obj}')
         # get pure encrypted binary, sealed
-        msg_sealed = self.seal_msg(msg_obj)
+        #msg_sealed = self.seal_msg(msg_obj)
         
         # pass onto next person...
         if not get_resp_from: get_resp_from=to_whom.ring_ring
-        resp_msg_b = get_resp_from(msg_sealed)
+        resp_msg_obj = get_resp_from(msg_obj)
+        self.log('resp_msg_obj <-',resp_msg_obj)
+
+        # decrypt?
+        resp_msg_obj.decrypt()
 
         # unseal msg
-        resp_msg_obj = self.unseal_msg(resp_msg_b)
+        # resp_msg_obj = self.unseal_msg(resp_msg_b)
 
         return resp_msg_obj
         

komrade/backend/people.py

@@ -7,20 +7,20 @@ class Persona(Caller):
 
     def __init__(self, name, passphrase=DEBUG_DEFAULT_PASSPHRASE):
         super().__init__(name=name,passphrase=passphrase)
-        self.boot(create=False)
+    #     self.boot(create=False)
 
-    def boot(self,create=False):
+    # def boot(self,create=False):
-        # Do I already have my keys?
+    #     # Do I already have my keys?
-        # yes? -- login
+    #     # yes? -- login
 
-        keys = self.keychain()
+    #     keys = self.keychain()
-        if keys.get('pubkey') and keys.get('privkey'):
+    #     if keys.get('pubkey') and keys.get('privkey'):
-            self.log('booted!')
+    #         self.log('booted!')
-            return True
+    #         return True
         
-        # If not, forge them -- only once!
+    #     # If not, forge them -- only once!
-        if not have_keys and create:
+    #     if not have_keys and create:
-            self.get_new_keys()
+    #         self.get_new_keys()
 
 
     def exists_locally_as_contact(self):
@@ -30,9 +30,10 @@ class Persona(Caller):
         return self.pubkey and self.privkey
 
     def exists_on_server(self):
-        answer = self.phone.ring_ring(
+        return self.ring_ring({
-            msg={'_please':'does_username_exist','name':self.name}
+            '_route':'does_username_exist',
-        )
+            'name':self.name
+        })
 
 
     # login?
@@ -52,7 +53,7 @@ class Persona(Caller):
 
         # form request
         msg_to_op = {
-            '_please':'forge_new_keys',
+            '_route':'forge_new_keys',
             'name':name,
             'passphrase':hashish(passphrase.encode())
         }
@@ -85,7 +86,7 @@ class Persona(Caller):
     def send_msg_to(self,msg,to_whom):
         msg = self.compose_msg_to(msg,to_whom)
         
-        {'_please':'deliver_to', 'msg':msg}
+        {'_route':'deliver_to', 'msg':msg}
         
         return self.ring_ring(msg)
 
@@ -96,12 +97,12 @@ if __name__=='__main__':
     marx = Persona('marx')
     elon = Persona('elon')
 
-    marx.register()
+    # marx.register()
     # elon.register()
     # person.register()
     # 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({'_route':'say_hello','_msg':'my dumb message to operator'})
 
     print(marx.exists_on_server())

komrade/backend/the_operator.py

@@ -118,7 +118,7 @@ class TheOperator(Operator):
     ### ROUTES
     def forge_new_keys(self,data):
         self.log('about to make some new keys!',data)
-        # return {'_please':'well_hello_to_you_too'}
+        # return {'_route':'well_hello_to_you_too'}
         
         # get keys
         forged_keys_plus_id = super().forge_new_keys(**data)

komrade/backend/the_telephone.py

@@ -18,8 +18,11 @@ class TheTelephone(Operator):
         return self.telephone_keychain.get('pubkey')
 
     def send_and_receive(self,msg_b):
+        # seal for transport
+        msg_b_sealed = self.seal_msg(msg_b)
+
         # prepare for transmission across net
-        msg_b64 = b64encode(msg_b)
+        msg_b64 = b64encode(msg_b_sealed)
         msg_b64_str = msg_b64.decode()
         msg_b64_str_esc = msg_b64_str.replace('/','_')
         self.log('msg_b64_str_esc',type(msg_b64_str_esc),msg_b64_str_esc)
@@ -38,7 +41,10 @@ class TheTelephone(Operator):
 
         resp_msg_b64 = resp_msg_b64_str.encode()
         resp_msg_b = b64decode(resp_msg_b64)
-        return resp_msg_b
+
+        # unseal
+        resp_msg_b_unsealed = self.unseal_msg(resp_msg_b)
+        return resp_msg_b_unsealed
 
 
     def ring_ring(self,msg):
@@ -58,7 +64,7 @@ def test_call():
     # caller.boot(create=True)
     # print(caller.keychain())
     # phone = TheTelephone()
-    # req_json = {'_please':'forge_new_keys','name':name, 'pubkey_is_public':pubkey_is_public}}
+    # req_json = {'_route':'forge_new_keys','name':name, 'pubkey_is_public':pubkey_is_public}}
     # req_json_s = jsonify(req_json)
     # res = phone.req({'forge_new_keys':{'name':'marx', 'pubkey_is_public':True}})
     # print(res)

komrade/constants.py

@@ -82,9 +82,9 @@ KEYMAKER_DEFAULT_KEYS_TO_GEN += KEYMAKER_DEFAULT_KEYS_TO_SAVE_ON_CLIENT
 KEYMAKER_DEFAULT_KEYS_TO_GEN = list(set(KEYMAKER_DEFAULT_KEYS_TO_GEN))
 KEYMAKER_DEFAULT_KEYS_TO_GEN.sort(key=lambda x: x.count('_'))
 
-print('KEYMAKER_DEFAULT_KEYS_TO_SAVE_ON_SERVER',KEYMAKER_DEFAULT_KEYS_TO_SAVE_ON_SERVER)
+# print('KEYMAKER_DEFAULT_KEYS_TO_SAVE_ON_SERVER',KEYMAKER_DEFAULT_KEYS_TO_SAVE_ON_SERVER)
-print('KEYMAKER_DEFAULT_KEYS_TO_SAVE_ON_CLIENT',KEYMAKER_DEFAULT_KEYS_TO_SAVE_ON_CLIENT)
+# print('KEYMAKER_DEFAULT_KEYS_TO_SAVE_ON_CLIENT',KEYMAKER_DEFAULT_KEYS_TO_SAVE_ON_CLIENT)
-print('KEYMAKER_DEFAULT_KEYS_TO_GEN',KEYMAKER_DEFAULT_KEYS_TO_GEN)
+# print('KEYMAKER_DEFAULT_KEYS_TO_GEN',KEYMAKER_DEFAULT_KEYS_TO_GEN)
 
 
 KEY_TYPE_ASYMMETRIC_PUBKEY = 'asymmetric_pubkey'
@@ -154,4 +154,4 @@ ALLOW_CLEARNET = True
 DEBUG_DEFAULT_PASSPHRASE = 'all your base are belong to us'
 
 
-ROUTE_KEYNAME = '_please'
+ROUTE_KEYNAME = '_route'

komrade/utils.py

@@ -24,6 +24,12 @@ def log(*x):
     tolog=' '.join(str(_) for _ in x)
     LOG(tolog)
 
+def clear_screen():
+    import os
+    os.system('cls' if os.name == 'nt' else 'clear')
+
+def pause():
+    input('')
 
 import inspect
 class Logger(object):
@@ -33,6 +39,11 @@ class Logger(object):
         mytype = type(self).__name__
         caller = calframe[1][3]
         log(f'\n[{mytype}.{caller}()]',*x)
+        try:
+            pause()
+            clear_screen()
+        except KeyboardInterrupt:
+            exit()
 
 import binascii,base64
 def isBase64(sb):