def propose(self):
self.compute_beacon(self.shared_secret)
new_shared_secret, encrypted_shares, proof = pvss.share_random_secret(self.OTHER_PUBLIC_KEYS, T)
dataset = Dataset(
round_idx=self.round,
prev_round_idx=self.last_confirmed_round,
revealed_secret=self.shared_secret,
beacon=self.beacon,
recovered_beacons=self.beacons[self.last_confirmed_round + 1: self.round],
merkle_root=merkle.compute_root([Hash(bytes(es)) for es in encrypted_shares]),
encrypted_shares=encrypted_shares,
proof=proof,
confirmation_certificate=self.last_confirmation_certificate,
recovery_certificates=self.recovery_certificates[self.last_confirmed_round + 1: self.round],
)
msg = ProposeMessage(
sender=self.ID,
dataset=dataset,
dataset_header_signature=Signature.create_later(
lambda: dataset.serialized_header, self.KEYPAIR.secret_key
),
confirmation_certificate_signature=Signature.create_later(
lambda: ConfirmMessage(self.ID, self.round, dataset.header_digest).serialize(),
self.KEYPAIR.secret_key
),
)
self.broadcast_message(msg)
self.datasets[self.round] = dataset
self.shared_secret = new_shared_secret
self.confirmations.append(Confirmation(self.ID, dataset.header_digest, msg.confirmation_certificate_signature))
self.confirmation_counter.update([dataset.header_digest])
self.update_phase(Phase.Vote)
def generate_sample_config(n=None, write_to_disk=False):
if n is None:
n = N
from hydrand import merkle, pvss
from hydrand.data import NodeInfo
addresses, ports = load_network_config()
node_infos = []
t = math.ceil(n / 3)
keypairs = [KeyPair.random() for node_id in range(n)]
for node_id, keypair in enumerate(keypairs):
receiver_pks = [
kp.public_key for j, kp in enumerate(keypairs) if j != node_id
]
secret, shares, proof = pvss.share_random_secret(receiver_pks, t)
merkle_root = merkle.compute_root(
[merkle.Hash(bytes(es)) for es in shares])
node_infos.append(
NodeInfo(node_id, addresses[node_id], ports[node_id], keypair,
keypair.public_key, secret, shares, proof, merkle_root))
if write_to_disk:
save_config(node_infos)
return node_infos
verify_shares,
verify_secret,
ShareCorrectnessProof,
recover,
Polynomial,
)
from hydrand.pvss import G, H, _DLEQ_prove, _DLEQ_verify
from hydrand.ed25519 import Scalar
NUM_NODES = 10
RECOVERY_THRESHOLD = 5
keypairs = [keygen() for _ in range(NUM_NODES)]
secret_keys = [key[0] for key in keypairs]
public_keys = [key[1] for key in keypairs]
secret, encrypted_shares, proof = share_random_secret(public_keys,
RECOVERY_THRESHOLD)
decrypted_shares = [
decrypt_share(share, sk)
for share, sk in zip(encrypted_shares, secret_keys)
]
def test_dleq():
α = Scalar.random()
e, z = _DLEQ_prove(G, G * α, H, H * α, α)
assert _DLEQ_verify(G, G * α, H, H * α, e, z)
def test_dleq_invalid_challenge():
α = Scalar.random()
e, z = _DLEQ_prove(G, G * α, H, H * α, α)
from hydrand import pvss
from hydrand.ed25519 import KeyPair
from time import time
import math
keypairs = [KeyPair.random() for node_id in range(256)]
for n in [32 * x for x in range(1, 9)]:
t = math.ceil(n / 3)
print(f"benchmark pvss performance for n={n}, t={t}: ", end="")
public_keys = [k.public_key for k in keypairs][:n - 1]
tstart = time()
results = [pvss.share_random_secret(public_keys, t) for _ in range(100)]
tend = time()
print((tend - tstart) / 100)
from hydrand import pvss, utils, ed25519, merkle
from hydrand.ed25519 import KeyPair, Scalar, Point
from hydrand.data import Serializer, MessageType, RecoverMessage, RecoveredShare, DatasetHeader, Hash, Signature
import time
from hydrand.config import N, T, F
assert N == 128, "set i.e. N=128 before running this file in config.py"
keypairs = [KeyPair.random() for i in range(N - 1)]
public_keys = [k.public_key for k in keypairs]
shared_secret, encrypted_shares, proofs = pvss.share_random_secret(
public_keys, T)
decrypted_shares = [
pvss.decrypt_share(share, keypair.secret_scalar)
for share, keypair in zip(encrypted_shares, keypairs)
]
dataset_header = DatasetHeader(
round_idx=4711,
prev_round_idx=4710,
revealed_secret=Scalar.random(),
beacon=Hash(utils.deterministic_random_bytes(32, "some beacon")),
recovered_beacons=[],
merkle_root=merkle.compute_root(
[Hash(bytes(es)) for es in encrypted_shares]))
decryption_proofs = [
pvss.prove_share_decryption(decrypted_share, encrypted_share,
keypair.secret_scalar, keypair.public_key)
for decrypted_share, encrypted_share, keypair in zip(