verification.cpp

Go to the documentation of this file.

#include "verification.hpp"

using namespace proofs;


Verification::Verification(XmlConfig * config,
                           std::vector<uint8_t> prefix,
                           unsigned int nZero)
{
        protocolFile = config;
        
        // initializing constants
        n0 = nZero;
        ne = protocolFile->getVbitlenro();
        nr = protocolFile->getStatdist();
        nv = protocolFile->getCbitlenro();
        H = protocolFile->getRohash();
        prg = new cryptoTools::PRG(protocolFile->getPrghash());
        gq = protocolFile->getPgroup();
        zq = new arithm::ModField(gq->getMultOrder());
        rho = prefix;

        // initializing the random oracles
        ROs = new cryptoTools::RO(H,protocolFile->getPrghash()->getHashLength());
        ROv = new cryptoTools::RO(H,protocolFile->getCbitlenro());

        // initialising the independant random generators
        verifierUtils::ByteTree * bt =
                verifierUtils::ByteTree::string2ByteTree("generators");
        std::vector<uint8_t> seed = rho, s, btVector(bt->toVector());
        seed.insert(seed.end(),btVector.begin(),btVector.end());
        s = ROs->query(seed);
        prg->initialize(s);
        h = gq->getRandArray(prg,nr,n0);
}


arithm::ArrayOfElmts Verification::randomExponents(
        verifierUtils::ByteTree * bts, std::vector<uint8_t> &s)
{
        // first, we compute the seed s
        std::vector<uint8_t>  queryROs = rho, btsVector(bts->toVector());
        queryROs.insert(queryROs.end(),
                        btsVector.begin(),btsVector.end());
        s = ROs->query(queryROs);
        
        // then, we use the prg's output to compute the exponents
        prg->initialize(s);
        arithm::ArrayOfElmts e;
        unsigned int eiByteLength = ne/8;
        mpz_class twoToTheNe = 2;
        mpz_pow_ui(twoToTheNe.get_mpz_t(),twoToTheNe.get_mpz_t(),ne);
        for (unsigned int i=0; i<n0; i++)
        {
                mpz_class ei = 0;
                for (unsigned int j=0; j<eiByteLength; j++)
                        ei = ei*0x100 + prg->getNextRandByte();
                ei = ei % twoToTheNe;
                e.addElmt(arithm::Elmt(ei,NULL));
        }
        return e;
}


arithm::Elmt Verification::getChallenge(std::vector<uint8_t> s)
{
        verifierUtils::ByteTree * btv = new verifierUtils::Node();
        btv->addChild(new verifierUtils::Leaf(s));
        btv->addChild(tau);
        std::vector<uint8_t> vBytes, queryROv = rho, btvVector(btv->toVector());
        queryROv.insert(queryROv.end(), btvVector.begin(), btvVector.end());
        vBytes = ROv->query(queryROv);
        mpz_class v = 1, modulo = 2;
        for (unsigned int i=0; i<nv/8; i++)
                v = v*0x100 + vBytes[i];
        mpz_pow_ui(
                modulo.get_mpz_t(),
                modulo.get_mpz_t(),
                nv);
        return arithm::Elmt(v % modulo,NULL);
}


arithm::ArrayOfElmts Verification::getGenerators()
{
        return h;
}


bool Verification::isEverythingOK()
{
        return false;
}