def init1():
group = IntegerGroupQ()
group.paramgen(bit)
alpha = group.randomGen()
key = group.random()
beta = alpha ** key
x = [ odd_random(group) for _ in range(numbers['cards']) ]
room = Room(request.environ.get('beaker.session'), False)
try:
room.get('win')
except:
room.set('win', 0)
[room.set(n, v) for n, v in [('p', group.p), ('q', group.q), ('alpha', alpha), ('key', key), ('beta_i', beta), ('x', x)]]
room.save()
response.content_type = 'application/json'
return json.dumps(map(toStr, {
'p' : group.p,
'q' : group.q,
'alpha' : alpha,
'beta' : beta,
'x' : x,
}))
Receiver chooses random poly S of degree k such that S(0) = alpha Receiver's plan is to use R(x) = Q(x, S(x)) to learn P(alpha) R(0) = Q(0, S(0)) = P(S(0)) = P(alpha) """ import random from charm.toolbox.integergroup import IntegerGroupQ from charm.core.math.integer import integer from charm.core.math.integer import reduce as reduce_modulus from utils import Poly, LI SECURITY_PARAM = 20 G = IntegerGroupQ() G.paramgen(SECURITY_PARAM) g = G.randomGen() k = 4 m = 4 d_p = 12 # Degree of P d = d_p * k # Degree of P_x def main(): # Receiver has alpha. alpha = G.random() # Sender has polynomial P. P = Poly([G.random() for _ in range(d_p + 1)]) # Sender generates random masking poly P_x P_x = Poly([G.random() for _ in range(d + 1)])
class OneOfTwo(Protocol):
def __init__(self):
super().__init__(None)
sender_states = {
1: self.sender_state_1,
3: self.sender_state_3,
5: self.sender_state_5,
}
receiver_states = {
2: self.receiver_state_2,
4: self.receiver_state_4,
}
sender_trans = {1: 3, 3: 5}
receiver_trans = {2: 4}
self.group = IntegerGroupQ()
self.group.paramgen(SECURITY_PARAM)
Protocol.addPartyType(self, SENDER, sender_states, sender_trans, True)
Protocol.addPartyType(self, RECEIVER, receiver_states, receiver_trans)
def sender_state_1(self):
print('Sender generates random value c and computes C = g ^ c.')
g = self.group.randomGen()
c = self.group.random()
C = g**c
super().setState(3)
super().store(('g', g))
return {'g': g, 'C': C}
def receiver_state_2(self, data):
print('Receiver got C, generates PKs and sends to sender.')
C, g = data['C'], data['g']
k = self.group.random()
super().store(('g', g), ('k', k))
PK_0 = g**k
PK_1 = C / (g**k)
super().setState(4)
return {'PK_0': PK_0, 'PK_1': PK_1}
def sender_state_3(self, data):
PK_0, PK_1 = data['PK_0'], data['PK_1']
print('Sender receives PKs, gets messages and calculates.')
g = self.db['g']
r0 = self.group.random()
r1 = self.group.random()
m0 = b"message 0"
m1 = b"message 1"
super().store(
('m0', m0),
('m1', m1),
)
c0 = (g**r0, xor(get_hash(PK_0**r0), m0).hex())
c1 = (g**r1, xor(get_hash(PK_1**r1), m1).hex())
super().setState(5)
return {'c0': c0, 'c1': c1}
def receiver_state_4(self, data):
c0 = data['c0']
k, = super().get(['k'])
w0 = bytes.fromhex(c0[1])
H = c0[0]**k
decoded_msg = xor(get_hash(H), w0)
super().setState(None)
return {'decoded_msg': decoded_msg.hex()}
def sender_state_5(self, data):
decoded_msg = bytes.fromhex(data['decoded_msg'])
m0, m1 = super().get(['m0', 'm1'])
assert decoded_msg == m0
super().setState(None)
return None
