PRSONA/prsona/src/serverEntity.cpp

#include <iostream>

#include "serverEntity.hpp"

const int maxAllowedVote = 3;

PrsonaServerEntity::PrsonaServerEntity(size_t numServers)
{
    if (numServers < 1)
        std::cerr << "You have to have at least 1 server. I'm making it anyways." << std::endl;

    PrsonaServer firstServer;
    servers.push_back(firstServer);

    const BGN& sharedBGN = firstServer.get_bgn_details();
    Curvepoint sharedEGBlindGenerator = firstServer.get_blinding_generator();

    for (size_t i = 1; i < numServers; i++)
    {
        PrsonaServer currServer(sharedBGN, sharedEGBlindGenerator);
        servers.push_back(currServer);
    }
}

BGNPublicKey PrsonaServerEntity::get_bgn_public_key() const
{
    return servers[0].get_bgn_public_key();
}

Curvepoint PrsonaServerEntity::get_blinding_generator() const
{
    return servers[0].get_blinding_generator();
}

Curvepoint PrsonaServerEntity::get_fresh_generator(Proof& pi) const
{
    Curvepoint retval = PrsonaServer::elGamalGenerator;
    for (size_t j = 0; j < servers.size(); j++)
        retval = servers[j].add_seed_to_generator(pi, retval);

    return retval;
}

Scalar PrsonaServerEntity::decrypt(const CurveBipoint& input)
{
    return servers[0].bgn_system.decrypt(input);
}

std::vector<CurveBipoint> PrsonaServerEntity::get_current_votes_by(Proof& pi, const Curvepoint& shortTermPublicKey) const
{
    return servers[0].get_current_votes_by(pi, shortTermPublicKey);
}

void PrsonaServerEntity::add_new_client(PrsonaClient& newUser)
{
    Proof proofOfValidGenerator, proofOfValidSTPK, proofOfCorrectAddition, proofOfDefaultTally, proofOfValidVotes;
    Curvepoint freshGenerator = get_fresh_generator(proofOfValidGenerator);

    newUser.receive_fresh_generator(proofOfValidGenerator, freshGenerator);
    Curvepoint shortTermPublicKey = newUser.get_short_term_public_key(proofOfValidSTPK);

    servers[0].add_new_client(proofOfValidSTPK, proofOfCorrectAddition, shortTermPublicKey);

    std::vector<TwistBipoint> previousVoteTally;
    std::vector<Curvepoint> currentPseudonyms;
    std::vector<std::vector<CurveBipoint>> voteMatrix;
    servers[0].export_updates(previousVoteTally, currentPseudonyms, voteMatrix);

    for (size_t j = 1; j < servers.size(); j++)
        servers[j].import_updates(proofOfCorrectAddition, previousVoteTally, currentPseudonyms, voteMatrix);

    Scalar randomizationMask;
    EGCiphertext defaultTally = get_default_tally(proofOfDefaultTally, shortTermPublicKey, randomizationMask);
    newUser.receive_vote_tally(proofOfDefaultTally, defaultTally, true, randomizationMask);
    std::vector<CurveBipoint> encryptedDefaults = servers[0].get_current_votes_by(proofOfValidVotes, shortTermPublicKey);
    newUser.receive_encrypted_votes(proofOfValidVotes, encryptedDefaults, true);
}

void PrsonaServerEntity::receive_vote(const Proof& pi, const std::vector<CurveBipoint>& votes, const Curvepoint& shortTermPublicKey)
{
    for (size_t j = 0; j < servers.size(); j++)
        servers[j].receive_vote(pi, votes, shortTermPublicKey);
}

void PrsonaServerEntity::epoch()
{
    Proof pi, proofOfCorrectTally, testUserPi;
    Curvepoint nextGenerator = PrsonaServer::elGamalGenerator;
    std::vector<Scalar> decryptedTalliedScores = tally_scores(proofOfCorrectTally);
    std::vector<TwistBipoint> previousVoteTally;
    std::vector<Curvepoint> currentPseudonyms;
    std::vector<std::vector<CurveBipoint>> voteMatrix;

    encryptedTallyMasks.clear();
    for (size_t i = 0; i < decryptedTalliedScores.size(); i++)
        encryptedTallyMasks.push_back(Scalar());

    for (size_t i = 0; i < servers.size(); i++)
    {
        servers[i].epoch_part_one(pi, nextGenerator, decryptedTalliedScores, encryptedTallyMasks);
        servers[i].export_updates(previousVoteTally, currentPseudonyms, voteMatrix);
        if (i < servers.size() - 1)
            servers[i + 1].import_updates(pi, previousVoteTally, currentPseudonyms, voteMatrix);
    }

    encryptedTallies.clear();
    for (size_t i = 0; i < decryptedTalliedScores.size(); i++)
    {
        EGCiphertext currCiphertext;
        encryptedTallies.push_back(currCiphertext);

        servers[0].bgn_system.encrypt(previousVoteTally[i], decryptedTalliedScores[i]);
        
        encryptedTallies[i].mask = currentPseudonyms[i] * encryptedTallyMasks[i];
        encryptedTallies[i].encryptedMessage = (nextGenerator * encryptedTallyMasks[i]) + (get_blinding_generator() * decryptedTalliedScores[i]);
    }

    pi = generate_epoch_round_one_proof(pi, proofOfCorrectTally);
    servers[0].import_updates(pi, previousVoteTally, currentPseudonyms, voteMatrix);
    
    for (size_t i = 0; i < servers.size(); i++)
    {
        servers[i].epoch_part_two(pi, nextGenerator, encryptedTallies, encryptedTallyMasks);
        servers[i].export_updates(previousVoteTally, currentPseudonyms, voteMatrix);
        if (i < servers.size() - 1)
            servers[i + 1].import_updates(pi, previousVoteTally, currentPseudonyms, voteMatrix);
    }

    for (size_t i = 0; i < servers.size() - 1; i++)
        servers[i].import_updates(pi, previousVoteTally, currentPseudonyms, voteMatrix);

    tallyProofs.clear();
    for (size_t i = 0; i < encryptedTallies.size(); i++)
        tallyProofs.push_back(generate_epoch_proof(pi, encryptedTallies[i]));
}

