def get_body_and_meta(consensus):
consensus_text = consensus["text"]
unpacked_text = canonical.from_unicode_canonical(consensus_text)
body = unpacked_text.get("body", {})
canonical_body = canonical.to_canonical(body)
meta = unpacked_text.get("meta", {})
return canonical_body, meta
def mixnet_url_process(mixnet_url):
catalog_url, endpoint_id = split_mixnet_url(mixnet_url)
cfg.set_value("CATALOG_URL", catalog_url)
client.register_catalog_url(catalog_url)
print endpoint_id
endpoint = client.endpoint_info(endpoint_id)
if endpoint["status"] != "OPEN":
abort("Endpoint is not open.")
if endpoint["endpoint_type"] != "SPHINXMIX_GATEWAY":
abort("Not a SPHINXMIX_GATEWAY.")
peer_id = endpoint["peer_id"]
cfg.set_value("PEER_ID", peer_id)
peer = client.peer_info(peer_id)
assert peer["crypto_backend"] == TYPE
backend = common.BACKENDS[TYPE]
client.register_backend(backend)
cfg.set_value("CRYPTO_BACKEND", backend)
crypto_params = canonical.from_unicode_canonical(peer["crypto_params"])
cfg.set_value("CRYPTO_PARAMS", crypto_params)
description = {"gateway": endpoint,
"mixnet_peer": peer}
cfg.set_value("MIXNET_DESCRIPTION", description)
def verify(mixnet_data, signature, public, params):
signature = canonical.from_unicode_canonical(signature)
crypto = signature['crypto']
modulus = crypto['modulus']
generator = crypto['generator']
order = crypto['order']
if modulus != params.modulus or \
generator != params.generator or order != params.order:
raise ValueError("cryptographic parameters mismatch")
element = core.element_from_texts_hash(
modulus, generator, order, mixnet_data)
if element != signature['e']:
return False, None
if public is None:
public_int = signature['public']
public = utils.int_to_unicode(public_int)
else:
public_int = utils.unicode_to_int(public)
key_id = get_key_id_from_key_data(public)
valid = bool(core.verify_element_signature(
signature, modulus, generator, order, public_int))
return valid, key_id
def verify(mixnet_data, signature, params):
signature = canonical.from_unicode_canonical(signature)
digest = sha256(mixnet_data).digest()
sig = tuple(map(bn_decode, (signature["r"], signature["s"])))
ver_key = mk_EcPt(signature["public"], params)
valid = ecdsa.do_ecdsa_verify(params.group.G, ver_key, sig, digest)
key_id = get_key_id_from_key_data(ver_key)
return valid, key_id
def contribution_accept(self, negotiation_id, contribution_id):
data = {"id": contribution_id, "negotiation": negotiation_id}
r = self.clients.contributions.retrieve(contribution_id, params=data)
contrib = r.json()["data"]
realtext = canonical.from_unicode_canonical(contrib["text"])
body = realtext["body"]
r = self.run_contribution(negotiation_id, body, True)
d = r.json()["data"]
return d
def check_close_negotiation(negotiation):
latests = negotiation.get_latest_contributions()
text_set = set(c.text for c in latests)
if len(text_set) == 1:
text = text_set.pop()
unpacked_text = canonical.from_unicode_canonical(text)
meta = unpacked_text.get("meta", {})
accept = meta.get("accept", False)
if accept:
_close_negotiation(negotiation, latests)
def process_sk_mix(endpoint, messages, params):
endpoint_params = canonical.from_unicode_canonical(
endpoint["endpoint_params"])
election_public = utils.unicode_to_int(
endpoint_params["election_public"])
message_texts = [m["text"] for m in messages]
recipient = get_unique_recipient(messages)
mixed_messages, proof = mix(message_texts, params, election_public)
return utils.with_recipient(mixed_messages, recipient), proof
def handle_consensus(expected_body, part, consensus_id):
consensus = retrieve_consensus(consensus_id)
signings = consensus["signings"]
body, meta = get_body_and_meta(consensus)
if part is not None:
body = canonical.from_unicode_canonical(body)
assert isinstance(body, list)
body = body[part]
body = canonical.to_canonical(body)
check_bodies_equal(expected_body, body)
check_accepted(meta)
check_all_signed(signings, meta)
return signings
def join_crypto_params_set(contrib):
text = get_contribution_text(contrib)
crypto_params = text["body"]["data"]["crypto_params"]
crypto_params = canonical.from_unicode_canonical(crypto_params)
default = "accept"
response = ui.ask_value(
"response", "Proposed crypto params: '%s'; "
"'accept' or 'abort'? (default: '%s')" % (crypto_params, default))
if not response:
response = default
if response == "accept":
return crypto_params
elif response == "abort":
abort()
def take_action(self, parsed_args):
vargs = vars(parsed_args)
negotiation_id = vargs["negotiation_id"]
client = mk_panoramix_client(cfg)
contribs = filter_data_only(client.contribution_list(negotiation_id))
listing = []
for contrib in contribs:
realtext = canonical.from_unicode_canonical(contrib["text"])
listing.append({
"body": realtext["body"],
"meta": realtext["meta"],
"id": contrib["id"],
"signer_key_id": contrib["signer_key_id"],
})
return from_list_of_dict(listing)
def write_to_file(self, message, filename):
text = canonical.from_unicode_canonical(message["text"])
with open(filename, "a") as f:
f.write("%s\n\0" % utils.unicode_to_locale(text))
return (message["id"], "file", filename)
def decode_message(message):
return canonical.from_unicode_canonical(message)
def init_client():
panoramix_client = client.PanoramixClient()
catalog_url = cfg.get("CATALOG_URL")
panoramix_client.register_catalog_url(catalog_url)
backend = cfg.get("CRYPTO_BACKEND")
panoramix_client.register_backend(backend)
panoramix_client.register_crypto_client(cfg)
mixnet_description = cfg.get("MIXNET_DESCRIPTION")
panoramix_client.register_mixnet(mixnet_description)
return panoramix_client
panoramix_client = init_client()
while True:
outbox = panoramix_client.box_list(endpoint_id, client.OUTBOX)
if outbox:
print "Found outbox, checking..."
outbox_messages = [(from_unicode_canonical(msg['text']),
msg['recipient']) for msg in outbox]
if messages == outbox_messages:
raise AssertionError("messages not shuffled")
if messages != sorted(outbox_messages):
raise AssertionError("messages do not match")
print "Outbox verified!"
break
else:
print "Outbox not ready yet..."
time.sleep(3)
def get_contribution_text(contribution):
return canonical.from_unicode_canonical(contribution["text"])
def get_negotiation_text(negotiation):
return canonical.from_unicode_canonical(negotiation["text"])