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)