def generate_binary_triple(size0, size1, device=None):
"""Generate binary triples of given size"""
generator = TTPClient.get().get_generator(device=device)
a = generate_kbit_random_tensor(size0,
generator=generator,
device=device)
b = generate_kbit_random_tensor(size1,
generator=generator,
device=device)
if comm.get().get_rank() == 0:
# Request c from TTP
c = TTPClient.get().ttp_request("binary", device, size0, size1)
else:
size2 = torch.broadcast_tensors(a, b)[0].size()
c = generate_kbit_random_tensor(size2,
generator=generator,
device=device)
# Stack to vectorize scatter function
a = BinarySharedTensor.from_shares(a)
b = BinarySharedTensor.from_shares(b)
c = BinarySharedTensor.from_shares(c)
return a, b, c
def PRZS(*size, device=None):
"""
Generate a Pseudo-random Sharing of Zero (using arithmetic shares)
This function does so by generating `n` numbers across `n` parties with
each number being held by exactly 2 parties. Therefore, each party holds
two numbers. A zero sharing is found by having each party xor their two
numbers together.
"""
from crypten import generators
tensor = BinarySharedTensor(src=SENTINEL)
if device is None:
device = torch.device("cpu")
elif isinstance(device, str):
device = torch.device(device)
g0 = generators["prev"][device]
g1 = generators["next"][device]
current_share = generate_kbit_random_tensor(*size,
device=device,
generator=g0)
next_share = generate_kbit_random_tensor(*size,
device=device,
generator=g1)
tensor.share = current_share ^ next_share
return tensor
def generate_binary_triple(size):
"""Generate xor triples of given size"""
a = generate_kbit_random_tensor(size)
b = generate_kbit_random_tensor(size)
c = a & b
# Stack to vectorize scatter function
abc = torch.stack([a, b, c])
abc = BinarySharedTensor(abc, src=0)
return abc[0], abc[1], abc[2]
def generate_binary_triple(size0, size1, device=None):
"""Generate xor triples of given size"""
a = generate_kbit_random_tensor(size0, device=device)
b = generate_kbit_random_tensor(size1, device=device)
c = a & b
a = BinarySharedTensor(a, src=0)
b = BinarySharedTensor(b, src=0)
c = BinarySharedTensor(c, src=0)
return a, b, c
def PRZS(*size):
"""
Generate a Pseudo-random Sharing of Zero (using arithmetic shares)
This function does so by generating `n` numbers across `n` parties with
each number being held by exactly 2 parties. Therefore, each party holds
two numbers. A zero sharing is found by having each party xor their two
numbers together.
"""
tensor = BinarySharedTensor(src=SENTINEL)
current_share = generate_kbit_random_tensor(*size, generator=comm.get().g0)
next_share = generate_kbit_random_tensor(*size, generator=comm.get().g1)
tensor.share = current_share ^ next_share
return tensor
def test_BaseOT(self):
ot = baseOT.BaseOT((self.rank + 1) % self.world_size)
self.length = 8
if self.rank == 0:
#Alice code her input x = 9 into choice in reverse order
choices = [1, 0, 0, 1, 0, 0, 0, 0]
self.assertEqual(len(choices), self.length)
choices.append(0)
msgcs = ot.receive(choices)
SA = 0
print("Alice receives messages: ", msgcs)
for i in range(self.length):
SA += int(msgcs[i])
print("SA is ", SA)
print("SB is ", msgcs[-1])
S = (int(msgcs[-1]) + SA) % (2**self.length)
print("S is ", S)
self.assertEqual(S, 207)
else:
y = 23
msg0s = []
msg1s = []
SB = 0
for i in range(self.length):
random_num = generate_kbit_random_tensor(size=(1, ),
bitlength=32)
msg0s.append(str(-random_num.item()))
msg1s.append(
str((y * (2**i) - random_num.item()) % (2**self.length)))
SB += random_num.item()
#Bob send the SB in the last entry
msg0s.append(str(SB))
msg1s.append(str(SB))
ot.send(msg0s, msg1s)
def generate_binary_triple(size):
"""Generate binary triples of given size"""
generator = TTPClient.get().generator
a = generate_kbit_random_tensor(size, generator=generator)
b = generate_kbit_random_tensor(size, generator=generator)
if comm.get().get_rank() == 0:
# Request c from TTP
c = TTPClient.get().ttp_request("binary", size)
else:
c = generate_kbit_random_tensor(size, generator=generator)
# Stack to vectorize scatter function
a = BinarySharedTensor.from_shares(a)
b = BinarySharedTensor.from_shares(b)
c = BinarySharedTensor.from_shares(c)
return a, b, c
def B2A_rng(size, device=None):
"""Generate random bit tensor as arithmetic and binary shared tensors"""
# generate random bit
r = generate_kbit_random_tensor(size, bitlength=1, device=device)
rA = ArithmeticSharedTensor(r, precision=0, src=0)
rB = BinarySharedTensor(r, src=0)
return rA, rB
def rand(*size, bits=64, device=None):
"""
Generate a uniform random samples with a given size.
"""
tensor = BinarySharedTensor(src=SENTINEL)
if isinstance(size[0], (torch.Size, tuple)):
size = size[0]
tensor.share = generate_kbit_random_tensor(size, bitlength=bits, device=device)
return tensor
def _get_binary_PRSS(self, size, bitlength=None, remove_rank=None):
"""
Generates a plaintext value from a set of random binary secret shares
generated by each party
"""
gens = self.generators[1:] if remove_rank else self.generators
result = [
generate_kbit_random_tensor(size, bitlength=bitlength, generator=g)
for g in gens
]
return reduce(lambda a, b: a ^ b, result)
def _get_binary_PRSS(self, size, bitlength=None, remove_rank=None):
"""
Generates a plaintext value from a set of random binary secret shares
generated by each party
"""
gens = self._get_generators(device=self.device)
if remove_rank:
gens = gens[1:]
result = None
for idx, g in enumerate(gens):
elem = generate_kbit_random_tensor(
size, bitlength=bitlength, generator=g, device=g.device
)
result = elem if idx == 0 else result ^ elem
return result
def B2A_rng(size):
"""Generate random bit tensor as arithmetic and binary shared tensors"""
generator = TTPClient.get().generator
# generate random bit
rB = generate_kbit_random_tensor(size, bitlength=1, generator=generator)
if comm.get().get_rank() == 0:
# Request rA from TTP
rA = TTPClient.get().ttp_request("B2A", size)
else:
rA = generate_random_ring_element(size, generator=generator)
rA = ArithmeticSharedTensor.from_shares(rA, precision=0)
rB = BinarySharedTensor.from_shares(rB)
return rA, rB
