modpgrp.cpp

Go to the documentation of this file.

#include "modpgrp.hpp"
#include "../field/modfield.hpp"

using namespace arithm;


ModPGrp::ModPGrp(mpz_class ord, mpz_class add,
                 mpz_class gen, uint8_t encoding) :
        PSubGroup(new ModField(add), ord, gen)
{
        code = encoding;
        addOrder = add;
}


ModPGrp::ModPGrp(verifierUtils::ByteTree * bt) :
        PSubGroup(new ModField(bt->getChild(0)->toInteger()),
                  bt->getChild(1)->toInteger(),
                  bt->getChild(2)->toInteger())
{
        if (!bt->isNode())
        {
                std::cout<<"ERROR: in ModPGrp(bt), bt is not a node. "
                         <<"\nbt=";
                bt->prettyPrint("");
                std::cout<<std::endl;
                exit(1);
        }
        addOrder = bt->getChild(0)->toInteger();
        code = bt->getChild(3)->toInteger().get_ui();
}


verifierUtils::ByteTree * ModPGrp::toByteTree()
{
        unsigned int length = getLeafSize();
        verifierUtils::ByteTree * res = new verifierUtils::Node();
        res->addChild(new verifierUtils::Leaf(addOrder,length));
        res->addChild(new verifierUtils::Leaf(multOrder,length));
        res->addChild(new verifierUtils::Leaf(generator,length));
        res->addChild(new verifierUtils::Leaf(code,4));
        return res;
}


ArrayOfElmts ModPGrp::getRandArray(cryptoTools::PRG * prg, unsigned int nr,
                          unsigned int n0)
{
        ArrayOfElmts result;
        unsigned int np = mpz_sizeinbase(addOrder.get_mpz_t(),2);
        unsigned int tiLength = (np+nr)/8; // The byte length of the
                                           // t_i:s
        mpz_class ti(0);
        mpz_class base(2),
                modulo(0);
        mpz_pow_ui(modulo.get_mpz_t(),
                   base.get_mpz_t(),
                   np+nr);
        for (unsigned int i=0; i<n0; i++)
        {
                ti = 0;
                for (unsigned int j=0; j<=tiLength; j++)
                        ti = ti*0x100 + prg->getNextRandByte();
                ti = (ti % modulo);
                // don't use ->exponentiation as 'ti' may well
                // not be in 'field'
                mpz_powm(ti.get_mpz_t(),
                         ti.get_mpz_t(),
                         coOrder.get_mpz_t(),
                         addOrder.get_mpz_t());
                result.addElmt(getElmt(ti));
        }
        return result;
}


// ---------------------------------- encoding


// void ModPGrpElmt::encode0(std::vector<uint8_t> message)
// {
//         if (message.size() > 3)
//         {
//                 std::cout<<"ERROR: in ModPGrpElmt.encode0, message to "
//                         "encode too big for encoding type 0 (size: "
//                          <<message.size()<<"). Aborting."<<std::endl;
//                 exit(1);
//         }
//         else
//         {
//                 cryptoTools::SHAx * H = new cryptoTools::SHA256();
//                 RingElmt * a = baseField->getGenerator();
//                 bool found = false;
//                 // Finding an element in the group that fits
//                 while (!found)
//                 {
//                         H->hash(a->toByteTree()->toVector());
//                         // testing the validity of the element
//                         if (
//                                 (H->getHash()[0] % 4 == message.size())
//                                 &&(H->getHash()[1] == message[0])
//                                 &&(H->getHash()[2] == message[1])
//                                 &&(H->getHash()[3] == message[2])
//                                 )
//                         {
//                                 representative = a->getRepresentative();
//                                 found = true;
//                         }
//                         else
//                                 a = baseField->multiplication(a,a);
//                 }
//         }
// }


// void ModPGrpElmt::encode1(std::vector<uint8_t> message)
// {
//         unsigned int b = (baseField->getAdditiveOrderByteSize()-2)/8 - 4;
//         if (message.size() > b)
//         {
//                 std::cout<<"ERROR: in ModPGrpElmt.encode1, message to "
//                         "encode too big for encoding type 1 (size: "
//                          <<message.size()<<"). Aborting."<<std::endl;
//                 exit(1);  
//         }
//         else
//         {
//                 uint32_t bm = message.size();
//                 std::vector<uint8_t> mPrime(b,0);
//                 if (message.size() == 0)
//                         mPrime[0] = 1;
//                 else
//                         for (unsigned int i=0; i<bm; i++)
//                                 mPrime[i] = message[i];
//                 mpz_class k=bm;
//                 for (unsigned int i=0; i<mPrime.size(); i++)
//                         k = k*0x100 + mPrime[i];
//                 representative = (baseField->isInField(k))? 
//                         k : baseField->getAdditiveOrder() - k;
//         }
// }



