updates

komrade/__init__.py

@@ -8,6 +8,7 @@ from collections import defaultdict
 from base64 import b64encode,b64decode
 import ujson as json
 import binascii,asyncio
+from pprint import pprint
 
 # common external imports
 from pythemis.skeygen import KEY_PAIR_TYPE, GenerateKeyPair

komrade/backend/__init__.py

@@ -13,7 +13,7 @@ from .the_telephone import *
 
 from .callers import *
 
-
+from .phonelines import *
 
 
 ## define default entities

komrade/backend/callers.py

@@ -14,10 +14,13 @@ class Caller(Operator):
 
 
     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)
+        if not to_phone: to_phone=self.op
         to_whom = to_phone
 
         # ring 1: encrypt caller2phone

komrade/backend/keymaker.py

@@ -98,30 +98,34 @@ class Keymaker(Logger):
         return self._pubkey
 
     def keychain(self,look_for=KEYMAKER_DEFAULT_ALL_KEY_NAMES):
-        keys = {'pubkey':self.pubkey}
+        self._keychain = keys = {**{'pubkey':self.pubkey}, **self._keychain}
         uri = self.uri_id
 
         # get from cache
         for keyname in look_for:
+            if keyname in keys and keys[keyname]: continue
+            
+            self.log('??',keyname)
             key = self.crypt_keys.get(uri,prefix=f'/{keyname}/')
-            if key:
-                keys[keyname]=key
+            if key: keys[keyname]=key
+        
+        self.log('keys 1!',self._keychain)
 
         # try to assemble
         keys = self.assemble(self.assemble(keys))
-
+        self.log('keys 2!',self._keychain)
         return keys
 
 
     @property
     def pubkey(self):
         if not self._pubkey: self._pubkey = self.crypt_keys.get(self.name, prefix='/pubkey/')
-        if not self._pubkey: self._pubkey = b64decode(self.load_qr.get(self.name, prefix='/pubkey/').encode())
+        if not self._pubkey: self._pubkey = self.load_qr(self.name)
         return self._pubkey
     @property
-    def privkey(self): return self.keychain()['privkey']
+    def privkey(self): return self.keychain().get('privkey')
     @property
-    def adminkey(self): return self.keychain()['adminkey']
+    def adminkey(self): return self.keychain().get('adminkey')
 
 
 
@@ -133,13 +137,16 @@ class Keymaker(Logger):
         # with open(contact_fnfn,'rb') as f: dat=f.read()
         from pyzbar.pyzbar import decode
         from PIL import Image
-        return decode(Image.open(contact_fnfn))[0].data
+        res= decode(Image.open(contact_fnfn))[0].data
 
+        # self.log('QR??',res,b64decode(res))
+        return b64decode(res)
 
     @property
     def uri_id(self):
-        if not hasattr(self,'_uri_id') or not self._uri_id:
-            self._uri_id = b64encode(self.pubkey)
+        if not self._uri_id:
+            if self.pubkey:
+                self._uri_id = b64encode(self.pubkey)
         return self._uri_id
 
 

komrade/backend/operators.py

@@ -65,6 +65,9 @@ class Operator(Keymaker):
         msg_b = package_for_transmission(msg_json)
         self.log('packing for transmission: msg_b',type(msg_b),msg_b)
         # try:
