proofofcorrectdecryption.cpp

Go to the documentation of this file.

#include "../elgamal/elgamal.hpp"

#include "proofofcorrectdecryption.hpp"
#include "verification.hpp"


using namespace proofs;


ProofOfCorrectDecryption::ProofOfCorrectDecryption(
        bool &readingWasOK,
        XmlConfig * config,
        std::vector<uint8_t> prefix,
        unsigned int N,
        arithm::Elmt partialJointKey,
        elGamal::CipherGroup cipherTextsGrp,
        arithm::Group * plainTextGrp,
        elGamal::ArrayOfCiphers inputCiphers,
        arithm::ArrayOfElmts decryptionFactors,
        verifierUtils::ByteTree * commitmentFSproof,
        verifierUtils::ByteTree * replyFSproof)
        :
        Verification(config,prefix,N),
        y(partialJointKey),
        C(cipherTextsGrp),
        M(plainTextGrp),
        w(inputCiphers),
        f(decryptionFactors)
{
        readingWasOK = true;

        // checking arrays' sizes
        if (w.size() != n0)
        {
                std::cout<<"ERROR: in ProofOfCorrectDecryption:"
                         <<"number of input ciphers does not match N:"
                         <<"\nN="<<n0
                         <<"\nw->getSize()="<<w.size()<<std::endl;
                readingWasOK = false;
        }
        if (f.size() != n0)
        {
                std::cout<<"ERROR: in ProofOfCorrectDecryption:"
                         <<"number of decryption factors does not match N:"
                         <<"\nN="<<n0
                         <<"\nf->getSize()="<<f.size()<<std::endl;
                readingWasOK = false;
        }

        // Assigning bytetrees
        tau = commitmentFSproof;
        if ((tau->size()<2) || (!tau->isNode())
            || (!tau->getChild(0)->isLeaf())
            || (!tau->getChild(1)->isNode())
            || (!tau->getChild(1)->getChild(0)->isLeaf())
                )
        {
                std::cout<<"ERROR: in ProofOfCorrectDecryption:"
                         <<"tau is not valid.\ntau="
                         <<tau->toString()<<std::endl;
                readingWasOK = false;
        }
        sigma = replyFSproof;
        if (!sigma->isLeaf())
        {
                std::cout<<"ERROR: in ProofOfCorrectDecryption:"
                         <<"sigma is not valid.\nsigma="
                         <<sigma->toString()<<std::endl;
                readingWasOK = false;
        }
}


bool ProofOfCorrectDecryption::isEverythingOK()
{
        // 1-a Parsing tau
        arithm::Elmt
                yPrime = gq->getElmt(tau->getChild(0)),
                BPrime = M->getArray(tau->getChild(1)).getElmt(0);

        // 1-b Parsing sigma
        arithm::Elmt kx = zq->getElmt(sigma);
        

        // 2- compute the bytetree part of s
        std::vector<uint8_t> s;
        verifierUtils::ByteTree
                * bts  = new verifierUtils::Node(),
                * sub1 = new verifierUtils::Node(),
                * sub2 = new verifierUtils::Node();
        sub1->addChild(gq->getGenerator().toByteTree());
        sub1->addChild(w.toByteTree());
        bts->addChild(sub1);
        sub2->addChild(y.toByteTree());
        sub2->addChild(f.toByteTree());
        bts->addChild(sub2);
        
                
        // 3- compute A
        arithm::ArrayOfElmts e = randomExponents(bts,s);
        elGamal::CipherText A = C.expProduct(w,e);
        arithm::Elmt B = gq->expProduct(f,e);
        

        // 4- compute a challenge v
        arithm::Elmt v = getChallenge(s);


        // First verification
        arithm::Elmt
                lhs = gq->multiplication(
                        gq->exponentiation(y,v),
                        yPrime
                        ),
                rhs = gq->exponentiation(
                        gq->getGenerator(),
                        kx
                        );
        if ( !gq->compare(lhs,rhs) )
        {
                std::cout<<"In ProofOfCorrectDecryption, $y^v y'$ does "
                         <<"not equal $g^{k_x}$"<<std::endl;
                return false;
        }

        // Second verification
        lhs = M->multiplication(
                M->exponentiation(B,v),
                BPrime
                );
        rhs = C.pdec(kx,A);
        if ( !gq->compare(lhs,rhs) )
        {
                std::cout<<"In ProofOfCorrectDecryption, $B^v B'$ does "
                         <<"not equal $PDec_{k_x}(A)$"<<std::endl;
                return false;
        }



        // If we reached this point, everything went perfectly!
        return true;
}