def create_petition_checker(inputs, reference_inputs, parameters, outputs,
returns, dependencies):
try:
# retrieve petition
petition = loads(outputs[1])
# retrieve ID list
spent_list = loads(outputs[2])
# retrieve parameters
sig = pet_unpack(parameters[0])
# check format
if len(inputs) != 1 or len(reference_inputs) != 0 or len(
outputs) != 3 or len(returns) != 0:
return False
# check types
if loads(inputs[0])['type'] != 'PToken' or loads(
outputs[0])['type'] != 'PToken':
return False
if petition['type'] != 'PObject' or spent_list['type'] != 'PList':
return False
# check fields
petition['UUID'] # check presence of UUID
petition['verifier'] # check presence of verifier
options = petition['options']
scores = petition['scores']
pub_owner = pet_unpack(petition['owner'])
if len(options) < 1 or len(options) != len(scores): return False
# check initalised scores
if not all(init_score == 0 for init_score in scores): return False
# verify signature
pet_params = pet_setup()
hasher = sha256()
hasher.update(outputs[1].encode('utf8'))
if not do_ecdsa_verify(pet_params[0], pub_owner, sig, hasher.digest()):
return False
# verify that the spent list is empty
if spent_list['list']: return False
# otherwise
return True
except (KeyError, Exception):
return False
def create_tumbler_checker(inputs, reference_inputs, parameters, outputs, returns, dependencies):
try:
# retrieve ID list
spent_list = loads(outputs[1])
# retrieve vvk & sig
packed_vvk = spent_list['vvk']
sig = pet_unpack(parameters[0])
# check format
if len(inputs) != 1 or len(reference_inputs) != 0 or len(outputs) != 2 or len(returns) != 0:
return False
# check types
if loads(inputs[0])['type'] != 'TToken' or loads(outputs[0])['type'] != 'TToken': return False
if spent_list['type'] != 'TList': return False
# verify that the spent list is empty
if spent_list['list']: return False
# verify signature
bp_params = bp_setup()
hasher = sha256()
hasher.update(outputs[1].encode('utf8'))
m = Bn.from_binary(hasher.digest())
vvk = (unpackG2(bp_params,packed_vvk[0]), unpackG2(bp_params,packed_vvk[1]), unpackG2(bp_params,packed_vvk[2]))
if not verify(bp_params, vvk, m, sig): return False
# otherwise
return True
except (KeyError, Exception):
return False
def verify_checker(inputs, reference_inputs, parameters, outputs, returns,
dependencies):
try:
# retrieve data
instance = loads(reference_inputs[0])
# check format
if len(inputs) != 0 or len(reference_inputs) != 1 or len(
outputs) != 0 or len(returns) != 1:
return False
# verify signature
params = setup(instance['q'])
packed_sig = parameters[0]
sig = (unpackG1(params,
packed_sig[0]), unpackG1(params, packed_sig[1]))
clear_m = loads(parameters[1])
kappa = unpackG2(params, parameters[2])
proof_v = pet_unpack(parameters[3])
packed_vvk = instance['verifier']
vvk = (unpackG2(params,
packed_vvk[0]), unpackG2(params, packed_vvk[1]),
[unpackG2(params, y) for y in packed_vvk[2]])
if not mix_verify(params, vvk, kappa, sig, proof_v, clear_m):
return False
# otherwise
return True
except (KeyError, Exception):
return False
def issue(inputs, reference_inputs, parameters, sk, index):
# extract data
request = loads(inputs[0])
updated_request = loads(inputs[0])
instance = request['instance']
q = instance['q']
params = setup(q)
cm = unpackG1(params, request['cm'])
c = [(unpackG1(params, packed_ci[0]), unpackG1(params, packed_ci[1]))
for packed_ci in request['c']]
clear_m = pet_unpack(request['clear_m'])
# sign
(h, enc_epsilon) = mix_sign(params, sk, cm, c, clear_m)
packed_enc_sig = (pack(h), (pack(enc_epsilon[0]), pack(enc_epsilon[1])))
# update request
# NOTE: indexes are used to re-order the signature for threshold aggregation
updated_request['sigs'].append((index, packed_enc_sig))
# return
return {
'outputs': (dumps(updated_request), ),
'extra_parameters': ((index, packed_enc_sig), )
}
def sign(inputs, reference_inputs, parameters, priv_signer, sig, vvk):
# ini petition, list and parameters
old_petition = loads(inputs[0])
new_petition = loads(inputs[0])
old_list = loads(inputs[1])
new_list = loads(inputs[1])
new_values = loads(parameters[0])
# update petition values
for i in range(0, len(new_values)):
new_petition['scores'][i] = old_petition['scores'][i] + new_values[i]
# prepare showing of credentials
UUID = pet_unpack(old_petition['UUID'])
bp_params = bp_setup()
(kappa, nu, proof_v) = show_coconut_petition(bp_params, vvk, priv_signer,
UUID)
#print(coconut_petition_verify(bp_params, vvk, kappa, sig, proof_v, UUID, nu))
# update spent list
new_list['list'].append(pack(nu))
# pack sig
packed_sig = (pack(sig[0]), pack(sig[1]))
# return
return {
'outputs': (dumps(new_petition), dumps(new_list)),
'extra_parameters':
(packed_sig, pack(kappa), pack(nu), pet_pack(proof_v))
}
def request_checker(inputs, reference_inputs, parameters, outputs, returns,
dependencies):
try:
# retrieve instance
instance = loads(outputs[0])
request = loads(outputs[1])
# retrieve parameters
packed_proof = parameters[0]
packed_pub = parameters[1]
# check format
if len(inputs) != 1 or len(reference_inputs) != 0 or len(
outputs) != 2 or len(returns) != 0:
return False
# check types
if request['type'] != 'CoCoRequest': return False
# check fields
request['clear_m']
params = setup(instance['q'])
cm = unpackG1(params, request['cm'])
packed_c = request['c']
c = [(unpackG1(params, ci[0]), unpackG1(params, ci[1]))
for ci in packed_c]
if inputs[0] != outputs[0] or loads(inputs[0]) != request['instance']:
return False
if request['sigs']: return False
# verify proof
proof = pet_unpack(packed_proof)
pub = unpackG1(params, packed_pub)
if not verify_mix_sign(params, pub, c, cm, proof): return False
# verify depend transaction -- specified by 'callback'
# NOTE: the checker of the dependency is automatcally called
callback = dependencies[0]
if callback['contractID'] + '.' + callback['methodID'] != instance[
'callback']:
return False
# otherwise
return True
except (KeyError, Exception):
return False
def sign_checker(inputs, reference_inputs, parameters, outputs, returns,
dependencies):
try:
# retrieve petition
old_petition = loads(inputs[0])
new_petition = loads(outputs[0])
# retrieve ID list
old_list = loads(inputs[1])
new_list = loads(outputs[1])
# retrieve parameters
bp_params = bp_setup()
new_values = loads(parameters[0])
packed_sig = parameters[1]
sig = (unpackG1(bp_params,
packed_sig[0]), unpackG1(bp_params, packed_sig[1]))
kappa = unpackG2(bp_params, parameters[2])
nu = unpackG1(bp_params, parameters[3])
proof_v = pet_unpack(parameters[4])
# check format
if len(inputs) != 2 or len(reference_inputs) != 0 or len(
outputs) != 2 or len(returns) != 0:
return False
# check types
if new_petition['type'] != 'PObject' or new_list['type'] != 'PList':
return False
# check format & consistency with old object
UUID = pet_unpack(new_petition['UUID'])
options = new_petition['options']
packed_vvk = new_petition['verifier']
scores = new_petition['scores']
if old_petition['UUID'] != new_petition['UUID']: return False
if len(old_petition['owner']) != len(new_petition['owner']):
return False
if len(old_petition['options']) != len(new_petition['options']):
return False
if old_petition['verifier'] != new_petition['verifier']: return False
# check new values
if sum(new_values) != 1: return False
for i in range(len(scores)):
if scores[i] != old_petition['scores'][i] + new_values[i]:
return False
if new_values[i] != 0 and new_values[i] != 1: return False
# check spent list
packed_nu = parameters[3]
if (packed_nu in old_list['list']) or (new_list['list'] !=
old_list['list'] + [packed_nu]):
return False
# verify signature and nu's correctness
vvk = (unpackG2(bp_params,
packed_vvk[0]), unpackG2(bp_params, packed_vvk[1]),
unpackG2(bp_params, packed_vvk[2]))
if not coconut_petition_verify(bp_params, vvk, kappa, sig, proof_v,
UUID, nu):
return False
# otherwise
return True
except (KeyError, Exception):
return False