def calculate_voting_result_rtk_handler():
data = get_post_data(request)
indexes = str_to_int(data.get('indexes'))
polynomialCoefficientsExponents = str_to_int(
data.get('polynomialCoefficientsExponents'))
partialDecrypts = str_to_int(data.get('partialDecrypts'))
sum_A = str_to_int(data.get('sum_A'))
sum_B = str_to_int(data.get('sum_B'))
votersNum = str_to_int(data.get('votersNum'))
optionsNum = str_to_int(data.get('optionsNum'))
commissionPubKey = str_to_hex(data.get('commissionPubKey'))
decryptKey = str_to_int(data.get('decryptKey'))
commissionDecrypt = str_to_int(data.get('commissionDecrypt'))
result, error = calculate_voting_result_rtk(
indexes, votersNum, optionsNum, polynomialCoefficientsExponents,
partialDecrypts, sum_A, sum_B, decryptKey, commissionPubKey,
commissionDecrypt)
if not result:
return jsonify(error), 400
else:
return jsonify({"result": result})
def calculate_voting_result_v2_handler():
data = get_post_data(request)
indexes = str_to_int(data.get('indexes'))
polynomialCoefficientsExponents = str_to_int(
data.get('polynomialCoefficientsExponents'))
partialDecrypts = str_to_int(data.get('partialDecrypts'))
mainKey = str_to_int(data.get('mainKey'))
sum_A = str_to_int(data.get('sum_A'))
sum_B = str_to_int(data.get('sum_B'))
votersNum = str_to_int(data.get('votersNum'))
optionsNum = str_to_int(data.get('optionsNum'))
result, error = calculate_voting_result(indexes, votersNum, optionsNum,
polynomialCoefficientsExponents,
partialDecrypts, sum_A, sum_B,
mainKey)
if not result:
return jsonify(error), 400
else:
return jsonify({"result": result})
def calculate_main_key_hanlder():
data = get_post_data(request)
publicKeysCommits = list(
map(lambda publicKeyCommit: str_to_int(publicKeyCommit),
data.get('publicKeysCommits')))
secretKeysOfCommits = str_to_int(data.get('secretKeysOfCommits'))
mainKey = calculate_main_key(publicKeysCommits, secretKeysOfCommits)
return jsonify({"mainKey": int_to_str(mainKey)})
def verify_private_key_handler():
data = get_post_data(request)
publicKey = str_to_hex(data.get('publicKey'))
privateKey = int(data.get('privateKey'))
valid, error = validate_private_key(
[str(publicKey[0]), str(publicKey[1])], privateKey)
return jsonify({"valid": valid, "error": error})
def verify_encrypted_bulletin_handler():
data = get_post_data(request)
encryptedBulletin = str_to_int(data.get('encryptedBulletin')[0])
sumRangeProof = str_to_int(data.get('encryptedBulletin')[1])
mainKey = str_to_int(data.get('mainKey'))
verified = verify_encrypted_bulletin(encryptedBulletin, sumRangeProof,
mainKey)
return jsonify({"verified": verified})
def add_commission_key_handler():
data = get_post_data(request)
decryptKey = str_to_int(data.get('decryptKey'))
commissionPubKey = str_to_hex(data.get('commissionPubKey'))
result, data = add_commission_key(decryptKey, commissionPubKey)
if not result:
return jsonify(data), 400
else:
return jsonify({"mainKey": int_to_str(data)})
def verify_equality_of_dl_handler():
data = get_post_data(request)
decrypted = str_to_int(data.get('decrypted'))
publicKey = str_to_hex(data.get('publicKey'))
sum_A = str_to_int(data.get('sum_A'))
verified = verify_equality_of_dl_wrapped(decrypted, sum_A, publicKey)
return jsonify({"verified": verified})
def add_encrypted_bulletins_to_sum_handler():
data = get_post_data(request)
encryptedBulletins = list(str_to_int(data.get('encryptedBulletins')))
mainKey = str_to_int(data.get('mainKey'))
prevSums = data.get('prevSums')
sum_A, sum_B = add_encrypted_bulletins_to_sum(encryptedBulletins, mainKey,
prevSums)
return jsonify({"sum_A": int_to_str(sum_A), "sum_B": int_to_str(sum_B)})
def calculate_polynomial_coefficients_exponents_handler():
data = get_post_data(request)
coefficients = str_to_int(data.get('polynomialCoefficients'))
polynomialCoefficientsExponents = calculate_polynomial_coefficients_exponents(
coefficients)
return jsonify({
"polynomialCoefficientsExponents":
list(
map(lambda exponent: int_to_str([exponent.x, exponent.y]),
polynomialCoefficientsExponents))
})
def generate_key_pair_handler():
data = get_post_data(request)
privateKey, publicKey = generate_key_pair()
if data.get('format') == 'hex':
publicKey = [format(publicKey.x, 'x'), format(publicKey.y, 'x')]
else:
publicKey = int_to_str([publicKey.x, publicKey.y])
return jsonify({
"privateKey": int_to_str(privateKey),
"publicKey": publicKey
})
def subtract_encrypted_bulletins_from_sum_handler():
data = get_post_data(request)
encryptedBulletins = list(
map(lambda v: [str_to_int(v[0]), str_to_int(v[1])],
data.get('encryptedBulletins')))
mainKey = str_to_int(data.get('mainKey'))
prevSums = data.get('prevSums')
sum_A, sum_B = subtract_encrypted_bulletins_from_sum(
encryptedBulletins, mainKey, prevSums)
return jsonify({"sum_A": int_to_str(sum_A), "sum_B": int_to_str(sum_B)})
def blind_signature_verify_rsa_handler():
data = get_post_data(request)
signature = int(data.get('signature'), 16)
modulo = int(data.get('modulo'), 16)
publicExp = int(data.get('publicExp'), 16)
message = bytes(data.get('message'), encoding='utf-8')
return jsonify({
"verified":
blind_signature_verify_rsa(signature, message, publicExp, modulo)
})
def blind_signature_generate_rsa_handler():
data = get_post_data(request)
message = bytes(data.get('message'), encoding='utf-8')
signature = dummy_blind_signature_generate_rsa(message)
return jsonify({
"message": data.get('message'),
"signature": dec_to_hexstr(signature),
"publicExp": dec_to_hexstr(public_exp),
"modulo": dec_to_hexstr(modulo)
})
def point_validate_handler():
data = get_post_data(request)
point = str_to_hex(data.get('point'))
if data.get('curve') == 'gost':
valid = gost_point_validate(point)
elif data.get('curve') == 'bitcoin':
point = [str(point[0]), str(point[1])]
valid = point_validate(point)
else:
return jsonify({"valid": False, "error": "Unknown curve"}), 400
return jsonify({"valid": valid})
def unblind_public_keys_hanlder():
data = get_post_data(request)
publicKeysCommits = list(
map(lambda publicKeyCommit: str_to_int(publicKeyCommit),
data.get('publicKeysCommits')))
secretKeysOfCommits = str_to_int(data.get('secretKeysOfCommits'))
unblindedPublicKeys = unblind_public_keys(publicKeysCommits,
secretKeysOfCommits)
return jsonify({
"unblindedPublicKeys":
list(
map(lambda publicKey: int_to_str([publicKey.x, publicKey.y]),
unblindedPublicKeys))
})
def blind_signature_generate_handler():
data = get_post_data(request)
message = data.get('message')
rho, omega, sigma, delta, Z, public_key = dummy_blind_signature_generate(
message)
return jsonify({
"rho": dec_to_hexstr(rho),
"omega": dec_to_hexstr(omega),
"sigma": dec_to_hexstr(sigma),
"delta": dec_to_hexstr(delta),
"Z": dec_to_hexstr([Z.x, Z.y]),
"message": message,
"publicKey": dec_to_hexstr([public_key.x, public_key.y]),
})
def calculate_encrypted_shadows_handler():
data = get_post_data(request)
coefficients = str_to_int(data.get('polynomialCoefficients'))
unblindedPublicKeys = list(
map(lambda publicKey: str_to_int(publicKey),
data.get('unblindedPublicKeys')))
encryptedShadows = calculate_encrypted_shadows(coefficients,
unblindedPublicKeys)
return jsonify({
"encryptedShadows":
list(
map(
lambda encryptedShadow: {
"privateKey":
int_to_str(encryptedShadow[0]),
"publicKey":
int_to_str([encryptedShadow[1].x, encryptedShadow[1].y])
}, encryptedShadows))
})
def blind_signature_verify_handler():
data = get_post_data(request)
rho = int(data.get('rho'), 16)
omega = int(data.get('omega'), 16)
delta = int(data.get('delta'), 16)
sigma = int(data.get('sigma'), 16)
message = data.get('message')
Z = data.get('Z')
Z = [int(Z[0], 16), int(Z[1], 16)]
public_key = data.get('publicKey')
public_key = [int(public_key[0], 16), int(public_key[1], 16)]
return jsonify({
"verified":
blind_signature_verify(rho, omega, sigma, delta, Z, message,
public_key)
})
def decrypt_and_check_shadows_handler():
data = get_post_data(request)
privateKey = str_to_int(data.get('privateKey'))
idx = str_to_int(data.get('idx'))
polynomialCoefficientsExponents = list(
str_to_int(data.get('polynomialCoefficientsExponents')))
encrypted_shadows = list(
map(
lambda shadow: [
str_to_int(shadow['privateKey']),
str_to_int([shadow['publicKey'][0], shadow['publicKey'][1]])
], data.get('encryptedShadows')))
unblindedPublicKeys = list(
map(lambda publicKey: str_to_int(publicKey),
data.get('unblindedPublicKeys')))
result = decrypt_and_check_shadows(privateKey, idx, encrypted_shadows,
polynomialCoefficientsExponents,
unblindedPublicKeys)
return result
def restore_common_secret_handler():
data = get_post_data(request)
indexes = str_to_int(data.get('indexes'))
decryptedShadowsSums = str_to_int(data.get('decryptedShadowsSums'))
commonSecret = restore_common_secret(indexes, decryptedShadowsSums)
return jsonify({"commonSecret": int_to_str(commonSecret)})
def make_encrypted_bulletin_handler():
data = get_post_data(request)
bulletin = str_to_int(data.get('bulletin'))
mainKey = str_to_int(data.get('mainKey'))
encrypted_bulletin, proof = make_encrypted_bulletin(bulletin, mainKey)
return jsonify([list(int_to_str(encrypted_bulletin)), int_to_str(proof)])
def partially_decrypt_sum_a_handler():
data = get_post_data(request)
sum_A = str_to_int(data.get('sum_A'))
decryptedShadowsSum = str_to_int(data.get('decryptedShadowsSum'))
partiallyDecrypted = partially_decrypt_sum_a(sum_A, decryptedShadowsSum)
return jsonify({"partiallyDecrypted": int_to_str(partiallyDecrypted)})
def generate_polynomial_coefficients_handler():
data = get_post_data(request)
privateKey = str_to_int(data.get('privateKey'))
k = str_to_int(data.get('k'))
coefficients = generate_polynomial_coefficients(privateKey, k)
return jsonify({"polynomialCoefficients": int_to_str(coefficients)})
def verify_encrypted_bulletins_handler_v2():
data = get_post_data(request)
encryptedBulletins = str_to_int(data.get('encryptedBulletins'))
mainKey = str_to_int(data.get('mainKey'))
verified = verify_encrypted_bulletins_v2(encryptedBulletins, mainKey)
return jsonify({"verified": verified})