// void ModPGrpElmt::encode2(std::vector<uint8_t> message)
// {
//         unsigned int n = baseField->getAdditiveOrderByteSize();
//         mpz_class tBis = (baseField->getAdditiveOrder()-1)/baseField->getMultiplicativeOrder();
//         unsigned int t = tBis.get_ui();
//         unsigned int b = n/8 - (t/8+1) - 4;
//         unsigned int bm= message.size();
//         if (message.size() > b)
//         {
//                 std::cout<<"ERROR: in ModPGrpElmt.encode2, message to "
//                         "encode too big for encoding type 2 (size: "
//                          <<message.size()<<"). Aborting."<<std::endl;
//                 exit(1);  
//         }
//         else
//         {
//                 mpz_class k = bm;
//                 for (unsigned int i=0; i<bm; i++)
//                         k = k*0x100 + message[i];
//                 for (unsigned int i=0; i<b-bm; i++)
//                         k = k*0x100;
//                 mpz_class pow2i = 2;
//                 mpz_pow_ui(pow2i.get_mpz_t(), pow2i.get_mpz_t(), 8*(b+4));
//                 unsigned int i=0;
//                 while (!baseField->isInField(k))
//                         k = k + i*pow2i;
//                 representative = k;
//         }
// }



// void ModPGrpElmt::encode(std::vector<uint8_t> message)
// {
//         switch (baseField->getEncodingType()) {
//         case 0:
//                 return encode0(message);
//         case 1:
//                 return encode1(message);
//         case 2:
//                 return encode2(message);
//         default:
//         {
//                 std::cout<<"ERROR: in ModPGrp.encode(), encoding type "
//                         "non (or badly) initialised (e="
//                          <<baseField->getEncodingType()<<")"<<std::endl;
//                 exit(1);
//         }
//         }
// }




// // ==================================================================
// // ================================================== DECODING ======

// std::vector<uint8_t> ModPGrpElmt::decode()
// {
//         switch (baseField->getEncodingType()) {
//         case 0:
//                 return decode0();
//         case 1:
//                 return decode1();
//         case 2:
//                 return decode2();
//         default:
//         {
//                 std::cout<<"ERROR: in ModPGrp, encoding type non"
//                          <<" (or badly) initialised (e="
//                          <<baseField->getEncodingType()<<")"<<std::endl;
//                 exit(1);
//         }
//         }
// }


// std::vector<uint8_t> ModPGrpElmt::decode0()
// {
//         cryptoTools::SHAx * H = new cryptoTools::SHA256();
//         H->hash(toByteTree()->toVector());        
//         std::vector<uint8_t> hash = H->getHash();
//         uint8_t l = hash[0] % 4;
//         std::vector<uint8_t> message(hash.begin()+1, hash.end()+l+1);
//         return message;
// }


// std::vector<uint8_t> ModPGrpElmt::decode1()
// {
//         mpz_class k = (representative < baseField->getAdditiveOrder())?
//                 representative :
//                 baseField->getAdditiveOrder() - representative;
//         unsigned int b = (baseField->getAdditiveOrderByteSize()-2)/8 - 4,
//                 l = 0;
//         mpz_mod_2exp(k.get_mpz_t(),k.get_mpz_t(),8*(b+4));
//         std::vector<uint8_t> bytes = verifierUtils::largeNum2byteVector(k);
//         for (unsigned int i=0; i<bytes.size()-b; i++)
//                 l = l*0x100 + bytes[i];
//         if ((l<0) || (l>b))
//                 l = 0;
//         bytes.assign(bytes.begin()+bytes.size()-b,bytes.end());
//         return bytes;
// }


// std::vector<uint8_t> ModPGrpElmt::decode2()
// {
//         // computing b
//         unsigned int n = baseField->getAdditiveOrderByteSize();
//         mpz_class tBis = (baseField->getAdditiveOrder()-1)/baseField->getMultiplicativeOrder();
//         unsigned int t = tBis.get_ui();
//         unsigned int b = n/8 - (t/8+1) - 4;
//         mpz_class pow2i = 2;
//         mpz_pow_ui(pow2i.get_mpz_t(), pow2i.get_mpz_t(), 8*(b+4));
//         mpz_class k = representative % pow2i;
//         std::vector<uint8_t> bytes = verifierUtils::largeNum2byteVector(k);
//         unsigned int l = 0;
//         for (unsigned int i=0; i<bytes.size()-b; i++)
//                 l = l*0x100 + bytes[i];
//         if ((l<0) || (l>b))
//                 l = 0;
//         bytes.assign(bytes.begin()+bytes.size()-b,bytes.end());
//         return bytes;
// }