arithmtest.cpp

Go to the documentation of this file.

#include <cstdlib>
#include <cstring>
#include <iostream>
#include <fstream>

#include "arithm.hpp"

using namespace arithm;

#define PATH_TO_INPUT_FILE  "./input.txt"
#define PATH_TO_OUTPUT_FILE "./actual_output.txt"
#define STATISTICAL_ERROR 100
#define N_RAND_ARRAYS 3


void test_ModPGrp_toByteTree(std::ifstream &input,
                             std::ofstream &output)
{
        verifierUtils::ByteTree * bt = NULL;
        std::string line;
        while (input>>line)
        {
                bt = verifierUtils::ByteTree::parseString(line);
                ModPGrp modpgrp(bt);
                output<<modpgrp.toByteTree()->toString()<<std::endl;
        }
        free(bt);
}


void test_ModPGrp_exponentiation(std::ifstream &input,
                                 std::ofstream &output)
{
        mpz_class exp;
        verifierUtils::ByteTree * bt;
        std::string line;
        while (input>>line)
        {
                bt = verifierUtils::ByteTree::parseString(line);
                ModPGrp modpgrp(bt);

                bt = verifierUtils::ByteTree::parseString(line);
                Elmt elm = modpgrp.getElmt(bt);

                bt = verifierUtils::ByteTree::parseString(line);
                Elmt exp(bt->toInteger(), NULL);

                elm = modpgrp.exponentiation(elm,exp);
                bt = new verifierUtils::Leaf(elm.getValue());

                output<<bt->toString()<<std::endl;
        }
        free(bt);
}


void test_ModPGrp_multiplication(std::ifstream &input,
                                 std::ofstream &output)
{
        verifierUtils::ByteTree * bt;
        std::string line;
        while (input>>line)
        {
                bt = verifierUtils::ByteTree::parseString(line);
                ModPGrp modpgrp(bt);

                bt = verifierUtils::ByteTree::parseString(line);
                Elmt elm1 = modpgrp.getElmt(bt);

                bt = verifierUtils::ByteTree::parseString(line);
                Elmt elm2 = modpgrp.getElmt(bt);

                Elmt res = modpgrp.multiplication(elm1,elm2);
                bt = new verifierUtils::Leaf(res.getValue());
                output<<bt->toString()<<std::endl;
        }
        free(bt);
}


void test_ModPGrp_getRandArray(
        std::ifstream &input, std::ofstream &output)
{
        verifierUtils::ByteTree * bt;
        std::vector<uint8_t> seed(32,0);
        cryptoTools::SHAx * hash = new cryptoTools::SHA256();
        cryptoTools::PRG * prg = new cryptoTools::PRG(hash);
        std::string line;
        while (input>>line)
        {
                // reading group
                bt = verifierUtils::ByteTree::parseString(line);
                ModPGrp modpgrp(bt);

                // reading seed
                for (unsigned int i=0; i<seed.size(); i++)
                {
                        unsigned int read;
                        input>>read;
                        seed[i] = read;
                }
                prg->initialize(seed);
                // generating an array in the ModPGrp using the seed
                for (unsigned int i=0; i<N_RAND_ARRAYS; i++)
                {
                        unsigned int size;
                        input>>size;
                        ArrayOfElmts arr = modpgrp.getRandArray(prg,STATISTICAL_ERROR,size);
                        for (unsigned int j=0; j<arr.size(); j++)
                                output<<arr.getElmt(j).toByteTree()->toString()<<std::endl;
                }
        }
        free(bt);
}


void test_ModPGrp_product(std::ifstream &input,
                                      std::ofstream &output)
{
        verifierUtils::ByteTree * bt;
        std::string line;
        while (input>>line)
        {
                bt = verifierUtils::ByteTree::parseString(line);
                ModPGrp modpgrp(bt);
 
                bt = verifierUtils::ByteTree::parseString(line);
                ArrayOfElmts ar = modpgrp.getArray(bt);
                
                bt = modpgrp.product(ar).toByteTree();
                output<<bt->toString()<<std::endl;
        }
}


void test_ModPGrp_expProduct(std::ifstream &input,
                                      std::ofstream &output)
{
        verifierUtils::ByteTree * bt;
        std::string line;
        while (input>>line)
        {
                bt = verifierUtils::ByteTree::parseString(line);
                ModPGrp modpgrp(bt);
                ModField modfield(bt->getChild(0)->toInteger());

                bt = verifierUtils::ByteTree::parseString(line);
                ArrayOfElmts ar = modpgrp.getArray(bt);

                bt = verifierUtils::ByteTree::parseString(line);
                ArrayOfElmts ex = modfield.getArray(bt);

                Elmt res = modfield.expProduct(ar,ex);
                output<<res.toByteTree()->toString()<<std::endl;
        }
}


void printHelp()
{
        std::cout<<"Run ./arithm_test <function to test> and it will parse"
                 << "the"<<PATH_TO_INPUT_FILE<< "file to produce the "
                 <<PATH_TO_OUTPUT_FILE<<" file.  If this is giberish to you,"
                 <<"you\nshould read the documentation ^^"<<"\n\n"
                 <<"Available functions are:"<<"\n"
                 <<" - ModPGrp.toByteTree\n"
                 <<" - ModPGrp.exponentiation\n"
                 <<" - ModPGrp.multiplication\n"
                 <<" - ModPGrp.getRandArray\n"
                 <<" - ModPGrp.product\n"
                 <<" - ModPGrp.expProduct\n"
                 <<"\n"<<std::endl;
}


int main(int argc, char ** argv)
{
        if (argc<2)
                printHelp();
        else
        {
                std::ifstream input(PATH_TO_INPUT_FILE,
                                    std::ifstream::in);
                std::ofstream output(PATH_TO_OUTPUT_FILE);
                if (strcmp(argv[1],"ModPGrp.toByteTree") == 0)
                        test_ModPGrp_toByteTree(input,output);
                else if (strcmp(argv[1], "ModPGrp.exponentiation") == 0)
                        test_ModPGrp_exponentiation(input,output);
                else if (strcmp(argv[1], "ModPGrp.multiplication") == 0)
                        test_ModPGrp_multiplication(input,output);
                else if (strcmp(argv[1], "ModPGrp.getRandArray") == 0)
                        test_ModPGrp_getRandArray(input,output);
                else if (strcmp(argv[1], "ModPGrp.product") == 0)
                        test_ModPGrp_product(input,output);
                else if (strcmp(argv[1], "ModPGrp.expProduct") == 0)
                        test_ModPGrp_expProduct(input,output);
                else
                        printHelp();
                output.close();
        }
        return 0;
}