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 {
