def get_degree_and_secret(shares):
decoder = DecoderFactory.get(eval_point)
polys = decoder.decode(list(range(n)),
transpose_lists(list(shares)))
secrets = [p[0] for p in polys]
degrees = [get_degree(p) for p in polys]
return degrees, secrets
async def test_randousha(test_router, polynomial, galois_field, n, k):
t = (n - 1) // 3
sends, receives, _ = test_router(n)
shares_per_party = await asyncio.gather(*[
randousha(n, t, k, i, sends[i], receives[i], galois_field)
for i in range(n)
])
assert len(shares_per_party) == n
assert all(
len(random_shares) == (n - 2 * t) * k
for random_shares in shares_per_party)
random_values = []
eval_point = EvalPoint(galois_field, n, use_omega_powers=False)
decoder = DecoderFactory.get(eval_point, Algorithm.VANDERMONDE)
for i, shares in enumerate(zip(*shares_per_party)):
shares_t, shares_2t = zip(*shares)
poly_t = polynomial(decoder.decode(list(range(n)), shares_t))
poly_2t = polynomial(decoder.decode(list(range(n)), shares_2t))
r_t = poly_t(0)
r_2t = poly_2t(0)
assert len(poly_t.coeffs) == t + 1
assert len(poly_2t.coeffs) == 2 * t + 1
assert r_t == r_2t
random_values.append(r_t)
assert len(set(random_values)) == (n - 2 * t) * k
async def robust_reconstruct(field_futures, field, n, t, point, degree):
use_omega_powers = point.use_omega_powers
enc = EncoderFactory.get(
point, Algorithm.FFT if use_omega_powers else Algorithm.VANDERMONDE)
dec = DecoderFactory.get(
point, Algorithm.FFT if use_omega_powers else Algorithm.VANDERMONDE)
robust_dec = RobustDecoderFactory.get(t, point, algorithm=Algorithm.GAO)
incremental_decoder = IncrementalDecoder(enc, dec, robust_dec, degree, 1,
t)
async for (idx, d) in fetch_one(field_futures):
incremental_decoder.add(idx, [d.value])
if incremental_decoder.done():
polys, errors = incremental_decoder.get_results()
return polynomials_over(field)(polys[0]), errors
return None, None
def test_auto_decode_fft_enabled(fft_decoding_test_cases):
for test_case in fft_decoding_test_cases:
z, encoded, decoded, point = test_case
dec = DecoderFactory.get(point)
actual = dec.decode(z, encoded)
assert actual == decoded