Bunny2.0
Headers/Bunny24m24k.hxx
00001 //CONSTRUCTOR
00003 
00006 template <unsigned nb_sbox, unsigned nround>
00007 inline
00008 Bunny24m24k<nb_sbox,nround>::Bunny24m24k(){
00009         rk.resize(nround+1) ; // allocates memory for the round keys
00010 }
00011 
00019 template <unsigned nb_sbox, unsigned nround>
00020 inline
00021 typename Bunny24m24k<nb_sbox,nround>::msgType
00022 Bunny24m24k<nb_sbox,nround>::encode( msgType m, keyType k ) {
00023         msgType c ;
00024         c = m ;
00025         keySchedule(k) ;
00026         //Round 0, a-tipical
00027         c = addRoundKey(c,rk[0]) ;
00028         //cout << "state at round: 0 --> " << bitsetToHex(c) << endl ;
00029         //Tipical rounds
00030         for (unsigned i = 1 ; i <= nround ; ++i){
00031                 c = sBox(c) ;
00032                 //cout << "state after sBox: --> " << bitsetToHex(c) << endl ;
00033                 c = mixingLayer(c) ;
00034                 //cout << "state after mixL: --> " << bitsetToHex(c) << endl ;
00035                 c = addRoundKey(c,rk[i]) ;
00036                 //cout << "state at round: " << i <<  " --> " << bitsetToHex(c) << endl ;
00037         }
00038         return c ;
00039 }
00040 
00048 template <unsigned nb_sbox, unsigned nround>
00049 inline
00050 typename Bunny24m24k<nb_sbox,nround>::msgType
00051 Bunny24m24k<nb_sbox,nround>::decode (msgType m, keyType k) {
00052         msgType c ;
00053         c = m ;
00054         //keyschedule
00055         keySchedule(k) ;
00056         //Tipical rounds
00057         for (unsigned i = nround ; i > 0 ; --i){
00058                 c = addRoundKey(c,rk[i]) ;
00059                 //cout <<   "state after add round: " << i <<  " --> " << bitsetToHex(c) << endl ;
00060                 c = mixingLayerInverse(c) ;
00061                 //cout << "state after mixLInv: --> " << bitsetToHex(c) << endl ;
00062                 c = sBoxInverse(c) ;
00063                 //cout << "state after sBoxInv: --> " << bitsetToHex(c) << endl ;
00064         }
00065         //Round 0, a-tipical
00066         c = addRoundKey(c,rk[0]) ;
00067         return c ;
00068 }
00069 
00073 
00080 template <unsigned nb_sbox, unsigned nround>
00081 inline
00082 void Bunny24m24k<nb_sbox,nround>::keySchedule(keyType k) {
00083         //number of word generated
00084         unsigned nword = 80 ;//(nround+10) * 4 ;//to have some more bitsj
00085         //dimension of the blocks that fill the round keys
00086         //i.e.: nrow round keys at a time are filled
00087         unsigned nb_msg = 24 ;
00088         unsigned ncol   = nb_msg/nb_sbox ;
00089         unsigned nrow   = nb_msg/nb_sbox + 1 ;
00090         vector<sboxType> w ;
00091 
00092         w.resize(nword) ; // initialize a vector of nword elements of type sboxType, set to 00...0
00093 
00094         //CREATE W, a vector of 80 words
00095         //put the key bits in the first 4 words
00096         for (unsigned i = 0 ; i < ncol ; ++i) w[i] = extractBlock(i,k) ;
00097 
00098         w[4] = sbox(0,w[0]) ^ w[1];
00099         w[5] = sbox(1,w[1]) ^ w[2];
00100         w[6] = sbox(2,w[2]) ^ w[3];
00101         w[7] = sbox(3,w[3]) ^ w[0];
00102 
00103         for (unsigned i = 8; i < w.size() ; ++i){
00104       // se i = 0 mod 8 => w[i] = w[i-8] ^ s2(RB(w[i-1])) + 101010
00105       if (i % 8 == 0) w[i] = w[i-8] ^ sbox(1,(w[i-1]<<1)) ^ sboxType (string("101010")) ;
00106       // se i = 4 mod 8 => w[i] = w[i-8] ^ sbox(2,w[i-1])
00107       else if (i % 8 == 4) w[i] = w[i-8] ^ sbox(2,w[i-1]) ;
00108       // se i != 0 mod 4 w[i] = w[i-8] ^ w[i-1]
00109       else w[i] = w[i-8] ^ w[i-1] ;
00110         }
00111 
00112         //CREATE the ROUND KEYS
00113         //0,5,10,15
00114         //1,6,11,16
00115         //2,7,12,17
00116         //3,8,13,18
00117         //4,9,14,19
00118         //..
00119         //20,25,30,35...
00120         unsigned pos = 0 ;
00121         for (unsigned i = 0 ; i <= nround ; ++i){
00122                 if ( (i % nrow) == 0 ) pos = i * ncol ;
00123                 for (unsigned j = 0 ; j < ncol ; ++j){
00124                         rk[i] = insertBlock(rk[i],j,w[pos+j*nrow]) ;
00125                 }
00126                 ++pos ;
00127         }
00128 
00129         //Print W
00130         /*cout << endl ;
00131         cout << "k = " << k << endl ;
00132         cout << "W = " << endl ;
00133         for (unsigned i = 0; i < w.size() ; ++i){
00134                 if (i % 4 == 3) cout << " " << w[i] << endl ;
00135                 else cout << " " << w[i] ;
00136         }*/
00137 return ;
00138 }
00139 
00143 
00152 template <unsigned nb_sbox, unsigned nround>
00153 inline
00154 typename Bunny24m24k<nb_sbox,nround>::msgType
00155 Bunny24m24k<nb_sbox,nround>::addRoundKey (msgType m, msgType k){
00156         return m ^ k;
00157 }
00158 
00159 
00163 
00172 template <unsigned nb_sbox, unsigned nround>
00173 inline
00174 typename Bunny24m24k<nb_sbox,nround>::msgType
00175 Bunny24m24k<nb_sbox,nround>::mixingLayer (msgType m ) {
00176   unsigned const nb_msg = 24 ;
00177   bitset<nb_msg> lambda[nb_msg] ;
00178   msgType c ;
00179   //creazione di lambda
00180   if (m.size() == 24) {
00181                 lambda[0]  = bitset<nb_msg> (string("001010001000110011100101"));
00182                 lambda[1]  = bitset<nb_msg> (string("000101000100110100111111"));
00183                 lambda[2]  = bitset<nb_msg> (string("101111000010011010110010"));
00184                 lambda[3]  = bitset<nb_msg> (string("111010000001001101011001"));
00185                 lambda[4]  = bitset<nb_msg> (string("011101101101101011100001"));
00186                 lambda[5]  = bitset<nb_msg> (string("100011111011111000111101"));
00187                 lambda[6]  = bitset<nb_msg> (string("100001000101011000000010"));
00188                 lambda[7]  = bitset<nb_msg> (string("111101101111001100000001"));
00189                 lambda[8]  = bitset<nb_msg> (string("110011111010000110101101"));
00190                 lambda[9]  = bitset<nb_msg> (string("110100011101000011111011"));
00191                 lambda[10] = bitset<nb_msg> (string("011010100011101100110000"));
00192                 lambda[11] = bitset<nb_msg> (string("001101111100010110011000"));
00193                 lambda[12] = bitset<nb_msg> (string("111011110001111000001001"));
00194                 lambda[13] = bitset<nb_msg> (string("110000110101011100101001"));
00195                 lambda[14] = bitset<nb_msg> (string("011000110111001110111001"));
00196                 lambda[15] = bitset<nb_msg> (string("001100110110000111110001"));
00197                 lambda[16] = bitset<nb_msg> (string("000110011011101110110101"));
00198                 lambda[17] = bitset<nb_msg> (string("000011100000010111110111"));
00199                 lambda[18] = bitset<nb_msg> (string("110000011100110011001110"));
00200                 lambda[19] = bitset<nb_msg> (string("011000001110110100000111"));
00201                 lambda[20] = bitset<nb_msg> (string("001100000111011010101110"));
00202                 lambda[21] = bitset<nb_msg> (string("000110101110001101010111"));
00203                 lambda[22] = bitset<nb_msg> (string("000011010111101011100110"));
00204                 lambda[23] = bitset<nb_msg> (string("101100100110111000010011"));
00205 
00206                 // To acces element (I,J) of matrix lambda use:
00207                 // lambda(I,J) = lambda[I+J*nb_msg]
00208                 //vector x matrix PRODUCT
00209                 for ( unsigned i = 0 ; i < nb_msg ; ++i ){
00210                         c[i] = 0 ;
00211                         for ( unsigned j = 0 ; j < nb_msg ; ++j ) {
00212                                 c[i] = c[i] ^ ( m[j] & lambda[nb_msg-j-1][i] ) ;
00213                         }
00214                 }
00215         }
00216         else if (m.size() == 128){
00217                 /*
00218                 lambda[0]   = bitset<nb_msg> (string("00011101100000001000000010011101000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00219                 lambda[1]   = bitset<nb_msg> (string("10000000010000000100000011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00220                 lambda[2]   = bitset<nb_msg> (string("01000000001000000010000001100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00221                 lambda[3]   = bitset<nb_msg> (string("00100000000100000001000000110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00222                 lambda[4]   = bitset<nb_msg> (string("00010000000010000000100000011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00223                 lambda[5]   = bitset<nb_msg> (string("00001000000001000000010000001100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00224                 lambda[6]   = bitset<nb_msg> (string("00000100000000100000001000000110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00225                 lambda[7]   = bitset<nb_msg> (string("00000010000000010000000100000011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00226                 lambda[8]   = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010011101000111011000000010000000"));
00227                 lambda[9]   = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011000000100000000100000001000000"));
00228                 lambda[10]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001100000010000000010000000100000"));
00229                 lambda[11]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000110000001000000001000000010000"));
00230                 lambda[12]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011000000100000000100000001000"));
00231                 lambda[13]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001100000010000000010000000100"));
00232                 lambda[14]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000110000001000000001000000010"));
00233                 lambda[15]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011000000100000000100000001"));
00234                 lambda[16]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000001000000010011101000111011000000000000000000000000000000000000000"));
00235                 lambda[17]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000100000011000000100000000100000000000000000000000000000000000000"));
00236                 lambda[18]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000010000001100000010000000010000000000000000000000000000000000000"));
00237                 lambda[19]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000001000000110000001000000001000000000000000000000000000000000000"));
00238                 lambda[20]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000100000011000000100000000100000000000000000000000000000000000"));
00239                 lambda[21]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000010000001100000010000000010000000000000000000000000000000000"));
00240                 lambda[22]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000001000000110000001000000001000000000000000000000000000000000"));
00241                 lambda[23]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000100000011000000100000000100000000000000000000000000000000"));
00242                 lambda[24]  = bitset<nb_msg> (string("00000000000000000000000000000000100000001000000010011101000111010000000000000000000000000000000000000000000000000000000000000000"));
00243                 lambda[25]  = bitset<nb_msg> (string("00000000000000000000000000000000010000000100000011000000100000000000000000000000000000000000000000000000000000000000000000000000"));
00244                 lambda[26]  = bitset<nb_msg> (string("00000000000000000000000000000000001000000010000001100000010000000000000000000000000000000000000000000000000000000000000000000000"));
00245                 lambda[27]  = bitset<nb_msg> (string("00000000000000000000000000000000000100000001000000110000001000000000000000000000000000000000000000000000000000000000000000000000"));
00246                 lambda[28]  = bitset<nb_msg> (string("00000000000000000000000000000000000010000000100000011000000100000000000000000000000000000000000000000000000000000000000000000000"));
00247                 lambda[29]  = bitset<nb_msg> (string("00000000000000000000000000000000000001000000010000001100000010000000000000000000000000000000000000000000000000000000000000000000"));
00248                 lambda[30]  = bitset<nb_msg> (string("00000000000000000000000000000000000000100000001000000110000001000000000000000000000000000000000000000000000000000000000000000000"));
00249                 lambda[31]  = bitset<nb_msg> (string("00000000000000000000000000000000000000010000000100000011000000100000000000000000000000000000000000000000000000000000000000000000"));
00250                 lambda[32]  = bitset<nb_msg> (string("00000000000000000000000000000000000111011000000010000000100111010000000000000000000000000000000000000000000000000000000000000000"));
00251                 lambda[33]  = bitset<nb_msg> (string("00000000000000000000000000000000100000000100000001000000110000000000000000000000000000000000000000000000000000000000000000000000"));
00252                 lambda[34]  = bitset<nb_msg> (string("00000000000000000000000000000000010000000010000000100000011000000000000000000000000000000000000000000000000000000000000000000000"));
00253                 lambda[35]  = bitset<nb_msg> (string("00000000000000000000000000000000001000000001000000010000001100000000000000000000000000000000000000000000000000000000000000000000"));
00254                 lambda[36]  = bitset<nb_msg> (string("00000000000000000000000000000000000100000000100000001000000110000000000000000000000000000000000000000000000000000000000000000000"));
00255                 lambda[37]  = bitset<nb_msg> (string("00000000000000000000000000000000000010000000010000000100000011000000000000000000000000000000000000000000000000000000000000000000"));
00256                 lambda[38]  = bitset<nb_msg> (string("00000000000000000000000000000000000001000000001000000010000001100000000000000000000000000000000000000000000000000000000000000000"));
00257                 lambda[39]  = bitset<nb_msg> (string("00000000000000000000000000000000000000100000000100000001000000110000000000000000000000000000000000000000000000000000000000000000"));
00258                 lambda[40]  = bitset<nb_msg> (string("10011101000111011000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00259                 lambda[41]  = bitset<nb_msg> (string("11000000100000000100000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00260                 lambda[42]  = bitset<nb_msg> (string("01100000010000000010000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00261                 lambda[43]  = bitset<nb_msg> (string("00110000001000000001000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00262                 lambda[44]  = bitset<nb_msg> (string("00011000000100000000100000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00263                 lambda[45]  = bitset<nb_msg> (string("00001100000010000000010000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00264                 lambda[46]  = bitset<nb_msg> (string("00000110000001000000001000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00265                 lambda[47]  = bitset<nb_msg> (string("00000011000000100000000100000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00266                 lambda[48]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000100111010001110110000000"));
00267                 lambda[49]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000110000001000000001000000"));
00268                 lambda[50]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000011000000100000000100000"));
00269                 lambda[51]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000001100000010000000010000"));
00270                 lambda[52]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000110000001000000001000"));
00271                 lambda[53]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000011000000100000000100"));
00272                 lambda[54]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000001100000010000000010"));
00273                 lambda[55]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000110000001000000001"));
00274                 lambda[56]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000001000000010000000100111010001110100000000000000000000000000000000"));
00275                 lambda[57]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000100000001000000110000001000000000000000000000000000000000000000"));
00276                 lambda[58]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000010000000100000011000000100000000000000000000000000000000000000"));
00277                 lambda[59]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000001000000010000001100000010000000000000000000000000000000000000"));
00278                 lambda[60]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000100000001000000110000001000000000000000000000000000000000000"));
00279                 lambda[61]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000010000000100000011000000100000000000000000000000000000000000"));
00280                 lambda[62]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000001000000010000001100000010000000000000000000000000000000000"));
00281                 lambda[63]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000100000001000000110000001000000000000000000000000000000000"));
00282                 lambda[64]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000001110110000000100000001001110100000000000000000000000000000000"));
00283                 lambda[65]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000001000000001000000010000001100000000000000000000000000000000000000"));
00284                 lambda[66]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000100000000100000001000000110000000000000000000000000000000000000"));
00285                 lambda[67]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000010000000010000000100000011000000000000000000000000000000000000"));
00286                 lambda[68]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000001000000001000000010000001100000000000000000000000000000000000"));
00287                 lambda[69]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000100000000100000001000000110000000000000000000000000000000000"));
00288                 lambda[70]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000010000000010000000100000011000000000000000000000000000000000"));
00289                 lambda[71]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000001000000001000000010000001100000000000000000000000000000000"));
00290                 lambda[72]  = bitset<nb_msg> (string("00000000000000000000000000000000100111010001110110000000100000000000000000000000000000000000000000000000000000000000000000000000"));
00291                 lambda[73]  = bitset<nb_msg> (string("00000000000000000000000000000000110000001000000001000000010000000000000000000000000000000000000000000000000000000000000000000000"));
00292                 lambda[74]  = bitset<nb_msg> (string("00000000000000000000000000000000011000000100000000100000001000000000000000000000000000000000000000000000000000000000000000000000"));
00293                 lambda[75]  = bitset<nb_msg> (string("00000000000000000000000000000000001100000010000000010000000100000000000000000000000000000000000000000000000000000000000000000000"));
00294                 lambda[76]  = bitset<nb_msg> (string("00000000000000000000000000000000000110000001000000001000000010000000000000000000000000000000000000000000000000000000000000000000"));
00295                 lambda[77]  = bitset<nb_msg> (string("00000000000000000000000000000000000011000000100000000100000001000000000000000000000000000000000000000000000000000000000000000000"));
00296                 lambda[78]  = bitset<nb_msg> (string("00000000000000000000000000000000000001100000010000000010000000100000000000000000000000000000000000000000000000000000000000000000"));
00297                 lambda[79]  = bitset<nb_msg> (string("00000000000000000000000000000000000000110000001000000001000000010000000000000000000000000000000000000000000000000000000000000000"));
00298                 lambda[80]  = bitset<nb_msg> (string("10000000100111010001110110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00299                 lambda[81]  = bitset<nb_msg> (string("01000000110000001000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00300                 lambda[82]  = bitset<nb_msg> (string("00100000011000000100000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00301                 lambda[83]  = bitset<nb_msg> (string("00010000001100000010000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00302                 lambda[84]  = bitset<nb_msg> (string("00001000000110000001000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00303                 lambda[85]  = bitset<nb_msg> (string("00000100000011000000100000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00304                 lambda[86]  = bitset<nb_msg> (string("00000010000001100000010000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00305                 lambda[87]  = bitset<nb_msg> (string("00000001000000110000001000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00306                 lambda[88]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000100000001001110100011101"));
00307                 lambda[89]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000010000001100000010000000"));
00308                 lambda[90]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000001000000110000001000000"));
00309                 lambda[91]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000100000011000000100000"));
00310                 lambda[92]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000010000001100000010000"));
00311                 lambda[93]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000001000000110000001000"));
00312                 lambda[94]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000100000011000000100"));
00313                 lambda[95]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000010000001100000010"));
00314                 lambda[96]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011101100000001000000010011101"));
00315                 lambda[97]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000010000000100000011000000"));
00316                 lambda[98]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000001000000010000001100000"));
00317                 lambda[99]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000100000001000000110000"));
00318                 lambda[100] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000010000000100000011000"));
00319                 lambda[101] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000001000000010000001100"));
00320                 lambda[102] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000100000001000000110"));
00321                 lambda[103] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000010000000100000011"));
00322                 lambda[104] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000001001110100011101100000001000000000000000000000000000000000000000"));
00323                 lambda[105] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000001100000010000000010000000100000000000000000000000000000000000000"));
00324                 lambda[106] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000110000001000000001000000010000000000000000000000000000000000000"));
00325                 lambda[107] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000011000000100000000100000001000000000000000000000000000000000000"));
00326                 lambda[108] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000001100000010000000010000000100000000000000000000000000000000000"));
00327                 lambda[109] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000110000001000000001000000010000000000000000000000000000000000"));
00328                 lambda[110] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000011000000100000000100000001000000000000000000000000000000000"));
00329                 lambda[111] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000001100000010000000010000000100000000000000000000000000000000"));
00330                 lambda[112] = bitset<nb_msg> (string("00000000000000000000000000000000100000001001110100011101100000000000000000000000000000000000000000000000000000000000000000000000"));
00331                 lambda[113] = bitset<nb_msg> (string("00000000000000000000000000000000010000001100000010000000010000000000000000000000000000000000000000000000000000000000000000000000"));
00332                 lambda[114] = bitset<nb_msg> (string("00000000000000000000000000000000001000000110000001000000001000000000000000000000000000000000000000000000000000000000000000000000"));
00333                 lambda[115] = bitset<nb_msg> (string("00000000000000000000000000000000000100000011000000100000000100000000000000000000000000000000000000000000000000000000000000000000"));
00334                 lambda[116] = bitset<nb_msg> (string("00000000000000000000000000000000000010000001100000010000000010000000000000000000000000000000000000000000000000000000000000000000"));
00335                 lambda[117] = bitset<nb_msg> (string("00000000000000000000000000000000000001000000110000001000000001000000000000000000000000000000000000000000000000000000000000000000"));
00336                 lambda[118] = bitset<nb_msg> (string("00000000000000000000000000000000000000100000011000000100000000100000000000000000000000000000000000000000000000000000000000000000"));
00337                 lambda[119] = bitset<nb_msg> (string("00000000000000000000000000000000000000010000001100000010000000010000000000000000000000000000000000000000000000000000000000000000"));
00338                 lambda[120] = bitset<nb_msg> (string("10000000100000001001110100011101000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00339                 lambda[121] = bitset<nb_msg> (string("01000000010000001100000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00340                 lambda[122] = bitset<nb_msg> (string("00100000001000000110000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00341                 lambda[123] = bitset<nb_msg> (string("00010000000100000011000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00342                 lambda[124] = bitset<nb_msg> (string("00001000000010000001100000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00343                 lambda[125] = bitset<nb_msg> (string("00000100000001000000110000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00344                 lambda[126] = bitset<nb_msg> (string("00000010000000100000011000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00345                 lambda[127] = bitset<nb_msg> (string("00000001000000010000001100000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00346                 */
00347     }
00348 
00349         return c ;
00350 }
00351 
00355 template <unsigned nb_sbox, unsigned nround>
00356 inline
00357 typename Bunny24m24k<nb_sbox,nround>::msgType
00358 Bunny24m24k<nb_sbox,nround>::mixingLayerInverse (msgType m ){
00359     unsigned const nb_msg = 24 ;
00360         bitset<nb_msg> lambda[nb_msg] ;
00361         msgType c ;
00362         //creazione di lambda
00363         if (m.size() == 24){
00364                 lambda[0]  = bitset<nb_msg> (string("010100111011001100100010"));
00365                 lambda[1]  = bitset<nb_msg> (string("001010110000000110010001"));
00366                 lambda[2]  = bitset<nb_msg> (string("000101011000000011100101"));
00367                 lambda[3]  = bitset<nb_msg> (string("101111001100101100111111"));
00368                 lambda[4]  = bitset<nb_msg> (string("111010000110010110110010"));
00369                 lambda[5]  = bitset<nb_msg> (string("011101000011001011011001"));
00370                 lambda[6]  = bitset<nb_msg> (string("010101001011011110100101"));
00371                 lambda[7]  = bitset<nb_msg> (string("100111101000001111111111"));
00372                 lambda[8]  = bitset<nb_msg> (string("111110010100101010110010"));
00373                 lambda[9]  = bitset<nb_msg> (string("011111001010010101011001"));
00374                 lambda[10] = bitset<nb_msg> (string("100010000101100111100001"));
00375                 lambda[11] = bitset<nb_msg> (string("010001101111111110111101"));
00376                 lambda[12] = bitset<nb_msg> (string("001101111000010011000001"));
00377                 lambda[13] = bitset<nb_msg> (string("101011011100100100101101"));
00378                 lambda[14] = bitset<nb_msg> (string("111000001110010010111011"));
00379                 lambda[15] = bitset<nb_msg> (string("011100000111001001110000"));
00380                 lambda[16] = bitset<nb_msg> (string("001110101110101001011000"));
00381                 lambda[17] = bitset<nb_msg> (string("000111010111111001001100"));
00382                 lambda[18] = bitset<nb_msg> (string("101100101000100001100110"));
00383                 lambda[19] = bitset<nb_msg> (string("010110010100111101010011"));
00384                 lambda[20] = bitset<nb_msg> (string("001011001010110011100100"));
00385                 lambda[21] = bitset<nb_msg> (string("101000000101110100010010"));
00386                 lambda[22] = bitset<nb_msg> (string("010100101111011010001001"));
00387                 lambda[23] = bitset<nb_msg> (string("001010111010001101101001"));
00388         }
00389         else if (m.size() == 128){
00390                         /*
00391                         lambda[0]  = bitset<nb_msg> (string("01010011000000000000000000000000000000001111010000000000000000000000000000000000110011100000000000000000000000000000000011101001"));
00392                         lambda[1]  = bitset<nb_msg> (string("10100111000000000000000000000000000000000111101000000000000000000000000000000000011001110000000000000000000000000000000011111010"));
00393                         lambda[2]  = bitset<nb_msg> (string("11011101000000000000000000000000000000000011110100000000000000000000000000000000101111010000000000000000000000000000000001111101"));
00394                         lambda[3]  = bitset<nb_msg> (string("11100000000000000000000000000000000000001001000000000000000000000000000000000000110100000000000000000000000000000000000010110000"));
00395                         lambda[4]  = bitset<nb_msg> (string("01110000000000000000000000000000000000000100100000000000000000000000000000000000011010000000000000000000000000000000000001011000"));
00396                         lambda[5]  = bitset<nb_msg> (string("00111000000000000000000000000000000000000010010000000000000000000000000000000000001101000000000000000000000000000000000000101100"));
00397                         lambda[6]  = bitset<nb_msg> (string("00011100000000000000000000000000000000000001001000000000000000000000000000000000000110100000000000000000000000000000000000010110"));
00398                         lambda[7]  = bitset<nb_msg> (string("00001110000000000000000000000000000000000000100100000000000000000000000000000000000011010000000000000000000000000000000000001011"));
00399                         lambda[8]  = bitset<nb_msg> (string("11101001000000000000000000000000000000000101001100000000000000000000000000000000111101000000000000000000000000000000000011001110"));
00400                         lambda[9]  = bitset<nb_msg> (string("11111010000000000000000000000000000000001010011100000000000000000000000000000000011110100000000000000000000000000000000001100111"));
00401                         lambda[10] = bitset<nb_msg> (string("01111101000000000000000000000000000000001101110100000000000000000000000000000000001111010000000000000000000000000000000010111101"));
00402                         lambda[11] = bitset<nb_msg> (string("10110000000000000000000000000000000000001110000000000000000000000000000000000000100100000000000000000000000000000000000011010000"));
00403                         lambda[12] = bitset<nb_msg> (string("01011000000000000000000000000000000000000111000000000000000000000000000000000000010010000000000000000000000000000000000001101000"));
00404                         lambda[13] = bitset<nb_msg> (string("00101100000000000000000000000000000000000011100000000000000000000000000000000000001001000000000000000000000000000000000000110100"));
00405                         lambda[14] = bitset<nb_msg> (string("00010110000000000000000000000000000000000001110000000000000000000000000000000000000100100000000000000000000000000000000000011010"));
00406                         lambda[15] = bitset<nb_msg> (string("00001011000000000000000000000000000000000000111000000000000000000000000000000000000010010000000000000000000000000000000000001101"));
00407                         lambda[16] = bitset<nb_msg> (string("11001110000000000000000000000000000000001110100100000000000000000000000000000000010100110000000000000000000000000000000011110100"));
00408                         lambda[17] = bitset<nb_msg> (string("01100111000000000000000000000000000000001111101000000000000000000000000000000000101001110000000000000000000000000000000001111010"));
00409                         lambda[18] = bitset<nb_msg> (string("10111101000000000000000000000000000000000111110100000000000000000000000000000000110111010000000000000000000000000000000000111101"));
00410                         lambda[19] = bitset<nb_msg> (string("11010000000000000000000000000000000000001011000000000000000000000000000000000000111000000000000000000000000000000000000010010000"));
00411                         lambda[20] = bitset<nb_msg> (string("01101000000000000000000000000000000000000101100000000000000000000000000000000000011100000000000000000000000000000000000001001000"));
00412                         lambda[21] = bitset<nb_msg> (string("00110100000000000000000000000000000000000010110000000000000000000000000000000000001110000000000000000000000000000000000000100100"));
00413                         lambda[22] = bitset<nb_msg> (string("00011010000000000000000000000000000000000001011000000000000000000000000000000000000111000000000000000000000000000000000000010010"));
00414                         lambda[23] = bitset<nb_msg> (string("00001101000000000000000000000000000000000000101100000000000000000000000000000000000011100000000000000000000000000000000000001001"));
00415                         lambda[24] = bitset<nb_msg> (string("11110100000000000000000000000000000000001100111000000000000000000000000000000000111010010000000000000000000000000000000001010011"));
00416                         lambda[25] = bitset<nb_msg> (string("01111010000000000000000000000000000000000110011100000000000000000000000000000000111110100000000000000000000000000000000010100111"));
00417                         lambda[26] = bitset<nb_msg> (string("00111101000000000000000000000000000000001011110100000000000000000000000000000000011111010000000000000000000000000000000011011101"));
00418                         lambda[27] = bitset<nb_msg> (string("10010000000000000000000000000000000000001101000000000000000000000000000000000000101100000000000000000000000000000000000011100000"));
00419                         lambda[28] = bitset<nb_msg> (string("01001000000000000000000000000000000000000110100000000000000000000000000000000000010110000000000000000000000000000000000001110000"));
00420                         lambda[29] = bitset<nb_msg> (string("00100100000000000000000000000000000000000011010000000000000000000000000000000000001011000000000000000000000000000000000000111000"));
00421                         lambda[30] = bitset<nb_msg> (string("00010010000000000000000000000000000000000001101000000000000000000000000000000000000101100000000000000000000000000000000000011100"));
00422                         lambda[31] = bitset<nb_msg> (string("00001001000000000000000000000000000000000000110100000000000000000000000000000000000010110000000000000000000000000000000000001110"));
00423                         lambda[32] = bitset<nb_msg> (string("00000000000000000000000011101001010100110000000000000000000000000000000011110100000000000000000000000000000000001100111000000000"));
00424                         lambda[33] = bitset<nb_msg> (string("00000000000000000000000011111010101001110000000000000000000000000000000001111010000000000000000000000000000000000110011100000000"));
00425                         lambda[34] = bitset<nb_msg> (string("00000000000000000000000001111101110111010000000000000000000000000000000000111101000000000000000000000000000000001011110100000000"));
00426                         lambda[35] = bitset<nb_msg> (string("00000000000000000000000010110000111000000000000000000000000000000000000010010000000000000000000000000000000000001101000000000000"));
00427                         lambda[36] = bitset<nb_msg> (string("00000000000000000000000001011000011100000000000000000000000000000000000001001000000000000000000000000000000000000110100000000000"));
00428                         lambda[37] = bitset<nb_msg> (string("00000000000000000000000000101100001110000000000000000000000000000000000000100100000000000000000000000000000000000011010000000000"));
00429                         lambda[38] = bitset<nb_msg> (string("00000000000000000000000000010110000111000000000000000000000000000000000000010010000000000000000000000000000000000001101000000000"));
00430                         lambda[39] = bitset<nb_msg> (string("00000000000000000000000000001011000011100000000000000000000000000000000000001001000000000000000000000000000000000000110100000000"));
00431                         lambda[40] = bitset<nb_msg> (string("00000000000000000000000011001110111010010000000000000000000000000000000001010011000000000000000000000000000000001111010000000000"));
00432                         lambda[41] = bitset<nb_msg> (string("00000000000000000000000001100111111110100000000000000000000000000000000010100111000000000000000000000000000000000111101000000000"));
00433                         lambda[42] = bitset<nb_msg> (string("00000000000000000000000010111101011111010000000000000000000000000000000011011101000000000000000000000000000000000011110100000000"));
00434                         lambda[43] = bitset<nb_msg> (string("00000000000000000000000011010000101100000000000000000000000000000000000011100000000000000000000000000000000000001001000000000000"));
00435                         lambda[44] = bitset<nb_msg> (string("00000000000000000000000001101000010110000000000000000000000000000000000001110000000000000000000000000000000000000100100000000000"));
00436                         lambda[45] = bitset<nb_msg> (string("00000000000000000000000000110100001011000000000000000000000000000000000000111000000000000000000000000000000000000010010000000000"));
00437                         lambda[46] = bitset<nb_msg> (string("00000000000000000000000000011010000101100000000000000000000000000000000000011100000000000000000000000000000000000001001000000000"));
00438                         lambda[47] = bitset<nb_msg> (string("00000000000000000000000000001101000010110000000000000000000000000000000000001110000000000000000000000000000000000000100100000000"));
00439                         lambda[48] = bitset<nb_msg> (string("00000000000000000000000011110100110011100000000000000000000000000000000011101001000000000000000000000000000000000101001100000000"));
00440                         lambda[49] = bitset<nb_msg> (string("00000000000000000000000001111010011001110000000000000000000000000000000011111010000000000000000000000000000000001010011100000000"));
00441                         lambda[50] = bitset<nb_msg> (string("00000000000000000000000000111101101111010000000000000000000000000000000001111101000000000000000000000000000000001101110100000000"));
00442                         lambda[51] = bitset<nb_msg> (string("00000000000000000000000010010000110100000000000000000000000000000000000010110000000000000000000000000000000000001110000000000000"));
00443                         lambda[52] = bitset<nb_msg> (string("00000000000000000000000001001000011010000000000000000000000000000000000001011000000000000000000000000000000000000111000000000000"));
00444                         lambda[53] = bitset<nb_msg> (string("00000000000000000000000000100100001101000000000000000000000000000000000000101100000000000000000000000000000000000011100000000000"));
00445                         lambda[54] = bitset<nb_msg> (string("00000000000000000000000000010010000110100000000000000000000000000000000000010110000000000000000000000000000000000001110000000000"));
00446                         lambda[55] = bitset<nb_msg> (string("00000000000000000000000000001001000011010000000000000000000000000000000000001011000000000000000000000000000000000000111000000000"));
00447                         lambda[56] = bitset<nb_msg> (string("00000000000000000000000001010011111101000000000000000000000000000000000011001110000000000000000000000000000000001110100100000000"));
00448                         lambda[57] = bitset<nb_msg> (string("00000000000000000000000010100111011110100000000000000000000000000000000001100111000000000000000000000000000000001111101000000000"));
00449                         lambda[58] = bitset<nb_msg> (string("00000000000000000000000011011101001111010000000000000000000000000000000010111101000000000000000000000000000000000111110100000000"));
00450                         lambda[59] = bitset<nb_msg> (string("00000000000000000000000011100000100100000000000000000000000000000000000011010000000000000000000000000000000000001011000000000000"));
00451                         lambda[60] = bitset<nb_msg> (string("00000000000000000000000001110000010010000000000000000000000000000000000001101000000000000000000000000000000000000101100000000000"));
00452                         lambda[61] = bitset<nb_msg> (string("00000000000000000000000000111000001001000000000000000000000000000000000000110100000000000000000000000000000000000010110000000000"));
00453                         lambda[62] = bitset<nb_msg> (string("00000000000000000000000000011100000100100000000000000000000000000000000000011010000000000000000000000000000000000001011000000000"));
00454                         lambda[63] = bitset<nb_msg> (string("00000000000000000000000000001110000010010000000000000000000000000000000000001101000000000000000000000000000000000000101100000000"));
00455                         lambda[64] = bitset<nb_msg> (string("00000000000000001100111000000000000000000000000000000000111010010101001100000000000000000000000000000000111101000000000000000000"));
00456                         lambda[65] = bitset<nb_msg> (string("00000000000000000110011100000000000000000000000000000000111110101010011100000000000000000000000000000000011110100000000000000000"));
00457                         lambda[66] = bitset<nb_msg> (string("00000000000000001011110100000000000000000000000000000000011111011101110100000000000000000000000000000000001111010000000000000000"));
00458                         lambda[67] = bitset<nb_msg> (string("00000000000000001101000000000000000000000000000000000000101100001110000000000000000000000000000000000000100100000000000000000000"));
00459                         lambda[68] = bitset<nb_msg> (string("00000000000000000110100000000000000000000000000000000000010110000111000000000000000000000000000000000000010010000000000000000000"));
00460                         lambda[69] = bitset<nb_msg> (string("00000000000000000011010000000000000000000000000000000000001011000011100000000000000000000000000000000000001001000000000000000000"));
00461                         lambda[70] = bitset<nb_msg> (string("00000000000000000001101000000000000000000000000000000000000101100001110000000000000000000000000000000000000100100000000000000000"));
00462                         lambda[71] = bitset<nb_msg> (string("00000000000000000000110100000000000000000000000000000000000010110000111000000000000000000000000000000000000010010000000000000000"));
00463                         lambda[72] = bitset<nb_msg> (string("00000000000000001111010000000000000000000000000000000000110011101110100100000000000000000000000000000000010100110000000000000000"));
00464                         lambda[73] = bitset<nb_msg> (string("00000000000000000111101000000000000000000000000000000000011001111111101000000000000000000000000000000000101001110000000000000000"));
00465                         lambda[74] = bitset<nb_msg> (string("00000000000000000011110100000000000000000000000000000000101111010111110100000000000000000000000000000000110111010000000000000000"));
00466                         lambda[75] = bitset<nb_msg> (string("00000000000000001001000000000000000000000000000000000000110100001011000000000000000000000000000000000000111000000000000000000000"));
00467                         lambda[76] = bitset<nb_msg> (string("00000000000000000100100000000000000000000000000000000000011010000101100000000000000000000000000000000000011100000000000000000000"));
00468                         lambda[77] = bitset<nb_msg> (string("00000000000000000010010000000000000000000000000000000000001101000010110000000000000000000000000000000000001110000000000000000000"));
00469                         lambda[78] = bitset<nb_msg> (string("00000000000000000001001000000000000000000000000000000000000110100001011000000000000000000000000000000000000111000000000000000000"));
00470                         lambda[79] = bitset<nb_msg> (string("00000000000000000000100100000000000000000000000000000000000011010000101100000000000000000000000000000000000011100000000000000000"));
00471                         lambda[80] = bitset<nb_msg> (string("00000000000000000101001100000000000000000000000000000000111101001100111000000000000000000000000000000000111010010000000000000000"));
00472                         lambda[81] = bitset<nb_msg> (string("00000000000000001010011100000000000000000000000000000000011110100110011100000000000000000000000000000000111110100000000000000000"));
00473                         lambda[82] = bitset<nb_msg> (string("00000000000000001101110100000000000000000000000000000000001111011011110100000000000000000000000000000000011111010000000000000000"));
00474                         lambda[83] = bitset<nb_msg> (string("00000000000000001110000000000000000000000000000000000000100100001101000000000000000000000000000000000000101100000000000000000000"));
00475                         lambda[84] = bitset<nb_msg> (string("00000000000000000111000000000000000000000000000000000000010010000110100000000000000000000000000000000000010110000000000000000000"));
00476                         lambda[85] = bitset<nb_msg> (string("00000000000000000011100000000000000000000000000000000000001001000011010000000000000000000000000000000000001011000000000000000000"));
00477                         lambda[86] = bitset<nb_msg> (string("00000000000000000001110000000000000000000000000000000000000100100001101000000000000000000000000000000000000101100000000000000000"));
00478                         lambda[87] = bitset<nb_msg> (string("00000000000000000000111000000000000000000000000000000000000010010000110100000000000000000000000000000000000010110000000000000000"));
00479                         lambda[88] = bitset<nb_msg> (string("00000000000000001110100100000000000000000000000000000000010100111111010000000000000000000000000000000000110011100000000000000000"));
00480                         lambda[89] = bitset<nb_msg> (string("00000000000000001111101000000000000000000000000000000000101001110111101000000000000000000000000000000000011001110000000000000000"));
00481                         lambda[90] = bitset<nb_msg> (string("00000000000000000111110100000000000000000000000000000000110111010011110100000000000000000000000000000000101111010000000000000000"));
00482                         lambda[91] = bitset<nb_msg> (string("00000000000000001011000000000000000000000000000000000000111000001001000000000000000000000000000000000000110100000000000000000000"));
00483                         lambda[92] = bitset<nb_msg> (string("00000000000000000101100000000000000000000000000000000000011100000100100000000000000000000000000000000000011010000000000000000000"));
00484                         lambda[93] = bitset<nb_msg> (string("00000000000000000010110000000000000000000000000000000000001110000010010000000000000000000000000000000000001101000000000000000000"));
00485                         lambda[94] = bitset<nb_msg> (string("00000000000000000001011000000000000000000000000000000000000111000001001000000000000000000000000000000000000110100000000000000000"));
00486                         lambda[95] = bitset<nb_msg> (string("00000000000000000000101100000000000000000000000000000000000011100000100100000000000000000000000000000000000011010000000000000000"));
00487                         lambda[96] = bitset<nb_msg> (string("00000000111101000000000000000000000000000000000011001110000000000000000000000000000000001110100101010011000000000000000000000000"));
00488                         lambda[97] = bitset<nb_msg> (string("00000000011110100000000000000000000000000000000001100111000000000000000000000000000000001111101010100111000000000000000000000000"));
00489                         lambda[98] = bitset<nb_msg> (string("00000000001111010000000000000000000000000000000010111101000000000000000000000000000000000111110111011101000000000000000000000000"));
00490                         lambda[99] = bitset<nb_msg> (string("00000000100100000000000000000000000000000000000011010000000000000000000000000000000000001011000011100000000000000000000000000000"));
00491                         lambda[100]= bitset<nb_msg> (string("00000000010010000000000000000000000000000000000001101000000000000000000000000000000000000101100001110000000000000000000000000000"));
00492                         lambda[101]= bitset<nb_msg> (string("00000000001001000000000000000000000000000000000000110100000000000000000000000000000000000010110000111000000000000000000000000000"));
00493                         lambda[102]= bitset<nb_msg> (string("00000000000100100000000000000000000000000000000000011010000000000000000000000000000000000001011000011100000000000000000000000000"));
00494                         lambda[103]= bitset<nb_msg> (string("00000000000010010000000000000000000000000000000000001101000000000000000000000000000000000000101100001110000000000000000000000000"));
00495                         lambda[104]= bitset<nb_msg> (string("00000000010100110000000000000000000000000000000011110100000000000000000000000000000000001100111011101001000000000000000000000000"));
00496                         lambda[105]= bitset<nb_msg> (string("00000000101001110000000000000000000000000000000001111010000000000000000000000000000000000110011111111010000000000000000000000000"));
00497                         lambda[106]= bitset<nb_msg> (string("00000000110111010000000000000000000000000000000000111101000000000000000000000000000000001011110101111101000000000000000000000000"));
00498                         lambda[107]= bitset<nb_msg> (string("00000000111000000000000000000000000000000000000010010000000000000000000000000000000000001101000010110000000000000000000000000000"));
00499                         lambda[108]= bitset<nb_msg> (string("00000000011100000000000000000000000000000000000001001000000000000000000000000000000000000110100001011000000000000000000000000000"));
00500                         lambda[109]= bitset<nb_msg> (string("00000000001110000000000000000000000000000000000000100100000000000000000000000000000000000011010000101100000000000000000000000000"));
00501                         lambda[110]= bitset<nb_msg> (string("00000000000111000000000000000000000000000000000000010010000000000000000000000000000000000001101000010110000000000000000000000000"));
00502                         lambda[111]= bitset<nb_msg> (string("00000000000011100000000000000000000000000000000000001001000000000000000000000000000000000000110100001011000000000000000000000000"));
00503                         lambda[112]= bitset<nb_msg> (string("00000000111010010000000000000000000000000000000001010011000000000000000000000000000000001111010011001110000000000000000000000000"));
00504                         lambda[113]= bitset<nb_msg> (string("00000000111110100000000000000000000000000000000010100111000000000000000000000000000000000111101001100111000000000000000000000000"));
00505                         lambda[114]= bitset<nb_msg> (string("00000000011111010000000000000000000000000000000011011101000000000000000000000000000000000011110110111101000000000000000000000000"));
00506                         lambda[115]= bitset<nb_msg> (string("00000000101100000000000000000000000000000000000011100000000000000000000000000000000000001001000011010000000000000000000000000000"));
00507                         lambda[116]= bitset<nb_msg> (string("00000000010110000000000000000000000000000000000001110000000000000000000000000000000000000100100001101000000000000000000000000000"));
00508                         lambda[117]= bitset<nb_msg> (string("00000000001011000000000000000000000000000000000000111000000000000000000000000000000000000010010000110100000000000000000000000000"));
00509                         lambda[118]= bitset<nb_msg> (string("00000000000101100000000000000000000000000000000000011100000000000000000000000000000000000001001000011010000000000000000000000000"));
00510                         lambda[119]= bitset<nb_msg> (string("00000000000010110000000000000000000000000000000000001110000000000000000000000000000000000000100100001101000000000000000000000000"));
00511                         lambda[120]= bitset<nb_msg> (string("00000000110011100000000000000000000000000000000011101001000000000000000000000000000000000101001111110100000000000000000000000000"));
00512                         lambda[121]= bitset<nb_msg> (string("00000000011001110000000000000000000000000000000011111010000000000000000000000000000000001010011101111010000000000000000000000000"));
00513                         lambda[122]= bitset<nb_msg> (string("00000000101111010000000000000000000000000000000001111101000000000000000000000000000000001101110100111101000000000000000000000000"));
00514                         lambda[123]= bitset<nb_msg> (string("00000000110100000000000000000000000000000000000010110000000000000000000000000000000000001110000010010000000000000000000000000000"));
00515                         lambda[124]= bitset<nb_msg> (string("00000000011010000000000000000000000000000000000001011000000000000000000000000000000000000111000001001000000000000000000000000000"));
00516                         lambda[125]= bitset<nb_msg> (string("00000000001101000000000000000000000000000000000000101100000000000000000000000000000000000011100000100100000000000000000000000000"));
00517                         lambda[126]= bitset<nb_msg> (string("00000000000110100000000000000000000000000000000000010110000000000000000000000000000000000001110000010010000000000000000000000000"));
00518                         lambda[127]= bitset<nb_msg> (string("00000000000011010000000000000000000000000000000000001011000000000000000000000000000000000000111000001001000000000000000000000000"));
00519                         */
00520         }
00521 
00522         // To acces element (I,J) of matrix lambda use:
00523         // lambda(I,J) = lambda[I+J*nb_msg]
00524         //vector x matrix PRODUCT
00525         for ( unsigned i = 0 ; i < nb_msg ; ++i ){
00526                 c[i] = 0 ;
00527                 for ( unsigned j = 0 ; j < nb_msg ; ++j ) {
00528                         c[i] = c[i] ^ ( m[j] & lambda[nb_msg-j-1][i] ) ;
00529                 }
00530         }
00531         /*for ( unsigned i = 0 ; i < nb_msg ; ++i ){
00532                 c[i] = 0 ;
00533                 for ( unsigned j = 0 ; j < nb_msg ; ++j ) {
00534                         c[i] = c[i] ^ ( m[j] & lambda[i+j*nb_msg] ) ;
00535                 }
00536         }*/
00537 
00538         return c ;
00539 }
00540 
00544 
00546 
00621 template <unsigned nb_sbox, unsigned nround>
00622 inline
00623 typename Bunny24m24k<nb_sbox,nround>::sboxType
00624 Bunny24m24k<nb_sbox,nround>::sbox(unsigned nbox, sboxType x) {
00625 
00626   int s_table[4][64] = { {   0,  1, 45, 54, 59, 18, 27, 30, 48, 10,  9, 49, 32, 62, 15, 14,
00627                             24, 51,  5, 58, 41, 56, 53, 35, 16, 50, 31,  6, 42, 38,  7, 26,
00628                             12, 63, 52, 23, 47, 61, 29, 43, 57, 20, 28, 39, 55,  2, 60, 36,
00629                              8, 11, 25, 17, 34, 22,  3, 44, 21, 40, 19,  4, 46, 37, 13, 33  },
00630                         {    0,  1, 32, 51, 49,  3, 63, 31, 36,  4, 59,  9, 62, 45, 15, 14,
00631                              7,  5, 54, 38,  8, 57, 23, 52, 30, 61, 16, 33, 58, 42, 26, 24,
00632                             13, 43, 22, 34, 41, 60, 28, 27, 55, 48, 19,  6, 56, 12, 50, 20,
00633                             47, 10, 37, 18, 53, 35, 17, 21, 40, 44, 29, 11, 25, 46,  2, 39  },
00634                         {    0,  1, 38, 54, 37, 18, 43, 13, 20, 50, 25, 46, 42, 58, 15, 14,
00635                             32, 51,  5,  7, 47, 10, 34, 22, 12, 56,  2, 39, 24, 26, 62, 45,
00636                             28, 27, 35, 53,  8, 57, 31, 63,  4, 36, 16, 33, 11, 29, 55, 48,
00637                             41, 60, 21, 17, 23, 52,  3, 49,  9, 59, 30, 61, 44, 40, 19,  6  },
00638                         {   4,  5, 34, 50, 33, 22, 47,  9, 16, 54, 29, 42, 46, 62, 11, 10,
00639                            36, 55,  1,  3, 43, 14, 38, 18,  8, 60,  6, 35, 28, 30, 58, 41,
00640                            24, 31, 39, 49, 12, 61, 27, 59,  0, 32, 20, 37, 15, 25, 51, 52,
00641                            45, 56, 17, 21, 19, 48,  7, 53, 13, 63, 26, 57, 40, 44, 23,  2   } } ;
00642   return sboxType ( s_table[nbox][x.to_ulong()] ) ;
00643 }
00644 
00646 template <unsigned nb_sbox, unsigned nround>
00647 inline
00648 typename Bunny24m24k<nb_sbox,nround>::sboxType
00649 Bunny24m24k<nb_sbox,nround>::sboxInverse(unsigned nbox, sboxType x) {
00650   static int sInv_table[4][64] = {   {  0,  1, 45, 54, 59, 18, 27, 30, 48, 10,  9, 49, 32, 62, 15, 14,
00651                                            24, 51,  5, 58, 41, 56, 53, 35, 16, 50, 31,  6, 42, 38,  7, 26,
00652                                            12, 63, 52, 23, 47, 61, 29, 43, 57, 20, 28, 39, 55,  2, 60, 36,
00653                                             8, 11, 25, 17, 34, 22,  3, 44, 21, 40, 19,  4, 46, 37, 13, 33  },
00654                                      {  0,  1, 62,  5,  9, 17, 43, 16, 20, 11, 49, 59, 45, 32, 15, 14,
00655                                        26, 54, 51, 42, 47, 55, 34, 22, 31, 60, 30, 39, 38, 58, 24,  7,
00656                                         2, 27, 35, 53,  8, 50, 19, 63, 56, 36, 29, 33, 57, 13, 61, 48,
00657                                        41,  4, 46,  3, 23, 52, 18, 40, 44, 21, 28, 10, 37, 25,  12, 6  },
00658                                      {  0,  1, 26, 54, 40, 18, 63, 19, 36, 56, 21, 44, 24,  7, 15, 14,
00659                                        42, 51,  5, 62,  8, 50, 23, 52, 28, 10, 29, 33, 32, 45, 58, 38,
00660                                        16, 43, 22, 34, 41,  4,  2, 27, 61, 48, 12,  6, 60, 31, 11, 20,
00661                                        47, 55,  9, 17, 53, 35,  3, 46, 25, 37, 13, 57, 49, 59, 30, 39  },
00662                                      { 40, 18, 63, 19,  0,  1, 26, 54, 24,  7, 15, 14, 36, 56, 21, 44,
00663                                         8, 50, 23, 52, 42, 51,  5, 62, 32, 45, 58, 38, 28, 10, 29, 33,
00664                                        41,  4,  2, 27, 16, 43, 22, 34, 60, 31, 11, 20, 61, 48, 12,  6,
00665                                        53, 35,  3, 46, 47, 55,  9, 17, 49, 59, 30, 39, 25, 37, 13, 57  } } ;
00666   return sboxType ( sInv_table[nbox][x.to_ulong()] );
00667 }
00668 
 All Classes Functions Variables Typedefs