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 ( ' \n Hello, this is Komrade @ ' )
print ( ' \n I would like to sign up for the socialist network revolution. ' , flush = True )
do_pause ( )
else :
print ( f ' Hello, this is Komrade @ { name } . \n \n I 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, \n you 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 \n using 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 \n using 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 \n as 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 \n as 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
2020-09-15 13:42:39 +00:00
self . download_msgs ( post_ids = inbox )
2020-09-15 09:12:11 +00:00
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/ '
)
2020-09-15 14:05:33 +00:00
def delete_msg ( self , post_id ) :
return self . delete_msgs ( [ post_id ] )
2020-09-15 10:59:19 +00:00
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/ '
)
2020-09-15 14:14:25 +00:00
if post_id in inbox_ids :
inbox_ids . remove ( post_id )
2020-09-15 10:59:19 +00:00
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:44:04 +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 13:44:04 +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:38:16 +00:00
#print(res,'ressss')
2020-09-15 13:13:32 +00:00
if not res . get ( ' success ' ) :
2020-09-15 13:45:07 +00:00
# return res
2020-09-15 13:45:38 +00:00
continue
2020-09-15 11:45:19 +00:00
msg = res . get ( ' msg ' )
2020-09-15 13:45:38 +00:00
if not msg : continue
2020-09-15 13:38:16 +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
2020-09-15 14:02:42 +00:00
msg . post_id = post_id
2020-09-15 10:54:15 +00:00
if not malformed :
2020-09-15 13:46:36 +00:00
# print('good msg:',msg)
2020-09-15 10:54:15 +00:00
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:38:16 +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 13:46:36 +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/ ' )
2020-09-15 13:46:36 +00:00
# print(post_id,'????')
2020-09-15 12:13:43 +00:00
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 13:46:36 +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 13:34:53 +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 '
)
2020-09-15 13:34:53 +00:00
# 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 ( )