You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
310 lines
11 KiB
Python
310 lines
11 KiB
Python
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 *
|
|
|
|
|
|
|
|
|
|
def create_phonelines():
|
|
# crypt
|
|
keycrypt = Crypt(fn=PATH_CRYPT_OP_KEYS)
|
|
|
|
# Operator
|
|
op_keypair = KomradeAsymmetricKey()
|
|
op_pubkey,op_privkey = op_keypair.pubkey_obj,op_keypair.privkey_obj
|
|
op_privkey_decr = KomradeSymmetricKeyWithPassphrase()
|
|
op_privkey_encr_b = op_privkey_decr.encrypt(op_privkey.data)
|
|
op_privkey_encr = KomradeEncryptedAsymmetricPrivateKey(op_privkey_encr_b)
|
|
|
|
# save pub and priv
|
|
op_uri = op_pubkey.data_b64
|
|
keycrypt.set(OPERATOR_NAME,op_pubkey.data,prefix='/pubkey/')
|
|
keycrypt.set(op_uri,op_privkey_encr.data,prefix='/privkey_encr/')
|
|
|
|
|
|
## Telephone
|
|
phone_keypair = KomradeAsymmetricKey()
|
|
phone_pubkey,phone_privkey = phone_keypair.pubkey_obj,phone_keypair.privkey_obj
|
|
phone_privkey_decr = KomradeSymmetricKeyWithoutPassphrase()
|
|
phone_privkey_encr_b = phone_privkey_decr.encrypt(phone_privkey.data)
|
|
phone_privkey_encr = KomradeEncryptedAsymmetricPrivateKey(phone_privkey_encr_b)
|
|
|
|
# save pub and priv
|
|
keycrypt.set(TELEPHONE_NAME,phone_pubkey.data,prefix='/pubkey/')
|
|
|
|
## world
|
|
world_keypair = KomradeAsymmetricKey()
|
|
world_pubkey,world_privkey = world_keypair.pubkey_obj,world_keypair.privkey_obj
|
|
world_privkey_decr = KomradeSymmetricKeyWithPassphrase()
|
|
world_privkey_encr_b = world_privkey_decr.encrypt(world_privkey.data)
|
|
world_privkey_encr = KomradeEncryptedAsymmetricPrivateKey(world_privkey_encr_b)
|
|
|
|
# save pub and priv
|
|
world_uri = world_pubkey.data_b64
|
|
keycrypt.set(WORLD_NAME,world_pubkey.data,prefix='/pubkey/')
|
|
keycrypt.set(world_uri,world_privkey_encr.data,prefix='/privkey_encr/')
|
|
|
|
|
|
|
|
|
|
# keys to save built in
|
|
builtin_keys = [
|
|
{
|
|
'name':OPERATOR_NAME,
|
|
'pubkey':op_pubkey.data,
|
|
},
|
|
{
|
|
'name':TELEPHONE_NAME,
|
|
'pubkey':phone_pubkey.data,
|
|
'privkey_encr':phone_privkey_encr.data,
|
|
'privkey_decr':phone_privkey_decr.data
|
|
},
|
|
{
|
|
'name':WORLD_NAME,
|
|
'pubkey':world_pubkey.data,
|
|
}
|
|
]
|
|
|
|
import pickle
|
|
from base64 import b64encode
|
|
builtin_keys_b = pickle.dumps(builtin_keys)
|
|
|
|
omega_key = KomradeSymmetricKeyWithoutPassphrase()
|
|
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_b64 = b64encode(builtin_keys_b_encr_with_key)
|
|
|
|
with open(PATH_BUILTIN_KEYCHAIN,'wb') as of:
|
|
of.write(builtin_keys_b_encr_with_key_b64)
|
|
print('>> saved:',PATH_BUILTIN_KEYCHAIN)
|
|
print(builtin_keys_b_encr_with_key_b64)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def create_secret():
|
|
if not os.path.exists(PATH_CRYPT_SECRET):
|
|
secret = get_random_binary_id()
|
|
from komrade.backend.keymaker import make_key_discreet
|
|
print('shhh! creating secret:',make_key_discreet(secret))
|
|
with open(PATH_CRYPT_SECRET,'wb') as of:
|
|
of.write(secret)
|
|
|
|
create_secret()
|
|
|
|
|
|
|
|
# ### 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)
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
phone = TheTelephone()
|
|
op = TheOperator()
|