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):
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 test_encode_decode(self, protocol):
signer = protocol.signer
encoded = signer.encode()
decoded = SignerBlindSignature().decode(encoded)
assert signer == decoded
class Protocol:
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 setup_method(self, message=None):
key = ECC.generate(curve='P-256')
self.message = Conversion.OS2IP(key.public_key().export_key(
format='DER')) if message is None else message
challenge = self.signer.get_challenge()
self.e = self.user.challenge_response(challenge, self.message)
proofs = self.signer.get_proofs(self.e)
self.sig = self.user.gen_signature(proofs)
def values(self):
self.zeta = self.sig.get('zeta')
self.zeta1 = self.sig.get('zeta1')
self.rho = self.sig.get('rho')
self.omega = self.sig.get('omega')
self.sigma1 = self.sig.get('sigma1')
self.sigma2 = self.sig.get('sigma2')
self.delta = self.sig.get('delta')
self.mu = self.sig.get('mu')
self.tmp1 = (self.verify.g**self.rho) * (
self.verify.y**self.omega) % self.verify.p
self.tmp2 = (self.verify.g**self.sigma1) * (
self.zeta1**self.delta) % self.verify.p
self.tmp3 = (self.verify.h**self.sigma2) * (
(self.zeta / self.zeta1)**self.delta) % self.verify.p
self.tmp4 = (self.verify.z**self.mu) * (self.zeta**
self.delta) % self.verify.p
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 signer(self):
return SignerBlindSignature().decode(self.signer_)