PRSONA/prsona/src/clientMain.cpp

#include <mutex>
#include <condition_variable>
#include <chrono>
#include <iostream>
#include <fstream>
#include <cstring>
#include <cstdlib>

#include "networkClient.hpp"

using namespace std;

enum EventType {
    CLIENT_MAKE_VOTE = 1,
    CLIENT_MAKE_REP_PROOF
};

struct synchronization_tool exitSync;

// Initialize the classes we use
void initialize_prsona_classes()
{
    Scalar::init();
    PrsonaBase::init();
    PrsonaBase::set_client_malicious();
}

BGNPublicKey get_bgn_public_key_from_file(
    struct synchronization_tool *sync,
    const char *filename)
{
    unique_lock<mutex> lck(sync->mtx);
    ifstream bgnFile(filename);

    BGNPublicKey publicKey;
    bgnFile >> publicKey;

    return publicKey;
}

BGNPublicKey get_bgn_public_key(
    default_random_engine *generator,
    const vector<string>& serverIPs)
{
    struct synchronization_tool sync;

    uniform_int_distribution<size_t> distribution(0, serverIPs.size() - 1);
    size_t whichServer = distribution(*randomGenerator);

    bool flag = false;
    while (!flag)
    {
        struct mg_connection *conn = mg_connect_websocket_client(
            serverIPs[whichServer].c_str(),
            PRSONA_PORT,
            USE_SSL,
            NULL,
            0,
            PUBLIC_BGN_URI,
            "null",
            file_websocket_data_handler,
            file_websocket_close_handler,
            (void *) &sync);

        if (!conn)
        {
            cerr << "Couldn't obtain BGN details" << endl;
            return 1;
        }

        unique_lock<mutex> lck(sync.mtx);
        char *filename = set_temp_filename(conn);
        sync.val = 0;

        mg_websocket_client_write(
            conn,
            MG_WEBSOCKET_OPCODE_DATACOMPLETE,
            "",
            0);

        while (!sync.val)
            sync.cv.wait(lck);

        mg_close_connection(conn);

        flag = true;
    }

    BGNPublicKey retval =
        get_bgn_public_key_from_file(&sync, filename);

    remove(filename);
    delete filename;

    return retval;
}

PrsonaClient *create_client(
    default_random_engine *generator,
    const vector<string> serverIPs,
    size_t numServers)
{
    BGNPublicKey publicKey =
        get_bgn_public_key(
            generator,
            serverIPs);

    vector<Proof> generatorProof;
    Twistpoint blindGenerator =
        get_generator(
            generator,
            serverIPs,
            generatorProof,
            false);

    return new PrsonaClient(generatorProof, blindGenerator, publicKey, numServers);
}

string make_vote_string(
    const vector<Proof>& pi,
    const vector<TwistBipoint>& newVotes,
    const Twistpoint& shortTermPublicKey)
{
    stringstream buffer;
    BinarySizeT sizeOfVector;

    sizeOfVector.set(pi.size());
    buffer << sizeOfVector;
    for (size_t i = 0; i < sizeOfVector.val(); i++)
        buffer << pi[i];

    sizeOfVector.set(newVotes.size());
    buffer << sizeOfVector;
    for (size_t i = 0; i < sizeOfVector.val(); i++)
        buffer << newVotes[i];

    buffer << shortTermPublicKey;

    BinaryBool shouldDeal(true);
    buffer << shouldDeal;

    return buffer.str();
}

void send_item(
    const string& target, const string& data, const char* whichUri)
{
    struct synchronization_tool sync;
    bool flag = false;
    while (!flag)
    {
        struct mg_connection *conn = mg_connect_websocket_client(
            target.c_str(),
            PRSONA_PORT,
            USE_SSL,
            NULL,
            0,
            whichUri,
            "null",
            synchro_websocket_data_handler,
            empty_websocket_close_handler,
            (void *) &sync);

        if (!conn)
        {
            cerr << "Couldn't obtain BGN details" << endl;
            continue;
        }

        unique_lock<mutex> lck(sync.mtx);
        sync.val = 0;

        mg_websocket_client_write(
            conn,
            MG_WEBSOCKET_OPCODE_BINARY,
            data.c_str(),
            data.length());

        mg_websocket_client_write(
            conn,
            MG_WEBSOCKET_OPCODE_DATACOMPLETE,
            "",
            0);

        while (!sync.val)
            sync.cv.wait(lck)

        mg_close_connection(conn);

        flag = true;
    }
}

void make_vote(
    default_random_engine& generator,
    const string& target,
    PrsonaClient* prsonaClient,
    const vector<string>& serverIPs,
    size_t numClients)
{
    uniform_int_distribution<size_t> voteDistribution(
        0, PrsonaBase::get_max_allowed_vote());

    // Make the correct number of new votes, but shuffle where they go
    vector<Scalar> votes;
    vector<bool> replaces;
    for (size_t j = 0; j < numClients; j++)
    {
        votes.push_back(Scalar(voteDistribution(generator)));
        replaces.push_back(j < numVotes);
    }
    shuffle(replaces.begin(), replaces.end(), generator);

    vector<Proof> generatorProof;
    Twistpoint freshGenerator =
        get_generator(
            generator,
            serverIPs,
            generatorProof,
            true);

    prsonaClient->receive_fresh_generator(
        generatorProof, freshGenerator);
    
    Twistpoint shortTermPublicKey =
        prsonaClient->get_short_term_public_key();

    vector<Proof> fullProof;
    vector<TwistBipoint> encryptedVotes =
        get_server_committed_val<vector<TwistBipoint>>(
            &generator,
            serverIPs,
            fullProof,
            shortTermPublicKey,
            VOTES_BY_URI,
            VOTES_BY_COMMIT_URI);
    
    vector<Proof> voteProof;
    encryptedVotes =
        prsonaClient->make_votes(
            currVoteProof,
            fullProof,
            encryptedVotes,
            votes,
            replaces);

    string data =
        make_vote_string(voteProof, encryptedVotes, shortTermPublicKey);

    send_item(target, data, GIVE_NEW_VOTE_URI);
}

