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 *
from komrade . backend . keymaker import *
from komrade . backend . messages import Message
class KomradeX ( Caller ) :
def __init__ ( self , name = None , pubkey = None ) :
super ( ) . __init__ ( name = name )
# self.log(f'booted komrade with {name} and {passphrase} and\n\n{dict_format(self.keychain())}')
# if SHOW_STATUS:
# from komrade.cli import CLI
# self.cli = CLI(name=name, komrade=self)
self . boot ( create = False )
# self.name=name
# pass
def boot ( self , create = False , ping = False ) :
# 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 ) :
return bool ( self . pubkey )
def exists_locally_as_contact ( self ) :
return bool ( self . pubkey ) and not bool ( self . privkey )
def exists_locally_as_account ( self ) :
return bool ( self . pubkey ) and bool ( self . privkey_encr )
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
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 )
####################################
## (1) Logging in and registering ##
####################################
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 ( ' \n Hello, this is Komrade @ ' )
logfunc ( ' I would like to sign up for the socialist network revolution. ' , flush = True , komrade_name = name , pause = True )
# do_pause()
else :
logfunc ( f ' Hello, this is Komrade @ { name } . \n \n I would like to sign up for the socialist network revolution. ' , pause = True , komrade_name = name )
# do_pause()
# clear_screen()
logfunc ( f ' Excellent. But to communicate with komrades securely, you must first cut your public & private encryption keys. ' , pause = True , clear = True )
# do_pause()
## 2) Make pub public/private keys
keypair = KomradeAsymmetricKey ( )
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 \n It 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 Komrade @Operator on the remote server. \n \n Shall Komrade @Telephone send them over? ' , pause = False , clear = False ) #),dict_format(data,tab=2),pause=True)
ok_to_send = 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... ' , komrade_name = ' Telephone ' )
# print()
# time.sleep(1)
## CALL OP WITH PUBKEY
resp_msg_d = self . ring_ring (
{
' name ' : name ,
' pubkey ' : pubkey . data ,
} ,
route = ' register_new_user '
)
# print()
clear_screen ( )
logfunc ( resp_msg_d . get ( ' status ' ) + ART_OLDPHONE4 , komrade_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. Komrade @Operator now has your name and public key on file (and nothing else!). ' , pause = True , clear = True )
logfunc ( f " (2) 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 )
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 = KomradeSymmetricKeyWithPassphrase ( 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 = KomradeEncryptedAsymmetricPrivateKey ( 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 , KomradeSymmetricKeyWithPassphrase . __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()
return resp_msg_d
@property
def secret_login ( self ) :
return self . crypt_keys . get (
self . pubkey . data_b64 ,
prefix = ' /secret_login/ '
)
def login ( self , passphrase = None ) :
# what keys do I have?
keys = self . keychain ( )
# 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 }
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 . secret_login
}
# 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?
return sorted ( [ fn . split ( ' .png ' ) [ 0 ] for fn in os . listdir ( PATH_QRCODES ) ] )
### MEETING PEOLPE
def meet ( self , name = None , pubkey = None , returning = False ) :
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
}
self . log ( ' msg_to_op ' , msg_to_op )
res = 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
return res
###################
## (3) MESSAGING ##
###################
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 } ! ''' )
# 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 ,
}
}
self . log ( ' going to send msg to op? ' , msg_to_op )
# dial operator
res = self . ring_ring (
msg_to_op ,
route = ' deliver_msg '
)
self . log ( ' --> ' , res )
return res
def post ( self , something ) :
return self . msg ( WORLD_NAME , something )
@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 = post_prefix ,
override = True
)
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
def get_updates ( self ) :
# get any parameters we need
post_ids_read = list ( self . inbox_read_db . values )
# compose msg
msg_to_op = {
* * self . login_details ,
* * { ' post_ids_read ' : post_ids_read }
}
self . log ( ' msg to op -> ' , msg_to_op )
res = 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
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 ( ) ) )
self . log ( f ' downloaded { len ( id2post ) } posts: ' , list ( id2post . keys ( ) ) )
self . save_msgs ( id2msg )
self . save_posts ( id2post )
# return {
# 'status':f'Retrieved {len(id2post)} posts and {len(id2msg)} messages.',
# 'id2msg':id2msg,
# 'id2post':id2post
# }
res [ ' status ' ] = f ' Retrieved { len ( id2post ) } posts and { len ( id2msg ) } messages. '
return res
def messages ( self , show_read = True , show_unread = True ) :
# meta inbox
inbox = self . inbox_db . values
self . log ( ' <- inbox ' , inbox )
# filter?
if not show_read :
inbox = [ x for x in inbox if not x in set ( self . inbox_read_db . values ) ]
if not show_unread :
inbox = [ x for x in inbox if not x in set ( self . inbox_unread_db . values ) ]
self . log ( ' <- inbox 2 ' , inbox )
# decrypt and read all posts
msgs = [ ]
for post_id in inbox :
# print('???',post_id)
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
msgs . append ( msgx )
return msgs
# def delete_msg(self,post_id):
def read_msg ( self , post_id = None , post_encr = None ) :
# get post
if not post_encr :
post_encr = self . crypt_data . get (
post_id ,
prefix = ' /post/ '
)
self . log ( ' found encrypted post store: ' , post_encr )
# first from op to me?
try :
msg_from_op_b_encr = post_encr
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 :
raise KomradeException ( ' Why am I getting this msg? ' )
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 ' , msg2me , 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 = Komrade ( botname )
# marxbot=Komrade()
marxbot . register ( passphrase = ' boo ' )
def test_msg ( ) :
b = Komrade ( ' bez ' )
b . inbox ( )
# b.read_msg(b'YWY3NDUxZjNjYjdhNDFmNmIyNDI2NzU3YTI4ZTA0OWM=')
#b.login()
#print(b.download_msgs())
# z = Komrade('zuckbot')
# b.msg(z,'you ssssssuck')
def test_loading ( ) :
z1 = Komrade ( ' elon ' )
# z1.register()
print ( z1 . keychain ( ) )
# exit()
z2 = Komrade ( b ' VUVDMgAAAC08BCMVA+0dMJXc66/W7hty669+3/3S61Q1yjmgJW8I0k3lqfDi ' )
print ( z2 )
print ( z2 . keychain ( ) )
pprint ( PHONEBOOK )
return
# z1.login()
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 )
def test_send ( ) :
z = Komrade ( ' zuckbot ' )
if __name__ == ' __main__ ' :
test_msg ( )