Archives
/
Comrad
mirror of https://github.com/ComradCollective/Comrad
2
0
Fork 0
Code Issues Releases Wiki Activity

updates

Browse Source
keychain-uses-objects
quadrismegistus 4 years ago
parent c51f243023
commit f01248112c
11 changed files with 143 additions and 110 deletions
Show Stats Download Patch File Download Diff File

4
komrade/api/api.py
Unescape Escape View File

@ -374,8 +374,8 @@ class Api(object):
timestamp = b64decode(time_b64).decode() timestamp = b64decode(time_b64).decode()
tmpP = Persona(from_name) tmpP = Persona(from_name)
await tmpP.boot() await tmpP.boot()
from_pubkey_b64_acc_to_name = tmpP.pubkey_b64 from_pubkey_b64_accto_name = tmpP.pubkey_b64
assert from_pubkey_b64==from_pubkey_b64_acc_to_name assert from_pubkey_b64==from_pubkey_b64_accto_name
encrypted_payload_b64 = self.verify(signed_encrypted_payload_b64, from_pubkey_b64) encrypted_payload_b64 = self.verify(signed_encrypted_payload_b64, from_pubkey_b64)
self.log('encrypted_payload_b64 =',encrypted_payload_b64) self.log('encrypted_payload_b64 =',encrypted_payload_b64)

4
komrade/api/persona0.py
Unescape Escape View File

@ -659,8 +659,8 @@ class Persona(object):
timestamp = b64decode(time_b64).decode() timestamp = b64decode(time_b64).decode()
tmpP = Persona(from_name) tmpP = Persona(from_name)
await tmpP.boot() await tmpP.boot()
from_pubkey_b64_acc_to_name = tmpP.pubkey_b64 from_pubkey_b64_accto_name = tmpP.pubkey_b64
assert from_pubkey_b64==from_pubkey_b64_acc_to_name assert from_pubkey_b64==from_pubkey_b64_accto_name
encrypted_payload_b64 = self.verify(signed_encrypted_payload_b64, from_pubkey_b64) encrypted_payload_b64 = self.verify(signed_encrypted_payload_b64, from_pubkey_b64)
self.log('encrypted_payload_b64 =',encrypted_payload_b64) self.log('encrypted_payload_b64 =',encrypted_payload_b64)

6
komrade/app/main.py
Unescape Escape View File

@ -2,7 +2,8 @@
# change this to your external ip address for your server # change this to your external ip address for your server
#(needs to be external to allow tor routing) #(needs to be external to allow tor routing)
from config import * from config import *
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 *
@ -53,9 +54,6 @@ from kivy.uix.image import Image
import sys import sys
sys.path.append("..") # Adds higher directory to python modules path. sys.path.append("..") # Adds higher directory to python modules path.
from p2p.api import *
from p2p.persona import *
from kivy.event import EventDispatcher from kivy.event import EventDispatcher
import threading,asyncio,sys import threading,asyncio,sys

4
komrade/backend/keymaker.py
Unescape Escape View File

@ -569,12 +569,12 @@ Keymaker ({self}) is forging new keys for {name}
encr_key = keychain.get(encr_key_name) encr_key = keychain.get(encr_key_name)
# self.log(f'about to decrypt {encr_key} with {decr_key}') # self.log(f'about to decrypt {encr_key} with {decr_key}')
unencr_key = decr_key.decrypt(encr_key.data) unencr_key = decr_key.decrypt(encr_key.data)
keychain[unencr_key_name] = get_key_obj(unencr_key_name,unencr_key.data) keychain[unencr_key_name] = get_key_obj(unencr_key_name,unencr_key)
else: else:
unencr_key = keychain.get(unencr_key_name) unencr_key = keychain.get(unencr_key_name)
# self.log(f'about to encrypt {unencr_key} with {decr_key}') # self.log(f'about to encrypt {unencr_key} with {decr_key}')
encr_key = decr_key.encrypt(unencr_key.data) encr_key = decr_key.encrypt(unencr_key.data)
keychain[encr_key_name] = get_key_obj(encr_key_name,encr_key.data) keychain[encr_key_name] = get_key_obj(encr_key_name,encr_key)
except ThemisError: except ThemisError:
pass pass

66
komrade/backend/messages.py
Unescape Escape View File

