PRSONA/prsona/inc/base.hpp

#ifndef __PRSONA_BASE_HPP
#define __PRSONA_BASE_HPP

#include <vector>

#include "Curvepoint.hpp"
#include "Bipoint.hpp"
#include "Scalar.hpp"

#include "EGCiphertext.hpp"
#include "proof.hpp"

class PrsonaBase {
    public:
        static size_t MAX_ALLOWED_VOTE;

        // SETUP FUNCTIONS
        static void init();
        static void set_server_malicious();
        static void set_client_malicious();

        // CONST GETTERS
        static size_t get_max_allowed_vote();
        Curvepoint get_blinding_generator() const;
        Curvepoint get_blinding_generator(std::vector<Proof>& pi) const;

    protected:
        // Essentially constants, true for both servers and clients
        static Curvepoint EL_GAMAL_GENERATOR;
        static Scalar SCALAR_N;
        static Scalar DEFAULT_TALLY;
        static Scalar DEFAULT_VOTE;

        static bool SERVER_IS_MALICIOUS;
        static bool CLIENT_IS_MALICIOUS;
        
        std::vector<Proof> elGamalBlindGeneratorProof;
        Curvepoint elGamalBlindGenerator;

        // PRIVATE ELEMENT SETTER
        bool set_EG_blind_generator(
            const std::vector<Proof>& pi,
            const Curvepoint& currGenerator,
            size_t numServers);

        // BINARY SEARCH
        size_t binary_search(
            const std::vector<Curvepoint> list, const Curvepoint& index) const;

        // SCHNORR PROOFS
        Proof schnorr_generation(
            const Curvepoint& generator,
            const Curvepoint& commitment,
            const Scalar& log
        ) const;

        bool schnorr_verification(
            const Curvepoint& generator,
            const Curvepoint& commitment,
            const Scalar& c,
            const Scalar& z
        ) const;

        // OWNERSHIP PROOFS
        Proof generate_ownership_proof(
            const Curvepoint& generator,
            const Curvepoint& commitment,
            const Scalar& log
        ) const;

        bool verify_ownership_proof(
            const Proof& pi,
            const Curvepoint& generator,
            const Curvepoint& commitment
        ) const;

        // ITERATED SCHNORR PROOFS
        Proof add_to_generator_proof(
            const Curvepoint& currGenerator, 
            const Scalar& seed
        ) const;

        bool verify_generator_proof(
            const std::vector<Proof>& pi,
            const Curvepoint& currGenerator,
            size_t numServers
        ) const;

        // REPUTATION PROOFS
        std::vector<Proof> generate_reputation_proof(
            const Proof& ownershipProof,
            const EGCiphertext& commitment,
            const Scalar& currentScore,
            const Scalar& threshold,
            const Scalar& inverseKey,
            size_t numClients
        ) const;

        bool verify_reputation_proof(
            const std::vector<Proof>& pi,
            const Curvepoint& generator,
            const Curvepoint& owner,
            const EGCiphertext& commitment,
            const Scalar& threshold
        ) const;

        // VALID VOTE PROOFS
        std::vector<Proof> generate_vote_proof(
            const Proof& ownershipProof,
            const CurveBipoint& g,
            const CurveBipoint& h,
            const std::vector<bool>& replaces,
            const std::vector<CurveBipoint>& oldEncryptedVotes,
            const std::vector<CurveBipoint>& newEncryptedVotes,
            const std::vector<Scalar>& seeds,
            const std::vector<Scalar>& votes
        ) const;

        bool verify_vote_proof(
            const CurveBipoint& g,
            const CurveBipoint& h,
            const std::vector<Proof>& pi,
            const std::vector<CurveBipoint>& oldEncryptedVotes,
            const std::vector<CurveBipoint>& newEncryptedVotes,
            const Curvepoint& freshGenerator,
            const Curvepoint& owner
        ) const;

        // NEW USER PROOFS
        std::vector<Proof> generate_proof_of_added_user(
            const Scalar& twistBipointSeed,
            const Scalar& EGCiphertextSeed,
            const std::vector<Scalar>& curveBipointSelfSeeds,
            const std::vector<Scalar>& curveBipointOtherSeeds
        ) const;

