2
0
mirror of https://github.com/ComradCollective/Comrad synced 2024-11-05 21:20:51 +00:00
Comrad/komrade/backend/komrades.py

656 lines
20 KiB
Python
Raw Normal View History

2020-09-08 11:23:41 +00:00
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 *
2020-09-11 14:35:47 +00:00
from komrade.backend.keymaker import *
2020-09-08 11:23:41 +00:00
2020-09-14 06:02:17 +00:00
class KomradeX(Caller):
2020-09-08 11:23:41 +00:00
2020-09-14 08:25:55 +00:00
def __init__(self, name=None, pubkey=None):
super().__init__(name=name)
2020-09-14 06:02:17 +00:00
# self.log(f'booted komrade with {name} and {passphrase} and\n\n{dict_format(self.keychain())}')
2020-09-13 19:03:29 +00:00
# if SHOW_STATUS:
# from komrade.cli import CLI
# self.cli = CLI(name=name, komrade=self)
2020-09-13 19:26:55 +00:00
self.boot(create=False)
2020-09-13 19:04:43 +00:00
# self.name=name
# pass
2020-09-08 12:11:13 +00:00
2020-09-13 18:55:14 +00:00
def boot(self,create=False,ping=False):
2020-09-13 18:47:25 +00:00
# Do I already have my keys?
# yes? -- login
2020-09-08 12:11:13 +00:00
2020-09-13 18:47:25 +00:00
keys = self.keychain()
2020-09-14 09:28:56 +00:00
# self.log(f'booting {self}!',dict_format(keys))
2020-09-14 07:58:26 +00:00
2020-09-13 18:47:25 +00:00
if keys.get('pubkey') and keys.get('privkey'):
2020-09-14 06:20:02 +00:00
# self.log('already booted! @'+self.name)
2020-09-13 18:47:25 +00:00
return True
2020-09-09 14:38:37 +00:00
2020-09-13 18:55:14 +00:00
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()
2020-09-09 14:38:37 +00:00
2020-09-14 04:43:59 +00:00
def exists_locally(self):
return bool(self.pubkey)
2020-09-09 17:34:19 +00:00
def exists_locally_as_contact(self):
2020-09-14 04:43:59 +00:00
return bool(self.pubkey) and not bool(self.privkey)
2020-09-09 17:34:19 +00:00
2020-09-13 18:55:14 +00:00
def exists_locally_as_account(self):
2020-09-14 04:43:59 +00:00
return bool(self.pubkey) and bool(self.privkey_encr)
2020-09-09 17:34:19 +00:00
def exists_on_server(self):
2020-09-10 21:32:59 +00:00
answer = self.phone.ring_ring({
2020-09-09 18:31:36 +00:00
'_route':'does_username_exist',
'name':self.name
})
2020-09-09 22:38:57 +00:00
self.log('answer??',answer)
2020-09-10 08:08:50 +00:00
return answer
2020-09-08 11:23:41 +00:00
2020-09-09 17:34:19 +00:00
# login?
2020-09-09 17:36:07 +00:00
# def login(self):
# if keys.get('pubkey') and keys.get('privkey')
2020-09-09 17:34:19 +00:00
2020-09-11 14:35:47 +00:00
def register(self, name = None, passphrase = None, is_group=None, show_intro=0,show_body=True):
2020-09-14 06:02:17 +00:00
# global PHONEBOOK
2020-09-13 14:15:06 +00:00
# print('got name:',name)
2020-09-12 13:11:39 +00:00
## Defaults
2020-09-10 17:52:07 +00:00
if name and not self.name: self.name=name
if not name and self.name: name=self.name
2020-09-13 13:57:06 +00:00
# if not name and not self.name: name=''
2020-09-13 14:15:06 +00:00
# print('got name',name)
2020-09-14 04:43:59 +00:00
# already have it?
if self.exists_locally_as_account():
2020-09-14 06:20:02 +00:00
return {'success':False, 'status':'You have already created this account.'}
2020-09-14 04:43:59 +00:00
if self.exists_locally_as_contact():
2020-09-14 06:20:02 +00:00
return {'success':False, 'status':'This is already a contact of yours'}
2020-09-14 04:43:59 +00:00
2020-09-12 13:11:39 +00:00
## 1) Have name?
2020-09-13 13:57:06 +00:00
tolog=''
2020-09-11 14:35:47 +00:00
if SHOW_STATUS and show_intro:
2020-09-13 13:57:06 +00:00
self.name = name = self.cli.status_keymaker_part1(name)
2020-09-12 13:17:54 +00:00
elif not name:
2020-09-13 13:57:06 +00:00
self.name = name = input('\nHello, this is Komrade @')
print('\nI would like to sign up for the socialist network revolution.',flush=True)
do_pause()
else:
print(f'Hello, this is Komrade @{name}.\n\nI would like to sign up for the socialist network revolution.')
do_pause()
clear_screen()
self.log(f'@Keymaker: Excellent. But to communicate with komrades securely,\nyou must first cut your public & private encryption keys. ')
# do_pause()
2020-09-12 13:11:39 +00:00
## 2) Make pub public/private keys
2020-09-11 14:35:47 +00:00
keypair = KomradeAsymmetricKey()
pubkey,privkey = keypair.pubkey_obj,keypair.privkey_obj
2020-09-13 13:57:06 +00:00
self.log(f'@Keymaker: I have cut for you a private and public asymmetric key pair\nusing the Elliptic Curve algorithm from Themis cryptography library:\n\n(1) {pubkey}\n\n(2) {privkey}{ART_KEY_PAIR}',clear=False,pause=True)
2020-09-11 14:35:47 +00:00
2020-09-12 13:11:39 +00:00
## 3) Have passphrase?
2020-09-11 17:17:21 +00:00
if SHOW_STATUS and not passphrase:
2020-09-12 14:32:03 +00:00
passphrase = self.cli.status_keymaker_part2(name,passphrase,pubkey,privkey,hasher,self)
2020-09-11 14:35:47 +00:00
else:
2020-09-13 05:33:37 +00:00
if not passphrase: passphrase = DEBUG_DEFAULT_PASSPHRASE
2020-09-13 05:39:38 +00:00
while not passphrase:
2020-09-13 13:57:06 +00:00
passphrase=getpass(f'@Keymaker: Enter a memorable password to encrypt your private key with: \n\n@{self.name}: ')
2020-09-13 07:50:15 +00:00
clear_screen()
2020-09-12 13:11:39 +00:00
## 4) Get hashed password
2020-09-12 14:32:03 +00:00
passhash = hasher(passphrase)
2020-09-13 07:57:40 +00:00
self.log(f'''@Keymaker: I have replaced your password with a disguised, hashed version\nusing a salted SHA-256 algorithm from python's hashlib:\n\n\t{make_key_discreet_str(passhash)}''')
2020-09-12 13:11:39 +00:00
## 5) Encrypt private key
2020-09-12 14:32:03 +00:00
privkey_decr = KomradeSymmetricKeyWithPassphrase(passphrase)
2020-09-11 17:17:21 +00:00
privkey_encr = privkey_decr.encrypt(privkey.data)
2020-09-12 07:55:23 +00:00
privkey_encr_obj = KomradeEncryptedAsymmetricPrivateKey(privkey_encr)
2020-09-13 13:57:06 +00:00
self.log(f"@Keymaker: Store your private key on your device hardware ONLY\nas it was encrypted by your password-generated key:\n\n[Encrypted Private Key]\n({make_key_discreet_str(privkey_encr_obj.data_b64)})")
2020-09-12 07:55:23 +00:00
2020-09-12 13:17:54 +00:00
## 6) Test keychain works
2020-09-14 04:19:55 +00:00
#privkey_decr2 = KomradeSymmetricKeyWithPassphrase(passphrase)
#assert privkey_decr2.decrypt(privkey_encr) == privkey.data
2020-09-12 13:17:54 +00:00
2020-09-12 14:32:03 +00:00
self._keychain['pubkey']=pubkey
self._keychain['privkey_encr']=privkey_encr_obj
2020-09-14 04:19:55 +00:00
self._keychain['privkey']=privkey
2020-09-12 19:31:29 +00:00
# self._keychain['privkey_decr']=privkey_decr
2020-09-12 14:32:03 +00:00
# we should be able to reassemble privkey now?
2020-09-12 19:31:29 +00:00
# self.log('this is my keychain now:')
2020-09-14 04:19:55 +00:00
#assert 'privkey' in self.keychain()
2020-09-12 13:17:54 +00:00
2020-09-14 04:19:55 +00:00
self.log('My keychain now looks like:',dict_format(self.keychain()))
2020-09-12 13:17:54 +00:00
2020-09-14 04:43:59 +00:00
# More narration?
if SHOW_STATUS: self.cli.status_keymaker_part3(privkey,privkey_decr,privkey_encr,passphrase)
# 6) Save for now on client -- will delete if fails on server
2020-09-14 06:35:40 +00:00
2020-09-14 06:02:17 +00:00
# storing myself in memory phonebook
# PHONEBOOK[name]=self
2020-09-12 13:11:39 +00:00
## 7) Save data to server
2020-09-10 10:59:37 +00:00
data = {
2020-09-12 07:55:23 +00:00
'name':name,
2020-09-12 18:18:37 +00:00
'pubkey': pubkey.data,
2020-09-10 10:59:37 +00:00
}
2020-09-13 07:49:54 +00:00
self.log('@Keymaker: Store your public key both on your device hardware\nas well as register it with Komrade @Operator on the remote server:\n\n',dict_format(data,tab=2))
2020-09-10 21:32:59 +00:00
2020-09-10 09:31:32 +00:00
# ring operator
2020-09-10 09:34:34 +00:00
# call from phone since I don't have pubkey on record on Op yet
2020-09-12 13:11:39 +00:00
# self.log('my keychain:',self._keychain,pubkey,self.op._keychain)
2020-09-13 09:42:22 +00:00
resp_msg_d = self.ring_ring(
2020-09-12 18:18:37 +00:00
{
'name':name,
'pubkey': pubkey.data,
},
route='register_new_user'
)
2020-09-13 09:42:22 +00:00
if not resp_msg_d.get('success'):
self.log(f'Registration failed. Message from operator was:\n\n{dict_format(resp_msg_d)}')
return
# otherwise, save things on our end
2020-09-13 09:44:13 +00:00
self.log(f'Registration successful. Message from operator was:\n\n{dict_format(resp_msg_d)}')
2020-09-13 10:57:06 +00:00
2020-09-13 09:42:22 +00:00
self.name=resp_msg_d.get('name')
2020-09-13 13:04:44 +00:00
pubkey_b = resp_msg_d.get('pubkey')
2020-09-14 04:43:59 +00:00
assert pubkey_b == pubkey.data
2020-09-14 06:35:40 +00:00
uri_id = pubkey.data_b64
2020-09-13 13:04:44 +00:00
sec_login = resp_msg_d.get('secret_login')
2020-09-13 09:42:22 +00:00
2020-09-13 11:36:03 +00:00
self.log(f'''Now saving name and public key on local device:''')
2020-09-14 06:35:40 +00:00
self.crypt_keys.set(name, pubkey_b, prefix='/pubkey/')
self.crypt_keys.set(uri_id, name, prefix='/name/')
2020-09-14 04:43:59 +00:00
self.crypt_keys.set(uri_id,sec_login,prefix='/secret_login/')
2020-09-10 09:34:34 +00:00
2020-09-14 08:25:55 +00:00
# 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, KomradeSymmetricKeyWithPassphrase.__name__, prefix='/privkey_decr/')
2020-09-13 09:42:22 +00:00
# save qr too:
2020-09-14 04:43:59 +00:00
self.save_uri_as_qrcode(uri_id)
2020-09-13 10:51:01 +00:00
# self.log(f'saved public key as QR code to:\n {fnfn}\n\n{qr_str}')
2020-09-13 09:43:15 +00:00
2020-09-13 14:18:36 +00:00
return resp_msg_d
2020-09-13 09:42:22 +00:00
# done!
2020-09-13 09:43:40 +00:00
self.log(f'Congratulations. Welcome, Komrade {self}.')
2020-09-08 15:14:48 +00:00
2020-09-13 11:18:04 +00:00
@property
def secret_login(self):
return self.crypt_keys.get(
2020-09-13 12:31:33 +00:00
self.pubkey.data_b64,
prefix='/secret_login/'
2020-09-13 11:18:04 +00:00
)
2020-09-13 12:27:45 +00:00
def login(self,passphrase=None):
2020-09-14 07:58:26 +00:00
# what keys do I have?
keys = self.keychain()
# self.log('here are my keys:',dict_format(keys))
2020-09-13 12:27:45 +00:00
2020-09-14 07:58:26 +00:00
# check hardware
if not 'pubkey' in keys:
emsg='''Login impossible. I do not have this komrade'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 komrade's private key on this hardware.'''
self.log(emsg)
return {'success':False, 'status':emsg}
2020-09-13 11:18:04 +00:00
2020-09-14 07:58:26 +00:00
if not 'privkey' in keys:
emsg='''Login failed. Private key did not unlock from passphrase.'''
return {'success':False, 'status': emsg}
2020-09-13 11:18:04 +00:00
# compose message
msg = {
'name':self.name,
2020-09-14 07:58:26 +00:00
'pubkey':keys['pubkey'].data,
2020-09-13 11:18:04 +00:00
'secret_login':self.secret_login
}
# ask operator and get response
resp_msg = self.ring_ring(
msg,
route='login'
)
# get result
self.log('Got result back from operator:',resp_msg)
2020-09-13 12:28:29 +00:00
return resp_msg
2020-09-13 11:18:04 +00:00
2020-09-13 18:06:41 +00:00
## MEETING PEOPLE
def find(self,someone):
if type(someone)==str:
return Komrade(name=someone)
if type(someone)==bytes:
return Komrade(pubkey=someone)
self.log('what is type of someoen here?',type(someone))
return someone
2020-09-15 11:29:16 +00:00
# def meet(self,someone):
# # get person obj
# someone = self.find(someone)
# self.log('got someone =',someone,type(someone))
2020-09-13 18:06:41 +00:00
2020-09-14 08:48:23 +00:00
def contacts(self):
# who do I know?
return sorted([fn.split('.png')[0] for fn in os.listdir(PATH_QRCODES)])
2020-09-13 18:06:41 +00:00
2020-09-13 11:18:04 +00:00
2020-09-08 15:14:48 +00:00
2020-09-12 18:18:37 +00:00
def ring_ring(self,msg,route=None,**y):
if type(msg)==dict and not ROUTE_KEYNAME in msg:
msg[ROUTE_KEYNAME]=route
return super().ring_ring(msg,caller=self,**y)
2020-09-09 15:30:34 +00:00
2020-09-13 14:48:26 +00:00
2020-09-14 07:58:26 +00:00
def msg(self,someone,something):
# find or boot
someone = Komrade(someone)
self.log(f'found {someone}')
# can we?
if not someone.pubkey:
self.log(f'''Don't know the public key of {someone}!''')
2020-09-13 19:42:04 +00:00
msg_obj = self.compose_msg_to(
2020-09-14 07:58:26 +00:00
something,
someone
2020-09-13 19:42:04 +00:00
)
self.log('composed msg:',msg_obj)
2020-09-14 07:58:26 +00:00
# encrypting
2020-09-13 19:42:04 +00:00
msg_obj.encrypt()
2020-09-14 07:58:26 +00:00
# attaching
direct_msg_data = msg_obj.msg
self.log('going to send only this to op:',direct_msg_data)
# enclosing
msg_to_op = {
'deliver_from':self.pubkey.data_b64,
2020-09-15 08:27:02 +00:00
'deliver_from_name':self.name,
2020-09-14 07:58:26 +00:00
'deliver_to':someone.pubkey.data_b64,
2020-09-15 08:27:02 +00:00
'deliver_to_name':someone.name,
2020-09-14 07:58:26 +00:00
'deliver_msg':direct_msg_data,
}
self.log('going to send msg to op?',msg_to_op)
2020-09-09 15:30:34 +00:00
2020-09-14 07:58:26 +00:00
return self.ring_ring(
msg_to_op,
route='deliver_msg'
)
2020-09-09 15:30:34 +00:00
2020-09-14 22:02:53 +00:00
def check_msgs(self,inbox=None):
2020-09-14 22:00:13 +00:00
if not self.pubkey and self.privkey:
return {'success':False,'status':'Need to be logged in'}
# checking my own mail I presume?
if not inbox:
inbox=self.pubkey.data_b64
# send info op needs
msg = {
'secret_login':self.secret_login,
'name':self.name,
2020-09-15 06:39:11 +00:00
'pubkey':self.uri,
2020-09-14 22:00:13 +00:00
'inbox':inbox
}
self.log('sending msg to op:',msg)
2020-09-15 10:54:15 +00:00
# Ring operator
res = self.ring_ring(
msg,
route='check_msgs'
)
2020-09-14 22:00:13 +00:00
self.log('got back response:',res)
2020-09-15 06:39:11 +00:00
# decrypt?
2020-09-14 22:22:50 +00:00
if not res.get('data_encr'):
return {'success':False, 'status':'No data'}
2020-09-15 06:39:11 +00:00
inbox_encr = res['data_encr']
# overwrite my local inbox with encrypted one from op?
self.crypt_keys.set(
self.uri,
inbox_encr,
prefix='/inbox/',
override=True
)
2020-09-15 07:56:09 +00:00
2020-09-15 09:12:11 +00:00
def refresh(self):
# refresh inbox
self.check_msgs()
# status?
inbox_status = self.get_inbox_ids()
if not inbox_status['success']: return inbox_status
unread=inbox_status.get('unread',[])
inbox=inbox_status.get('inbox',[])
# download new messages
self.download_msgs(post_ids = unread)
return {
'success':True,
'status':'Messages refreshed',
'unread':unread,
'inbox':inbox
}
2020-09-15 10:59:19 +00:00
def save_inbox(self,post_ids):
self.crypt_keys.set(
self.uri,
BSEP.join(post_ids),
'/inbox/'
)
def delete_msgs(self,post_ids):
inbox_ids = self.get_inbox_ids().get('inbox',[])
for post_id in post_ids:
2020-09-15 11:12:49 +00:00
print('deleting post:',post_id)
2020-09-15 10:59:19 +00:00
self.crypt_keys.delete(
post_id,
prefix='/post/'
)
inbox_ids.remove(post_id)
self.save_inbox(inbox_ids)
2020-09-15 10:54:15 +00:00
2020-09-15 11:42:57 +00:00
def inbox(self,topn=100,only_unread=False,delete_malformed=False):
2020-09-15 09:12:11 +00:00
# refreshing inbox
res = self.refresh()
2020-09-15 13:14:43 +00:00
print('got from refresh',res)
2020-09-15 09:12:11 +00:00
if not res['success']: return res
2020-09-15 13:13:32 +00:00
2020-09-15 09:12:11 +00:00
boxname = 'inbox' if not only_unread else 'unread'
post_ids = res[boxname]
msgs=[]
2020-09-15 10:59:19 +00:00
post_ids_malformed=[]
2020-09-15 09:12:11 +00:00
for post_id in post_ids:
2020-09-15 10:54:15 +00:00
malformed = False
2020-09-15 09:12:11 +00:00
try:
2020-09-15 11:45:19 +00:00
res = self.read_msg(post_id)
2020-09-15 11:48:59 +00:00
print('GOT FROM READ_MSG',res)
2020-09-15 09:12:11 +00:00
except ThemisError as e:
2020-09-15 11:42:57 +00:00
print(f'!! Could not decrypt post {post_id}')
2020-09-15 10:54:15 +00:00
malformed = True
2020-09-15 11:45:19 +00:00
2020-09-15 13:13:32 +00:00
print(res,'ressss')
if not res.get('success'):
return res
2020-09-15 11:45:19 +00:00
msg=res.get('msg')
2020-09-15 11:47:24 +00:00
print(msg,'?!?!??!')
2020-09-15 11:49:34 +00:00
# stop
2020-09-15 10:29:13 +00:00
2020-09-15 11:46:04 +00:00
if not msg.from_name or not msg.from_pubkey:
2020-09-15 11:42:57 +00:00
print('!! Invalid sender info!')
2020-09-15 10:54:15 +00:00
malformed = True
if not malformed:
msgs.append(msg)
2020-09-15 10:59:19 +00:00
else:
post_ids_malformed.append(post_id)
2020-09-15 09:12:11 +00:00
if len(msgs)>=topn: break
# print('!!',post_id,msg.from_whom, msg.to_whom, msg.from_whom is self)
2020-09-15 10:17:06 +00:00
2020-09-15 10:59:19 +00:00
if delete_malformed:
self.delete_msgs(post_ids_malformed)
2020-09-15 13:13:32 +00:00
print(msgs,'msssgs')
2020-09-15 12:07:09 +00:00
return {'success':True,
'msgs':msgs}
2020-09-15 09:12:11 +00:00
# return all messages read?
def get_inbox_ids(self):
2020-09-15 07:56:09 +00:00
inbox_encr = self.crypt_keys.get(
self.uri,
prefix='/inbox/',
)
2020-09-15 06:39:11 +00:00
# decrypt inbox?
2020-09-15 12:09:52 +00:00
if inbox_encr:
inbox = SMessage(
self.privkey.data,
self.op.pubkey.data
).unwrap(inbox_encr)
self.log('inbox decrypted:',inbox)
inbox = inbox.split(BSEP)
else:
inbox=[]
2020-09-14 22:22:50 +00:00
2020-09-15 06:39:11 +00:00
# find the unread ones
2020-09-14 22:29:47 +00:00
unread = []
2020-09-15 06:10:22 +00:00
for post_id in inbox:
2020-09-14 22:29:47 +00:00
if not post_id: continue
2020-09-15 06:10:22 +00:00
if not self.crypt_keys.get(post_id,prefix='/post/'):
unread.append(post_id)
2020-09-14 22:22:50 +00:00
2020-09-15 06:39:11 +00:00
self.log(f'I {self} have {len(unread)} new messages')
2020-09-15 06:10:22 +00:00
return {
'success':True,
'status':'Inbox retrieved.',
'unread':unread,
'inbox':inbox
}
2020-09-15 06:39:11 +00:00
def read_msg(self,post_id):
# get post
2020-09-15 06:40:32 +00:00
post_encr = self.crypt_keys.get(post_id,prefix='/post/')
2020-09-15 12:12:53 +00:00
print(post_id,'????')
2020-09-15 06:40:32 +00:00
if not post_encr:
2020-09-15 12:13:43 +00:00
self.download_msgs([post_id])
post_encr = self.crypt_keys.get(post_id,prefix='/post/')
print(post_id,'????')
2020-09-15 06:39:11 +00:00
return {
'success':False,
'status':'Post not found.'
}
2020-09-15 07:04:01 +00:00
self.log('found encrypted post store:',post_encr)
2020-09-15 08:07:57 +00:00
# self.log('unpickling?',pickle.loads(post_encr))
2020-09-15 06:39:11 +00:00
2020-09-15 06:50:21 +00:00
2020-09-15 06:39:11 +00:00
# it should be twice decrypted
2020-09-15 08:27:02 +00:00
msg_op2me_obj = Message(
from_whom=self.op,
2020-09-15 06:39:11 +00:00
to_whom=self,
msg=post_encr
)
2020-09-15 08:27:02 +00:00
self.log('assuming this is the message:',msg_op2me_obj)
2020-09-15 06:39:11 +00:00
# decrypt
2020-09-15 08:27:02 +00:00
msg_op2me_obj.decrypt()
2020-09-14 22:00:13 +00:00
2020-09-15 08:27:02 +00:00
# dict to/from/msg
msg_op2me = msg_op2me_obj.msg.msg_d
self.log('msg_op2me is now',msg_op2me)
# this really to me?
assert msg_op2me.get('to') == self.uri
# now try to decrypt?
msg2me = Message(
to_whom=self,
msg_d={
'from':msg_op2me.get('from'),
2020-09-15 08:51:52 +00:00
'from_name':msg_op2me.get('from_name'),
2020-09-15 08:27:02 +00:00
'msg': msg_op2me.get('msg')
}
)
# self.log('msg2me is now v1',msg2me)
msg2me.decrypt()
2020-09-15 08:51:52 +00:00
self.log('msg2me is now v2',dict_format(msg2me.msg_d))
2020-09-15 08:27:02 +00:00
2020-09-15 11:45:19 +00:00
return {
'success':True,
'msg':msg2me
}
2020-09-15 08:27:02 +00:00
2020-09-15 06:39:11 +00:00
def download_msgs(self,post_ids=[],inbox=None):
2020-09-15 06:10:22 +00:00
if not post_ids:
# get unerad
2020-09-15 09:12:11 +00:00
post_ids = self.get_inbox_ids().get('unread',[])
2020-09-15 06:10:22 +00:00
if not post_ids:
return {'success':False,'status':'No messages requested'}
# ask Op for them
2020-09-15 06:39:11 +00:00
res = self.ring_ring(
2020-09-15 06:10:22 +00:00
{
'secret_login':self.secret_login,
'name':self.name,
2020-09-15 06:39:11 +00:00
'pubkey':self.uri,
2020-09-15 06:10:22 +00:00
'post_ids':post_ids,
},
2020-09-15 06:39:11 +00:00
route='download_msgs'
2020-09-15 06:10:22 +00:00
)
2020-09-15 12:14:25 +00:00
print('got back from op!',res)
2020-09-15 06:39:11 +00:00
if not 'data_encr' or not res['data_encr'] or type(res['data_encr'])!=dict:
return {'success':False, 'status':'No valid data returned.'}
# store -- encrypted!
2020-09-15 08:07:57 +00:00
posts_downloaded = []
2020-09-15 06:39:11 +00:00
for post_id,post_encr in res['data_encr'].items():
2020-09-15 10:17:06 +00:00
# print('storing...',post_id)
2020-09-15 06:39:11 +00:00
self.crypt_keys.set(
post_id,
post_encr,
prefix='/post/'
)
2020-09-15 08:07:57 +00:00
posts_downloaded.append(post_id)
return {
'success':True,
'status':'Messages downloaded',
'downloaded':posts_downloaded,
}
2020-09-09 15:30:34 +00:00
2020-09-15 11:12:49 +00:00
2020-09-15 11:29:16 +00:00
### MEETING PEOLPE
def meet(self,name=None,pubkey=None):
if not name and not pubkey:
return {'success':False,'status':'Meet whom?'}
2020-09-15 11:12:49 +00:00
2020-09-15 11:31:25 +00:00
msg_to_op = {
'name':self.name,
'secret_login':self.secret_login,
'pubkey':self.uri,
2020-09-15 11:12:49 +00:00
2020-09-15 11:31:25 +00:00
'meet_name':name,
'meet_pubkey':pubkey
}
2020-09-15 11:29:16 +00:00
print('msg_to_op',msg_to_op)
2020-09-15 11:12:49 +00:00
2020-09-15 11:29:16 +00:00
res = self.ring_ring(
2020-09-15 11:31:57 +00:00
msg_to_op,
2020-09-15 11:29:16 +00:00
route='introduce_komrades'
)
print('res from op',res)
2020-09-15 11:12:49 +00:00
2020-09-15 11:29:16 +00:00
return res
2020-09-15 11:12:49 +00:00
2020-09-10 14:00:55 +00:00
def test_register():
import random
num = random.choice(list(range(0,1000)))
2020-09-10 21:32:59 +00:00
botname=f'marx{str(num).zfill(3)}'
2020-09-13 07:15:44 +00:00
marxbot = Komrade(botname)
# marxbot=Komrade()
2020-09-14 06:02:17 +00:00
marxbot.register(passphrase='boo')
2020-09-09 15:30:34 +00:00
2020-09-13 19:42:04 +00:00
2020-09-13 20:24:31 +00:00
2020-09-13 19:42:04 +00:00
def test_msg():
2020-09-15 06:10:22 +00:00
b = Komrade('bez')
2020-09-15 07:04:01 +00:00
b.inbox()
# b.read_msg(b'YWY3NDUxZjNjYjdhNDFmNmIyNDI2NzU3YTI4ZTA0OWM=')
2020-09-15 06:40:03 +00:00
#b.login()
2020-09-15 06:10:22 +00:00
2020-09-15 06:40:03 +00:00
#print(b.download_msgs())
2020-09-15 06:10:22 +00:00
# z = Komrade('zuckbot')
2020-09-13 20:24:31 +00:00
2020-09-15 06:10:22 +00:00
# b.msg(z,'you ssssssuck')
2020-09-13 20:24:31 +00:00
2020-09-13 19:42:04 +00:00
2020-09-14 07:58:26 +00:00
def test_loading():
2020-09-14 19:25:24 +00:00
z1 = Komrade('elon')
2020-09-14 11:52:56 +00:00
# z1.register()
2020-09-14 08:25:55 +00:00
print(z1.keychain())
2020-09-14 11:52:56 +00:00
# exit()
2020-09-14 07:58:26 +00:00
z2 = Komrade(b'VUVDMgAAAC08BCMVA+0dMJXc66/W7hty669+3/3S61Q1yjmgJW8I0k3lqfDi')
print(z2)
print(z2.keychain())
2020-09-08 15:14:48 +00:00
2020-09-14 07:58:26 +00:00
pprint(PHONEBOOK)
return
# z1.login()
2020-09-09 15:41:33 +00:00
2020-09-15 06:10:22 +00:00
def test_sign():
from pythemis import smessage
b = Komrade('bez')
m = Komrade('marx')
z = Komrade('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)
2020-09-15 06:18:34 +00:00
def test_send():
z = Komrade('zuckbot')
2020-09-09 17:39:30 +00:00
2020-09-14 07:58:26 +00:00
if __name__=='__main__':
2020-09-15 06:10:22 +00:00
test_msg()