@ -4,12 +4,13 @@ from komrade.backend import *
def is_valid_msg_d(msg_d): def is_valid_msg_d(msg_d):
if not type(msg_d)==dict: return False if not type(msg_d)==dict: return False
to_name=msg_d.get('_to_name') to_name=msg_d.get('to_name')
to_pub=msg_d.get('_to_pub') to_pub=msg_d.get('to')
from_name=msg_d.get('_from_name') from_name=msg_d.get('from_name')
from_pub=msg_d.get('_from_pub') from_pub=msg_d.get('from')
msg=msg_d.get('_msg') msg=msg_d.get('msg')
if to_name and to_pub and from_name and from_pub and msg: return True # if to_name and to_pub and from_name and from_pub and msg: return True
if to_pub and from_pub and msg: return True
return False return False
@ -20,11 +21,11 @@ class Message(Logger):
raise KomradeException('This is not a valid msg_d:',msg_d) raise KomradeException('This is not a valid msg_d:',msg_d)
# set fields # set fields
self.msg_d=msg_d self.msg_d=msg_d
self.to_name=msg_d.get('_to_name') self.to_name=msg_d.get('to_name')
self.to_pubkey=msg_d.get('_to_pub') self.to_pubkey=msg_d.get('to')
self.from_name=msg_d.get('_from_name') self.from_name=msg_d.get('from_name')
self.from_pubkey=msg_d.get('_from_pub') self.from_pubkey=msg_d.get('from')
self.msg=msg_d.get('_msg') self.msg=msg_d.get('msg')
self.embedded_msg=embedded_msg # only if this message has an embedded one self.embedded_msg=embedded_msg # only if this message has an embedded one
self._route=msg_d.get(ROUTE_KEYNAME) self._route=msg_d.get(ROUTE_KEYNAME)
self._from_whom=from_whom self._from_whom=from_whom
@ -37,13 +38,15 @@ class Message(Logger):
def __repr__(self): def __repr__(self):
msg_d_str=dict_format(self.msg_d,tab=6) msg_d_str=dict_format(self.msg_d,tab=6)
if type(self.msg)==dict:
msg=dict_format(self.msg,tab=4)
else:
msg=self.msg
return f""" return f"""
<MSG> from: {self.from_whom}
self.from_whom={self.from_whom} to: {self.to_whom}
self.to_whom={self.to_whom} msg: {msg}
self.msg={dict_format(self.msg,tab=4) if type(self.msg)==dict else self.msg} """
</MSG>
"""
@property @property
@ -52,21 +55,20 @@ class Message(Logger):
msg_d=self.msg_d msg_d=self.msg_d
while msg_d: while msg_d:
for k,v in msg_d.items(): md[k]=v for k,v in msg_d.items(): md[k]=v
msg_d = msg_d.get('_msg',{}) msg_d = msg_d.get('msg',{})
if type(msg_d)!=dict: msg_d=None if type(msg_d)!=dict: msg_d=None
if '_msg' in md and type(md['_msg']) == dict: if 'msg' in md and type(md['msg']) == dict:
del md['_msg'] del md['msg']
del md[ROUTE_KEYNAME] del md[ROUTE_KEYNAME]
return md return md
def mark_return_to_sender(self,new_msg=None): def mark_return_to_sender(self,new_msg=None):
self._from_whom,self._to_whom = self._to_whom,self._from_whom self._from_whom,self._to_whom = self._to_whom,self._from_whom
self.msg_d['_from_pub'],self.msg_d['_to_pub'] = self.msg_d['_to_pub'],self.msg_d['_from_pub'], self.msg_d['from'],self.msg_d['to'] = self.msg_d['to'],self.msg_d['from'],
self.msg_d['_from_name'],self.msg_d['_to_name'] = self.msg_d['_to_name'],self.msg_d['_from_name'], self.msg_d['from_name'],self.msg_d['to_name'] = self.msg_d['to_name'],self.msg_d['from_name'],
if new_msg: if new_msg:
self.msg=self.msg_d['_msg']=new_msg self.msg=self.msg_d['msg']=new_msg
def get_whom(self,name): def get_whom(self,name):
from komrade.backend.operators import locate_an_operator from komrade.backend.operators import locate_an_operator
return locate_an_operator(name) return locate_an_operator(name)
@ -126,14 +128,14 @@ class Message(Logger):
self.log(f'attempting to decrypt {self}') self.log(f'attempting to decrypt {self}')
# decrypt msg # decrypt msg
self.msg = self.msg_d['_msg'] = decr_msg_b = SMessage( self.msg = self.msg_d['msg'] = decr_msg_b = SMessage(
self.to_whom.privkey, self.to_whom.privkey,
self.from_whom.pubkey self.from_whom.pubkey
).unwrap(self.msg) ).unwrap(self.msg)
# self.log('Am I decrypted?',self) # self.log('Am I decrypted?',self)
# unpickle # unpickle
self.msg = self.msg_d['_msg'] = decr_msg = pickle.loads(decr_msg_b) self.msg = self.msg_d['msg'] = decr_msg = pickle.loads(decr_msg_b)
self.log('I am now decrypted and unpickled:',self) self.log('I am now decrypted and unpickled:',self)
# now, is the decrypted message itself a message? # now, is the decrypted message itself a message?
@ -159,7 +161,7 @@ class Message(Logger):
def encrypt(self): # each child message should already be encrypted before coming to its parent message ,recursive=False): def encrypt(self): # each child message should already be encrypted before coming to its parent message ,recursive=False):
if self._is_encrypted: return if self._is_encrypted: return
# self.log(f'attempting to encrypt msg {self.msg} from {self.from_whom} to {self.to_whom}') # self.log(f'attempting to encrypt msg {self.msg} from {self.from_whom} to {self.to_whom}')
self.log(f'About to encrypt self.msg! I now look like v1: {self}') self.log(f'I ({self.from_whom}) am about to encrypt my message to {self.to_whom},\n "end to end" so that only {self.to_whom} can read it.\n\n Before encryption, I look like:\n{self}')
# make sure msg is not meeta # make sure msg is not meeta
if self.has_embedded_msg: if self.has_embedded_msg:
@ -177,9 +179,9 @@ class Message(Logger):
).wrap(msg_b) ).wrap(msg_b)
self.msg_decr = self.msg self.msg_decr = self.msg
self.msg = msg_encr self.msg_d['msg'] = self.msg = b64encode(msg_encr)
self.msg_d['_msg'] = msg_encr self.log(f'I ({self.from_whom}) am about to encrypt my message to {self.to_whom}\n "end to end" so that only {self.to_whom} can read it.\n\n And after encryption, I look like:\n{self}')
self.log(f'Encrypted! I now look like v2: {self}') self.msg_d['msg'] = self.msg = msg_encr
self._is_encrypted = True self._is_encrypted = True
@ -216,8 +218,8 @@ class Message(Logger):
def delete_route(self): def delete_route(self):
if type(self.msg)==dict: if type(self.msg)==dict:
del self.msg[ROUTE_KEYNAME] del self.msg[ROUTE_KEYNAME]
if ROUTE_KEYNAME in self.msg_d['_msg']: if ROUTE_KEYNAME in self.msg_d['msg']:
del self.msg_d['_msg'][ROUTE_KEYNAME] del self.msg_d['msg'][ROUTE_KEYNAME]
if self.has_embedded_msg: if self.has_embedded_msg:
self.msg.delete_route() self.msg.delete_route()

