def create_vote(inputs, reference_inputs, parameters, options, participants,
tally_priv, tally_pub):
# genrate param
params = setup()
pub = unpack(tally_pub)
# encrypt initial score
(a, b, k) = binencrypt(params, pub, 0) # encryption of a zero
c = (a, b)
scores = [pack(c) for _ in loads(options)]
# new vote object
new_vote = {
'type': 'VoteObject',
'options': loads(options),
'scores': scores,
'participants': loads(participants),
'tally_pub': tally_pub
}
# proof that all init values are zero
proof_init = provezero(params, pub, c, unpack(tally_priv))
# return
return {
'outputs': (inputs[0], dumps(new_vote)),
'extra_parameters': {
'proof_init': pack(proof_init)
}
}
def add_signature(inputs, reference_inputs, parameters, added_signature):
old_signature = loads(inputs[0])
new_signature = loads(inputs[0])
added_signature = loads(added_signature)
params = setup()
tally_pub = unpack(old_signature['tally_pub'])
# encrypt signatures & proofs to build
enc_added_signatures = [] # encrypted signatures
proof_bin = [
] # signatures are binary, well-formed, and the prover know the signature's value
sum_a, sum_b, sum_k = (0, 0, 0) # sum of signatures equals 1
# loop over signatures
for i in range(0, len(added_signature)):
# encrypt added signature
(a, b, k) = binencrypt(params, tally_pub, added_signature[i])
c = (a, b)
enc_added_signatures.append(pack(c))
# update new scores
new_c = add(unpack(old_signature['scores'][i]), c)
new_signature['scores'][i] = pack(new_c)
# construct proof of binary
tmp1 = provebin(params, tally_pub, (a, b), k, added_signature[i])
proof_bin.append(pack(tmp1))
# update sum of signature
if i == 0:
sum_a, sum_b, sum_k = (a, b, k)
else:
sum_c = (sum_a, sum_b)
sum_a, sum_b, sum_k = add_side(sum_c, c, sum_k, k)
# build proof that sum of signatures equals 1
sum_c = (sum_a, sum_b)
proof_sum = proveone(params, tally_pub, sum_c, sum_k)
# compute signature
(G, _, _, _) = params
hasher = sha256()
hasher.update(dumps(old_signature).encode('utf8'))
hasher.update(dumps(enc_added_signatures).encode('utf8'))
# return
return {
'outputs': (dumps(new_signature), ),
'extra_parameters':
(dumps(enc_added_signatures), dumps(proof_bin), pack(proof_sum))
}
def add_vote(inputs, reference_inputs, parameters, added_vote, voter_priv,
voter_pub):
# retrieve old vote & init new vote object
old_vote = loads(inputs[0])
new_vote = loads(inputs[0])
added_vote = loads(added_vote)
# generate params & retrieve tally's public key
params = setup()
tally_pub = unpack(old_vote['tally_pub'])
# encrypt votes & proofs to build
enc_added_votes = [] # encrypted votes
proof_bin = [
] # votes are binary, well-formed, and the prover know the vote's value
sum_a, sum_b, sum_k = (0, 0, 0) # sum of votes equals 1
# loop over votes
for i in range(0, len(added_vote)):
# encrypt added vote
(a, b, k) = binencrypt(params, tally_pub, added_vote[i])
c = (a, b)
enc_added_votes.append(pack(c))
# update new scores
new_c = add(unpack(old_vote['scores'][i]), c)
new_vote['scores'][i] = pack(new_c)
# construct proof of binary
tmp1 = provebin(params, tally_pub, (a, b), k, added_vote[i])
proof_bin.append(pack(tmp1))
# update sum of votes
if i == 0:
sum_a, sum_b, sum_k = (a, b, k)
else:
sum_c = (sum_a, sum_b)
sum_a, sum_b, sum_k = add_side(sum_c, c, sum_k, k)
# build proof that sum of votes equals 1
sum_c = (sum_a, sum_b)
proof_sum = proveone(params, tally_pub, sum_c, sum_k)
# remove voter from participants
new_vote['participants'].remove(voter_pub)
# compute signature
(G, _, _, _) = params
hasher = sha256()
hasher.update(dumps(old_vote).encode('utf8'))
hasher.update(dumps(enc_added_votes).encode('utf8'))
sig = do_ecdsa_sign(G, unpack(voter_priv), hasher.digest())
# return
return {
'outputs': (dumps(new_vote), ),
'extra_parameters': {
'votes': dumps(enc_added_votes),
'signature': pack(sig),
'voter_pub': voter_pub, # already packed
'proof_bin': dumps(proof_bin),
'proof_sum': pack(proof_sum)
}
}