def key_and_peer_wizard():
on("KEY", common.set_key_wizard)
client.register_crypto_client(cfg)
name = on(
"PEER_NAME", lambda: utils.locale_to_unicode(
ui.ask_value("PEER_NAME", "Specify name to register as peer")))
peer_id = on("PEER_ID", lambda: do_register_wizard(name))
client.peer_import(peer_id)
def main(text=None, recipient=None):
import os
ui.inform("Welcome to Panoramix sphinxmix agent!")
ui.inform("Configuration file is: %s" % common.config_file)
ui.inform("Set PANORAMIX_CONFIG environment variable to override")
url = on("MIXNET_URL",
lambda: ui.ask_value("MIXNET_URL", "Give sphinxmix mixnet URL"))
mixnet_url_process(url)
on("KEY", common.set_key_wizard)
agent.main()
def join_endpoint_wizard(cycle):
setting = suffixed_setting(cycle)
neg_id = on(setting("EP_NEGOTIATION_ID"), read_next_negotiation_id)
contrib = on(setting("EP_COORD_INITIAL_CONTRIBUTION"),
retry(lambda: _check_initial_contribution(neg_id)))
register_next_negotiation_id(contrib)
on(setting("EP_CONTRIBUTION"),
lambda: join_ep_contribution(neg_id, contrib))
second_contrib = on(
setting("EP_COORD_SECOND_CONTRIBUTION"),
retry(lambda: _join_coord_second_contribution(
neg_id, contrib, for_ep=True)))
on(setting("EP_SECOND_CONTRIBUTION_ID"),
lambda: _join_second_contribution(neg_id, second_contrib))
finished_neg = on(setting("EP_FINISHED_NEGOTIATION"),
retry(lambda: finished_negotiation(neg_id)))
endpoints = on(setting("EP_COMBINED_ID"),
retry(lambda: join_combined_endpoint(finished_neg)))
inform_send_message(endpoints)
return endpoints
def main():
args = parser.parse_args()
global autodefault
autodefault = args.yes
ui.inform("Welcome to Panoramix wizard!")
ui.inform("Configuration file is: %s" % common.config_file)
ui.inform("Set PANORAMIX_CONFIG environment variable to override")
catalog_url = on("CATALOG_URL", set_catalog_url_wizard)
client.register_catalog_url(catalog_url)
role = on("SETUP_ROLE",
lambda: ui.ask_value("role", "Choose 'create' or 'join' mixnet"))
mixnet_creation_wizard(role)
handle_endpoints_wizard(role)
def create_ep_contribution(cycle, negotiation_id, peer_id):
peer = client.peer_info(peer_id)
owners = sorted(unpack_owners(peer["owners"]))
endpoint_id = get_endpoint_id(cycle)
size_min = on("MIN_SIZE", get_min_size)
size_max = on("MAX_SIZE", get_max_size)
next_neg = read_next_negotiation_id()
attrs = client.backend.make_description(endpoint_id, peer_id, owners,
size_min, size_max)
d = client.endpoints_create_contribution(attrs,
negotiation_id,
accept=False,
next_negotiation_id=next_neg)
return d["data"]
def main():
ui.inform("Welcome to Panoramix server wizard!")
ui.inform("Configuration file is: %s" % config_file)
ui.inform("Set PANORAMIX_CONFIG environment variable to override")
on("CATALOG_URL", set_catalog_url)
backend = on("CRYPTO_BACKEND", common.select_backend_wizard)
server.register_backend(backend)
on("CRYPTO_PARAMS", lambda: common.crypto_params_wizard_on(server))
on("INFORM_MIGRATE", inform_migrate)
inform_launch()
def operate_on_open_endpoint_coord(endpoint_id):
setting = suffixed_setting(endpoint_id)
neg_id = on(setting("CLOSE_NEGOTIATION_ID"),
new_negotiation_id_from_stream)
on(setting("LINKED_INBOX"), lambda: get_endpoint_input(endpoint_id, INBOX))
contrib = on(setting("CLOSE_CONTRIBUTION"),
lambda: create_ep_close_contribution(endpoint_id, neg_id))
on(setting("CLOSE_SECOND_CONTRIBUTION"),
lambda: _check_ep_negotiation(neg_id, contrib))
finished_neg = on(setting("CLOSE_FINISHED_NEGOTIATION"),
lambda: finished_negotiation(neg_id))
on(setting("CREATE_EP_CLOSE_ID"),
lambda: apply_endpoint_consensus(endpoint_id, finished_neg))
def operate_on_closed_endpoint_contrib(endpoint_id):
setting = suffixed_setting(endpoint_id)
neg_id = on(setting("PROCESS_NEGOTIATION_ID"), read_next_negotiation_id)
contrib = on(setting("PROCESS_COORD_INITIAL_CONTRIBUTION"),
lambda: _check_initial_contribution(neg_id))
register_next_negotiation_id(contrib)
on(setting("PROCESS_CONTRIBUTION"),
lambda: join_ep_process_contribution(endpoint_id, neg_id, contrib))
on(setting("PROCESS_FINISHED_NEGOTIATION"),
lambda: finished_negotiation(neg_id))
def operate_on_closed_endpoint_coord(endpoint_id):
setting = suffixed_setting(endpoint_id)
neg_id = on(setting("PROCESS_NEGOTIATION_ID"),
new_negotiation_id_from_stream)
hashes = on(setting("LINKED_PROCESSBOX"),
lambda: get_endpoint_input(endpoint_id, PROCESSBOX))
if hashes is None:
peer_id = cfg.get("PEER_ID")
log = on(setting("PROCESSING"),
lambda: do_processing(endpoint_id, peer_id))
else:
log = client.mk_process_log(hashes, "", wrap=False)
contrib = on(
setting("PROCESS_CONTRIBUTION"),
lambda: create_ep_record_contribution(endpoint_id, neg_id, log))
on(setting("PROCESS_SECOND_CONTRIBUTION"),
lambda: _check_ep_negotiation(neg_id, contrib))
finished_neg = on(setting("PROCESS_FINISHED_NEGOTIATION"),
lambda: finished_negotiation(neg_id))
on(setting("APPLY_PROCESS"),
lambda: apply_endpoint_consensus(endpoint_id, finished_neg))
def handle_endpoints_wizard(role):
while True:
cycle = on("CYCLE", lambda: 1)
peer_id = cfg.get("PEER_ID")
combined_peer_id = cfg.get("COMBINED_PEER_ID")
if role == "create":
endpoints = create_endpoint_wizard(cycle, combined_peer_id)
elif role == "join":
endpoints = join_endpoint_wizard(cycle)
endpoint_ids = [e["endpoint_id"] for e in endpoints]
remaining = endpoint_ids
while remaining:
ui.inform("Still need to handle endpoints %s." % remaining)
remaining = operate(remaining, peer_id, combined_peer_id, role)
time.sleep(3)
get_restart_response(role)
ui.inform("Starting a new cycle...")
cfg.set_value("CYCLE", cycle + 1)
def create_endpoint_wizard(cycle, combined_peer_id):
setting = suffixed_setting(cycle)
neg_id = on(setting("EP_NEGOTIATION_ID"), new_negotiation_id_from_stream)
contrib = on(
setting("EP_CONTRIBUTION"),
lambda: create_ep_contribution(cycle, neg_id, combined_peer_id))
on(setting("EP_SECOND_CONTRIBUTION"),
retry(lambda: _check_ep_negotiation(neg_id, contrib)))
finished_neg = on(setting("EP_FINISHED_NEGOTIATION"),
retry(lambda: finished_negotiation(neg_id)))
endpoints = on(setting("ENDPOINTS"),
lambda: create_multiple_endpoints(finished_neg))
inform_send_message(endpoints)
return endpoints
def create_mixnet_wizard():
backend = on("CREATE_CRYPTO_BACKEND", common.select_backend_wizard)
register_crypto_backend(backend)
crypto_params = on("CREATE_CRYPTO_PARAMS", crypto_params_wizard)
on("CRYPTO_PARAMS", lambda: crypto_params)
key_and_peer_wizard()
neg_id = on("CREATE_NEGOTIATION_ID", new_negotiation_id_from_stream)
contrib = on("CREATE_CONTRIBUTION_ID",
lambda: create_contribution_id(neg_id))
invitations = on("CREATE_INVITATIONS", create_invitations)
on("CREATE_INFORM",
lambda: print_information(neg_id, contrib, invitations))
on("CREATE_SECOND_CONTRIBUTION_ID",
retry(lambda: check_negotiation_wizard(neg_id, invitations)))
finished_neg = on("CREATE_FINISHED_NEGOTIATION",
retry(lambda: finished_negotiation(neg_id)))
combined_peer_id = on("CREATE_COMBINED_PEER_ID",
lambda: create_combined_peer(finished_neg))
register_peer_with_owners(combined_peer_id)
def join_mixnet_wizard():
inv = on(
"JOIN_INVITATION", lambda: ui.ask_value(
"JOIN_INVITATION", "Give invitation to create mix peer"))
negotiation_id, invitation_id = split_invitation(inv)
contrib = on("JOIN_COORD_INITIAL_CONTRIBUTION",
lambda: _check_initial_contribution(negotiation_id))
initial_contribution_info(contrib)
backend = on("JOIN_CRYPTO_BACKEND", lambda: join_backend_set(contrib))
register_crypto_backend(backend)
crypto_params = on("JOIN_CRYPTO_PARAMS",
lambda: join_crypto_params_set(contrib))
on("CRYPTO_PARAMS", lambda: crypto_params)
key_and_peer_wizard()
on("JOIN_CONTRIBUTION_ID",
lambda: join_contribution(negotiation_id, contrib, invitation_id))
second_contrib = on(
"JOIN_COORD_SECOND_CONTRIBUTION",
retry(
lambda: _join_coord_second_contribution(negotiation_id, contrib)))
on("JOIN_SECOND_CONTRIBUTION_ID",
lambda: _join_second_contribution(negotiation_id, second_contrib))
finished_neg = on("JOIN_FINISHED_NEGOTIATION",
retry(lambda: finished_negotiation(negotiation_id)))
combined_peer_id = on("COMBINED_PEER_ID",
retry(lambda: join_combined_peer(finished_neg)))
register_peer_with_owners(combined_peer_id)
def get_endpoint_id(cycle):
name = on("ENDPOINT_NAME", get_endpoint_name)
endpoint_id = "%s_%s" % (name, cycle)
return endpoint_id
def operate_own_endpoint(endpoint_id):
setting = suffixed_setting(endpoint_id)
on(setting("OWN_INBOX"), lambda: get_own_endpoint_input(endpoint_id))
on(setting("OWN_CLOSE"), lambda: close_own_endpoint(endpoint_id))
on(setting("OWN_PROCESS"), lambda: process_own_endpoint(endpoint_id))