+        self.log('from privkey =',from_privkey)
+        self.log('to pubkey =',to_pubkey)
+
         msg_encr = SMessage(
             from_privkey,
             to_pubkey,
@@ -100,13 +103,22 @@ class Operator(Keymaker):
 
 
     def package_msg_to(self,msg,another):
+        if not self.privkey or not self.pubkey:
+            self.log('why do I have no pub/privkey pair!?',self.privkey,self,self.name)
+            return b''
+        if not another.name or not another.pubkey:
+            self.log('why do I not know whom I\'m writing to?')
+            return b''
+
+        # otherwise send msg
         msg = {
             '_from_pub':self.pubkey,
             '_from_name':self.name,
             '_to_pub':another.pubkey,
-            '_to_name':another.name
+            '_to_name':another.name,
             '_msg':msg,
         }
+        self.log(f'I am a {type(self)} packaging a message to {another}')
         return self.encrypt_to_send(msg, self.privkey, another.pubkey)
 
     

komrade/backend/people.py

@@ -25,7 +25,7 @@ class Person(Caller):
 
     def ring_ring(self,with_msg,to_whom = None):
         # if no one intended, call the operator
-        to_whom = self.op
+        return super().ring_ring(with_msg,to_phone=self.op)
 
         # msg should be unencrypted
         msg_unencr = with_msg
@@ -53,7 +53,7 @@ class Person(Caller):
         return resp_msg_unencr
 
 
-    def register(self):
+    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: 
@@ -67,10 +67,12 @@ class Person(Caller):
         msg_to_op = {'_please':'forge_new_keys'}
 
         # call and ask operator to register us
-        resp = self.ring(
-            whom=self.op,
-            with_msg=msg_to_op
-        )
+        
+        # for only this one! we skip to Caller
+
+        resp = self.ring_ring(msg_to_op)
+
+        return resp
 
 
     def get_new_keys(self, name = None, passphrase = DEBUG_DEFAULT_PASSPHRASE, is_group=None):
@@ -108,3 +110,9 @@ class Person(Caller):
         # success!
         self.log('yay!!!!')
         return saved_keys
+
+
+if __name__=='__main__':
+    person = Person('marx')
+
+    person.register()

komrade/backend/the_operator.py

@@ -30,6 +30,8 @@ class TheOperator(Operator):
         # init req paths
         # if not os.path.exists(PATH_OPERATOR): os.makedirs(PATH_OPERATOR)
         global OPERATOR_KEYCHAIN,TELEPHONE_KEYCHAIN
+        
+        from komrade.backend.phonelines import connect_phonelines
         if not TELEPHONE_KEYCHAIN or not OPERATOR_KEYCHAIN:
             OPERATOR_KEYCHAIN,TELEPHONE_KEYCHAIN = connect_phonelines()
         if not passphrase: self.passphrase=passphrase=getpass.getpass('Hello, this is the Operator speaking. What is the passphrase?\n> ')
@@ -66,7 +68,9 @@ class TheOperator(Operator):
 
     def route(self, data):
         # route incoming call from the switchboard
+        self.log('Hello, this is the Operator. You said: ',data)
 
+        stop
 
         res=None
         route = data.get('_please')

komrade/backend/the_telephone.py

@@ -2,6 +2,7 @@
 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 *
+from komrade.backend.phonelines import *
 
 ### ACTUAL PHONE CONNECTIONS
 class TheTelephone(Operator):
@@ -41,7 +42,7 @@ class TheTelephone(Operator):
             encr_str_response_from_op = ringring.text
             self.log('encr_str_response_from_op',encr_str_response_from_op)
 
-            return encr_str_response_from_op.encode()
+            return encr_str_response_from_op #.encode()
         else:
             self.log('!! error in request',ringring.status_code,ringring.text)
             return None
@@ -50,18 +51,21 @@ class TheTelephone(Operator):
         if not to_phone: to_phone=self.op
         to_whom = to_phone
 
+        # msg is of type
+        msg_encr_caller2caller_caller2phone = with_msg
+
         # ring 1: encrypt
         msg_encr_caller2caller_caller2phone_phone2phone = self.package_msg_to(
-            msg_encr_caller2caller,
+            msg_encr_caller2caller_caller2phone,
             to_whom
         )
         self.log('final form of encr msg!',msg_encr_caller2caller_caller2phone_phone2phone)
 
         # ring 2: dial and get response
         resp_msg_encr_caller2caller_caller2phone_phone2phone = self.send_and_receive(
-            msg_encr_caller2caller_phone2phone
+            msg_encr_caller2caller_caller2phone_phone2phone
         )
-        msg_encr_caller2caller_caller2phone_phone2phone: return
+        # msg_encr_caller2caller_caller2phone_phone2phone: return
 
         # ring 3: decrypt
         resp_msg_encr_caller2caller_caller2phone = self.unpackage_msg_from(
@@ -73,7 +77,11 @@ class TheTelephone(Operator):
 
     
 def test_call():
-    caller = Caller('marx33') #Caller('marx')
+    phone = TheTelephone()
+    pprint(phone.keychain())
+
+
+    # caller = Caller('marx33') #Caller('marx')
     # caller.boot(create=True)
     # print(caller.keychain())
     # phone = TheTelephone()
@@ -82,9 +90,9 @@ def test_call():
     # res = phone.req({'forge_new_keys':{'name':'marx', 'pubkey_is_public':True}})
     # print(res)
     # asyncio.run(caller.get_new_keys())
-    x=caller.get_new_keys(passphrase='1869')
+    # x=caller.get_new_keys(passphrase='1869')
 
-    print('YEAH COOL',x)
+    # print('YEAH COOL',x)
 
 ## main
 if __name__=='__main__': test_call()