updates

komrade/backend/__init__.py

@@ -14,7 +14,7 @@ from .the_telephone import *
 from .callers import *
 
 from .phonelines import *
-
+from .messages import *
 
 ## define default entities
 OPERATOR = None

komrade/backend/messages.py

@@ -0,0 +1,82 @@
+import os,sys; sys.path.append(os.path.abspath(os.path.join(os.path.abspath(os.path.join(os.path.dirname(__file__),'..')),'..')))
+from komrade import *
+from komrade.backend import *
+
+
+def is_valid_msg_d(msg_d):
+    if not type(msg_d)==dict: return False
+    to_name=msg_d.get('_to_name')
+    to_pub=msg_d.get('_to_pub')
+    from_name=msg_d.get('_from_name')
+    from_pub=msg_d.get('_from_pub')
+    msg=msg_d.get('_msg')
+    if to_name and to_pub and from_name and from_pub and msg: return True
+    return False
+
+
+class Message(Logger):
+    def __init__(self,msg_d,caller=None,callee=None):
+        # check input
+        if not is_valid_msg_d(msg_d):
+            raise KomradeException('This is not a valid msg_d:',msg_d)
+        # set fields
+        self.msg_d=msg_d
+        self.to_name=msg_d.get('_to_name')
+        self.to_pubkey=msg_d.get('_to_pub')
+        self.from_name=msg_d.get('_from_name')
+        self.from_pubkey=msg_d.get('_from_pub')
+        self.msg=msg_d.get('_msg')
+        self.caller=caller
+        self.callee=callee
+        # get operators straight away?
+        if not self.caller or not self.callee:
+            self.get_callers()
+
+    def get_callers(self,msg_d):
+        if self.caller is not None and self.callee is not None:
+            return (self.caller,self.callee) 
+        alleged_caller = Operator(alleged_caller_name)
+        alleged_callee = Operator(alleged_callee_name)
+        if not self.caller_records_match(msg_d,alleged_caller,alleged_callee):
+            raise KomradeException('Records of callers on The Operator and the Caller do not match. Something fishy going on?')
+        else:
+            self.caller = alleged_caller
+            self.callee = alleged_callee
+        return (alleged_caller,alleged_caller)
+
+    def caller_records_match(alleged_caller,alleged_callee):
+        alleged_caller_name = self.from_name
+        alleged_caller_pubkey = self.from_pubkey
+        alleged_callee_name = self.to_name
+        alleged_callee_pubkey = msg_d.get('_to_pub')
+        if alleged_callee.name != alleged_callee_name:
+            return False
+        if alleged_caller.name != alleged_caller_name:
+            return False
+        if alleged_callee.pubkey != alleged_callee_pubkey:
+            return False
+        if alleged_caller.pubkey != alleged_caller_pubkey:
+            return False
+        return True
+
+    def is_encrypted(self):
+        return type(self.msg) == bytes
+
+    def decrypt(self,recursive=True):
+        # get callers
+        caller,callee = self.get_callers()
+        # decrypt msg
+        decr_msg = caller.unpackage_msg_from(
+            self.msg,
+            callee
+        )
+        self.msg_encr = self.msg
+        self.msg = decr_msg
+        self.msg_d['_msg'] = decr_msg
+        
+        # now, is the decrypted message itself a message?
+        if recursive and is_valid_msg_d(decr_msg):
+            # then ... make that, a message object, and decrypt it too!
+            self.msg_obj = decr_msg
+            self.msg_obj.decrypt()
+        return decr_msg

komrade/backend/operators.py

@@ -154,65 +154,3 @@ class Operator(Keymaker):
     #     self.log('resp_msg',resp_msg)
 
     #     return resp_msg
-
-    def is_valid_msg_d(self,msg_d):
-        if not type(msg_d)==dict: return False
-        to_name=msg_d.get('_to_name')
-        to_pub=msg_d.get('_to_pub')
-        from_name=msg_d.get('_from_name')
-        from_pub=msg_d.get('_from_pub')
-        msg=msg_d.get('_msg')
-        if to_name and to_pub and from_name and from_pub and msg: return True
-        return False
-        
-
-    def can_decrypt_this(self,msg_d):
-        # check info present
-        if not self.is_valid_msg_d(msg_d): return False
-        to_name=msg_d.get('_to_name')
-        to_pub=msg_d.get('_to_pub')
-        if to_name != self.name or to_pub != self.pubkey: return False
-        return True
-
-    def unpackage_msg_dict(self,msg_d):
-        if self.can_I_decrypt_this(msg_d):
-            # get right caller
-            alleged_caller_name = _msg.get('_from_name')
-            alleged_caller_pub = _msg.get('_from_pub')
-            my_record_of_them = Caller(alleged_caller_name)
-
-            if alleged_caller_name == my_record_of_them.name:
-                if alleged_caller_pub == my_record_of_them.pubkey:
-                    encr_msg=msg_d.get('_msg')
-
-                    try:
-                        msg_d['_msg'] = decr_msg = self.unpackage_msg_from(
-                            encr_msg,
-                            my_record_of_them
-                        )
-                    except KomradeException as e:
-                        self.log('!! e')
-        return msg_d
-
-    def msg_is_encrypted(self,_msg_d):
-        if not self.is_valid_msg_d(_msg_d): return False
-        
-
-
-    def unroll_decryption_onion(self,msg_d):
-        # does message even need decryption?
-
-        # get right caller
-        alleged_caller_name = _msg.get('_from_name')
-        alleged_caller_pub = _msg.get('_from_pub')
-        alleged_callee_name = _msg.get('_to_name')
-        alleged_callee_pub = _msg.get('_to_pub')
-
-        alleged_caller = Operator(alleged_caller_name)
-        alleged_callee = Operator(alleged_callee_name)
-
-        if alleged_callee.can_decrypt_this()
-
-        if self.can_I_decrypt_this(msg_d,I=):
-            msg_d['_msg'] = self.unroll_decryption_onion(msg_d['_msg'])
-        return msg_d

