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 3edafafd02
commit 20822e788e
2 changed files with 26 additions and 221 deletions
Show Stats Download Patch File Download Diff File

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

@ -563,16 +563,20 @@ Keymaker ({self}) is forging new keys for {name}
continue
decr_key = keychain.get(decr_key_name)
# self.log('?',decr_key,decr_key_name,encr_key_name,keychain[encr_key_name])
if decrypt:
encr_key = keychain.get(encr_key_name)
# self.log(f'about to decrypt {encr_key} with {decr_key}')
unencr_key = decr_key.decrypt(encr_key.data)
keychain[unencr_key_name] = get_key_obj(unencr_key_name,unencr_key.data)
else:
unencr_key = keychain.get(unencr_key_name)
# self.log(f'about to encrypt {unencr_key} with {decr_key}')
encr_key = decr_key.encrypt(unencr_key.data)
keychain[encr_key_name] = get_key_obj(encr_key_name,encr_key.data)
try:
if decrypt:
encr_key = keychain.get(encr_key_name)
# self.log(f'about to decrypt {encr_key} with {decr_key}')
unencr_key = decr_key.decrypt(encr_key.data)
keychain[unencr_key_name] = get_key_obj(unencr_key_name,unencr_key.data)
else:
unencr_key = keychain.get(unencr_key_name)
# self.log(f'about to encrypt {unencr_key} with {decr_key}')
encr_key = decr_key.encrypt(unencr_key.data)
keychain[encr_key_name] = get_key_obj(encr_key_name,encr_key.data)
except ThemisError:
pass
return keychain

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