string make_vote_string(
    const vector<Proof>& pi,
    const Twistpoint& shortTermPublicKey,
    const Scalar& threshold)
{
    stringstream buffer;
    BinarySizeT sizeOfVector;

    sizeOfVector.set(pi.size());
    buffer << sizeOfVector;
    for (size_t i = 0; i < sizeOfVector.val(); i++)
        buffer << pi[i];

    buffer << shortTermPublicKey;
    buffer << threshold;

    return buffer.str();
}

void make_reputation_proof(
    default_random_engine& generator,
    const string& target,
    PrsonaClient* prsonaClient,
    const vector<string>& serverIPs,
    size_t numClients)
{
    vector<Proof> generatorProof;
    Twistpoint freshGenerator =
        get_generator(
            generator,
            serverIPs,
            generatorProof,
            true);

    prsonaClient->receive_fresh_generator(
        generatorProof, freshGenerator);

    Twistpoint shortTermPublicKey =
        prsonaClient->get_short_term_public_key();

    vector<Proof> encryptedScoreProof;
    EGCiphertext encryptedScore =
        get_server_committed_val<EGCiphertext>(
            &generator,
            serverIPs,
            encryptedScoreProof,
            shortTermPublicKey,
            USER_TALLY_URI,
            USER_TALLY_COMMIT_URI);

    prsonaClient->receive_vote_tally(
        encryptedScoreProof,
        encryptedScore);

    Scalar threshold(0);

    vector<Proof> repProof =
        prsonaClient->generate_reputation_proof(
            threshold, numClients);

    string data =
        make_rep_proof_string(repProof, shortTermPublicKey, threshold);

    send_item(target, data, REP_PROOF_URI);
}

int main(int argc, char *argv[])
{
    initialize_prsona_classes();

#if USE_SSL
    mg_init_library(0);
#else
    mg_init_library(MG_FEATURES_SSL);
#endif
    
    const char *options[] = {"listening_ports", PRSONA_PORT, 0};

    vector<string> serverIPs, clientIPs;
    string selfIP;

    string seedStr = "seed";

    char buffer[40];
    ifstream serverConfig("serverIPs.cfg");
    while (!serverConfig.eof())
    {
        serverConfig.getline(buffer, 40);
        if (strlen(buffer) > 0)
            serverIPs.push_back(string(buffer));
    }

    ifstream clientConfig("clientIPs.cfg");
    while (!clientConfig.eof())
    {
        clientConfig.getline(buffer, 40);
        if (strlen(buffer) > 0)
            clientIPs.push_back(string(buffer));
    }

    ifstream selfConfig("selfIP.cfg");
    while (!selfConfig.eof())
    {
        selfConfig.getline(buffer, 40);
        if (strlen(buffer) > 0)
            selfIP = buffer;
    }

    // Defaults
    size_t numServers = serverIPs.size();
    size_t numClients = clientIPs.size();
    bool maliciousServers = true;
    uniform_int_distribution<size_t> distribution(0, numServers - 1);

    if (argc > 1)
    {
        bool setting = argv[1][0] == 't' || argv[1][0] == 'T';
        maliciousServers = setting;
    }

    seed_seq seed(seedStr.begin(), seedStr.end());
    default_random_engine generator(seed);

    cout << "Establishing PRSONA client with the following parameters: " << endl;
    cout << numServers << " PRSONA servers" << endl;
    cout << numClients << " PRSONA clients" << endl;
    cout << "Servers are set to " << (maliciousServers ? "MALICIOUS" : "HBC") << " security" << endl;
    cout << "This client is at IP address: " << selfIP << endl;
    cout << endl;

    // Set malicious flags where necessary
    if (maliciousServers)
        PrsonaBase::set_server_malicious();

    // Entities we operate with
    PrsonaClient *prsonaClient = create_client(numServers);
    CivetServer server(options);

    PrsonaClientWebSocketHandler wsHandler(prsonaClient, serverIPs, selfIP, &generator);
    server.addWebSocketHandler("/ws", wsHandler);

    unique_lock<mutex> exitLock(exitSync.mtx);
    exitSync.val = 0;
    exitSync.val2 = 0;
    RemoteControlHandler exitHandler(&exitSync, "Client coming down!");
    server.addHandler(EXIT_URI, exitHandler);

    AltRemoteControlHandler triggerVoteHandler(CLIENT_MAKE_VOTE, &exitSync, "Client will make new votes!");
    server.addHandler(TRIGGER_VOTE_URI, triggerVoteHandler);

    AltRemoteControlHandler triggerRepHandler(CLIENT_MAKE_REP_PROOF, &exitSync, "Client will make new votes!");
    server.addHandler(TRIGGER_REP_URI, triggerRepHandler);

    while (!exitSync.val)
    {
        while (!exitSync.val && !exitSync.val2)
            exitSync.cv.wait(lck);

        size_t whichServer = distribution(generator);

        switch (exitSync.val2)
        {
            case CLIENT_MAKE_VOTE:
                make_vote(
                    serverIPs[whichServer],
                    prsonaClient);
                break;

            case CLIENT_MAKE_REP_PROOF:
                make_reputation_proof(
                    triggerRepHandler.query(),
                    prsonaClient);
                break;

            default:
                break;
        }

        exitSync.val2 = 0;
    }

    mg_exit_library();

    delete prsonaClient;

    return 0;
}