komrade/backend/the_operator.py

@@ -70,49 +70,55 @@ class TheOperator(Operator):
         # decode
         data_b64 = data_b64_str.encode()
         data = b64decode(data_b64)
-        msg_encr_caller2caller_caller2phone_phone2phone = data
+        msg_d = msg_encr_caller2caller_caller2phone_phone2phone = data
         self.log('msg_encr_caller2caller_caller2phone_phone2phone incoming',msg_encr_caller2caller_caller2phone_phone2phone)
 
-        TOTAL_MSG_CHAIN = {}
-        TOTAL_DECR_MSG
+        # make top-level message object, addressed to me the operator
+        msg = Message(msg_d,caller=self.phone,callee=self)
+        msg.decrypt()
 
-        # top layer: phone -> me, the op
-        msg_d = msg_encr_caller2caller_caller2phone = self.unpackage_msg_from(
-            msg_encr_caller2caller_caller2phone_phone2phone,
-            self.phone
-        )
-        self.log('Operator unrolled the first layer of encryption:',msg_encr_caller2caller_caller2phone)
-        assert type(msg_encr_caller2caller_caller2phone)==dict
+
+
+        # TOTAL_MSG_CHAIN = {}
+        # TOTAL_DECR_MSG
+
+        # # top layer: phone -> me, the op
+        # msg_d = msg_encr_caller2caller_caller2phone = self.unpackage_msg_from(
+        #     msg_encr_caller2caller_caller2phone_phone2phone,
+        #     self.phone
+        # )
+        # self.log('Operator unrolled the first layer of encryption:',msg_encr_caller2caller_caller2phone)
+        # assert type(msg_encr_caller2caller_caller2phone)==dict
         
-        # is there another layer, encrypted caller2phone ?
-        msg_d['_msg'] = self.unpackage_msg_dict(msg_d)
-
-        # merge unencrypted messages
-
-
-
-        route=None
-        if _msg and type(_msg)==bytes:
-            alleged_name = msg_d.get('_from_name')
-            alleged_pubkey = msg_d.get('_from_pub')
-            if alleged_pubkey and alleged_name:
-                alleged_caller = Caller(alleged_name)
-                assert alleged_caller.pubkey == alleged_pubkey
-
-                msg_d2 = self.unpackage_msg_from(
-                    _msg,
-                    caller
-                )
-                assert type(msg_d2)==dict
-                _msg2 = msg_d2.get('_msg')
-                route = msg_d2.get('_msg',{}).get('_please')
-                dict_merge(_msg,_msg2)
-                msg_d['_msg'] = msg_d2
+        # # is there another layer, encrypted caller2phone ?
+        # msg_d['_msg'] = self.unpackage_msg_dict(msg_d)
+
+        # # merge unencrypted messages
+
+
+
+        # route=None
+        # if _msg and type(_msg)==bytes:
+        #     alleged_name = msg_d.get('_from_name')
+        #     alleged_pubkey = msg_d.get('_from_pub')
+        #     if alleged_pubkey and alleged_name:
+        #         alleged_caller = Caller(alleged_name)
+        #         assert alleged_caller.pubkey == alleged_pubkey
+
+        #         msg_d2 = self.unpackage_msg_from(
+        #             _msg,
+        #             caller
+        #         )
+        #         assert type(msg_d2)==dict
+        #         _msg2 = msg_d2.get('_msg')
+        #         route = msg_d2.get('_msg',{}).get('_please')
+        #         dict_merge(_msg,_msg2)
+        #         msg_d['_msg'] = msg_d2
         
-        if not route:
-            route = msg_d.get('_msg',{}).get('_please',None)
+        # if not route:
+        #     route = msg_d.get('_msg',{}).get('_please',None)
         
-        return self.route(msg_d,_msg,route)
+        # return self.route(msg_d,_msg,route)