proofs::ProofOfShuffleOfCiphers Class Reference

Performs a proof of shuffle of ciphers. It is an implementation of the Verfication class. More...

#include <proofofshuffleofciphers.hpp>

Inheritance diagram for proofs::ProofOfShuffleOfCiphers:

Collaboration diagram for proofs::ProofOfShuffleOfCiphers:

Public Member Functions
	ProofOfShuffleOfCiphers (bool &readingWasOK, XmlConfig *config, std::vector< uint8_t > prefix, arithm::ArrayOfElmts pedersen, unsigned int N, arithm::Field *randomizerGrp, elGamal::CipherGroup cipherTextsGrp, arithm::Elmt elGamalPkey, elGamal::ArrayOfCiphers inputCiphers, elGamal::ArrayOfCiphers outputCiphers, verifierUtils::ByteTree *commitmentFSproof, verifierUtils::ByteTree *replyFSproof)
	Creates an instance of a ProofOfShuffleOfCiphers class by setting all of its attributes.
bool	isEverythingOK ()
	Checks that the mix-servers re-encrypted and permuted the ciphered votes as they were commited to.
Public Member Functions inherited from proofs::Verification
	Verification (XmlConfig *config, std::vector< uint8_t > prefix, unsigned int nZero)
	Creates an instance of a Verification class by setting its two attributes.
arithm::ArrayOfElmts	randomExponents (verifierUtils::ByteTree *bts, std::vector< uint8_t > &s)
	Used to compute a random exponents vector according to the specification.
arithm::Elmt	getChallenge (std::vector< uint8_t > s)
	Returns a challenge computed from the original seed s and a bytetree.
arithm::ArrayOfElmts	getGenerators ()
	Returns the h attribute.

Private Attributes
arithm::ArrayOfElmts	u
	, an array of Pedersen commitments in .
arithm::Field *	R
	The randomizer field .
elGamal::CipherGroup	C
	The cipher group .
arithm::Elmt	pk
	The El-Gamal public key.
elGamal::ArrayOfCiphers	w
	The array containing the input cipher texts.
elGamal::ArrayOfCiphers	wPrime
	The array containing the output cipher texts.

Additional Inherited Members
Protected Attributes inherited from proofs::Verification
XmlConfig *	protocolFile
	A class containing the information in the protocol info file.
cryptoTools::SHAx *	H
	The hashfunction to be used by the random oracles.
cryptoTools::RO *	ROs
	The random oracle to use to seed the PRG.
cryptoTools::RO *	ROv
	The random oracle to use to generate challenges.
std::vector< uint8_t >	rho
	, a prefix for the random oracle.
unsigned int	n0
	(or ), the size of the arrays.
unsigned int	ne
	, number of bits in each component of random vectors used for batching.
unsigned int	nr
	, acceptable "statistical error" when deriving independent generators.
unsigned int	nv
	, number of bits in challenges.
cryptoTools::PRG *	prg
	Pseudo-random generator used to derive random vectors for batching.
arithm::Group *	gq
	a group of prime order with characteristic .
arithm::Field *	zq
	The field in which the exponent live, .
arithm::ArrayOfElmts	h
	An array of independant generators .
verifierUtils::ByteTree *	tau
	The commitment of the Fiat-Shamir proof, .
verifierUtils::ByteTree *	sigma
	The reply of the Fiat-Shamir proof, .

Detailed Description

Performs a proof of shuffle of ciphers. It is an implementation of the Verfication class.

The operation performed in this class are just implementation of the verificatum verifier specification, namely page 16.

Definition at line 30 of file proofofshuffleofciphers.hpp.

Constructor & Destructor Documentation

ProofOfShuffleOfCiphers::ProofOfShuffleOfCiphers	(	bool &	readingWasOK,
		XmlConfig *	config,
		std::vector< uint8_t >	prefix,
		arithm::ArrayOfElmts	pedersen,
		unsigned int	N,
		arithm::Field *	randomizerGrp,
		elGamal::CipherGroup	cipherTextsGrp,
		arithm::Elmt	elGamalPkey,
		elGamal::ArrayOfCiphers	inputCiphers,
		elGamal::ArrayOfCiphers	outputCiphers,
		verifierUtils::ByteTree *	commitmentFSproof,
		verifierUtils::ByteTree *	replyFSproof
	)

Creates an instance of a ProofOfShuffleOfCiphers class by setting all of its attributes.

Checks also whether or not tau and sigma will contain the data needed for the rest of the computations to run smoothly. Verifies that the size of the arrays is equal to N.

If any variable is wrong, readingWasOK takes the value false. Otherwise, this variable is equal to true at the end of the construction.

Parameters

[out]	readingWasOK	Is false at the end of the construction if there was a problem.
	config	The protocol info file to use.
	prefix	The value to give to the rho attribute.
	pedersen	Arrays of Pedersen commitments.
	N	The actual number ciphers
	randomizerGrp	The randomizer group.
	cipherTextsGrp	The ciphertext group.
	elGamalPkey	The El-Gamal public key.
	inputCiphers	The ciphers to check.
	outputCiphers	The shuffled ciphers — or are they?
	commitmentFSproof	Commitments of the Fiat-Shamir proof.
	replyFSproof	Reply of the Fiat-Shamir proof.

Definition at line 18 of file proofofshuffleofciphers.cpp.

        :
        Verification(config,prefix,N),
        u(pedersen),
        R(randomizerGrp),
        C(cipherTextsGrp),
        pk(elGamalPkey),
        w(inputCiphers),
        wPrime(outputCiphers)
{
        readingWasOK = true;
        
        // checking the arrays' sizes
        if (u.size() != n0)
        {
                std::cout<<"ERROR: in ProofOfShuffleOfCommitments:"
                         <<"u is not of the correct size."
                         <<"u->getSize()="<<u.size()
                         <<"n0="<<n0<<std::endl;
                readingWasOK = false;
        }
        if (w.size() != n0)
        {
                std::cout<<"ERROR: in ProofOfShuffleOfCiphers:"
                         <<"number of input ciphers does not match N:"
                         <<"\nN="<<n0
                         <<"\nw->getSize()="<<w.size()<<std::endl;
                readingWasOK = false;
        }
        if (wPrime.size() != n0)
        {
                std::cout<<"ERROR: in ProofOfShuffleOfCiphers:"
                         <<"number of output ciphers does not match N:"
                         <<"\nN="<<n0
                         <<"\nwPrime->getSize()="<<wPrime.size()<<std::endl;
                readingWasOK = false;
        }

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