def main(): group = verdict_1024() from elgamal import PrivateKey, PublicKey x0 = PrivateKey(group) y0 = x0.public_key() x1 = PrivateKey(group) y1 = x1.public_key() assert x0.exchange(y1) == y1.exchange(x0) data = b"hello" encrypted = y0.encrypt(data) assert x0.decrypt(encrypted) == data assert y0.verify(data, x0.sign(data))
def setup(self, group, clients, trustees, owner_idx): ckeys, cpkeys = self.gen_keys(group, clients) tkeys, tpkeys = self.gen_keys(group, trustees) akey = PrivateKey(group) apkey = akey.public_key() cverdicts = [] ccommitments = [] for idx in range(clients): if idx == owner_idx: cverdicts.append(OwnerVerdict(akey, ckeys[idx], cpkeys, tpkeys)) else: cverdicts.append( ClientVerdict(apkey, ckeys[idx], cpkeys, tpkeys)) ccommitments.append(cverdicts[-1].commitment()) tverdicts = [] tcommitments = [] for idx in range(trustees): tverdicts.append(TrusteeVerdict(apkey, tkeys[idx], cpkeys, tpkeys)) tcommitments.append(tverdicts[-1].commitment()) for verdict in cverdicts: verdict.set_commitments(ccommitments, tcommitments) for verdict in tverdicts: verdict.set_commitments(ccommitments, tcommitments) return (cverdicts, tverdicts)
def gen_keys(count): dhkeys = [] pkeys = [] for idx in range(count): dh = PrivateKey(global_group) dhkeys.append(dh) pkeys.append(dh.public_key()) return dhkeys, pkeys
def gen_keys(self, group, count): keys = [] pkeys = [] for idx in range(count): k = PrivateKey(group) keys.append(k) pkeys.append(k.public_key()) return (keys, pkeys)
def sync(self, client_set): """ Called at the beginning of an interval to generate new trap keys for secret sharing, and to update xornet with the new interval. """ self.interval += 1 trap_key = PrivateKey(global_group) self.trap_secrets = [trap_key.exchange(k) for k in self.nym_keys] self.trap_keys.append(trap_key) self.xornet = XorNet(self.secrets, self.interval) self.all_trap_secrets = [[] for _ in self.nym_keys]
def generate(cls, n): secrets = [PrivateKey(global_group) for _ in range(n)] keys = [key.public_key() for key in secrets] id = lambda x: SHA256.new(long_to_bytes(pub_to_long(x))).hexdigest() ids = [id(key) for key in keys] privates = [Private(id, secret) for id, secret in zip(ids, secrets)] return cls(ids, keys), privates
def generate(cls, n, host, port): secrets = [PrivateKey(global_group) for _ in range(n)] keys = [key.public_key() for key in secrets] id = lambda x: SHA256.new(long_to_bytes(pub_to_long(x))).hexdigest() ids = [id(key) for key in keys] privates = [Private(id, secret) for id, secret in zip(ids, secrets)] # TODO: This won't work for multiple access points if n == 1: hosts = [host] ports = [port] else: hosts = [host + str(i) for i in range(n)] ports = [port for i in range(len(ids))] mcasts = [(MCAST_ADDR, 4747 + i) for i in range(len(ids))] return cls(ids, keys, hosts, ports, mcasts), privates
def sync(self, client_set): self.interval += 1 trap_key = PrivateKey(global_group) self.trap_keys.append(trap_key) self.xornet = XorNet(self.secrets, self.interval)
def main(): t0 = time.time() p = argparse.ArgumentParser(description="Local, insecure DC-net test") p.add_argument("config_dir") opts = p.parse_args() # load the public system data with open(os.path.join(opts.config_dir, "system.json"), "r", encoding="utf-8") as fp: data = json.load(fp) clients = data["clients"] client_ids = [c["id"] for c in clients] client_keys = [PublicKey(global_group, c["key"]) for c in clients] trustees = data["servers"] trustee_ids = [t["id"] for t in trustees] trustee_keys = [PublicKey(global_group, t["key"]) for t in trustees] # and session data with open(os.path.join(opts.config_dir, "session.json"), "r", encoding="utf-8") as fp: data = json.load(fp) session_id = data["session-id"] nym_keys = [PublicKey(global_group, c["dhkey"]) for c in data["clients"]] # load the post-shuffle slots with open(os.path.join(opts.config_dir, "shuffle.json"), "r", encoding="utf-8") as fp: data = json.load(fp) slot_keys = [PublicKey(global_group, e) for e in data["slots"]] # start multiple clients in the same process # load private keys from individual files clients = [] for iden in client_ids: with open(os.path.join(opts.config_dir, "{}.json".format(iden)), "r", encoding="utf-8") as fp: data = json.load(fp) private_key = PrivateKey(global_group, data["private_key"]) with open(os.path.join(opts.config_dir, "{}-{}.json".format(iden, session_id)), "r", encoding="utf-8") as fp: data = json.load(fp) nym_private_key = PrivateKey(global_group, data["private_key"]) client = dcnet.Client(private_key, trustee_keys, NullCertifier(), NullEncoder()) client.add_own_nym(nym_private_key) client.add_nyms(slot_keys) clients.append(client) # same with trustees trustees = [] for iden in trustee_ids: with open(os.path.join(opts.config_dir, "{}.json".format(iden)), "r", encoding="utf-8") as fp: data = json.load(fp) private_key = PrivateKey(global_group, data["private_key"]) trustee = dcnet.Trustee(private_key, client_keys) trustee.add_nyms(slot_keys) trustees.append(trustee) # start a single relay relay = dcnet.Relay(len(trustees), NullAccumulator(), NullDecoder()) relay.add_nyms(len(clients)) relay.sync(None) trap_keys = [] for trustee in trustees: trustee.sync(None) trap_keys.append(trustee.trap_keys[-1].public_key()) for client in clients: client.sync(None, trap_keys) cleartexts = [] for i in range(1): relay.decode_start() for idx in range(len(trustees)): trustee = trustees[idx] ciphertext = trustee.produce_ciphertext() relay.decode_trustee(ciphertext) for idx in range(len(clients)): client = clients[idx] ciphertext = client.produce_ciphertexts() relay.decode_client(ciphertext) cleartexts.append(relay.decode_cell()) print(cleartexts) print(time.time() - t0) t0 = time.time() cleartexts = [] for i in range(len(clients)): relay.decode_start() for idx in range(len(trustees)): trustee = trustees[idx] ciphertext = trustee.produce_ciphertext() relay.decode_trustee(ciphertext) for i, client in enumerate(clients): ciphertext = client.produce_ciphertexts() cleartext = long_to_bytes(0) if i == 0: cleartext = bytes("Hello", "UTF-8") ciphertext = long_to_bytes( bytes_to_long(ciphertext) ^ bytes_to_long(cleartext)) relay.decode_client(ciphertext) cleartexts.append(relay.decode_cell()) print(cleartexts) print(time.time() - t0)
import argparse import json import os import random import shutil from Crypto.Hash import SHA256 from Crypto.Util.number import long_to_bytes, bytes_to_long from elgamal import PublicKey, PrivateKey from dcnet import global_group long_to_pub = lambda x: PublicKey(global_group, x) pub_to_long = lambda x: x.element long_to_priv = lambda x: PrivateKey(global_group, x) priv_to_long = lambda x: x.secret MCAST_ADDR = "224.0.0.251" class Relay: HOST = "host" PORT = "port" def __init__(self, host, port): self.host = host self.port = port def save(self): return {