93
komrade/backend/operators.py
Unescape Escape View File

@ -33,7 +33,7 @@ class Operator(Keymaker):
from komrade.backend.phonelines import check_phonelines from komrade.backend.phonelines import check_phonelines
check_phonelines() check_phonelines()
print(self.crypt_keys.get(OPERATOR_NAME,prefix='/pubkey/')) # print(self.crypt_keys.get(OPERATOR_NAME,prefix='/pubkey/'))
# stop # stop
@ -75,7 +75,7 @@ class Operator(Keymaker):
return OPERATOR return OPERATOR
def compose_msg_to(self,msg,another,route=None): def compose_msg_to(self,msg,another,incl_from_name=False,incl_to_name=False):
if not self.privkey or not self.pubkey: if not self.privkey or not self.pubkey:
raise KomradeException('why do I have no pub/privkey pair!?',self,self.name,self.pubkey,self.privkey,self.keychain()) raise KomradeException('why do I have no pub/privkey pair!?',self,self.name,self.pubkey,self.privkey,self.keychain())
if not another.name or not another.pubkey: if not another.name or not another.pubkey:
@ -83,13 +83,14 @@ class Operator(Keymaker):
# otherwise create msg # otherwise create msg
msg_d = { msg_d = {
'_from_pub':self.pubkey, 'from':self.pubkey.data,
'_from_name':self.name, # 'from_name':self.name,
'_to_pub':another.pubkey, 'to':another.pubkey.data,
'_to_name':another.name, # 'to_name':another.name,
'_msg':msg, 'msg':msg
ROUTE_KEYNAME:route
} }
if incl_from_name: msg_d['from_name']=self.name
if incl_to_name: msg_d['to_name']=self.name
# self.log(f'I am {self} packaging a message to {another}: {msg_d}') # self.log(f'I am {self} packaging a message to {another}: {msg_d}')
from komrade.backend.messages import Message from komrade.backend.messages import Message
@ -104,24 +105,16 @@ class Operator(Keymaker):
def seal_msg(self,msg_d): def seal_msg(self,msg_d):
# make sure encrypted
self.log('sealing msg!:',dict_format(msg_d))
# msg_obj.encrypt(recursive=True)
# return pure binary version of self's entire msg_d
msg_b = pickle.dumps(msg_d) msg_b = pickle.dumps(msg_d)
self.log('pickled!',msg_b) self.log('Message has being sealed in a final binary package:',b64encode(msg_b))
# encrypt by omega key
msg_b_encr = self.omega_key.encrypt(msg_b)
self.log('final seal:',msg_b_encr)
return msg_b_encr return msg_b_encr
def unseal_msg(self,msg_b_encr,from_whom=None,to_whom=None): def unseal_msg(self,msg_b_encr,from_whom=None,to_whom=None):
# default to assumption that I am the recipient # default to assumption that I am the recipient
if not to_whom: to_whom=self if not to_whom: to_whom=self
# decrypt by omega # decrypt by omega
msg_b = self.omega_key.decrypt(msg_b_encr) # msg_b = self.omega_key.decrypt(msg_b_encr)
msg_b = msg_b_encr
# unpackage from transmission # unpackage from transmission
msg_d = pickle.loads(msg_b) msg_d = pickle.loads(msg_b)
# get message obj # get message obj
@ -134,19 +127,21 @@ class Operator(Keymaker):
def __repr__(self): def __repr__(self):
clsname=(type(self)).__name__ clsname=(type(self)).__name__
name = clsname+' '+self.name if self.name!=clsname else clsname #name = clsname+' '+
try: name = 'Komrade @'+self.name # if self.name!=clsname else clsname
keystr='+'.join(self.top_keys) if self.pubkey else '' # try:
except TypeError: # keystr= 'on device: ' + ('+'.join(self.top_keys) if self.pubkey else '')
keystr='' # except TypeError:
# if self.pubkey: # keystr=''
# # if self.pubkey:
keystr=''
if False: if False:
pubk=self.pubkey_b64.decode() pubk=self.pubkey_b64.decode()
pubk=pubk[-5:] pubk=pubk[-5:]
pubk = f' ({pubk})'# if pubk else '' pubk = f' ({pubk})'# if pubk else ''
else: else:
pubk = '' pubk = ''
return f'[{name}]{pubk} ({keystr})' return f'{name}' #' ({keystr})'
def locate_an_operator(self,name): def locate_an_operator(self,name):
if name == OPERATOR_NAME: if name == OPERATOR_NAME:
@ -171,12 +166,12 @@ class Operator(Keymaker):
# route it! # route it!
func = getattr(self,route) func = getattr(self,route)
new_data = func(**data) new_data = func(**data)
msg_obj.msg = msg_obj.msg_d['_msg'] = new_data msg_obj.msg = msg_obj.msg_d['msg'] = new_data
# try passing it on? # try passing it on?
if msg_obj.has_embedded_msg: if msg_obj.has_embedded_msg:
new_data = self.route_msg(msg_obj.msg) new_data = self.route_msg(msg_obj.msg)
msg_obj.msg = msg_obj.msg_d['_msg'] = new_data msg_obj.msg = msg_obj.msg_d['msg'] = new_data
# time to turn around and encrypt # time to turn around and encrypt
msg_obj.mark_return_to_sender() msg_obj.mark_return_to_sender()
@ -189,36 +184,46 @@ class Operator(Keymaker):
return msg_obj return msg_obj
def ring_ring(self,msg,to_whom,from_whom=None,get_resp_from=None,route=None): def ring_ring(self,msg,to_whom,get_resp_from=None,route=None,caller=None):
# ring ring # ring ring
from komrade.cli.artcode import ART_PHONE_SM1 from komrade.cli.artcode import ART_PHONE_SM1
import textwrap as tw import textwrap as tw
self.log(f''' nxt=get_class_that_defined_method(get_resp_from).__name__
nxtfunc=get_resp_from.__name__
{ART_PHONE_SM1} # if from_whom != self:
ring ring ring! # self.status(f'''ring ring!
# @{self}: *picks up phone*
I am {self}. I have been given a message by {from_whom}, and told to pass it onto {to_whom}, by way of the function {get_resp_from}. # @{from_whom}: I have a message I need you to send for me.
# @{self}: To whom?
# @{from_whom}: To @{to_whom}. But not directly.
# @{self}: Who should it I pass it through?
# @{from_whom}: Pass it to {nxt}. Tell them to use "{nxtfunc}".
# @{self}: Got it... So what's the message?
# @{from_whom}: The message is:
# {dict_format(msg,tab=4)}
# ''')
if caller!=self:
self.log(f'ring ring! I ({self}) have received a message from {caller},\n which I will now encrypt and send on to {to_whom}.')
else:
self.log(f'I ({self}) will now compose and send an encrypted message to {to_whom}.')
The message is: if route and type(msg)==dict and not ROUTE_KEYNAME in msg:
msg[ROUTE_KEYNAME] = route
{dict_format(msg)}
''')
# get encr msg obj # get encr msg obj
msg_obj = self.compose_msg_to( msg_obj = self.compose_msg_to(
msg, msg,
to_whom, to_whom
route=route
) )
self.log(f'ring ring! here is the message object I made, to send to {to_whom}: {msg_obj}') self.log(f'Here is the message object I ({self}) made, to send to {to_whom}: {msg_obj}')
# encrypting # encrypting
msg_obj.encrypt() msg_obj.encrypt()
# pass through the telephone wire by the get_resp_from function # pass through the telephone wire by the get_resp_from function
if not get_resp_from: get_resp_from=to_whom.ring_ring if not get_resp_from: get_resp_from=to_whom.ring_ring
resp_msg_obj = get_resp_from(msg_obj.msg_d,from_whom=from_whom) resp_msg_obj = get_resp_from(msg_obj.msg_d,caller=caller)
self.log('resp_msg_obj <-',resp_msg_obj) self.log('resp_msg_obj <-',resp_msg_obj)
# decrypt # decrypt
@ -243,7 +248,7 @@ The message is:
# route_response = self.route_msg(msg_obj) # route_response = self.route_msg(msg_obj)
# self.log('route_response',route_response) # self.log('route_response',route_response)
# # set this to be the new msg # # set this to be the new msg
# #msg_obj.msg = msg_obj.msg_d['_msg'] = response # #msg_obj.msg = msg_obj.msg_d['msg'] = response
# #self.log('what msg_obj looks like now:',msg_obj) # #self.log('what msg_obj looks like now:',msg_obj)
# # send new content back # # send new content back

24
komrade/backend/people.py
Unescape Escape View File

@ -60,7 +60,7 @@ class Persona(Caller):
## 2) Make pub public/private keys ## 2) Make pub public/private keys
keypair = KomradeAsymmetricKey() keypair = KomradeAsymmetricKey()
pubkey,privkey = keypair.pubkey_obj,keypair.privkey_obj pubkey,privkey = keypair.pubkey_obj,keypair.privkey_obj
self.log(f'Keymaker has cut private and public keys:\n\n(1) {pubkey}\n\n(2) {privkey}') self.log(f'@Keymaker has cut private and public keys:\n\n(1) {pubkey}\n\n(2) {privkey}')
## 3) Have passphrase? ## 3) Have passphrase?
if SHOW_STATUS and not passphrase: if SHOW_STATUS and not passphrase:
@ -70,7 +70,7 @@ class Persona(Caller):
## 4) Get hashed password ## 4) Get hashed password
passhash = hasher(passphrase) passhash = hasher(passphrase)
self.log(f'''Keymaker has created a symmetric encryption cell using the disguised password:\n\n\t(2A) [Symmetric Encryption Key]\n\t({make_key_discreet_str(passhash)})''') self.log(f'''@Keymaker has created a symmetric encryption cell using the disguised password:\n\n\t(2A) [Symmetric Encryption Key]\n\t({make_key_discreet_str(passhash)})''')
## 5) Encrypt private key ## 5) Encrypt private key
privkey_decr = KomradeSymmetricKeyWithPassphrase(passphrase) privkey_decr = KomradeSymmetricKeyWithPassphrase(passphrase)
@ -97,21 +97,29 @@ class Persona(Caller):
## 7) Save data to server ## 7) Save data to server
data = { data = {
'name':name, 'name':name,
'pubkey': pubkey 'pubkey': pubkey.data,
} }
self.log('I will be sending this data to @TheOperator, on the remote server:',dict_format(data,tab=2)) # self.log('I will be sending this data to @TheOperator, on the remote server:',dict_format(data,tab=2))
# ring operator # ring operator
# call from phone since I don't have pubkey on record on Op yet # call from phone since I don't have pubkey on record on Op yet
# self.log('my keychain:',self._keychain,pubkey,self.op._keychain) # self.log('my keychain:',self._keychain,pubkey,self.op._keychain)
resp_msg_obj = self.ring_ring(data,route='register_new_user',from_whom=self) resp_msg_obj = self.ring_ring(
{
'name':name,
'pubkey': pubkey.data,
},
route='register_new_user'
)
self.log('register got back from op:',dict_format(resp_msg_obj,tab=2)) self.log('register got back from op:',dict_format(resp_msg_obj,tab=2))
def ring_ring(self,msg,**y): def ring_ring(self,msg,route=None,**y):
return super().ring_ring(msg,**y) if type(msg)==dict and not ROUTE_KEYNAME in msg:
msg[ROUTE_KEYNAME]=route
return super().ring_ring(msg,caller=self,**y)
def send_msg_to(self,msg,to_whom): def send_msg_to(self,msg,to_whom):
msg = self.compose_msg_to(msg,to_whom) msg = self.compose_msg_to(msg,to_whom)
@ -142,6 +150,6 @@ if __name__=='__main__':
# # print(person.pubkey) # # print(person.pubkey)
# # elon.send_msg_to('youre dumb',marx) # # elon.send_msg_to('youre dumb',marx)
# #Caller('elon').ring_ring({'_route':'say_hello','_msg':'my dumb message to operator'}) # #Caller('elon').ring_ring({'_route':'say_hello','msg':'my dumb message to operator'})
# # print(marx.exists_on_server()) # # print(marx.exists_on_server())

28
komrade/backend/phonelines.py
Unescape Escape View File

@ -65,15 +65,18 @@ def create_phonelines():
from base64 import b64encode from base64 import b64encode
builtin_keys_b = pickle.dumps(builtin_keys) builtin_keys_b = pickle.dumps(builtin_keys)
omega_key = KomradeSymmetricKeyWithoutPassphrase() # omega_key = KomradeSymmetricKeyWithoutPassphrase()
builtin_keys_b_encr = omega_key.encrypt(builtin_keys_b) # builtin_keys_b_encr = omega_key.encrypt(builtin_keys_b)
builtin_keys_b_encr_with_key = omega_key.data + BSEP + builtin_keys_b_encr # builtin_keys_b_encr_with_key = omega_key.data + BSEP + builtin_keys_b_encr
builtin_keys_b_encr_with_key_b64 = b64encode(builtin_keys_b_encr_with_key) # builtin_keys_b_encr_with_key_b64 = b64encode(builtin_keys_b_encr_with_key)
builtin_keys_b64 = b64encode(builtin_keys_b)
with open(PATH_BUILTIN_KEYCHAIN,'wb') as of: with open(PATH_BUILTIN_KEYCHAIN,'wb') as of:
of.write(builtin_keys_b_encr_with_key_b64) of.write(builtin_keys_b64)
# of.write(builtin_keys_b_encr_with_key_b64)
print('>> saved:',PATH_BUILTIN_KEYCHAIN) print('>> saved:',PATH_BUILTIN_KEYCHAIN)
print(builtin_keys_b_encr_with_key_b64) # print(builtin_keys_b_encr_with_key_b64)
print(builtin_keys_b64)
@ -107,12 +110,13 @@ def check_phonelines():
# builtins # builtins
with open(PATH_BUILTIN_KEYCHAIN,'rb') as f: with open(PATH_BUILTIN_KEYCHAIN,'rb') as f:
builtin_keys_encr_b64 = f.read() # builtin_keys_encr_b64 = f.read()
builtin_keys_encr = b64decode(builtin_keys_encr_b64) builtin_keys_b64 = f.read()
omega_key_b,builtin_keys_encr = builtin_keys_encr.split(BSEP) # builtin_keys_encr = b64decode(builtin_keys_encr_b64)
omega_key = KomradeSymmetricKeyWithoutPassphrase(omega_key_b) # omega_key_b,builtin_keys_encr = builtin_keys_encr.split(BSEP)
builtin_keys_b = omega_key.decrypt(builtin_keys_encr) # omega_key = KomradeSymmetricKeyWithoutPassphrase(omega_key_b)
builtin_keys = pickle.loads(builtin_keys_b) # builtin_keys_b = omega_key.decrypt(builtin_keys_encr)
builtin_keys = pickle.loads(b64decode(builtin_keys_b64))
# print(builtin_keys) # print(builtin_keys)
for name in builtin_keys: for name in builtin_keys:

2
komrade/backend/the_telephone.py
Unescape Escape View File

@ -19,7 +19,7 @@ class TheTelephone(Operator):
# def find_pubkey(self): # def find_pubkey(self):
# return self.telephone_keychain.get('pubkey') # return self.telephone_keychain.get('pubkey')
def send_and_receive(self,msg_d): def send_and_receive(self,msg_d,**y):
# seal for transport # seal for transport
msg_b_sealed = self.seal_msg(msg_d) msg_b_sealed = self.seal_msg(msg_d)

6
komrade/constants.py
Unescape Escape View File

@ -33,8 +33,8 @@ BSEP=b'||||||||||'
BSEP2=b'@@@@@@@@@@' BSEP2=b'@@@@@@@@@@'
BSEP3=b'##########' BSEP3=b'##########'
OPERATOR_NAME = 'TheOperator' OPERATOR_NAME = 'Operator'
TELEPHONE_NAME = 'TheTelephone' TELEPHONE_NAME = 'Telephone'
WORLD_NAME = 'komrades' WORLD_NAME = 'komrades'
PATH_APP = os.path.abspath(os.path.dirname(__file__)) PATH_APP = os.path.abspath(os.path.dirname(__file__))
# PATH_BUILTIN_KEYCHAINS_ENCR = os.path.join(PATH_APP,'.builtin.keychains.encr') # PATH_BUILTIN_KEYCHAINS_ENCR = os.path.join(PATH_APP,'.builtin.keychains.encr')
@ -131,7 +131,7 @@ ALLOW_CLEARNET = True
DEBUG_DEFAULT_PASSPHRASE = None # 'all your base are belong to us' DEBUG_DEFAULT_PASSPHRASE = None # 'all your base are belong to us'
ROUTE_KEYNAME = '_route' ROUTE_KEYNAME = 'request'
OPERATOR_ROUTES = [ OPERATOR_ROUTES = [
'forge_new_keys', 'forge_new_keys',

16
komrade/utils.py
Unescape Escape View File

@ -158,6 +158,22 @@ def isBase64(sb):
return False return False
import inspect,functools
def get_class_that_defined_method(meth):
if isinstance(meth, functools.partial):
return get_class_that_defined_method(meth.func)
if inspect.ismethod(meth) or (inspect.isbuiltin(meth) and getattr(meth, '__self__', None) is not None and getattr(meth.__self__, '__class__', None)):
for cls in inspect.getmro(meth.__self__.__class__):
if meth.__name__ in cls.__dict__:
return cls
meth = getattr(meth, '__func__', meth) # fallback to __qualname__ parsing
if inspect.isfunction(meth):
cls = getattr(inspect.getmodule(meth),
meth.__qualname__.split('.<locals>', 1)[0].rsplit('.', 1)[0],
None)
if isinstance(cls, type):
return cls
return getattr(meth, '__objclass__', None) # handle special descriptor objects
def hashish(binary_data): def hashish(binary_data):

Write Preview
Loading…
Cancel
Save