@ -48,21 +48,18 @@ def create_phonelines():
# keys to save built in
builtin_keys = [
{
'name':OPERATOR_NAME,
builtin_keys = {
OPERATOR_NAME: {
'pubkey':op_pubkey.data,
},
{
'name':TELEPHONE_NAME,
TELEPHONE_NAME: {
'pubkey':phone_pubkey.data,
'privkey':phone_privkey.data,
},
{
'name':WORLD_NAME,
WORLD_NAME: {
'pubkey':world_pubkey.data,
}
]
}
import pickle
from base64 import b64encode
@ -121,10 +118,13 @@ def check_phonelines():
for keyring in builtin_keys:
name = keyring.get('name')
keychain = dict((k,v) for k,v in keyring.items() if k!='name')
print(name,keychain)
if not 'pubkey' in keyring: continue
uri = b64encode(keychain.get('pubkey'))
if not keycrypt.has(name,prefix='/pubkey/'):
uri = b64encode(keychain.get('pubkey')
if not keycrypt.has(name,prefix='/pubkey/')
keycrypt.set(name,keychain['pubkey'],prefix='/pubkey/')
for key in [k for k in keychain if k!='pubkey']:
if not keycrypt.has(uri,prefix=f'/{key}/'):
keycrypt.set(uri,keychain[key],prefix=f'/{key}/')
@ -141,205 +141,6 @@ def check_phonelines():
return builtin_keys
# ### CREATE PRIME ENTITIES
# def create_phonelines1():
# # create secret
# create_secret()
# ## CREATE OPERATOR
# op = Keymaker(name=OPERATOR_NAME)
# op_keys_to_keep_on_client = ['pubkey'] # kept on app, stored under name
# op_keys_to_keep_on_3rdparty = [] # kept on .onion site
# op_keys_to_keep_on_server = ['pubkey', # stored under name
# 'privkey_encr'] # kept on op server
# ## create phone
# phone = Keymaker(name=TELEPHONE_NAME)
# phone_keys_to_keep_on_client = ['pubkey','privkey_encr','privkey_decr'] # kept on app; need both to init connection
# phone_keys_to_keep_on_3rdparty = [''] # dl by phone
# phone_keys_to_keep_on_server = ['pubkey'] # kept on op server
# ## create phone
# world = Keymaker(name=WORLD_NAME)
# world_keys_to_keep_on_client = ['pubkey','privkey_encr']
# world_keys_to_keep_on_3rdparty = []
# world_keys_to_keep_on_server = ['pubkey']
# # key types
# key_types = {
# 'pubkey':KomradeAsymmetricPublicKey,
# 'privkey':KomradeAsymmetricPrivateKey,
# 'privkey_encr':KomradeEncryptedAsymmetricPrivateKey,
# 'privkey_decr':KomradeSymmetricKeyWithoutPassphrase,
# 'adminkey':KomradeSymmetricKeyWithoutPassphrase,
# 'adminkey_encr':KomradeEncryptedSymmetricKey,
# 'adminkey_decr':KomradeSymmetricKeyWithPassphrase,
# }
# key_types_phone = {**key_types, **{'privkey_decr':KomradeSymmetricKeyWithoutPassphrase}}
# print('!?!?!?!',key_types_phone)
# # create keys for Op
# op_decr_keys = op.forge_new_keys(
# key_types=key_types,
# keys_to_save=op_keys_to_keep_on_server,
# keys_to_return=op_keys_to_keep_on_client + op_keys_to_keep_on_3rdparty # on clients only
# )
# #print('op!',op_uri)
# print(op_decr_keys)
# # exit()
# # create keys for phone
# phone_decr_keys = phone.forge_new_keys(
# key_types=key_types_phone,
# keys_to_save=phone_keys_to_keep_on_server, # on server only
# keys_to_return=phone_keys_to_keep_on_client + phone_keys_to_keep_on_3rdparty # on clients only
# )
# #print('phone!',op_uri)
# print(phone_decr_keys)
# # create keys for world
# world_decr_keys = world.forge_new_keys(
# key_types=key_types,
# keys_to_save=world_keys_to_keep_on_server,
# keys_to_return=world_keys_to_keep_on_client + world_keys_to_keep_on_3rdparty # on clients only
# )
# #print('world!',op_uri)
# print(world_decr_keys)
# ## store remote keys
# THIRD_PARTY_DICT = {OPERATOR_NAME:{}, TELEPHONE_NAME:{}, WORLD_NAME:{}}
# for key in op_keys_to_keep_on_3rdparty:
# if key in op_decr_keys:
# THIRD_PARTY_DICT[OPERATOR_NAME][key]=op_decr_keys[key]
# for key in phone_keys_to_keep_on_3rdparty:
# if key in phone_decr_keys:
# THIRD_PARTY_DICT[TELEPHONE_NAME][key]=phone_decr_keys[key]
# for key in world_keys_to_keep_on_3rdparty:
# if key in world_decr_keys:
# THIRD_PARTY_DICT[WORLD_NAME][key]=world_decr_keys[key]
# print('THIRD_PARTY_DICT',THIRD_PARTY_DICT)
# # store local keys
# STORE_IN_APP = {OPERATOR_NAME:{}, TELEPHONE_NAME:{}, WORLD_NAME:{}}
# for key in op_keys_to_keep_on_client:
# if key in op_decr_keys:
# STORE_IN_APP[OPERATOR_NAME][key]=op_decr_keys[key]
# for key in phone_keys_to_keep_on_client:
# if key in phone_decr_keys:
# STORE_IN_APP[TELEPHONE_NAME][key]=phone_decr_keys[key]
# for key in world_keys_to_keep_on_client:
# if key in world_decr_keys:
# STORE_IN_APP[WORLD_NAME][key]=world_decr_keys[key]
# print('STORE_IN_APP',STORE_IN_APP)
# # package
# import pickle
# STORE_IN_APP_pkg = pickle.dumps(STORE_IN_APP) #pickle.dumps(STORE_IN_APP[TELEPHONE_NAME]) + BSEP + pickle.dumps(STORE_IN_APP[OPERATOR_NAME])
# THIRD_PARTY_DICT_pkg = pickle.dumps(THIRD_PARTY_DICT) #pickle.dumps(THIRD_PARTY_DICT[TELEPHONE_NAME]) + BSEP + pickle.dumps(THIRD_PARTY_DICT[OPERATOR_NAME])
# # encrypt
# omega_key = KomradeSymmetricKeyWithoutPassphrase()
# STORE_IN_APP_encr = b64encode(omega_key.encrypt(STORE_IN_APP_pkg))
# THIRD_PARTY_totalpkg = b64encode(omega_key.data + BSEP + omega_key.encrypt(THIRD_PARTY_DICT_pkg))
# #print('THIRD_PARTY_totalpkg',THIRD_PARTY_totalpkg)
# # save
# with open(PATH_BUILTIN_KEYCHAIN,'wb') as of:
# of.write(STORE_IN_APP_encr)
# #print('STORE_IN_APP_encr',STORE_IN_APP_encr)
# with open(PATH_OPERATOR_WEB_KEYS_FILE,'wb') as of:
# of.write(THIRD_PARTY_totalpkg)
# #print('THIRD_PARTY_DICT_encr',THIRD_PARTY_totalpkg)
# def connect_phonelines():
# # globals
# global OMEGA_KEY,OPERATOR_KEYCHAIN,TELEPHONE_KEYCHAIN,WORLD_KEYCHAIN
# if OMEGA_KEY and OPERATOR_KEYCHAIN and TELEPHONE_KEYCHAIN and WORLD_KEYCHAIN:
# return (OPERATOR_KEYCHAIN,TELEPHONE_KEYCHAIN,WORLD_KEYCHAIN,OMEGA_KEY)
# # import
# from komrade.backend.mazes import tor_request
# from komrade.backend import PATH_OPERATOR_WEB_KEYS_URL
# # load remote keys
# r = komrade_request(PATH_OPERATOR_WEB_KEYS_URL)
# if r.status_code!=200:
# # return
# raise KomradeException('oh no!')
# pkg = r.text
# pkg = b64decode(pkg)
# OMEGA_KEY_b,remote_builtin_keychain_encr = pkg.split(BSEP)
# OMEGA_KEY = KomradeSymmetricKeyWithoutPassphrase(key=OMEGA_KEY_b)
# remote_builtin_keychain = pickle.loads(OMEGA_KEY.decrypt(remote_builtin_keychain_encr))
# (
# remote_builtin_keychain_phone_json,
# remote_builtin_keychain_op_json,
# remote_builtin_keychain_world_json
# ) = (
# remote_builtin_keychain[TELEPHONE_NAME],
# remote_builtin_keychain[OPERATOR_NAME],
# remote_builtin_keychain[WORLD_NAME]
# )
# #print('remote!',
# # remote_builtin_keychain_phone_json,
# # remote_builtin_keychain_op_json,
# # remote_builtin_keychain_world_json
# # #)
# # load local keys
# if not os.path.exists(PATH_BUILTIN_KEYCHAIN):
# return
# with open(PATH_BUILTIN_KEYCHAIN,'rb') as f:
# local_builtin_keychain_encr = b64decode(f.read())
# local_builtin_keychain = pickle.loads(OMEGA_KEY.decrypt(local_builtin_keychain_encr))
# (
# local_builtin_keychain_phone_json,
# local_builtin_keychain_op_json,
# local_builtin_keychain_world_json
# ) = (local_builtin_keychain[TELEPHONE_NAME],
# local_builtin_keychain[OPERATOR_NAME],
# local_builtin_keychain[WORLD_NAME]
# )
# #print('local!',
# # local_builtin_keychain_phone_json,
# # local_builtin_keychain_op_json,
# # local_builtin_keychain_world_json
# # )
# # set builtin keychains
# TELEPHONE_KEYCHAIN={}
# OPERATOR_KEYCHAIN={}
# WORLD_KEYCHAIN={}
# dict_merge(TELEPHONE_KEYCHAIN,local_builtin_keychain_phone_json)
# dict_merge(OPERATOR_KEYCHAIN,local_builtin_keychain_op_json)
# dict_merge(WORLD_KEYCHAIN,local_builtin_keychain_world_json)
# dict_merge(TELEPHONE_KEYCHAIN,remote_builtin_keychain_phone_json)
# dict_merge(OPERATOR_KEYCHAIN,remote_builtin_keychain_op_json)
# dict_merge(WORLD_KEYCHAIN,remote_builtin_keychain_world_json)
# # @hack: make sure world saved as contact?
# ofnfn=os.path.join(PATH_QRCODES,WORLD_NAME+'.png')
# if not os.path.exists(ofnfn):
# import pyqrcode
# uri_id = b64encode(WORLD_KEYCHAIN['pubkey'])
# qr = pyqrcode.create(uri_id)
# qr.png(ofnfn,scale=5)
# qr_str = qr.terminal()
# #print(f'Saved world to QR:\n{qr_str}')
# # ##print('>>>> loaded OPERATOR_KEYCHAIN',OPERATOR_KEYCHAIN)
# # ##print('>>>> loaded TELEPHONE_KEYCHAIN',TELEPHONE_KEYCHAIN)
# return (OPERATOR_KEYCHAIN,TELEPHONE_KEYCHAIN,WORLD_KEYCHAIN,OMEGA_KEY)
def test_phonelines():
from komrade.backend.the_telephone import TheTelephone
from komrade.backend.the_operator import TheOperator
@ -347,8 +148,8 @@ def test_phonelines():
phone = TheTelephone()
op = TheOperator()
print('phone',dict_format(phone.keychain()))
print('op',dict_format(op.keychain()))
print('phone',dict_format(phone._keychain))
print('op',dict_format(op._keychain))
if __name__ == '__main__':

Write Preview
Loading…
Cancel
Save