group.cpp

Go to the documentation of this file.

#include "group.hpp"


using namespace arithm;


Group::Group(mpz_class order, mpz_class gen)
{
        multOrder = order;
        generator = gen;
}


verifierUtils::ByteTree * Group::toByteTree()
{
        return NULL;
}


// ------------------------------------------ element operations


Elmt Group::multiplication(Elmt e1, Elmt e2)
{
        return Elmt(0,this);
}


Elmt Group::multInverse(Elmt e)       
{
        return Elmt(0,this);
}


Elmt Group::exponentiation(Elmt e, Elmt s)
{
        return Elmt(0,this);
}


bool Group::compare(Elmt e1, Elmt e2)
{
        return (e1.getValue() == e2.getValue());
}


// ------------------------------------------- array operations


ArrayOfElmts Group::multiplication(ArrayOfElmts e1, ArrayOfElmts e2)
{
        if (e1.size() != e2.size())
        {
                std::cout<<"ERROR: in Group.multiplication(e1,e2), "
                         <<"arrays are not of the same size."
                         <<"\ne1.size()="<<e1.size()
                         <<"\ne2.size()="<<e2.size()<<std::endl;
                exit(1);
        }
        ArrayOfElmts result;
        for (unsigned int i=0; i<e1.size(); i++)
                result.addElmt(
                        multiplication(e1.getElmt(i), e2.getElmt(i)));
        return result;
}


ArrayOfElmts Group::multInverse(ArrayOfElmts e)
{
        ArrayOfElmts result;
        for (unsigned int i=0; i<e.size(); i++)
                result.addElmt(multInverse(e.getElmt(i)));
        return result;
}


ArrayOfElmts Group::exponentiation(ArrayOfElmts e, ArrayOfElmts s)
{
        if (e.size() != s.size())
        {
                std::cout<<"ERROR: in Group.exponentiation(e,s), "
                         <<"arrays are not of the same size."
                         <<"\ne.size()="<<e.size()
                         <<"\ns.size()="<<s.size()<<std::endl;
                exit(1);
        }
        ArrayOfElmts result;
        for (unsigned int i=0; i<e.size(); i++)
                result.addElmt(
                        exponentiation(e.getElmt(i), s.getElmt(i)));
        return result;
}



Elmt Group::product(ArrayOfElmts e)
{
        Elmt result = getOne();
        for (unsigned int i=0; i<e.size(); i++)
                result = multiplication(result,e.getElmt(i));
        return result;
}


Elmt Group::expProduct(ArrayOfElmts e, ArrayOfElmts s)
{

        if (e.size() != s.size())
        {
                std::cout<<"ERROR: in Group.expProduct(e,s), "
                         <<"arrays are not of the same size."
                         <<"\ne.size()="<<e.size()
                         <<"\ns.size()="<<s.size()<<std::endl;
                exit(1);
        }
        Elmt result = getOne();
        for (unsigned int i=0; i<e.size(); i++)
                result = multiplication(
                        result,
                        exponentiation(e.getElmt(i),s.getElmt(i)));
        return result;
}



bool Group::compare(ArrayOfElmts e1, ArrayOfElmts e2)
{
        for (unsigned int i=0; i<e1.size(); i++)
                if (! compare(e1.getElmt(i),e2.getElmt(i)) )
                        return false;
        return true;
}


// ------------------------------------------- encoding/decoding


Elmt Group::encode(std::vector<uint8_t> message)
{
        return Elmt(0,this);
}


std::vector<uint8_t> Group::decode(Elmt e)
{
        std::vector<uint8_t> dummyResult;
        return dummyResult;
}


// ------------------------------------------- obtaining elements


Elmt Group::getOne()
{
        return getElmt(1);
}


ArrayOfElmts Group::getOne(unsigned int n)
{
        ArrayOfElmts result;
        for (unsigned int i=0; i<n; i++)
                result.addElmt(getOne());
        return result;
}


Elmt Group::getElmt(mpz_class repr)
{
        return Elmt(repr,this);
}


Elmt Group::getElmt(verifierUtils::ByteTree * bt)
{
        if (!bt->isLeaf())
        {
                std::cout<<"ERROR: in Group.getElmt(bt), bt is not a "
                         <<"Leaf.\nbt=";
                bt->prettyPrint("");
                std::cout<<std::endl;
                exit(1);
        }
        return Elmt(bt->toInteger(),this);
}


ArrayOfElmts Group::getArray(verifierUtils::ByteTree * bt)
{
        ArrayOfElmts result;
        if (!bt->isNode())
        {
                std::cout<<"ERROR: in Group.getArray(bt), bt is not a "
                         <<"Node.\nbt=";
                bt->prettyPrint("");
                std::cout<<std::endl;
                exit(1);
        }
        for (unsigned int i=0; i<bt->size(); i++)
                result.addElmt(getElmt(bt->getChild(i)));
        return result;
}


ArrayOfElmts Group::getRandArray(cryptoTools::PRG * prg,
                                   unsigned int nr,
                                   unsigned int n0)
{
        return ArrayOfElmts();
}



// ------------------------------- data about the group


mpz_class Group::getMultOrder()
{
        return multOrder;
}


unsigned int Group::getLeafSize()
{
        return mpz_sizeinbase(multOrder.get_mpz_t(),2);
}


Elmt Group::getGenerator()
{
        return getElmt(generator);
}


ArrayOfElmts Group::getGenerator(unsigned int n)
{
        ArrayOfElmts result;
        for (unsigned int i=0; i<n; i++)
                result.addElmt(getGenerator());
        return result;
}


bool Group::isIn(mpz_class repr)
{
        return true;
}


std::string Group::getType()
{
        return "Group";
}