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 take_action(self, parsed_args):
vargs = vars(parsed_args)
peer_id = vargs["peer_id"]
endpoint_id = vargs["endpoint_id"]
endpoint_type = vargs["endpoint_type"]
params = dict(vargs["param"] or [])
links = vargs["link"] or []
links = map(link_arg_to_dict, links)
endpoint_params = canonical.to_canonical(params)
size_min = int(vargs["size_min"])
size_max = int(vargs["size_max"])
description = vargs["description"] or ""
public = vargs["public"]
consensus_id = vargs["consensus_id"]
negotiation_id = vargs["negotiation_id"]
accept = vargs["accept"]
client = mk_panoramix_client(cfg)
is_contrib, d = client.endpoint_create(endpoint_id,
peer_id,
endpoint_type,
endpoint_params,
size_min,
size_max,
description,
public=public,
links=links,
consensus_id=consensus_id,
negotiation_id=negotiation_id,
accept=accept)
id_key = "id" if is_contrib else "endpoint_id"
print("%s" % d["data"][id_key])
def sign(body, params, secret, public):
modulus = params.modulus
generator = params.generator
order = params.order
element = core.element_from_texts_hash(modulus, generator, order, body)
signature = core.sign_element(element, modulus, generator, order, secret)
signature['public'] = public
return canonical.to_canonical(signature)
def sign(body, params, secret, public):
digest = sha256(body).digest()
sig = ecdsa.do_ecdsa_sign(params.group.G, secret, digest)
sig = tuple(map(bn_encode, sig))
signature = {
"r": sig[0],
"s": sig[1],
"public": public,
}
return canonical.to_canonical(signature)
def mk_signed_request(self, attrs):
mixnet_body = canonical.to_canonical(attrs)
signature = self.crypto_client.sign(mixnet_body)
key_data = self.crypto_client.get_key_data()
meta = "meta"
assert meta not in attrs
attrs[meta] = {
"signature": signature,
"key_data": key_data,
}
return attrs
def make_description(mixnet_name, combined_peer_id, owners, admin, size_min):
endpoint_params = canonical.to_canonical({})
in_endpoint = {
"endpoint_id": mixnet_name,
"peer_id": combined_peer_id,
"endpoint_type": "SPHINXMIX_GATEWAY",
"endpoint_params": endpoint_params,
"public": True,
"description": "Gateway for mixnet '%s'" % mixnet_name,
"admin": admin,
}
link = {
"from_endpoint_id": mk_contributing_endpoint_id(owners[-1], mixnet_name),
"from_state": 'ACCEPTED',
}
out_endpoint = {
"endpoint_id": mixnet_name + '_output',
"peer_id": combined_peer_id,
"endpoint_type": "SPHINXMIX_OUTPUT",
"endpoint_params": endpoint_params,
"public": True,
"description": "Output of mixnet '%s'" % mixnet_name,
"link": link,
"admin": admin,
}
mix_endpoints = {}
for peer_id in owners:
endpoint_id = mk_contributing_endpoint_id(peer_id, mixnet_name)
from_endpoint = compute_input_from(
peer_id, owners, mixnet_name)
link = {
"from_endpoint_id": from_endpoint,
"from_state": 'ACCEPTED',
}
mix_endpoints[peer_id] = {
"endpoint_id": endpoint_id,
"peer_id": peer_id,
"endpoint_type": "SPHINXMIX",
"endpoint_params": endpoint_params,
"description": "Mixing node for '%s'" % mixnet_name,
"public": False,
"link": link,
"admin": peer_id,
}
spec = {
'input': in_endpoint,
'output': out_endpoint,
'mix_endpoints': mix_endpoints,
'size_min': size_min,
}
return spec
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 _close_negotiation(negotiation, contributions):
now = get_now()
negotiation.text = get_text(contributions)
signings_dict = mk_signings(negotiation, contributions)
hashable = {
"timestamp": now.isoformat(),
"negotiation_id": negotiation.id,
"text": negotiation.text,
"signings": signings_dict,
}
consensus = utils.hash_string(canonical.to_canonical(hashable))
negotiation.timestamp = now
negotiation.consensus = consensus
negotiation.status = spec.NegotiationStatus.DONE
negotiation.save()
def make_description(mixnet_name, combined_peer_id, owners, size_min,
size_max):
owners = sorted(owners)
link = {
"from_endpoint_id":
mk_contributing_endpoint_id(owners[-1], mixnet_name),
"from_box": "OUTBOX",
"to_box": "PROCESSBOX"
}
endpoint_params = canonical.to_canonical({})
gateway = {
"endpoint_id": mixnet_name,
"peer_id": combined_peer_id,
"endpoint_type": "SPHINXMIX_GATEWAY",
"endpoint_params": endpoint_params,
"description": "Gateway for mixnet '%s'" % mixnet_name,
"public": True,
"links": [link],
"size_min": size_min,
"size_max": size_max,
}
endpoints = [gateway]
for peer_id in owners:
endpoint_id = mk_contributing_endpoint_id(peer_id, mixnet_name)
from_endpoint, from_box = compute_input_from(peer_id, owners,
mixnet_name)
link = {
"from_endpoint_id": from_endpoint,
"from_box": from_box,
"to_box": "INBOX"
}
endpoints.append({
"endpoint_id": endpoint_id,
"peer_id": peer_id,
"endpoint_type": "SPHINXMIX",
"endpoint_params": endpoint_params,
"description": "Mixing node for '%s'" % mixnet_name,
"public": False,
"links": [link],
"size_min": size_min,
"size_max": size_max,
})
return endpoints
def run_contribution(self, negotiation_id, body, accept, extra_meta=None):
meta = {}
if extra_meta is not None:
meta.update(extra_meta)
meta["accept"] = accept
text = {"body": body,
"meta": meta}
canonical_text = canonical.to_canonical(text)
signature = self.crypto_client.sign(canonical_text)
payload = {
"info": mk_info("contribution", "create"),
"data": {
"negotiation": self.mk_negotiation_hyperlink(negotiation_id),
"text": canonical_text,
"signature": signature,
"signer_key_id": self.crypto_client.get_keyid()
},
}
request = self.mk_signed_request(payload)
r = self.clients.contributions.create(data=request)
return r
def mk_process_log(self, msg_hashes, proof, wrap=True):
hashes = hash_dict_wrap(msg_hashes) if wrap else msg_hashes
return {
"message_hashes": hashes,
"process_proof": canonical.to_canonical(proof),
}
def get_crypto_params(self):
return canonical.to_canonical(self._crypto_params)
def encode_message(message):
return canonical.to_canonical(message)
def get_requested_consensus_body(request_data):
structure = {
"data": request_data.get("data"),
"info": request_data.get("info"),
}
return canonical.to_canonical(structure)