void PrsonaServerEntity::transmit_score(PrsonaClient& newUser) const
{
    Proof proofOfValidGenerator, proofOfValidSTPK, proofOfScore, proofOfCorrectVotes;
    Curvepoint freshGenerator = get_fresh_generator(proofOfValidGenerator);

    newUser.receive_fresh_generator(proofOfValidGenerator, freshGenerator);
    Curvepoint shortTermPublicKey = newUser.get_short_term_public_key(proofOfValidSTPK);

    Scalar randomizationMask;
    Proof proofOfOwner = newUser.generate_ownership_proof();
    EGCiphertext score = get_current_tally(proofOfOwner, proofOfScore, shortTermPublicKey, true, randomizationMask);
    newUser.receive_vote_tally(proofOfScore, score, false, randomizationMask);

    std::vector<CurveBipoint> encryptedVotes = servers[0].get_current_votes_by(proofOfCorrectVotes, shortTermPublicKey);
    newUser.receive_encrypted_votes(proofOfCorrectVotes, encryptedVotes, false);
}

EGCiphertext PrsonaServerEntity::get_default_tally(Proof& pi, const Curvepoint& shortTermPublicKey, Scalar& randomizationMask) const
{
    Proof unused;
    EGCiphertext retval;

    randomizationMask.set_random();

    retval.mask = shortTermPublicKey * randomizationMask;
    retval.encryptedMessage = get_fresh_generator(unused) * randomizationMask + get_blinding_generator() * PrsonaServer::defaultTally;

    pi = generate_valid_default_tally_proof(retval, randomizationMask);

    return retval;
}

Proof PrsonaServerEntity::generate_valid_default_tally_proof(const EGCiphertext& encryptedDefaultTally, const Scalar& lambda) const
{
    Proof retval;

    if (!PrsonaServer::malicious_server)
    {
        retval.basic = "PROOF";
        return retval;
    }

    retval.basic = "PROOF";
    return retval;
}

Proof PrsonaServerEntity::generate_epoch_round_one_proof(const Proof& pi1, const Proof& pi2) const
{
    Proof retval;

    if (!PrsonaServer::malicious_server)
    {
        retval.basic = "PROOF";
        return retval;
    }

    retval.basic = "PROOF";
    return retval;
}

Proof PrsonaServerEntity::generate_epoch_proof(const Proof& pi, const EGCiphertext& encryptedTally) const
{
    Proof retval;

    if (!PrsonaServer::malicious_server)
    {
        retval.basic = "PROOF";
        return retval;
    }

    retval.basic = "PROOF";
    return retval;
}

bool PrsonaServerEntity::verify_ownership_proof(const Proof& pi, const Curvepoint& shortTermPublicKey) const
{
    if (!PrsonaServer::malicious_client)
        return pi.basic == "PROOF";

    // Proof unused;
    // Curvepoint g = get_fresh_generator(unused);
    // Curvepoint u = pi.initParts[0];

    // std::stringstream oracleInput;
    // oracleInput << g << shortTermPublicKey << u;
    // Scalar c = oracle(oracleInput.str());

    // Scalar z = pi.responseParts[0];

    // return (g * z) == (shortTermPublicKey * c + u);

    return pi.basic == "PROOF";
}

EGCiphertext PrsonaServerEntity::get_current_tally(const Proof& ownerProof, Proof& serverProof, const Curvepoint& shortTermPublicKey, bool isOwner, Scalar& randomizationMask) const
{
    if (isOwner)
    {
        if (!verify_ownership_proof(ownerProof, shortTermPublicKey))
            return EGCiphertext();
    }

    size_t requester = binary_search(shortTermPublicKey);

    serverProof = tallyProofs[requester];

    if (isOwner)
        randomizationMask = encryptedTallyMasks[requester];

    return encryptedTallies[requester];
}

std::vector<Scalar> PrsonaServerEntity::tally_scores(Proof& pi)
{
    std::vector<Scalar> retval = servers[0].tally_scores(pi);
    mpz_class maxScorePossibleThisRound = servers[0].get_max_possible_score(pi).toInt() * maxAllowedVote;
    mpz_class topOfScoreRange = retval.size() * maxAllowedVote;

    for (size_t i = 0; i < retval.size(); i++)
        retval[i] = Scalar((retval[i].toInt() * topOfScoreRange) / maxScorePossibleThisRound);

    return retval;
}

size_t PrsonaServerEntity::binary_search(const Curvepoint& shortTermPublicKey) const
{
    return servers[0].binary_search(shortTermPublicKey);
}