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.
1109 lines
33 KiB
Python
1109 lines
33 KiB
Python
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 *
|
|
from comrad.backend.keymaker import *
|
|
from comrad.backend.messages import Message
|
|
|
|
import logging,asyncio
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class ComradX(Caller):
|
|
|
|
def __init__(self, name=None, pubkey=None, callbacks={}, getpass_func=None):
|
|
# logger.info('booting ComradX with getpass_func:',getpass_func)
|
|
self.updated=None
|
|
super().__init__(name=name, callbacks=callbacks, getpass_func=getpass_func)
|
|
self.log(f'Starting up with callbacks: {self._callbacks}')
|
|
# self.boot(create=False)
|
|
# special?
|
|
if self.name==WORLD_NAME:
|
|
if os.path.exists(PATH_SUPER_SECRET_OP_KEY):
|
|
print(f'Dare I claim to be the one true @{WORLD_NAME}?')
|
|
with open(PATH_SUPER_SECRET_OP_KEY,'rb') as f:
|
|
#pass_encr=f.read()
|
|
opk1,opk2,privkey_decr,privkey_encr = b64dec(f.read()).split(BSEP)
|
|
privkey_decr_obj = ComradSymmetricKeyWithoutPassphrase(privkey_decr)
|
|
privkey_encr_obj = ComradEncryptedAsymmetricPrivateKey(privkey_encr)
|
|
self._keychain['privkey_decr']=privkey_decr_obj
|
|
self._keychain['privkey_encr']=privkey_encr_obj
|
|
|
|
|
|
def boot(self,create=False,ping=False):
|
|
return
|
|
|
|
# # Do I already have my keys?
|
|
# # yes? -- login
|
|
|
|
# keys = self.keychain()
|
|
# # self.log(f'booting {self}!',dict_format(keys))
|
|
|
|
# if keys.get('pubkey') and keys.get('privkey'):
|
|
# # self.log('already booted! @'+self.name)
|
|
# return True
|
|
|
|
# if self.exists_locally_as_account():
|
|
# self.log(f'this account (@{self.name}) can be logged into')
|
|
# return #self.login()
|
|
|
|
|
|
# elif self.exists_locally_as_contact():
|
|
# self.log(f'this account (@{self.name}) is a contact')
|
|
# return #pass #???
|
|
|
|
# elif ping and self.exists_on_server():
|
|
# self.log(f'this account exists on server. introduce?')
|
|
# return
|
|
|
|
# elif create:
|
|
# self.log('account is free: register?')
|
|
# return self.register()
|
|
|
|
|
|
def exists_locally(self,name=None):
|
|
pubkey=self.find_pubkey(name=name)
|
|
self.log(f'I am {self.name}, looking for {name}, and found pubkey {pubkey} (mine is {self.pubkey})')
|
|
return bool(pubkey)
|
|
|
|
def exists_locally_as_contact(self,name=None):
|
|
pubkey=self.find_pubkey(name=name)
|
|
if not pubkey: return False
|
|
uri=pubkey.data_b64
|
|
if self.crypt_keys.get(uri,prefix='/privkey_encr/'):
|
|
return False
|
|
self.log(pubkey,self.name,'???')
|
|
return True
|
|
|
|
def exists_locally_as_account(self,name=None):
|
|
#return bool(self.pubkey) and bool(self.privkey_encr)
|
|
pubkey=self.find_pubkey(name=name)
|
|
# self.log('found pubkey:',pubkey)
|
|
if not pubkey: return False
|
|
uri=pubkey.data_b64
|
|
# self.log('crypt????',self.crypt_keys.fn)
|
|
res = self.crypt_keys.get(uri,prefix='/privkey_encr/')
|
|
if res:
|
|
# self.log('found privkey_encr:',res)
|
|
return True
|
|
return False
|
|
|
|
def exists_on_server(self):
|
|
answer = self.phone.ring_ring({
|
|
'_route':'does_username_exist',
|
|
'name':self.name
|
|
})
|
|
# self.log('answer??',answer)
|
|
return answer
|
|
|
|
|
|
|
|
## Talking with Operator
|
|
async def ring_ring(self,msg,route=None,**y):
|
|
# logger.info('got here 2!')
|
|
if type(msg)==dict and not ROUTE_KEYNAME in msg:
|
|
msg[ROUTE_KEYNAME]=route
|
|
return await super().ring_ring(msg,caller=self,**y)
|
|
|
|
|
|
def refresh(self,include_posts=True):
|
|
res = asyncio.run(self.get_updates(include_posts=include_posts))
|
|
return {'res':res, 'success':res.get('success'), 'status':res.get('status','')}
|
|
|
|
|
|
####################################
|
|
## (1) Logging in and registering ##
|
|
####################################
|
|
|
|
async def log_async(self,*x,**y):
|
|
return self.log(*x,**y)
|
|
|
|
|
|
|
|
def register(self, name = None, passphrase = None, is_group=None, show_intro=0,show_body=True,logfunc=None):
|
|
# global PHONEBOOK
|
|
|
|
# print('got name:',name)
|
|
## Defaults
|
|
if name and not self.name: self.name=name
|
|
if not name and self.name: name=self.name
|
|
# if not name and not self.name: name=''
|
|
# print('got name',name)
|
|
if not logfunc: logfunc=self.log
|
|
|
|
# already have it?
|
|
if self.exists_locally_as_account():
|
|
return {'success':False, 'status':'You have already created this account.'}
|
|
|
|
if self.exists_locally_as_contact():
|
|
return {'success':False, 'status':'This is already a contact of yours'}
|
|
|
|
|
|
## 1) Have name?
|
|
clear_screen()
|
|
tolog=''
|
|
if SHOW_STATUS and show_intro:
|
|
self.name = name = self.cli.status_keymaker_part1(name)
|
|
elif not name:
|
|
self.name = name = input('\nHello, this is Comrad @')
|
|
logfunc('I would like to sign up for the socialist network revolution.',flush=True,comrad_name=name,pause=True)
|
|
# do_pause()
|
|
else:
|
|
logfunc(f'Hello, this is Comrad @{name}.\n\nI would like to sign up for the socialist network revolution.',pause=True,comrad_name=name)
|
|
# do_pause()
|
|
|
|
# clear_screen()
|
|
logfunc(f'Excellent. But to communicate with comrades securely, you must first cut your public & private encryption keys.',pause=True,clear=True)
|
|
# do_pause()
|
|
## 2) Make pub public/private keys
|
|
keypair = ComradAsymmetricKey()
|
|
pubkey,privkey = keypair.pubkey_obj,keypair.privkey_obj
|
|
logfunc(f'I have cut for you a private and public asymmetric key pair, using the iron-clad Elliptic curve algorithm:\n\n(1) {pubkey}\n\n(2) {privkey}{ART_KEY_PAIR}',clear=True,pause=True)
|
|
self._keychain['pubkey']=pubkey
|
|
self._keychain['privkey']=privkey
|
|
self.log('My keychain now looks like:',dict_format(self.keychain()))
|
|
|
|
|
|
### PUBLIC KEY
|
|
qr_str=self.qr_str(pubkey.data_b64)
|
|
logfunc(f'(1) You may store your public key both on your device hardware, as well as share it with anyone you wish:\n\n{pubkey.data_b64_s}\n\nIt will also be stored as a QR code on your device:\n{qr_str}',pause=True,clear=True)
|
|
logfunc('You must also register your username and public key with Comrad @Operator on the remote server.\n\nShall Comrad @Telephone send them over?',pause=False,clear=False)#),dict_format(data,tab=2),pause=True)
|
|
ok_to_send = 'y' #input(f'\n@{name}: [Y/n] ')
|
|
if ok_to_send.strip().lower()=='n':
|
|
logfunc('Cancelling registration.')
|
|
return
|
|
else:
|
|
print()
|
|
logfunc('Connecting you to the @Operator...',comrad_name='Telephone')
|
|
# print()
|
|
# time.sleep(1)
|
|
|
|
## CALL OP WITH PUBKEY
|
|
resp_msg_d = asyncio.run(self.ring_ring(
|
|
{
|
|
'name':name,
|
|
'pubkey': pubkey.data,
|
|
},
|
|
route='register_new_user'
|
|
))
|
|
# print()
|
|
clear_screen()
|
|
logfunc(resp_msg_d.get('status')+ART_OLDPHONE4,comrad_name='Operator',pause=True)
|
|
print()
|
|
|
|
if not resp_msg_d.get('success'):
|
|
logfunc('''That's too bad. Cancelling registration for now.''',pause=True,clear=True)
|
|
return
|
|
|
|
# clear_screen()
|
|
logfunc('Great. Comrad @Operator now has your name and public key on file (and nothing else!).',pause=True,clear=True)
|
|
|
|
logfunc(f"Your PRIVATE key, on the other hand, must be stored only on your device hardware.",pause=True)
|
|
logfunc('''Your private key is so sensitive we'll even encrypt it before storing it.''',pause=True,use_prefix=False)
|
|
|
|
|
|
|
|
## 3) Have passphrase?
|
|
if SHOW_STATUS and not passphrase:
|
|
passphrase = self.cli.status_keymaker_part2(name,passphrase,pubkey,privkey,hasher,self)
|
|
elif not passphrase and self.getpass_func:
|
|
passphrase=self.getpass_func(WHY_MSG)
|
|
else:
|
|
if not passphrase: passphrase = DEBUG_DEFAULT_PASSPHRASE
|
|
while not passphrase:
|
|
# logfunc('Please type a password:',use_prefix=False)
|
|
logfunc('''Please enter a memorable password to generate a (symmetric AES) encryption key with:''',use_prefix=True)
|
|
passphrase=getpass(f'\n@{self.name}: ')
|
|
# clear_screen()
|
|
## 4) Get hashed password
|
|
|
|
passhash = hasher(passphrase)
|
|
privkey_decr = ComradSymmetricKeyWithPassphrase(passhash=passhash)
|
|
print()
|
|
logfunc(f'''Let's immediately run whatever you typed through a 1-way hashing algorithm (SHA-256), inflating it to (redacted):\n\n{make_key_discreet_str(passhash)}''',pause=True,clear=False)
|
|
|
|
privkey_encr = privkey_decr.encrypt(privkey.data)
|
|
privkey_encr_obj = ComradEncryptedAsymmetricPrivateKey(privkey_encr)
|
|
self._keychain['privkey_encr']=privkey_encr_obj
|
|
self.log('My keychain now looks like v2:',dict_format(self.keychain()))
|
|
|
|
logfunc('With this inflated password we can encrypt your super-sensitive private key.',pause=True,clear=True)
|
|
|
|
logfunc(f"Your original private key looks like this (redacted):\n\n{privkey}",pause=True,clear=False)
|
|
|
|
logfunc(f"After we encrypt it with your passworded key, it looks like this (redacted):\n\n{privkey_encr_obj}",pause=True,clear=False)
|
|
|
|
logfunc('Only this encrypted version is stored.',pause=True,clear=True)
|
|
|
|
|
|
|
|
|
|
# More narration?
|
|
if SHOW_STATUS: self.cli.status_keymaker_part3(privkey,privkey_decr,privkey_encr,passphrase)
|
|
|
|
|
|
self.name=resp_msg_d.get('name')
|
|
pubkey_b = resp_msg_d.get('pubkey')
|
|
assert pubkey_b == pubkey.data
|
|
uri_id = pubkey.data_b64
|
|
sec_login = resp_msg_d.get('secret_login')
|
|
# stop
|
|
|
|
logfunc(f'''Saving keys to device:''',pause=True)
|
|
logfunc(f'''(1) {pubkey}''',pause=True,use_prefix=False)
|
|
logfunc(f'''(2) {privkey_encr_obj}''',pause=True,use_prefix=False)
|
|
logfunc(f'''(3) [Shared Login Secret with @Operator]\n({make_key_discreet(sec_login)})''',pause=True,use_prefix=False)
|
|
# print()
|
|
self.crypt_keys.set(name, pubkey_b, prefix='/pubkey/')
|
|
self.crypt_keys.set(uri_id, name, prefix='/name/')
|
|
self.crypt_keys.set(uri_id,sec_login,prefix='/secret_login/')
|
|
|
|
# store privkey pieces
|
|
self.crypt_keys.set(uri_id, privkey_encr_obj.data, prefix='/privkey_encr/')
|
|
# just to show we used a passphrase -->
|
|
self.crypt_keys.set(uri_id, ComradSymmetricKeyWithPassphrase.__name__, prefix='/privkey_decr/')
|
|
|
|
|
|
# save qr too:
|
|
_fnfn=self.save_uri_as_qrcode(uri_id)
|
|
logfunc(f'Also saving public key as QR code to: {_fnfn}.',pause=True,clear=False,use_prefix=False)
|
|
|
|
# done!
|
|
print()
|
|
logfunc(f'Congratulations. Welcome, {self}.',pause=True,clear=True)
|
|
# self.help()
|
|
|
|
|
|
##
|
|
# last minute: get posts
|
|
if 'res_posts' in resp_msg_d and resp_msg_d['res_posts'].get('success'):
|
|
id2post=resp_msg_d.get('res_posts').get('posts',{})
|
|
if id2post:
|
|
self.log('found starter posts:',list(id2post.keys()))
|
|
self.save_posts(id2post)
|
|
resp_msg_d['status']+=f' You\'ve got {len(id2post)} new posts and 0 new messages.'
|
|
|
|
return resp_msg_d
|
|
|
|
|
|
###
|
|
|
|
|
|
|
|
|
|
return resp_msg_d
|
|
|
|
def get_secret_login(self,pubkey):
|
|
return self.crypt_keys.get(
|
|
b64enc(pubkey),
|
|
prefix='/secret_login/'
|
|
)
|
|
|
|
@property
|
|
def secret_login(self):
|
|
return self.get_secret_login(self.pubkey.data_b64)
|
|
|
|
def login(self,passphrase=None):
|
|
# what keys do I have?
|
|
keys = self.keychain()
|
|
|
|
# check hardware
|
|
if not 'pubkey' in keys or not self.pubkey:
|
|
emsg='''Login impossible. I do not have this comrad's public key, much less private one.'''
|
|
# self.log()
|
|
return {'success':False, 'status':emsg}
|
|
|
|
if not 'privkey_encr' in keys:
|
|
emsg='''Login impossible. I do not have this comrad's private key on this hardware.'''
|
|
self.log(emsg)
|
|
return {'success':False, 'status':emsg}
|
|
|
|
if not 'privkey' in keys:
|
|
emsg='''Login failed. Private key did not unlock from passphrase.'''
|
|
return {'success':False, 'status': emsg}
|
|
|
|
# compose message
|
|
msg = {
|
|
'name':self.name,
|
|
'pubkey':keys['pubkey'].data,
|
|
'secret_login':self.get_secret_login(keys['pubkey'].data)
|
|
}
|
|
|
|
# ask operator and get response
|
|
resp_msg_d = self.ring_ring(
|
|
msg,
|
|
route='login'
|
|
)
|
|
|
|
# print('got resp_msg_d:',resp_msg_d)
|
|
|
|
# get result
|
|
self.log('Got resp_msg_d back from operator:',resp_msg_d)
|
|
|
|
# check msgs?
|
|
if 'inbox' in resp_msg_d:
|
|
self.do_check_msgs(resp_msg_d['inbox'])
|
|
resp_msg_d['res_refresh'] = self.refresh(check_msgs=False) # already done in previous line
|
|
|
|
self.log('-->',resp_msg_d)
|
|
return resp_msg_d
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
########################
|
|
## (2) MEETING PEOPLE ##
|
|
########################
|
|
|
|
def contacts(self):
|
|
# who do I know?
|
|
qr_names = sorted([
|
|
fn.split('.png')[0] for fn in os.listdir(PATH_QRCODES)
|
|
])
|
|
ppl = [Comrad(name) for name in qr_names]
|
|
ppl = [p for p in ppl if p.exists_locally_as_contact()]
|
|
return ppl
|
|
|
|
|
|
### MEETING PEOLPE
|
|
def meet(self,*x,**y):
|
|
return asyncio.run(self.meet_async(*x,**y))
|
|
|
|
async def meet_async(self,name=None,pubkey=None,returning=False,other_data={}):
|
|
if not name and not pubkey:
|
|
return {'success':False,'status':'Meet whom?'}
|
|
|
|
# already met this person?
|
|
keystr=self.name+'->'+name
|
|
# if self.crypt_keys.get(
|
|
# keystr,
|
|
# prefix='/met/'
|
|
# ):
|
|
# return {
|
|
# 'success':False,
|
|
# 'status':f'You have already sent an introduction to @{name}. It would be rude to send another.'
|
|
# }
|
|
|
|
# send msg to op
|
|
msg_to_op = {
|
|
'name':self.name,
|
|
'secret_login':self.secret_login,
|
|
'pubkey':self.uri,
|
|
|
|
'meet_name':name,
|
|
'meet_pubkey':pubkey,
|
|
'returning':returning,
|
|
|
|
'other_data':other_data,
|
|
}
|
|
self.log('msg_to_op',msg_to_op)
|
|
|
|
res = await self.ring_ring(
|
|
msg_to_op,
|
|
route='introduce'
|
|
)
|
|
self.log('res from op <-',res)
|
|
|
|
# record that I've already tried this
|
|
# self.crypt_keys.set(
|
|
# keystr,
|
|
# b'y',
|
|
# prefix='/met/'
|
|
# )
|
|
|
|
# return result
|
|
succ=res.get('success')
|
|
if succ:
|
|
msgd=res.get('msg_d',{})
|
|
msg=msgd.get('msg',{}).get('txt','[?]')
|
|
toname=msgd.get('to_name')
|
|
status = f"""I sent the following message to {toname}:\n\n"{msg}" """
|
|
else:
|
|
status = res.get('status')
|
|
return {
|
|
'status':status,
|
|
'success':succ,
|
|
'res':res
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
###################
|
|
## (3) MESSAGING ##
|
|
###################
|
|
|
|
|
|
|
|
def msg(self,someone,something):
|
|
return asyncio.run(self.msg_async(someone,something))
|
|
|
|
async def msg_async(self,someone,something):
|
|
# find or boot
|
|
someone = Comrad(someone)
|
|
self.log(f'found {someone}')
|
|
|
|
# can we?
|
|
if not someone.pubkey:
|
|
self.log(f'''Don't know the public key of {someone}!''')
|
|
|
|
# write them message
|
|
msg_obj = self.compose_msg_to(
|
|
something,
|
|
someone
|
|
)
|
|
self.log('composed msg:',msg_obj)
|
|
|
|
# encrypt it
|
|
msg_obj.encrypt()
|
|
|
|
# attaching
|
|
direct_msg_data = msg_obj.msg
|
|
self.log('going to send only this to op:',direct_msg_data)
|
|
|
|
# enclosing
|
|
msg_to_op = {
|
|
'deliver_msg': {
|
|
'from':self.pubkey.data_b64,
|
|
'from_name':self.name,
|
|
'to':someone.pubkey.data_b64,
|
|
'to_name':someone.name,
|
|
'msg':direct_msg_data,
|
|
'timestamp':time.time()
|
|
}
|
|
|
|
}
|
|
self.log('going to send msg to op?',msg_to_op)
|
|
|
|
# dial operator
|
|
res=await self.ring_ring(
|
|
msg_to_op,
|
|
route='deliver_msg'
|
|
)
|
|
self.log('-->',res)
|
|
# if successful
|
|
if res.get('success'):
|
|
# add to outbox
|
|
post_id = res.get('post_id')
|
|
if post_id:
|
|
self.add_to_msg_outbox(
|
|
post_id,
|
|
username=self.name
|
|
)
|
|
|
|
return res
|
|
|
|
#def post(self,something):
|
|
# return self.msg(WORLD_NAME,something)
|
|
|
|
def post(self,something):
|
|
return asyncio.run(self.post_async(something))
|
|
|
|
|
|
async def post_async(self,something):
|
|
# sign it!
|
|
self.log('something =',something)
|
|
|
|
something_b = pickle.dumps(something)
|
|
self.log('something_b =',something_b)
|
|
|
|
something_b_signed = ssign(
|
|
self.privkey.data,
|
|
something_b
|
|
)
|
|
self.log('something_b_signed =',something_b_signed)
|
|
|
|
# something_b_signed_b64 = b64enc(
|
|
# something_b_signed
|
|
# )
|
|
# self.log('something_b_signed_b64 =',something_b_signed_b64)
|
|
|
|
# encrypt package to world (or op?)
|
|
world=Comrad(WORLD_NAME)
|
|
something_b_signed_encr4world = SMessage(
|
|
self.privkey.data,
|
|
world.pubkey.data
|
|
).wrap(something_b_signed)
|
|
self.log(something_b_signed_encr4world)
|
|
|
|
post_pkg_d = {
|
|
'post':something_b_signed_encr4world,
|
|
'post_from':self.uri,
|
|
'post_from_name':self.name,
|
|
'post_timestamp':time.time(),
|
|
}
|
|
self.log('post_pkg_d =',post_pkg_d)
|
|
|
|
post_pkg_b = pickle.dumps(post_pkg_d)
|
|
self.log('post_pkg_b =',post_pkg_d)
|
|
|
|
# post_pkg_b_encr4world = SMessage(
|
|
# self.privkey.data,
|
|
# Comrad(WORLD_NAME).pubkey.data
|
|
# ).wrap(post_pkg_b)
|
|
# self.log(post_pkg_b_encr4world)
|
|
|
|
res_op = await self.ring_ring(
|
|
{
|
|
'data':post_pkg_b
|
|
},
|
|
route='deliver_post'
|
|
)
|
|
|
|
self.log('post res from Op <-',res_op)
|
|
# if successful
|
|
if res_op.get('success'):
|
|
# add to outbox
|
|
post_id = res_op.get('post_id')
|
|
if post_id:
|
|
self.add_to_post_outbox(
|
|
post_id,
|
|
username=self.name
|
|
)
|
|
|
|
# any posts to save right now?
|
|
if res_op.get('res_posts',{}).get('success'):
|
|
id2post=res_op.get('res_posts',{}).get('posts',{})
|
|
if id2post:
|
|
self.save_posts(id2post)
|
|
|
|
# stop
|
|
return res_op
|
|
|
|
def add_to_post_outbox(self,post_id,username='',prefix='/outbox/post/'):
|
|
if username: prefix+=username+'/'
|
|
outbox = self.get_inbox_crypt(prefix=prefix)
|
|
outbox.prepend(post_id)
|
|
self.log('added to outbox:',post_id,prefix,username,outbox.values)
|
|
return {'success':True,'status':f'Added {post_id} to {prefix} for posts.'}
|
|
|
|
def add_to_msg_outbox(self,post_id,username='',prefix='/outbox/msg/'):
|
|
return self.add_to_post_outbox(
|
|
post_id=post_id,
|
|
username=username,
|
|
prefix=prefix
|
|
)
|
|
|
|
|
|
@property
|
|
def login_details(self):
|
|
return {
|
|
'name':self.name,
|
|
'secret_login':self.secret_login,
|
|
'pubkey':self.uri
|
|
}
|
|
|
|
def save_posts(self,
|
|
id2post,
|
|
inbox_prefix='/feed/',
|
|
post_prefix='/post/'):
|
|
|
|
# update inbox
|
|
new_inbox = list(id2post.keys())
|
|
self.log('new_inbox ->',new_inbox,inbox_prefix,post_prefix)
|
|
inbox = self.get_inbox_crypt(
|
|
prefix=inbox_prefix
|
|
)
|
|
inbox.prepend(new_inbox)
|
|
self.log('new vals =',inbox.values)
|
|
|
|
# update posts
|
|
for post_id,post in id2post.items():
|
|
self.log(f'saving post! --> {post_prefix}{post_id} --> {post}')
|
|
|
|
self.crypt_data.set(
|
|
post_id,
|
|
post,
|
|
prefix=f'{post_prefix}{self.name}/',
|
|
override=True
|
|
)
|
|
|
|
|
|
## add to outbox
|
|
post_ids = list(id2post.keys())
|
|
for post in self.posts(post_ids=post_ids):
|
|
self.log('adding post to outbox!',post)
|
|
self.add_to_post_outbox(
|
|
post.post_id,
|
|
username=post.from_name
|
|
)
|
|
|
|
res = {
|
|
'success':True,
|
|
'status':f'Saved {len(id2post)} posts.'
|
|
}
|
|
|
|
self.log('-->',res)
|
|
return res
|
|
|
|
|
|
def save_msgs(self,id2msg):
|
|
return self.save_posts(
|
|
id2post=id2msg,
|
|
inbox_prefix='/inbox/',
|
|
post_prefix='/post/'
|
|
)
|
|
|
|
## Getting updates
|
|
async def get_updates(self,include_posts=True):
|
|
# get any parameters we need
|
|
# post_ids_read = list(self.inbox_read_db.values)
|
|
if not self.pubkey:
|
|
return {'success':False, 'status':'Cannot log into this user whose public key I do not have'}
|
|
if not self.privkey:
|
|
return {'success':False, 'status':'Cannot log into this user whose private key I do not have'}
|
|
|
|
# compose msg
|
|
msg_to_op = {
|
|
**self.login_details,
|
|
}
|
|
self.log('msg to op ->',msg_to_op)
|
|
|
|
res = await self.ring_ring(
|
|
msg_to_op,
|
|
route='get_updates'
|
|
)
|
|
self.log('<- Op.get_updates <-',res)
|
|
|
|
# error?
|
|
if not res.get('success'): return res
|
|
|
|
# (2) save msgs
|
|
id2msg=res.get('res_msgs').get('posts',{})
|
|
|
|
# (3) save posts
|
|
if include_posts:
|
|
id2post=res.get('res_posts').get('posts',{})
|
|
|
|
# save them: but posts arent msgs!
|
|
# @hack! why is this happening?
|
|
id2msg = dict([(k,v) for k,v in id2msg.items() if k not in id2post])
|
|
|
|
|
|
self.log(f'downloaded {len(id2msg)} messages:',list(id2msg.keys()))
|
|
if include_posts:
|
|
self.log(f'downloaded {len(id2post)} posts:',list(id2post.keys()))
|
|
|
|
self.save_msgs(id2msg)
|
|
if include_posts:
|
|
self.save_posts(id2post)
|
|
|
|
# return {
|
|
# 'status':f'Retrieved {len(id2post)} posts and {len(id2msg)} messages.',
|
|
# 'id2msg':id2msg,
|
|
# 'id2post':id2post
|
|
# }
|
|
#res['status']=''
|
|
#if len(id2post) or len(id2msg):
|
|
# res['status']=f'You\'ve got {len(id2post)} new posts and {len(id2msg)} new messages.'
|
|
|
|
_nup=self.num_unread_posts
|
|
_num=self.num_unread_msgs
|
|
res['status']=f'''You have {_nup} unseen post{'s' if _nup!=1 else ''} and {_num} unread msg{'s' if _num!=1 else ''}.'''
|
|
|
|
self.updated=time.time()
|
|
return res
|
|
|
|
@property
|
|
def num_unread_posts(self):
|
|
return len(self.posts(unread=True))
|
|
|
|
@property
|
|
def num_posts(self):
|
|
return len(self.posts())
|
|
|
|
@property
|
|
def num_unread_msgs(self):
|
|
return len(self.messages(unread=True))
|
|
|
|
@property
|
|
def num_msgs(self):
|
|
return len(self.messages())
|
|
|
|
|
|
def sent_posts(self,username='',prefix='/outbox/post/'):
|
|
if username: prefix+=username+'/'
|
|
posts = self.posts(inbox_prefix=prefix)
|
|
self.log(f'got {len(posts)} at prefix {prefix}')
|
|
return posts
|
|
|
|
|
|
def sent_messages(self,username='',prefix='/outbox/msg/'):
|
|
if username: prefix+=username+'/'
|
|
return self.messages(inbox_prefix=prefix)
|
|
|
|
def posts(self,
|
|
unread=None,
|
|
inbox_prefix='/feed/',
|
|
post_ids=[]):
|
|
|
|
if not post_ids:
|
|
inbox=self.get_inbox_crypt(prefix=inbox_prefix).values
|
|
read=self.get_inbox_crypt(prefix=inbox_prefix+'read/').values
|
|
self.log('post index<-',inbox_prefix,inbox)
|
|
# self.log('post index read<-',read)
|
|
|
|
if unread:
|
|
inbox = [x for x in inbox if not x in set(read)]
|
|
else:
|
|
inbox=post_ids
|
|
|
|
posts=[]
|
|
done=set()
|
|
for post_id in inbox:
|
|
if post_id in done: continue
|
|
done|={post_id}
|
|
# self.log('???',post_id,inbox_prefix)
|
|
try:
|
|
res_post = self.read_post(post_id)
|
|
except ThemisError as e:
|
|
self.log('!! ',e)
|
|
continue
|
|
# self.log('got post:',res_post)
|
|
if res_post.get('success') and res_post.get('post'):
|
|
post=res_post.get('post')
|
|
post.post_id=post_id
|
|
post.inbox_prefix=inbox_prefix
|
|
posts.append(post)
|
|
|
|
# sort by timestamp!
|
|
posts.sort(key=lambda post: -post.timestamp)
|
|
|
|
return posts
|
|
|
|
def read_post(self,post_id,post_encr=None,post_prefix='/post/'):
|
|
# get post
|
|
if not post_encr:
|
|
post_encr = self.crypt_data.get(
|
|
post_id,
|
|
prefix=f'{post_prefix}{self.name}/',
|
|
)
|
|
# self.log('found encrypted post store:',post_encr)
|
|
|
|
# first from op to me?
|
|
try:
|
|
msg_from_op_b_encr = post_encr
|
|
# self.log('!?!?',self.name,self.uri,post_id,'\n',self.privkey)
|
|
msg_from_op_b = SMessage(
|
|
self.privkey.data,
|
|
self.op.pubkey.data
|
|
).unwrap(msg_from_op_b_encr)
|
|
# self.log('decrypted??',msg_from_op_b)
|
|
except (ThemisError,TypeError) as e:
|
|
self.log(f'!!!!! {e} !!!!!')
|
|
return {
|
|
'success':False,
|
|
'status':'Could not decrypt from operator.'
|
|
}
|
|
|
|
# decoded?
|
|
msg_from_op = pickle.loads(msg_from_op_b)
|
|
# self.log('decoded?',msg_from_op)
|
|
post_signed_b = msg_from_op.get('post')
|
|
post_from_uri = msg_from_op.get('post_from')
|
|
post_from_name = msg_from_op.get('post_from_name')
|
|
post_timestamp = msg_from_op.get('post_timestamp')
|
|
|
|
# verify!
|
|
try:
|
|
post_b = sverify(
|
|
b64dec(post_from_uri),
|
|
post_signed_b
|
|
)
|
|
except ThemisError:
|
|
return {'success':False,'status':'Verification failed'}
|
|
|
|
# decode
|
|
post_data = pickle.loads(post_b)
|
|
|
|
# pretend its a message to world?
|
|
post_obj = Message(
|
|
{
|
|
'from':post_from_uri,'from_name':post_from_name,
|
|
'to':Comrad(WORLD_NAME).uri, 'to_name':WORLD_NAME,
|
|
'msg':post_data,
|
|
'timestamp':post_timestamp
|
|
}
|
|
)
|
|
# self.log('post obj?',post_obj)
|
|
post_obj.post_id = post_id
|
|
return {
|
|
'success':True,
|
|
'post':post_obj
|
|
}
|
|
|
|
|
|
|
|
def msgs(self,*x,**y): return self.messages(*x,**y)
|
|
|
|
|
|
|
|
|
|
def messages(self,
|
|
unread=None,
|
|
inbox_prefix='/inbox/',
|
|
post_ids=[]):
|
|
# meta inbox
|
|
if not post_ids:
|
|
self.log('<--',inbox_prefix,'???')
|
|
|
|
inbox_db=self.get_inbox_crypt(prefix=inbox_prefix)
|
|
read_db=self.get_inbox_crypt(prefix=inbox_prefix+'read/')
|
|
|
|
inbox = inbox_db.values
|
|
read = read_db.values
|
|
self.log('<- inbox',inbox)
|
|
self.log('<- read',read)
|
|
|
|
# filter?
|
|
if unread:
|
|
inbox = [x for x in inbox if not x in set(read)]
|
|
else:
|
|
inbox=post_ids
|
|
|
|
# decrypt and read all posts
|
|
msgs=[]
|
|
done=set()
|
|
for post_id in inbox:
|
|
if post_id in done: continue
|
|
done|={post_id}
|
|
# self.log('???',post_id,inbox_prefix)
|
|
res_msg = self.read_msg(post_id)
|
|
# self.log('got msg:',res_msg)
|
|
if res_msg.get('success') and res_msg.get('msg'):
|
|
msgx=res_msg.get('msg')
|
|
msgx.post_id=post_id
|
|
msgx.inbox_prefix=inbox_prefix
|
|
msgs.append(msgx)
|
|
return msgs
|
|
|
|
def seen_msg(self,msg_or_post):
|
|
# read_msgs = self.get_inbox_crypt(
|
|
# uri=self.uri,
|
|
# prefix=msg_or_post.inbox_prefix + 'read/'
|
|
# )
|
|
inbox_prefix=msg_or_post.inbox_prefix
|
|
self.log('inbox_prefix',inbox_prefix)
|
|
read_db=self.get_inbox_crypt(prefix=inbox_prefix+'read/')
|
|
self.log('read_db.values 1',read_db.values)
|
|
read_db.append(msg_or_post.post_id)
|
|
self.log('read_db.values 2',read_db.values)
|
|
|
|
|
|
def read_msg(self,post_id=None,post_encr=None,post_prefix='/post/'):
|
|
# get post
|
|
if not post_encr:
|
|
post_encr = self.crypt_data.get(
|
|
post_id,
|
|
prefix=f'{post_prefix}{self.name}/',
|
|
)
|
|
self.log('found encrypted post store:',post_encr)
|
|
if not post_encr:
|
|
# this is an invalid post_id!
|
|
self.delete_post(
|
|
post_id=post_id,
|
|
inbox_uri=self.uri,
|
|
inbox_prefix='/inbox/'
|
|
)
|
|
return {'success':False,'status':'No post found.'}
|
|
|
|
# first from op to me?
|
|
try:
|
|
msg_from_op_b_encr = post_encr
|
|
self.log('!?!?',self.name,self.uri,post_id,'\n',self.privkey)
|
|
msg_from_op_b = SMessage(
|
|
self.privkey.data,
|
|
self.op.pubkey.data
|
|
).unwrap(msg_from_op_b_encr)
|
|
# self.log('decrypted??',msg_from_op_b)
|
|
except (ThemisError,TypeError) as e:
|
|
self.log(f'!!!!! {e} !!!!!')
|
|
return {
|
|
'success':False,
|
|
'status':'Could not decrypt from operator.'
|
|
}
|
|
|
|
# decoded?
|
|
msg_from_op = pickle.loads(msg_from_op_b)
|
|
# self.log('decoded?',msg_from_op)
|
|
|
|
# self.log('msg_from_op is now',msg_from_op)
|
|
|
|
# this really to me?
|
|
if msg_from_op.get('to_name') != self.name:
|
|
if msg_from_op.get('to_name') == WORLD_NAME:
|
|
return {
|
|
'success':True,
|
|
'msg':Message(msg_from_op)
|
|
}
|
|
else:
|
|
# print(msg_from_op)
|
|
raise ComradException('Why am I getting this msg? '+str(msg_from_op))
|
|
return
|
|
|
|
# now try to decrypt?
|
|
msg2me = Message(
|
|
to_whom=self,
|
|
msg_d={
|
|
'from':msg_from_op.get('from'),
|
|
'from_name':msg_from_op.get('from_name'),
|
|
'msg': msg_from_op.get('msg')
|
|
}
|
|
)
|
|
self.log('msg2me is now v1',dict_format(msg2me.msg_d),dict_format(msg2me.data),msg2me.is_encrypted,msg2me.has_embedded_msg)
|
|
|
|
if not msg2me.is_encrypted:
|
|
return {
|
|
'success':True,
|
|
'msg':msg2me
|
|
}
|
|
|
|
try:
|
|
msg2me.decrypt()
|
|
self.log('msg2me is now v2',dict_format(msg2me.msg_d))
|
|
except ThemisError as e:
|
|
self.log('decryption failuire!!!')
|
|
return {
|
|
'success':False,
|
|
'status':f'De/encryption failure: {e}'
|
|
}
|
|
|
|
msg2me.post_id=post_id
|
|
return {
|
|
'success':True,
|
|
'msg':msg2me
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def test_register():
|
|
import random
|
|
num = random.choice(list(range(0,1000)))
|
|
botname=f'marx{str(num).zfill(3)}'
|
|
marxbot = Comrad(botname)
|
|
# marxbot=Comrad()
|
|
marxbot.register(passphrase='boo')
|
|
|
|
|
|
|
|
def test_msg():
|
|
b = Comrad('bez')
|
|
b.inbox()
|
|
# b.read_msg(b'YWY3NDUxZjNjYjdhNDFmNmIyNDI2NzU3YTI4ZTA0OWM=')
|
|
#b.login()
|
|
|
|
#print(b.download_msgs())
|
|
|
|
# z = Comrad('zuckbot')
|
|
|
|
# b.msg(z,'you ssssssuck')
|
|
|
|
|
|
def test_loading():
|
|
z1 = Comrad('elon')
|
|
# z1.register()
|
|
print(z1.keychain())
|
|
# exit()
|
|
|
|
z2 = Comrad(b'VUVDMgAAAC08BCMVA+0dMJXc66/W7hty669+3/3S61Q1yjmgJW8I0k3lqfDi')
|
|
print(z2)
|
|
print(z2.keychain())
|
|
|
|
pprint(PHONEBOOK)
|
|
|
|
return
|
|
|
|
# z1.login()
|
|
|
|
def test_sign():
|
|
from pythemis import smessage
|
|
|
|
b = Comrad('bez')
|
|
m = Comrad('marx')
|
|
z = Comrad('zuckbot')
|
|
|
|
msg = b'this is cool. --bez'
|
|
|
|
signed_msg = smessage.ssign(b.privkey.data, msg)
|
|
|
|
print(signed_msg)
|
|
|
|
verified_msg = smessage.sverify(b.pubkey.data, signed_msg)
|
|
print(verified_msg)
|
|
|
|
def test_send():
|
|
z = Comrad('zuckbot')
|
|
|
|
if __name__=='__main__':
|
|
test_msg() |