def __init__(self, p=0, q=0):
ChamHash.__init__(self)
global group
group = IntegerGroupQ(0)
# if p and q parameters have already been selected
group.p, group.q, group.r = p, q, 2
self.group = group
def __init__(self, group=None, p=0, q=0, secparam=512):
self.group = group if group is not None else IntegerGroupQ()
self.group.p, self.group.q, self.group.r = p, q, 2
if self.group.p == 0 or self.group.q == 0:
self.group.paramgen(secparam)
self.p = self.group.p
self.q = self.group.q
self.x, self.g, = self.group.random(), self.group.randomGen()
self.z, self.h, = self.group.randomGen(), self.group.randomGen()
self.y = (self.g ** self.x) % self.p
hs1 = hashlib.new('sha256')
hs1.update(Conversion.IP2OS(integer(self.p)))
hs1.update(Conversion.IP2OS(integer(self.q)))
hs1.update(Conversion.IP2OS(integer(self.g)))
hs1.update(Conversion.IP2OS(integer(self.h)))
hs1.update(Conversion.IP2OS(integer(self.y)))
msg = integer(Conversion.OS2IP(hs1.digest()))
self.z = ((msg ** ((self.p - 1) / self.q)) % self.p)
self.u = None
self.d = None
self.s1 = None
self.s2 = None
def params(self, p=0, q=0, bits=1024):
global group
group = IntegerGroupQ(0)
if p == 0 or q == 0:
group.paramgen(bits)
else:
group.p, group.q, group.r = p, q, 2
def setup_key_handler(timestamp: int, number: int, policy: int):
"""
:param timestamp: (int) Timestamp of when the first knowledge proofs should be available on the ledger
:param number: (int) Number of requested credentials
:param policy: (int) The policy that a user is requesting credentials for.
:return: (dict)
"""
resp = []
policy = PolicyModel.query.get(policy)
sigvars = UserModel.query.get(current_user.id).get_sigvar(
timestamp, policy)
if not policy:
raise Exception("Couldn't find policy")
if sigvars:
raise Exception("Key already exists")
for i in range(0, number):
# Retrieve key for particular timestamp and policy combination
time = timestamp + (i * policy.publication_interval * 60
) # publication_interval is in minutes
# If no KeyModel exists for a given policy at a set time we create one
key_model = policy.get_key(time)
if key_model is None:
signer = SignerBlindSignature(IntegerGroupQ())
new = KeyModel(time, policy, signer)
policy.keys.append(new)
new.save_to_db()
policy.save_to_db()
else:
signer = key_model.signer
# Retrieve pubkey and generate challenge to send in the response
pubkey = SigConversion.convert_dict_strlist(signer.get_public_key())
challenge = SigConversion.convert_dict_strlist(signer.get_challenge())
# Save
sigvars = SigVarsModel(timestamp=time,
policy=policy.policy,
u=signer.u,
d=signer.d,
s1=signer.s1,
s2=signer.s2,
user_id=current_user.id)
sigvars.save_to_db()
data = {
'timestamp': time,
'public_key': pubkey,
'challenge': challenge
}
resp.append(data)
return resp
def __init__(self, pubk: dict):
self.p = pubk.get('p')
self.q = pubk.get('q')
self.g = pubk.get('g')
self.y = pubk.get('y')
self.h = pubk.get('h')
self.z = pubk.get('z')
self.group = IntegerGroupQ()
self.group.setparam(p=self.p, q=self.q)
def __init__(self):
self.groupObj = IntegerGroupQ()
self.groupObj.paramgen(256)
self.signer = SignerBlindSignature(self.groupObj, 0, 0, 256)
self.user = UserBlindSignature(self.signer.get_public_key())
self.verify = BlindSignatureVerifier(self.signer.get_public_key())
self.user = UserBlindSignature(self.signer.get_public_key())
self.sig, self.e, self.message = None, None, None
self.zeta, self.zeta1, self.rho = None, None, None
self.omega, self.sigma1, self.sigma2 = None, None, None
self.delta, self.mu, self.tmp1 = None, None, None
self.tmp2, self.tmp3, self.tmp4 = None, None, None
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 get_key(self, timestamp: int) -> KeyModel:
"""
Find a policy key model based on the timestamp given.
:param timestamp: (int)
:return: (KeyModel) or None
"""
key = self.__get_from_list(self.keys, timestamp)
if key is None:
signer = SignerBlindSignature(IntegerGroupQ())
key = KeyModel(timestamp, self.policy, signer)
key.save_to_db()
self.keys.append(key)
self.save_to_db()
return key
def testElGamal(self):
p = integer(
148829018183496626261556856344710600327516732500226144177322012998064772051982752493460332138204351040296264880017943408846937646702376203733370973197019636813306480144595809796154634625021213611577190781215296823124523899584781302512549499802030946698512327294159881907114777803654670044046376468983244647367
)
q = integer(
74414509091748313130778428172355300163758366250113072088661006499032386025991376246730166069102175520148132440008971704423468823351188101866685486598509818406653240072297904898077317312510606805788595390607648411562261949792390651256274749901015473349256163647079940953557388901827335022023188234491622323683
)
groupObj = IntegerGroupQ()
el = ElGamal(groupObj, p, q)
(pk, sk) = el.keygen()
msg = b"hello world!"
cipher1 = el.encrypt(pk, msg)
m = el.decrypt(pk, sk, cipher1)
assert m == msg, "Failed Decryption!!!"
if debug: print("SUCCESSFULLY DECRYPTED!!!")
def decode(self, jsn):
obj = json.loads(jsn)
db = obj.pop('db') if obj.get('db') is not None else None
if isinstance(self, SignerBlindSignature):
new = SignerBlindSignature(IntegerGroupQ())
elif isinstance(self, UserBlindSignature):
new = UserBlindSignature()
else:
raise Exception("Unexpected argument")
for key in obj:
if obj[key] == 'null':
attr_val = None
else:
attr_val = SigConversion.strlist2modint(obj[key])
setattr(new, key, attr_val)
if db:
for key in db:
db[key] = SigConversion.strlist2modint(db[key])
setattr(new, 'db', db)
new.group = IntegerGroupQ()
new.group.setparam(p=new.p, q=new.q)
return new
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 main():
nr_of_clients = 200
G = IntegerGroupQ()
G.paramgen(1024)
g = G.randomG()
clients_list = [Client(G, g, i) for i in range(nr_of_clients)]
for client in clients_list:
g_v , r = client.proof_x
g_x, id = client.g_x, client.id
hash = G.hash(g, g_v, g_x, id)
assert g_v == (g**r) * (g_x **hash)
g_xs = [client.g_x for client in clients_list]
hashes = []
for client in clients_list:
client.compute_g_y(g_xs)
hashes.append(client.answer())
# print(hashes)
answers = []
for client in clients_list:
assert G.hash(client.g_c_y) == hashes[client.id]
answers.append(client.g_c_y)
print(reduce(lambda x, y: x * y, answers, integer(1, G.p)) % G.p)
Receiver hides alpha in a univariate polynomial: 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)])
def setup(security_parameter):
G = IntegerGroupQ()
G.paramgen(security_parameter)
g = G.randomG()
sk = G.random()
return G, g, sk
def __init__(self):
global group
group = IntegerGroupQ(0)
self.T = list(range(self.N))
self.X = [self.group.random() for _ in range(self.N)]
random.shuffle(self.T)
self.T = self.T[:self.n]
R = [(x, self.S(x) if i in self.T else self.group.random())
for i, x in enumerate(self.X)]
return R
def getValue(self, Q):
A = [xq for i, xq in enumerate(Q) if i in self.T]
value = lagrange_interpolation(A, integer(0, self.group.q))
return value
group = IntegerGroupQ()
group.paramgen(256)
# security parameter
k = 5
degree_of_polynomial = 10
m = 5
start = time.time()
# generate polynomial and masked polynomial with point (0,0)
alice = Alice(group, k, degree_of_polynomial)
bob = Bob(group, k)
# polynomial used to calculate P(A)
print("Verification OK:", p1 == p2)
Protocol.setState(self, None)
return None
if __name__ == "__main__":
p = integer(
156053402631691285300957066846581395905893621007563090607988086498527791650834395958624527746916581251903190331297268907675919283232442999706619659475326192111220545726433895802392432934926242553363253333261282122117343404703514696108330984423475697798156574052962658373571332699002716083130212467463571362679
)
q = integer(
78026701315845642650478533423290697952946810503781545303994043249263895825417197979312263873458290625951595165648634453837959641616221499853309829737663096055610272863216947901196216467463121276681626666630641061058671702351757348054165492211737848899078287026481329186785666349501358041565106233731785681339
)
groupObj = IntegerGroupQ()
sp = Asig(groupObj, p, q, 1024)
if sys.argv[1] == "-s":
print("Operating as signer...")
svr = socket(AF_INET, SOCK_STREAM)
svr.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
svr.bind((HOST, PORT))
svr.listen(1)
svr_sock, addr = svr.accept()
print("Connected by ", addr)
_name, _type, _sock = "signer", SIGNER, svr_sock
elif sys.argv[1] == "-u":
print("Operating as user...")
clt = socket(AF_INET, SOCK_STREAM)
clt.connect((HOST, PORT))
