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,
}))
import random
import pdb
from charm.schemes.pkenc.pkenc_rsa import RSA
from charm.toolbox.integergroup import IntegerGroupQ, integer
SECURITY_PARAM = 20
X_SIZE = 10
Y_SIZE = 10
G = IntegerGroupQ()
G.paramgen(SECURITY_PARAM)
N = 127
g = G.random()
def generate_sets(number_of_mutual):
mutual_elements = generate_elements(number_of_mutual)
X = generate_elements(X_SIZE)
Y = [e for e in generate_elements(Y_SIZE) if e not in X]
X += mutual_elements
Y += mutual_elements
# shuffle sets
# random.shuffle(X)
# random.shuffle(Y)
return X, Y, mutual_elements
def setup(security_parameter):
G = IntegerGroupQ()
G.paramgen(security_parameter)
g = G.randomG()
sk = G.random()
return G, g, sk
class UserBlindSignature(BlindSigner):
"""
This class represents the entity who wishes to have a certain message blindly signed.
"""
def __init__(self, input_=None):
if input_ is not None:
self.p = input_.get('p')
self.q = input_.get('q')
self.g = input_.get('g')
self.y = input_.get('y')
self.h = input_.get('h')
self.z = input_.get('z')
self.group = IntegerGroupQ()
self.group.setparam(p=self.p, q=self.q)
self.db = input_.get('db')
if self.db is None:
self.db = {}
def __store__(self, *args):
for i in args:
if isinstance(i, tuple):
self.db[i[0]] = i[1]
return None
def __get__(self, keys, _type=tuple):
if not type(keys) == list:
return
if _type == tuple:
ret = []
else:
ret = {}
# get the data
for i in keys:
if _type == tuple:
ret.append(self.db[i])
else: # dict
ret[i] = self.db[i]
# return data
if _type == tuple:
return tuple(ret)
return ret
def challenge_response(self, input, message):
rnd = input.get('rnd')
a = input.get('a')
b1 = input.get('b1')
b2 = input.get('b2')
msg = integer(Conversion.OS2IP(SHA1(Conversion.IP2OS(rnd))))
z1 = (msg ** ((self.p - 1) / self.q)) % self.p
gamma = self.group.random()
tau = self.group.random()
t1 = self.group.random()
t2 = self.group.random()
t3 = self.group.random()
t4 = self.group.random()
t5 = self.group.random()
zeta = self.z ** gamma
zeta1 = z1 ** gamma
zeta2 = zeta / zeta1
alpha = a * (self.g ** t1) * (self.y ** t2) % self.p
beta1 = (b1 ** gamma) * (self.g ** t3) * (zeta1 ** t4) % self.p
beta2 = (b2 ** gamma) * (self.h ** t5) * (zeta2 ** t4) % self.p
eta = self.z ** tau
epsilon = integer(hash_int([zeta, zeta1, alpha, beta1, beta2, eta, message])) % self.q
e = (epsilon - t2 - t4) % self.q
self.__store__(self, ('z1', z1), ('zeta', zeta), ('zeta1', zeta1))
self.__store__(self, ('zeta2', zeta2), ('alpha', alpha), ('beta1', beta1), ('beta2', beta2))
self.__store__(self, ('t1', t1), ('t2', t2), ('t3', t3), ('t4', t4), ('t5', t5))
self.__store__(self, ('gamma', gamma), ('tau', tau), ('eta', eta))
return {'e': e}
def gen_signature(self, proofs: dict) -> dict:
r = proofs.get('r')
c = proofs.get('c')
d = proofs.get('d')
s1 = proofs.get('s1')
s2 = proofs.get('s2')
(zeta, zeta1, z, z1) = self.__get__(['zeta', 'zeta1', 'zeta2', 'z1'])
(t1, t2, t3, t4, t5) = self.__get__(['t1', 't2', 't3', 't4', 't5'])
(gamma, tau, eta) = self.__get__(['gamma', 'tau', 'eta'])
rho = (r + t1) % self.q
omega = (c + t2) % self.q
sigma1 = ((gamma * s1) + t3) % self.q
sigma2 = ((gamma * s2) + t5) % self.q
delta = (d + t4) % self.q
mu = (tau - (delta * gamma)) % self.q
return {'zeta': zeta, 'zeta1': zeta1, 'rho': rho, 'omega': omega,
'sigma1': sigma1, 'sigma2': sigma2, 'delta': delta, 'mu': mu}
from charm.toolbox.integergroup import IntegerGroupQ, integer
from utils import ID, Poly, product, LIexp
import random
import time
# Setup
G = IntegerGroupQ()
G.paramgen(1024)
g = G.randomG()
sk = G.random()
z = 16
n = 256
NUM_BLOCKS = 1
print("Params")
# Client message
M = [[integer(random.randrange(2**n), G.q) for _ in range(z)]
for _ in range(NUM_BLOCKS)]
print("File")
def poly(sk, fid):
""" Generate random polynomial from seed := sk + id_f """
random.seed(str(sk) + fid) # Seed initialized by string sk + fid
return Poly([integer(random.randrange(G.q), G.q) for _ in range(z + 1)])
# pylint: disable=invalid-name
"""Implementation Proof of possession algorithm for Cloud Storage."""
import random
import hashlib
from charm.core.math.integer import integer # pylint: disable=no-name-in-module
from charm.toolbox.integergroup import IntegerGroupQ
from utils import Poly, LI_exp
SECURITY_PARAM = 5
G = IntegerGroupQ()
G.paramgen(SECURITY_PARAM)
g = G.randomG()
SECRET_KEY = G.random()
NUM_OF_BLOCKS = 4
NUM_OF_SUBBLOCKS = 4
z = NUM_OF_SUBBLOCKS
def ID(block):
return hashlib.sha512(str(block).encode('utf-8')).hexdigest()
def poly(secret_key, block_id):
"""Yields an secret polynomial Lf over Zq for a given block f."""
random.seed(str(secret_key) + block_id)
return Poly(
[integer(random.randrange(G.q), G.q) for _ in range(NUM_OF_SUBBLOCKS)]) # pylint: disable=not-callable
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
