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(