def test_encode_decode(self, protocol):
signer = protocol.signer
encoded = signer.encode()
decoded = SignerBlindSignature().decode(encoded)
assert signer == decoded
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 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_)