        bool verify_proof_of_added_user(
            const std::vector<Proof>& pi,
            const Curvepoint& currentFreshGenerator,
            const Curvepoint& shortTermPublicKey,
            const CurveBipoint& curveG,
            const CurveBipoint& curveH,
            const TwistBipoint& twistG,
            const TwistBipoint& twistH,
            size_t selfIndex,
            const EGCiphertext& userEncryptedScore,
            const TwistBipoint& serverEncryptedScore,
            const std::vector<std::vector<CurveBipoint>> encryptedVoteMatrix
        ) const;

        // EPOCH PROOFS
        std::vector<Proof> generate_valid_permutation_proof(
            const std::vector<std::vector<Scalar>>& permutations,
            const std::vector<std::vector<Scalar>>& seeds,
            const std::vector<std::vector<Curvepoint>>& commits
        ) const;

        bool verify_valid_permutation_proof(
            const std::vector<Proof>& pi,
            const std::vector<std::vector<Curvepoint>>& commits
        ) const;

        std::vector<Proof> generate_proof_of_reordering_plus_power(
            const std::vector<std::vector<Scalar>>& permutations,
            const Scalar& power,
            const std::vector<std::vector<Scalar>>& permutationSeeds,
            const std::vector<std::vector<Scalar>>& productSeeds,
            const std::vector<Curvepoint>& oldValues,
            const std::vector<std::vector<Curvepoint>>& permutationCommits,
            const std::vector<std::vector<Curvepoint>>& productCommits,
            const std::vector<std::vector<Curvepoint>>& seedCommits
        ) const;

        bool verify_proof_of_reordering_plus_power(
            const std::vector<Proof>& pi,
            const std::vector<Curvepoint>& oldValues,
            const std::vector<std::vector<Curvepoint>>& permutationCommits,
            const std::vector<std::vector<Curvepoint>>& productCommits,
            const std::vector<std::vector<Curvepoint>>& seedCommits
        ) const;

        template <typename T>
        std::vector<Proof> generate_proof_of_reordering(
            const std::vector<std::vector<Scalar>>& permutations,
            const std::vector<std::vector<Scalar>>& permutationSeeds,
            const std::vector<std::vector<Scalar>>& productSeeds,
            const std::vector<T>& oldValues,
            const std::vector<std::vector<Curvepoint>>& permutationCommits,
            const std::vector<std::vector<T>>& productCommits,
            const T& otherG,
            const T& otherH,
            bool inverted
        ) const;

        template <typename T>
        bool verify_proof_of_reordering(
            const std::vector<Proof>& pi,
            const std::vector<T>& oldValues,
            const std::vector<std::vector<Curvepoint>>& permutationCommits,
            const std::vector<std::vector<T>>& productCommits,
            const T& otherG,
            const T& otherH,
            bool inverted
        ) const;

        // SERVER AGREEMENT PROOFS
        Proof generate_valid_vote_row_proof(
            const std::vector<CurveBipoint>& commitment) const;
        Proof generate_valid_vote_matrix_proof(
            const std::vector<std::vector<CurveBipoint>>& commitment) const;
        Proof generate_valid_user_tally_proof(
            const EGCiphertext& commitment) const;
        Proof generate_valid_server_tally_proof(
            const TwistBipoint& commitment) const;
        Proof generate_valid_pseudonyms_proof(
            const std::vector<Curvepoint>& commitment) const;
        
        bool verify_valid_vote_row_proof(
            const std::vector<Proof>& pi,
            const std::vector<CurveBipoint>& commitment
        ) const;
        bool verify_valid_vote_matrix_proof(
            const std::vector<Proof>& pi,
            const std::vector<std::vector<CurveBipoint>>& commitment
        ) const;
        bool verify_valid_user_tally_proof(
            const std::vector<Proof>& pi,
            const EGCiphertext& commitment
        ) const;
        bool verify_valid_server_tally_proof(
            const std::vector<Proof>& pi,
            const TwistBipoint& commitment
        ) const;
        bool verify_valid_pseudonyms_proof(
            const std::vector<Proof>& pi,
            const std::vector<Curvepoint>& commitment
        ) const;
};

#endif