ciphergroup.cpp

Go to the documentation of this file.

#include "ciphertext.hpp"
#include "ciphergroup.hpp"
#include "arrayofciphers.hpp"

using namespace elGamal;



CipherGroup::CipherGroup(arithm::Group * group)
{
        grp = group;
}


arithm::Group * CipherGroup::getGrp()
{
        return grp;
}


CipherText CipherGroup::getCipherText(verifierUtils::ByteTree * bt)
{
        return CipherText(bt,*this);
}


ArrayOfCiphers CipherGroup::getArrayOfCiphers(
        verifierUtils::ByteTree * bt)
{
        return ArrayOfCiphers(bt,*this);
}


// -------------------------------------------- Encryption/Decryption



CipherText CipherGroup::enc(arithm::Elmt y, arithm::Elmt m,
                            arithm::Elmt s)
{
        arithm::Elmt u = grp->exponentiation(grp->getGenerator(),s);
        arithm::Elmt v = grp->multiplication(grp->exponentiation(y,s),m);
        return CipherText(u,v);
}


arithm::Elmt CipherGroup::dec(arithm::Elmt x, CipherText uv)
{
        return grp->multiplication(
                grp->exponentiation(grp->multInverse(uv.getU()),x),
                uv.getV());
}


arithm::Elmt CipherGroup::pdec(arithm::Elmt xl, CipherText uv)
{
        return grp->exponentiation(uv.getU(),xl);
}


arithm::ArrayOfElmts CipherGroup::pdec(arithm::Elmt xl, ArrayOfCiphers uv)
{
        arithm::ArrayOfElmts result;
        for (unsigned int i=0; i<uv.size(); i++)
                result.addElmt(pdec(xl, uv.getCipherText(i)));
        return result;
}


arithm::Elmt CipherGroup::tdec(CipherText uv, arithm::Elmt f)
{
        return grp->multiplication(uv.getV(),grp->multInverse(f));
}


arithm::ArrayOfElmts CipherGroup::tdec(ArrayOfCiphers uv, arithm::ArrayOfElmts f)
{
        arithm::ArrayOfElmts result;
        for (unsigned int i=0; i<uv.size(); i++)
                result.addElmt(tdec(uv.getCipherText(i),f.getElmt(i)));
        return result;
}


// ------------------------------------------------ Group operations



CipherText CipherGroup::exponentiation(CipherText c, arithm::Elmt s)
{
        return CipherText(grp->exponentiation(c.getU(),s),
                          grp->exponentiation(c.getV(),s));
                          
}


CipherText CipherGroup::multiplication(CipherText c1, CipherText c2)
{
        return CipherText(grp->multiplication(c1.getU(),c2.getU()),
                          grp->multiplication(c1.getV(),c2.getV()));
}


ArrayOfCiphers CipherGroup::exponentiation(ArrayOfCiphers c,
                                           arithm::ArrayOfElmts s)
{
        return ArrayOfCiphers(grp->exponentiation(c.getUarray(),s),
                              grp->exponentiation(c.getVarray(),s));
}


CipherText CipherGroup::expProduct(ArrayOfCiphers c,
                                   arithm::ArrayOfElmts s)
{
        return CipherText(grp->expProduct(c.getUarray(),s),
                          grp->expProduct(c.getVarray(),s));
}


bool CipherGroup::compare(CipherText c1, CipherText c2)
{
        return (  (grp->compare(c1.getU(), c2.getU())) &&
                  (grp->compare(c1.getV(), c2.getV()))  );
}


bool CipherGroup::compare(ArrayOfCiphers c1, ArrayOfCiphers c2)
{
        for (unsigned int i=0; i<c1.size(); i++)
                if (! compare(c1.getCipherText(i), c2.getCipherText(i)) )
                        return false;
        return true;
}