You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
403 lines
12 KiB
Python
403 lines
12 KiB
Python
# internal imports
|
|
import os,sys; sys.path.append(os.path.abspath(os.path.join(os.path.abspath(os.path.join(os.path.dirname(__file__),'..')),'..')))
|
|
from comrad import *
|
|
from comrad.backend import *
|
|
|
|
|
|
# BEGIN PHONE BOOK (in memory singleton mapping)
|
|
PHONEBOOK = {}
|
|
CALLBACKS = {}
|
|
|
|
# Factory constructor
|
|
def Comrad(name=None,pubkey=None,*x,**y):
|
|
if issubclass(type(name),Operator): return name
|
|
if name and not pubkey and type(name)==bytes:
|
|
pubkey=b64enc(name)
|
|
name=None
|
|
|
|
|
|
from comrad.backend.the_operator import TheOperator
|
|
from comrad.backend.the_telephone import TheTelephone
|
|
from comrad.backend.comrades import ComradX
|
|
global PHONEBOOK
|
|
# already have?
|
|
|
|
if not name and not pubkey: return ComradX()
|
|
|
|
if name in PHONEBOOK: return PHONEBOOK[name]
|
|
pk64 = None if not pubkey else b64enc(pubkey)
|
|
if pk64 in PHONEBOOK: return PHONEBOOK[pk64]
|
|
|
|
global CALLBACKS
|
|
callbacks = y.get('callbacks',{})
|
|
callbacks = callbacks if callbacks else CALLBACKS
|
|
CALLBACKS = callbacks
|
|
|
|
# print(f'finding Comrad {name} / {pubkey} for the first time!')
|
|
# operator?
|
|
if name==OPERATOR_NAME:
|
|
commie = TheOperator(callbacks=callbacks) #(*x,**y)
|
|
if name==TELEPHONE_NAME:
|
|
commie = TheTelephone(callbacks=callbacks) #(*x,**y)
|
|
else:
|
|
# print('booting new commie')
|
|
commie = ComradX(name,*x,**y)
|
|
|
|
|
|
|
|
|
|
|
|
# print('found!',name,PHONEBOOK[name],PHONEBOOK[name].keychain())
|
|
PHONEBOOK[name] = commie
|
|
pubkey=commie.find_pubkey(name)
|
|
if pubkey: PHONEBOOK[pubkey.data_b64] = commie
|
|
|
|
return commie
|
|
|
|
|
|
|
|
|
|
# from comrad.constants import OPERATOR_ROUTES
|
|
class Operator(Keymaker):
|
|
ROUTES = [
|
|
'register_new_user',
|
|
'login',
|
|
'deliver_msg',
|
|
'introduce',
|
|
'deliver_post',
|
|
'get_updates'
|
|
]
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def __eq__(self,other):
|
|
if not self.pubkey or not other.pubkey: return False
|
|
return self.pubkey.data == other.pubkey.data
|
|
|
|
def __init__(self,
|
|
name=None,
|
|
pubkey=None,
|
|
keychain = {},
|
|
path_crypt_keys=PATH_CRYPT_CA_KEYS,
|
|
path_crypt_data=PATH_CRYPT_CA_DATA,
|
|
callbacks={},
|
|
getpass_func=None
|
|
):
|
|
|
|
global PHONEBOOK
|
|
|
|
# call Keymaker's intro
|
|
super().__init__(
|
|
name=name,
|
|
keychain=keychain,
|
|
path_crypt_keys=path_crypt_keys,
|
|
path_crypt_data=path_crypt_data,
|
|
callbacks=callbacks,
|
|
getpass_func=getpass_func
|
|
)
|
|
|
|
# add to phonebook
|
|
if name:
|
|
PHONEBOOK[name]=self
|
|
pubkey=self.find_pubkey(name)
|
|
if pubkey:
|
|
PHONEBOOK[pubkey.data_b64]=self
|
|
self._inbox_crypt=None
|
|
|
|
|
|
@property
|
|
def phone(self):
|
|
from comrad.backend.the_telephone import TheTelephone
|
|
if type(self)==TheTelephone: return self
|
|
|
|
if hasattr(self,'_phone'): return self._phone
|
|
|
|
global TELEPHONE,TELEPHONE_KEYCHAIN
|
|
if TELEPHONE: return TELEPHONE
|
|
|
|
self._phone=TELEPHONE=TheTelephone(callbacks=self._callbacks)
|
|
|
|
return TELEPHONE
|
|
|
|
@property
|
|
def op(self):
|
|
from comrad.backend.the_operator import TheOperator
|
|
if type(self)==TheOperator: return self
|
|
|
|
if hasattr(self,'_op'): return self._op
|
|
|
|
global OPERATOR,OPERATOR_KEYCHAIN
|
|
if OPERATOR: return OPERATOR
|
|
|
|
self._op=OPERATOR=TheOperator(callbacks=self._callbacks)
|
|
|
|
return OPERATOR
|
|
|
|
|
|
def compose_msg_to(self,msg,another):
|
|
if not self.privkey or not self.pubkey:
|
|
raise ComradException('I appear not yet to have an encryption keypair.',self,self.name,self.pubkey,self.privkey,self.keychain())
|
|
if not another.name or not another.pubkey:
|
|
self.log(f'I {self} failed to compose a message to {another} ?')
|
|
raise ComradException('I do not know the Comrad I am writing to.')
|
|
|
|
# otherwise create msg
|
|
frompub = self.pubkey.data if hasattr(self.pubkey,'data') else self.pubkey
|
|
topub = another.pubkey.data if hasattr(another.pubkey,'data') else another.pubkey
|
|
|
|
msg_d = {
|
|
'from':frompub,
|
|
'from_name':self.name,
|
|
'to':topub,
|
|
'to_name':another.name,
|
|
'msg':msg,
|
|
'timestamp':time.time()
|
|
}
|
|
self.log(f'I am {self} packaging a message to {another}: {msg_d}')
|
|
from comrad.backend.messages import Message
|
|
|
|
msg_obj = Message(msg_d)
|
|
|
|
# encrypt!
|
|
# msg_obj.encrypt()
|
|
|
|
return msg_obj
|
|
|
|
|
|
|
|
|
|
def __repr__(self):
|
|
clsname=(type(self)).__name__
|
|
#name = clsname+' '+
|
|
name = '@'+ (self.name if self.name else '?') # if self.name!=clsname else clsname
|
|
# try:
|
|
# keystr= 'on device: ' + ('+'.join(self.top_keys) if self.pubkey else '')
|
|
# except TypeError:
|
|
# keystr=''
|
|
# # if self.pubkey:
|
|
keystr=''
|
|
if False:
|
|
pubk=self.pubkey_b64.decode()
|
|
pubk=pubk[-5:]
|
|
pubk = f' ({pubk})'# if pubk else ''
|
|
else:
|
|
pubk = ''
|
|
return f'{name}' #' ({keystr})'
|
|
|
|
|
|
|
|
|
|
def route_msg(self,msg_obj,reencrypt=True,new_data=None):
|
|
# decrypt
|
|
# self.log('got msg_obj!',msg_obj)
|
|
if msg_obj.is_encrypted:
|
|
msg_obj.decrypt()
|
|
|
|
# try route
|
|
if msg_obj.route:
|
|
data,route = msg_obj.data, msg_obj.route
|
|
if not hasattr(self,route) or route not in self.ROUTES:
|
|
raise ComradException(f'Not a valid route!: {route}')
|
|
|
|
# route it!
|
|
self.log(f'Routing msg to {self}.{route}():\n\n{dict_format(msg_obj.data,tab=4)}')
|
|
func = getattr(self,route)
|
|
# new_data = func(**data)
|
|
new_data = func(msg_obj)
|
|
self.log(f'New data was received back from {self}.{route}() route:\b\b{new_data}')
|
|
msg_obj.msg = msg_obj.msg_d['msg'] = new_data
|
|
|
|
# try passing it on?
|
|
if msg_obj.has_embedded_msg:
|
|
new_data = self.route_msg(msg_obj.msg)
|
|
msg_obj.msg = msg_obj.msg_d['msg'] = new_data
|
|
|
|
if not new_data or not reencrypt:
|
|
# end of the line?
|
|
return msg_obj
|
|
|
|
# time to turn around and encrypt
|
|
# @unsure?``
|
|
# from comrad.backend.comrades import Comrad
|
|
# if self != self.phone and type(self)!=Comrad:
|
|
# # if client, let the request rest
|
|
# return msg_obj
|
|
|
|
# # if remote operator, keep going?
|
|
# self.log('time to flip msg around and return to sender. v1:',msg_obj,dict_format(msg_obj.msg_d))#,new_data,reencrypt,msg_obj.route)
|
|
|
|
|
|
# new_msg_obj = msg_obj.to_whom.compose_msg_to(
|
|
# msg=new_data,
|
|
# another=msg_obj.from_whom
|
|
# ) #msg_obj.mark_return_to_sender()
|
|
# self.log('returning to sender as:',new_msg_obj)
|
|
new_msg_obj = msg_obj.return_to_sender(new_data)
|
|
|
|
# encrypt
|
|
if reencrypt:
|
|
# self.log('reencrypting v1',new_msg_obj)
|
|
new_msg_obj.encrypt()
|
|
# self.log('reencrypting v2',new_msg_obj)
|
|
|
|
|
|
return new_msg_obj
|
|
|
|
|
|
async def ring_ring(self,msg,to_whom,get_resp_from=None,route=None,caller=None):
|
|
# ring ring
|
|
from comrad.cli.artcode import ART_PHONE_SM1
|
|
import textwrap as tw
|
|
|
|
if caller!=self:
|
|
from comrad.cli.artcode import ART_PHONE_SM1
|
|
self.log(f'ring ring! I the {self} have received a message from {caller},\n which I will now encrypt and send along to {to_whom}.\n {ART_PHONE_SM1} ')
|
|
else:
|
|
pass
|
|
self.log(f'I ({self}) will now compose and send an encrypted message to {to_whom}.')
|
|
|
|
if route and type(msg)==dict and not ROUTE_KEYNAME in msg:
|
|
msg[ROUTE_KEYNAME] = route
|
|
|
|
# get encr msg obj
|
|
|
|
msg_obj = self.compose_msg_to(
|
|
msg,
|
|
to_whom
|
|
)
|
|
self.log(f'Here is the message I will now encrypt and to send to {to_whom}:\n\n {dict_format(msg_obj.msg,tab = 2)}')
|
|
|
|
# encrypting
|
|
msg_obj.encrypt()
|
|
|
|
# pass through the telephone wire by the get_resp_from function
|
|
if not get_resp_from: get_resp_from=to_whom.ring_ring
|
|
|
|
resp_msg_obj = await get_resp_from(msg_obj.msg_d,caller=caller)
|
|
self.log('resp_msg_obj <-',str(resp_msg_obj))
|
|
|
|
if not resp_msg_obj or type(resp_msg_obj)==dict and not resp_msg_obj.get('success'):
|
|
return {'status':'I cannot reach the @Operator. Perhaps she has stepped out. Please hang up and try again later.','success':False,'res':resp_msg_obj}
|
|
# exit()
|
|
|
|
# decrypt
|
|
if resp_msg_obj.is_encrypted:
|
|
resp_msg_obj.decrypt()
|
|
|
|
# route back?
|
|
new_msg_obj=self.route_msg(resp_msg_obj,reencrypt=False)
|
|
new_msg = new_msg_obj.msg
|
|
|
|
# print('new_msg_obj',new_msg_obj)
|
|
# print('new_msg',new_msg)
|
|
return new_msg
|
|
|
|
def pronto_pronto(self, msg_obj):
|
|
self.log(f'''*ring *ring*
|
|
...
|
|
|
|
{self}: pronto?
|
|
{msg_obj.from_whom}: Ciao ciao. I have a message for you:\n{msg_obj}\n''')
|
|
|
|
return self.route_msg(msg_obj,reencrypt=True)
|
|
|
|
|
|
|
|
|
|
|
|
## inboxes?
|
|
def get_inbox_crypt(self,
|
|
crypt=None,
|
|
uri=None,
|
|
prefix='/inbox/'):
|
|
if not crypt: crypt=self.crypt_data
|
|
if not uri: uri=self.uri
|
|
prefix+=self.name+'/'
|
|
|
|
self.log(f'I am {self.name} and my uri is {self.uri}.')
|
|
|
|
inbox_crypt = CryptList(
|
|
crypt=self.crypt_data,
|
|
keyname=uri,
|
|
prefix=prefix,
|
|
)
|
|
self.log('--> inbox crypt:',uri,prefix,inbox_crypt.values)
|
|
return inbox_crypt
|
|
|
|
def delete_post(self,post_id,**y):
|
|
return self.delete_posts([post_id],**y)
|
|
|
|
def delete_posts(self,
|
|
post_ids,
|
|
inbox_uri=None,
|
|
inbox_prefix='/inbox/',
|
|
post_prefix='/post/'):
|
|
|
|
# delete from posts
|
|
deleted_post_ids=[]
|
|
for post_id in post_ids:
|
|
self.log('deleting post id?',post_id)
|
|
del_res = self.crypt_data.delete(
|
|
post_id,
|
|
prefix=f'{post_prefix}{self.name}/',
|
|
)
|
|
#del_res = 1
|
|
self.log('del_res =',del_res)
|
|
if del_res:
|
|
deleted_post_ids.append(post_id)
|
|
self.log('deleted_post_ids',deleted_post_ids,'...')
|
|
|
|
res = {
|
|
'deleted':deleted_post_ids,
|
|
}
|
|
|
|
# delete from inbox
|
|
#inbox_uri = self.uri if not inbox_uri else inbox_uri
|
|
# if inbox_uri:
|
|
# inbox_db=self.get_inbox_crypt(
|
|
# uri=inbox_uri,
|
|
# )
|
|
# res['deleted_from_inbox']=inbox_db.remove(
|
|
# deleted_post_ids
|
|
# )
|
|
inbox_db=self.get_inbox_crypt(
|
|
prefix='/inbox/'
|
|
)
|
|
self.log('inbox!?',inbox_db.values)
|
|
res['deleted_from_inbox']=inbox_db.remove(post_ids)
|
|
|
|
self.log('-->',res)
|
|
res['success']=True
|
|
res['status']=f'Deleted {len(deleted_post_ids)} posts.'
|
|
return res
|
|
|
|
|
|
|
|
@property
|
|
def inbox_db(self):
|
|
if not hasattr(self,'_inbox_db'):
|
|
self._inbox_db=self.get_inbox_crypt(
|
|
prefix='/inbox/'
|
|
)
|
|
return self._inbox_db
|
|
@property
|
|
def inbox_unread_db(self):
|
|
if not hasattr(self,'_inbox_unread_db'):
|
|
self._inbox_unread_db=self.get_inbox_crypt(
|
|
prefix='/inbox/unread/',
|
|
)
|
|
return self._inbox_unread_db
|
|
@property
|
|
def inbox_read_db(self):
|
|
if not hasattr(self,'_inbox_read_db'):
|
|
self._inbox_read_db=self.get_inbox_crypt(
|
|
prefix='/inbox/read/',
|
|
)
|
|
return self._inbox_read_db
|