async def test_open_future_shares():
n, t = 4, 1
pp_elements = PreProcessedElements()
pp_elements.generate_rands(1000, n, t)
pp_elements.generate_triples(1000, n, t)
async def _prog(context):
e1_, e2_ = [context.preproc.get_rand(context) for _ in range(2)]
e1, e2 = await asyncio.gather(*[e1_.open(), e2_.open()],
return_exceptions=True)
s_prod_f = e1_ * e2_
s_prod_f2 = s_prod_f * e1_
final_prod = s_prod_f2 + e1_ + e2_
final_prod_2 = final_prod * e1_
wrapped_final_prod_2 = context.Share(final_prod_2.open())
assert await s_prod_f2.open() == e1 * e1 * e2
assert await final_prod.open() == e1 * e1 * e2 + e1 + e2
assert await final_prod_2.open() == (e1 * e1 * e2 + e1 + e2) * e1
assert await wrapped_final_prod_2.open() == await final_prod_2.open()
program_runner = TaskProgramRunner(
n, t, {MixinConstants.MultiplyShare: BeaverMultiply()})
program_runner.add(_prog)
await program_runner.join()
from pytest import mark
from honeybadgermpc.elliptic_curve import Jubjub, Point
from honeybadgermpc.progs.jubjub import SharedPoint, share_mul
from honeybadgermpc.progs.mixins.share_arithmetic import (
BeaverMultiply,
BeaverMultiplyArrays,
DivideShareArrays,
DivideShares,
Equality,
InvertShare,
InvertShareArray,
)
MIXINS = [
BeaverMultiply(),
BeaverMultiplyArrays(),
InvertShare(),
InvertShareArray(),
DivideShares(),
DivideShareArrays(),
Equality(),
]
TEST_PREPROCESSING = ["rands", "triples", "bits"]
TEST_CURVE = Jubjub()
TEST_POINT = Point(
5,
6846412461894745224441235558443359243034138132682534265960483512729196124138,
TEST_CURVE,
import asyncio
from honeybadgermpc.mpc import TaskProgramRunner
from honeybadgermpc.progs.mixins.dataflow import Share
from honeybadgermpc.preprocessing import (
PreProcessedElements as FakePreProcessedElements,
)
from honeybadgermpc.utils.typecheck import TypeCheck
from honeybadgermpc.progs.mixins.share_arithmetic import (
MixinConstants,
BeaverMultiply,
BeaverMultiplyArrays,
)
config = {
MixinConstants.MultiplyShareArray: BeaverMultiplyArrays(),
MixinConstants.MultiplyShare: BeaverMultiply(),
}
@TypeCheck()
async def beaver_multiply(ctx, x: Share, y: Share):
"""The hello world of MPC: beaver multiplication
- Linear operations on Share objects are easy
- Shares of random values are available from preprocessing
- Opening a Share returns a GFElementFuture
"""
a, b, ab = ctx.preproc.get_triples(ctx)
D = await (x - a).open()
E = await (y - b).open()
# D*E is multiplying GFElements
from pytest import mark
from random import randint
from honeybadgermpc.elliptic_curve import Jubjub
from honeybadgermpc.progs.mimc import mimc_mpc_batch
from honeybadgermpc.progs.mixins.share_arithmetic import (
BeaverMultiply,
BeaverMultiplyArrays,
InvertShare,
InvertShareArray,
DivideShares,
DivideShareArrays,
Equality,
)
CONFIG = {
BeaverMultiply.name: BeaverMultiply(),
BeaverMultiplyArrays.name: BeaverMultiplyArrays(),
InvertShare.name: InvertShare(),
InvertShareArray.name: InvertShareArray(),
DivideShares.name: DivideShares(),
DivideShareArrays.name: DivideShareArrays(),
Equality.name: Equality(),
}
PREPROCESSING = ["rands", "triples", "zeros", "cubes", "bits"]
n, t = 4, 1
k = 300000
TEST_CURVE = Jubjub()
TEST_FIELD = Jubjub.Field
TEST_KEY = TEST_FIELD(randint(0, TEST_FIELD.modulus))
from pytest import mark
from random import randint
from honeybadgermpc.field import GF
from honeybadgermpc.mpc import Subgroup
from honeybadgermpc.progs.mimc import mimc_mpc, mimc_plain, mimc_mpc_batch
from honeybadgermpc.progs.mixins.share_arithmetic import BeaverMultiply
MIXINS = [BeaverMultiply()]
PREPROCESSING = ["rands", "triples", "zeros", "cubes"]
n, t = 4, 1
k = 3500
@mark.asyncio
async def test_mimc(test_runner):
async def _prog(context):
x = context.preproc.get_zero(context)
field = GF(Subgroup.BLS12_381)
key = field(15)
# Compute F_MiMC_mpc
mm = await mimc_mpc(context, x, key)
mm_open = await mm.open()
# open x, then compute F_MiMC_plain
x_open = await x.open()
mp = mimc_plain(x_open, key)
# Compare the MPC evaluation to the plain one
assert mm_open == mp
import asyncio
import logging
import time
from honeybadgermpc.elliptic_curve import Subgroup
from honeybadgermpc.field import GF
from honeybadgermpc.mpc import TaskProgramRunner
from honeybadgermpc.preprocessing import (
PreProcessedElements as FakePreProcessedElements, )
from honeybadgermpc.progs.mixins.share_arithmetic import BeaverMultiply, MixinConstants
config = {MixinConstants.MultiplyShare: BeaverMultiply()}
"""
Secure Computation With Fixed-Point Numbers
Catrina and Saxena
http://www.ifca.ai/pub/fc10/31_47.pdf
"""
# Fixed Point parameters
F = 32 # The precision (binary bits)
"""
This implementation of the library is not completely hiding. This leaks information about the bits used in computation which is determinied by the security parameter Kappa.
In particular, we leak O(1/(2^Kappa)) information theorotic bits per operation on a floating point secret.
"""
KAPPA = 32 # Statistical security parameter
K = 64 # Total number of padding bits ()
p = modulus = Subgroup.BLS12_381
Field = GF(p)
"""
Library for fixed point operations:
import random
from pytest import mark
from honeybadgermpc.preprocessing import (
PreProcessedElements as FakePreProcessedElements, )
from honeybadgermpc.progs.fixedpoint import FixedPoint
from honeybadgermpc.progs.mixins.share_arithmetic import BeaverMultiply, MixinConstants
config = {MixinConstants.MultiplyShare: BeaverMultiply()}
STANDARD_ARITHMETIC_MIXINS = [BeaverMultiply()]
STANDARD_PREPROCESSING = ["triples", "bits", "zeros"]
n, t = 4, 1
async def run_test_program(prog,
test_runner,
n=n,
t=t,
k=1000,
mixins=STANDARD_ARITHMETIC_MIXINS):
return await test_runner(prog, n, t, STANDARD_PREPROCESSING, k, mixins)
def approx_equal(value, expected, epsilon=0.0001):
return abs(value - expected) <= epsilon