From d35fa3457bd5ba0be5f707a1259cc0bd943b5e67 Mon Sep 17 00:00:00 2001 From: quadrismegistus Date: Wed, 9 Sep 2020 11:58:00 +0100 Subject: [PATCH] updates --- komrade/backend/messages.py | 28 +++++++++++-- komrade/backend/the_operator.py | 70 ++++++++++----------------------- komrade/constants.py | 5 ++- 3 files changed, 49 insertions(+), 54 deletions(-) diff --git a/komrade/backend/messages.py b/komrade/backend/messages.py index 783d923..5e4ebe3 100644 --- a/komrade/backend/messages.py +++ b/komrade/backend/messages.py @@ -26,12 +26,16 @@ class Message(Logger): self.from_name=msg_d.get('_from_name') self.from_pubkey=msg_d.get('_from_pub') self.msg=msg_d.get('_msg') + self.embedded_msg=None # only if this message has an embedded one + self._route=msg_d.get(ROUTE_KEYNAME) self.caller=caller self.callee=callee # get operators straight away? if not self.caller or not self.callee: self.get_callers() + + ## loading messages def get_callers(self,msg_d): if self.caller is not None and self.callee is not None: return (self.caller,self.callee) @@ -65,6 +69,7 @@ class Message(Logger): def decrypt(self,recursive=True): # get callers caller,callee = self.get_callers() + self.log(f'attempting to decrypt msg {self.msg}' from {caller} to {caller}'') # decrypt msg decr_msg = caller.unpackage_msg_from( self.msg, @@ -76,7 +81,24 @@ class Message(Logger): # 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() + # then ... make that, a message object and decrypt it too! + self.embedded_msg = Message(decr_msg) + self.embedded_msg.decrypt() return decr_msg + + + + ## msg properties + def has_embedded_msg(self): + return self.embedded_msg is not None + + @property + def messages(self): + # move through msgs recursively + msgs = [self] if not self.has_embedded_msg else [self] + self.embedded_msg.messages + return msgs + + @property + def route(self): + for msg in self.messages: + if msg._route: return msg._route diff --git a/komrade/backend/the_operator.py b/komrade/backend/the_operator.py index e5e77e3..3766f1f 100644 --- a/komrade/backend/the_operator.py +++ b/komrade/backend/the_operator.py @@ -72,51 +72,12 @@ class TheOperator(Operator): self.log('msg_encr_caller2caller_caller2phone_phone2phone incoming',msg_encr_caller2caller_caller2phone_phone2phone) # make top-level message object, addressed to me the operator - msg = Message(msg_d,caller=self.phone,callee=self) - msg.decrypt() + from komrade.backend.messages import Message + msg_obj = Message(msg_d,caller=self.phone,callee=self) + msg_obj.decrypt() - - - # 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 - - # if not route: - # route = msg_d.get('_msg',{}).get('_please',None) - - # return self.route(msg_d,_msg,route) + # route msg back to caller + return self.route(msg_obj) @@ -126,16 +87,25 @@ class TheOperator(Operator): return encr_data_b - def route(self, msg_d, _msg, route=None): - if not route: route=_msg.get('_please') - if not route: raise KomradeException('no route!') - if '_please' in _msg: del _msg['_please'] + def route(self, msg_obj): + # get route from msg + route = msg_obj.route + + # no route? + if not msg_obj.route: raise KomradeException('no route!') + + # what we working with? self.log(f'route() got incoming msg_d = {msg_d}, _msg = {_msg}, and route = {route}') + + # hard code the acceptable routes if route == 'forge_new_keys': - return self.forge_new_keys(**_msg) + return self.forge_new_keys(msg) + + # otherwise, hang up and try again return OPERATOR_INTERCEPT_MESSAGE - def forge_new_keys(self,**data): + def forge_new_keys(self,msg_obj): + data = msg_obj.msg self.log('about to make some new keys!',data) # get keys diff --git a/komrade/constants.py b/komrade/constants.py index 1241ede..d57c8d1 100644 --- a/komrade/constants.py +++ b/komrade/constants.py @@ -150,4 +150,7 @@ PATH_OPERATOR_WEB_CONTACT_PH_URL = f'http://{KOMRADE_URL}/.contacts/TheTelephone ALLOW_CLEARNET = True -DEBUG_DEFAULT_PASSPHRASE = 'all your base are belong to us' \ No newline at end of file +DEBUG_DEFAULT_PASSPHRASE = 'all your base are belong to us' + + +ROUTE_KEYNAME = '_please' \ No newline at end of file