updates

komrade/backend/callers.py

@@ -11,11 +11,19 @@ class Caller(Operator):
     Variant of an Operator which handles local keys and keymaking.
     """
 
-    def ring_ring(self,msg_encr_caller2caller):
+
+
+    def ring_ring(self,with_msg,to_phone=None):
+        # message should be encrypted caller2caller (by Person.ring)
+        msg_encr_caller2caller = with_msg
+
+        # Caller can only encrypt for Operator (end phone)
+        to_whom = to_phone
+
         # ring 1: encrypt caller2phone
         msg_encr_caller2caller_caller2phone = self.package_msg_to(
             msg_encr_caller2caller,
-            self.op
+            to_whom
         )
         self.log('msg_encr_caller2caller_caller2phone',msg_encr_caller2caller_caller2phone)
 
@@ -53,7 +61,7 @@ class Caller(Operator):
             'passphrase':hashish(passphrase.encode())
         }
 
-        phone_res = self.phone.ring_ring(msg_to_op)
+        phone_res = self.phone.ring(msg_to_op)
         
         # URI id
         uri_id = phone_res.get('uri_id')

komrade/backend/operators.py

@@ -111,4 +111,28 @@ class Operator(Keymaker):
 
     
     def unpackage_msg_from(self,msg_encr_b,another):
-        return self.decrypt_from_send(msg_encr_b,anonther.pubkey,self.privkey)
+        return self.decrypt_from_send(msg_encr_b,another)
+        
+
+    # def ring(self,with_msg,to_whom=None,by_way_of=None):
+    #     # ring 1: encrypt from me to 'whom'
+    #     msg_encr = self.package_msg_to(
+    #         with_msg,
+    #         whom
+    #     )
+    #     self.log(f'msg_encr --> {whom} layer 1',msg_encr)
+
+    #     # ring 2: keep ringing via mediator
+    #     resp_msg_encr = by_way_of.ring(
+    #         msg_encr
+    #     )
+    #     self.log('resp_msg_encr',resp_msg_encr)
+
+    #     # ring 3: decrypt and send back
+    #     resp_msg = self.unpackage_msg_from(
+    #         resp_msg_encr,
+    #         whom
+    #     )
+    #     self.log('resp_msg',resp_msg)
+
+    #     return resp_msg

komrade/backend/people.py

@@ -5,15 +5,35 @@ from komrade.backend import *
 
 class Person(Caller):
 
-    def call_person(self,person):
-        pass
+    # def ring_person(self,with_msg,to_whom):
+    #     res = self.ring(
+    #         with_msg,
+    #         to_whom,
+    #         )
+    #     self.log('<--',res)
+    #     return res
 
 
-    def ring_ring(self,msg_unencr,whom_to_call):
+    # def ring_ring(self,with_msg,to_whom = None):
+    #     # if no one intended, call the operator
+    #     if to_whom is None:
+    #         return self.ring_operator(with_msg)
+    #     elif type(to_whom)==Person:
+    #         return self.ring_person(with_msg,to_whom)
+    #     raise KomradeException('Ring whom?')
+
+
+    def ring_ring(self,with_msg,to_whom = None):
+        # if no one intended, call the operator
+        to_whom = self.op
+
+        # msg should be unencrypted
+        msg_unencr = with_msg
+
         # ring 1: encrypt caller2phone
         msg_encr_caller2caller = self.package_msg_to(
             msg_unencr,
-            whom_to_call
+            to_whom
         )
         self.log('msg_encr_caller2caller',msg_encr_caller2caller)
 
@@ -26,7 +46,7 @@ class Person(Caller):
         # ring 3: decrypt and send back
         resp_msg_unencr = self.unpackage_msg_from(
             msg_encr_caller2caller,
-            whom_to_call
+            to_whom
         )
         self.log('resp_msg_unencr',resp_msg_encr_caller2caller)
 
@@ -47,9 +67,9 @@ class Person(Caller):
         msg_to_op = {'_please':'forge_new_keys'}
 
         # call and ask operator to register us
-        resp = self.ring_ring(
+        resp = self.ring(
             whom=self.op,
-            msg_unencr=msg_to_op
+            with_msg=msg_to_op
         )
 
 
@@ -65,7 +85,7 @@ class Person(Caller):
 
         
 
-        phone_res = self.phone.ring_ring(msg_to_op)
+        phone_res = self.phone.ring(msg_to_op)
         
         # URI id
         uri_id = phone_res.get('uri_id')

komrade/backend/the_operator.py

@@ -40,14 +40,14 @@ class TheOperator(Operator):
             path_crypt_data=PATH_CRYPT_OP_DATA)
         self._keychain = OPERATOR_KEYCHAIN
         
-    def ring_ring(self,
+    def ring(self,
         from_caller=None,
         to_caller=None,
         json_phone2phone={}, 
         json_caller2phone={},   # (person) -> operator or operator -> (person)
         json_caller2caller={}):
         
-        encr_msg_to_send = super().ring_ring(
+        encr_msg_to_send = super().ring(
             from_phone=self,
             to_phone=self.phone,
             from_caller=from_caller,
@@ -82,7 +82,7 @@ class TheOperator(Operator):
         forged_keys_plus_id = super().forge_new_keys(**data)
 
         # return to Telephone/Caller
-        return self.ring_ring(json_phone2phone=forged_keys_plus_id)
+        return self.ring(json_phone2phone=forged_keys_plus_id)
 
         
         

komrade/backend/the_telephone.py

@@ -46,26 +46,30 @@ class TheTelephone(Operator):
             self.log('!! error in request',ringring.status_code,ringring.text)
             return None
 
-    def ring_ring(self,msg_encr_caller2caller_caller2phone):
+    def ring_ring(self,with_msg,to_phone=None):
+        if not to_phone: to_phone=self.op
+        to_whom = to_phone
 
         # ring 1: encrypt
         msg_encr_caller2caller_caller2phone_phone2phone = self.package_msg_to(
             msg_encr_caller2caller,
-            self.op
+            to_whom
         )
         self.log('final form of encr msg!',msg_encr_caller2caller_caller2phone_phone2phone)
 
         # ring 2: dial and get response
-        msg_encr_caller2caller_caller2phone_phone2phone = self.send_and_receive(msg_encr_caller2caller_phone2phone)
+        resp_msg_encr_caller2caller_caller2phone_phone2phone = self.send_and_receive(
+            msg_encr_caller2caller_phone2phone
+        )
         msg_encr_caller2caller_caller2phone_phone2phone: return
 
         # ring 3: decrypt
-        msg_encr_caller2caller_caller2phone = self.unpackage_msg_from(
-            msg_encr_caller2caller_caller2phone_phone2phone,
-            self.op
+        resp_msg_encr_caller2caller_caller2phone = self.unpackage_msg_from(
+            resp_msg_encr_caller2caller_caller2phone_phone2phone,
+            to_whom
         )
 
-        return msg_encr_caller2caller_caller2phone
+        return resp_msg_encr_caller2caller_caller2phone
 
     
 def test_call():