Bunny2.0
Headers/Bunny3243545.hxx
00001 //#ifdef WIN32
00002   //  #include "stdafx.h" // works for Visual C++ 2010
00003 //#endif
00004 
00005 #include <iostream>
00006 #include <stdio.h>
00007 #include <stdlib.h>
00008 #include <time.h>
00009 #include <iomanip> // to use the function setw()
00010 #include <bitset> // to use the bitset class
00011 #include <vector>
00012 
00013 #include <math.h>
00014 
00015 
00016 // using namespace Bunny<nb_msg,nb_key,nb_sbox,nround> ;
00017 using namespace std ;
00018 
00022 
00023 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00024 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::sboxType
00025 Bunny<nb_msg,nb_key,nb_sbox,nround>::extractBlock( unsigned nblk, msgType x ) {
00026   sboxType y ;
00027   for ( unsigned i = 0 ; i < nb_sbox ; ++i) y[i] = x[i+nblk*nb_sbox] ;
00028   return y ;
00029 }
00030 
00031 
00032 
00033 
00034 
00042 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00043 inline
00044 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::msgType
00045 Bunny<nb_msg,nb_key,nb_sbox,nround>::encode( msgType m, keyType k ) {
00046         msgType c ;
00047         c = m ;
00048         Bunny<nb_msg,nb_key,nb_sbox,nround>::keySchedule(k) ;
00049         //Round 0, a-tipical
00050         c = Bunny<nb_msg,nb_key,nb_sbox,nround>::addRoundKey(c,rk[0]) ;
00051         //cout << "state at round: 0 --> " << bitsetToHex(c) << endl ;
00052         //Tipical rounds
00053         for (unsigned i = 1 ; i <= nround ; ++i){
00054                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::sBox(c) ;
00055                 //cout << "state after sBox: --> " << bitsetToHex(c) << endl ;
00056                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::mixingLayer(c) ;
00057                 //cout << "state after mixL: --> " << bitsetToHex(c) << endl ;
00058                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::addRoundKey(c,rk[i]) ;
00059                 //cout << "state at round: " << i <<  " --> " << bitsetToHex(c) << endl ;
00060         }
00061         return c ;
00062 }
00063 
00071 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00072 inline
00073 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::msgType
00074 Bunny<nb_msg,nb_key,nb_sbox,nround>::decode (msgType m, keyType k) {
00075         msgType c ;
00076         c = m ;
00077         //keyschedule
00078         Bunny<nb_msg,nb_key,nb_sbox,nround>::keySchedule(k) ;
00079         //Tipical rounds
00080         for (unsigned i = nround ; i > 0 ; --i){
00081                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::addRoundKey(c,rk[i]) ;
00082                 //cout <<   "state after add round: " << i <<  " --> " << bitsetToHex(c) << endl ;
00083                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::mixingLayerInverse(c) ;
00084                 //cout << "state after mixLInv: --> " << bitsetToHex(c) << endl ;
00085                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::sBoxInverse(c) ;
00086                 //cout << "state after sBoxInv: --> " << bitsetToHex(c) << endl ;
00087         }
00088         //Round 0, a-tipical
00089         c = Bunny<nb_msg,nb_key,nb_sbox,nround>::addRoundKey(c,rk[0]) ;
00090         return c ;
00091 }
00092 
00096 
00103 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00104 inline
00105 void Bunny<nb_msg,nb_key,nb_sbox,nround>::keySchedule(keyType k) {
00106         //number of word generated
00107         unsigned nword = 80 ;//(nround+10) * 4 ;//to have some more bitsj
00108         //dimension of the blocks that fill the round keys
00109         //i.e.: nrow round keys at a time are filled
00110         unsigned ncol = nb_msg/nb_sbox ;
00111         unsigned nrow = nb_msg/nb_sbox + 1 ;
00112         vector<sboxType> w ;
00113 
00114         w.resize(nword) ; // initialize a vector of nword elements of type sboxType, set to 00...0
00115 
00116         //CREATE W, a vector of 80 words
00117         //put the key bits in the first 4 words
00118         for (unsigned i = 0 ; i < (nb_msg/nb_sbox) ; ++i){
00119                 w[i] = Bunny<nb_msg,nb_key,nb_sbox,nround>::extract(i*nb_sbox,k) ;
00120         }
00121         w[4] = Bunny<nb_msg,nb_key,nb_sbox,nround>::s1(w[0]) ^ w[1];
00122         w[5] = Bunny<nb_msg,nb_key,nb_sbox,nround>::s2(w[1]) ^ w[2];
00123         w[6] = Bunny<nb_msg,nb_key,nb_sbox,nround>::s3(w[2]) ^ w[3];
00124         w[7] = Bunny<nb_msg,nb_key,nb_sbox,nround>::s4(w[3]) ^ w[0];
00125 
00126         for (unsigned i = 8; i < w.size() ; ++i){
00127                 // se i = 0 mod 8 => w[i] = w[i-8] ^ s2(RB(w[i-1])) + 101010
00128                 if (i % 8 == 0) w[i] = w[i-8] ^ Bunny<nb_msg,nb_key,nb_sbox,nround>::s2((w[i-1]<<1)) ^ sboxType (string("101010")) ;
00129                 // se i = 4 mod 8 => w[i] = w[i-8] ^ s3(w[i-1])
00130                 else if (i % 8 == 4) w[i] = w[i-8] ^ Bunny<nb_msg,nb_key,nb_sbox,nround>::s3(w[i-1]) ;
00131                 // se i != 0 mod 4 w[i] = w[i-8] ^ w[i-1]
00132                 else w[i] = w[i-8] ^ w[i-1] ;
00133         }
00134 
00135         //CREATE the ROUND KEYS
00136         //0,5,10,15
00137         //1,6,11,16
00138         //2,7,12,17
00139         //3,8,13,18
00140         //4,9,14,19
00141         //..
00142         //20,25,30,35...
00143         unsigned pos = 0 ;
00144         for (unsigned i = 0 ; i <= nround ; ++i){
00145                 if ( (i % nrow) == 0 ) pos = i * ncol ;
00146                 for (unsigned j = 0 ; j < ncol ; ++j){
00147                         rk[i] = Bunny<nb_msg,nb_key,nb_sbox,nround>::copy(rk[i],j*nb_sbox,w[pos+j*nrow]) ;
00148                 }
00149                 ++pos ;
00150         }
00151 
00152         //Print W
00153         /*cout << endl ;
00154         cout << "k = " << k << endl ;
00155         cout << "W = " << endl ;
00156         for (unsigned i = 0; i < w.size() ; ++i){
00157                 if (i % 4 == 3) cout << " " << w[i] << endl ;
00158                 else cout << " " << w[i] ;
00159         }*/
00160 return ;
00161 }
00162 
00166 
00175 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00176 inline
00177 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::msgType
00178 Bunny<nb_msg,nb_key,nb_sbox,nround>::addRoundKey (msgType m, msgType k){
00179         return m ^ k;
00180 }
00181 
00185 
00196 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00197 inline
00198 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::msgType
00199 Bunny<nb_msg,nb_key,nb_sbox,nround>::sBox (msgType m){
00200         msgType c ;
00201         c = m ;
00202         sboxType s ;
00203 
00204         //unsigned n = nb_msg / nb_sbox ;
00205         //for (unsigned i = 0 ; i < n ; ++i){
00206                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::extract(0*nb_sbox,m) ; // extract nb_sbox bits starting from left to right
00207                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::s1(s) ; // elaborate the nb_sbox bits extracted
00208                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::copy(c,0*nb_sbox,s) ; // put nb_bit bits in the position i*nb_sbox of the message c
00209 
00210                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::extract(1*nb_sbox,m) ; // extract nb_sbox bits starting from left to right
00211                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::s2(s) ; // elaborate the nb_sbox bits extracted
00212                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::copy(c,1*nb_sbox,s) ; // put nb_bit bits in the position i*nb_sbox of the message c
00213 
00214                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::extract(2*nb_sbox,m) ; // extract nb_sbox bits starting from left to right
00215                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::s3(s) ; // elaborate the nb_sbox bits extracted
00216                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::copy(c,2*nb_sbox,s) ; // put nb_bit bits in the position i*nb_sbox of the message c
00217 
00218                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::extract(3*nb_sbox,m) ; // extract nb_sbox bits starting from left to right
00219                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::s4(s) ; // elaborate the nb_sbox bits extracted
00220                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::copy(c,3*nb_sbox,s) ; // put nb_bit bits in the position i*nb_sbox of the message c
00221         //}
00222         return c;
00223 }
00224 
00228 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00229 inline
00230 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::msgType
00231 Bunny<nb_msg,nb_key,nb_sbox,nround>::sBoxInverse (msgType m){
00232         msgType c ;
00233         c = m ;
00234         sboxType s ;
00235 
00236         //unsigned n = nb_msg / nb_sbox ;
00237         //for (unsigned i = 0 ; i < n ; ++i){
00238                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::extract(0*nb_sbox,m) ; // extract nb_sbox bits starting from left to right
00239                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::s1Inv(s) ; // elaborate the nb_sbox bits extracted
00240                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::copy(c,0*nb_sbox,s) ; // put nb_bit bits in the position i*nb_sbox of the message c
00241 
00242                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::extract(1*nb_sbox,m) ; // extract nb_sbox bits starting from left to right
00243                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::s2Inv(s) ; // elaborate the nb_sbox bits extracted
00244                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::copy(c,1*nb_sbox,s) ; // put nb_bit bits in the position i*nb_sbox of the message c
00245 
00246                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::extract(2*nb_sbox,m) ; // extract nb_sbox bits starting from left to right
00247                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::s3Inv(s) ; // elaborate the nb_sbox bits extracted
00248                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::copy(c,2*nb_sbox,s) ; // put nb_bit bits in the position i*nb_sbox of the message c
00249 
00250                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::extract(3*nb_sbox,m) ; // extract nb_sbox bits starting from left to right
00251                 s = Bunny<nb_msg,nb_key,nb_sbox,nround>::s4Inv(s) ; // elaborate the nb_sbox bits extracted
00252                 c = Bunny<nb_msg,nb_key,nb_sbox,nround>::copy(c,3*nb_sbox,s) ; // put nb_bit bits in the position i*nb_sbox of the message c
00253         //}
00254         return c;
00255 }
00256 
00260 
00269 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00270 inline
00271 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::msgType
00272 Bunny<nb_msg,nb_key,nb_sbox,nround>::mixingLayer (msgType m ){
00273         bitset<nb_msg> lambda[nb_msg] ;
00274         msgType c ;
00275         //creazione di lambda
00276         if (m.size() == 24){
00277                 lambda[0]  = bitset<nb_msg> (string("001010001000110011100101"));
00278                 lambda[1]  = bitset<nb_msg> (string("000101000100110100111111"));
00279                 lambda[2]  = bitset<nb_msg> (string("101111000010011010110010"));
00280                 lambda[3]  = bitset<nb_msg> (string("111010000001001101011001"));
00281                 lambda[4]  = bitset<nb_msg> (string("011101101101101011100001"));
00282                 lambda[5]  = bitset<nb_msg> (string("100011111011111000111101"));
00283                 lambda[6]  = bitset<nb_msg> (string("100001000101011000000010"));
00284                 lambda[7]  = bitset<nb_msg> (string("111101101111001100000001"));
00285                 lambda[8]  = bitset<nb_msg> (string("110011111010000110101101"));
00286                 lambda[9]  = bitset<nb_msg> (string("110100011101000011111011"));
00287                 lambda[10] = bitset<nb_msg> (string("011010100011101100110000"));
00288                 lambda[11] = bitset<nb_msg> (string("001101111100010110011000"));
00289                 lambda[12] = bitset<nb_msg> (string("111011110001111000001001"));
00290                 lambda[13] = bitset<nb_msg> (string("110000110101011100101001"));
00291                 lambda[14] = bitset<nb_msg> (string("011000110111001110111001"));
00292                 lambda[15] = bitset<nb_msg> (string("001100110110000111110001"));
00293                 lambda[16] = bitset<nb_msg> (string("000110011011101110110101"));
00294                 lambda[17] = bitset<nb_msg> (string("000011100000010111110111"));
00295                 lambda[18] = bitset<nb_msg> (string("110000011100110011001110"));
00296                 lambda[19] = bitset<nb_msg> (string("011000001110110100000111"));
00297                 lambda[20] = bitset<nb_msg> (string("001100000111011010101110"));
00298                 lambda[21] = bitset<nb_msg> (string("000110101110001101010111"));
00299                 lambda[22] = bitset<nb_msg> (string("000011010111101011100110"));
00300                 lambda[23] = bitset<nb_msg> (string("101100100110111000010011"));
00301 
00302                 // To acces element (I,J) of matrix lambda use:
00303                 // lambda(I,J) = lambda[I+J*nb_msg]
00304                 //vector x matrix PRODUCT
00305                 for ( unsigned i = 0 ; i < nb_msg ; ++i ){
00306                         c[i] = 0 ;
00307                         for ( unsigned j = 0 ; j < nb_msg ; ++j ) {
00308                                 c[i] = c[i] ^ ( m[j] & lambda[nb_msg-j-1][i] ) ;
00309                         }
00310                 }
00311         }
00312         else if (m.size() == 128){
00313                 /*
00314                 lambda[0]   = bitset<nb_msg> (string("00011101100000001000000010011101000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00315                 lambda[1]   = bitset<nb_msg> (string("10000000010000000100000011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00316                 lambda[2]   = bitset<nb_msg> (string("01000000001000000010000001100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00317                 lambda[3]   = bitset<nb_msg> (string("00100000000100000001000000110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00318                 lambda[4]   = bitset<nb_msg> (string("00010000000010000000100000011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00319                 lambda[5]   = bitset<nb_msg> (string("00001000000001000000010000001100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00320                 lambda[6]   = bitset<nb_msg> (string("00000100000000100000001000000110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00321                 lambda[7]   = bitset<nb_msg> (string("00000010000000010000000100000011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00322                 lambda[8]   = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010011101000111011000000010000000"));
00323                 lambda[9]   = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011000000100000000100000001000000"));
00324                 lambda[10]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001100000010000000010000000100000"));
00325                 lambda[11]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000110000001000000001000000010000"));
00326                 lambda[12]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011000000100000000100000001000"));
00327                 lambda[13]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001100000010000000010000000100"));
00328                 lambda[14]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000110000001000000001000000010"));
00329                 lambda[15]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011000000100000000100000001"));
00330                 lambda[16]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000001000000010011101000111011000000000000000000000000000000000000000"));
00331                 lambda[17]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000100000011000000100000000100000000000000000000000000000000000000"));
00332                 lambda[18]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000010000001100000010000000010000000000000000000000000000000000000"));
00333                 lambda[19]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000001000000110000001000000001000000000000000000000000000000000000"));
00334                 lambda[20]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000100000011000000100000000100000000000000000000000000000000000"));
00335                 lambda[21]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000010000001100000010000000010000000000000000000000000000000000"));
00336                 lambda[22]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000001000000110000001000000001000000000000000000000000000000000"));
00337                 lambda[23]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000100000011000000100000000100000000000000000000000000000000"));
00338                 lambda[24]  = bitset<nb_msg> (string("00000000000000000000000000000000100000001000000010011101000111010000000000000000000000000000000000000000000000000000000000000000"));
00339                 lambda[25]  = bitset<nb_msg> (string("00000000000000000000000000000000010000000100000011000000100000000000000000000000000000000000000000000000000000000000000000000000"));
00340                 lambda[26]  = bitset<nb_msg> (string("00000000000000000000000000000000001000000010000001100000010000000000000000000000000000000000000000000000000000000000000000000000"));
00341                 lambda[27]  = bitset<nb_msg> (string("00000000000000000000000000000000000100000001000000110000001000000000000000000000000000000000000000000000000000000000000000000000"));
00342                 lambda[28]  = bitset<nb_msg> (string("00000000000000000000000000000000000010000000100000011000000100000000000000000000000000000000000000000000000000000000000000000000"));
00343                 lambda[29]  = bitset<nb_msg> (string("00000000000000000000000000000000000001000000010000001100000010000000000000000000000000000000000000000000000000000000000000000000"));
00344                 lambda[30]  = bitset<nb_msg> (string("00000000000000000000000000000000000000100000001000000110000001000000000000000000000000000000000000000000000000000000000000000000"));
00345                 lambda[31]  = bitset<nb_msg> (string("00000000000000000000000000000000000000010000000100000011000000100000000000000000000000000000000000000000000000000000000000000000"));
00346                 lambda[32]  = bitset<nb_msg> (string("00000000000000000000000000000000000111011000000010000000100111010000000000000000000000000000000000000000000000000000000000000000"));
00347                 lambda[33]  = bitset<nb_msg> (string("00000000000000000000000000000000100000000100000001000000110000000000000000000000000000000000000000000000000000000000000000000000"));
00348                 lambda[34]  = bitset<nb_msg> (string("00000000000000000000000000000000010000000010000000100000011000000000000000000000000000000000000000000000000000000000000000000000"));
00349                 lambda[35]  = bitset<nb_msg> (string("00000000000000000000000000000000001000000001000000010000001100000000000000000000000000000000000000000000000000000000000000000000"));
00350                 lambda[36]  = bitset<nb_msg> (string("00000000000000000000000000000000000100000000100000001000000110000000000000000000000000000000000000000000000000000000000000000000"));
00351                 lambda[37]  = bitset<nb_msg> (string("00000000000000000000000000000000000010000000010000000100000011000000000000000000000000000000000000000000000000000000000000000000"));
00352                 lambda[38]  = bitset<nb_msg> (string("00000000000000000000000000000000000001000000001000000010000001100000000000000000000000000000000000000000000000000000000000000000"));
00353                 lambda[39]  = bitset<nb_msg> (string("00000000000000000000000000000000000000100000000100000001000000110000000000000000000000000000000000000000000000000000000000000000"));
00354                 lambda[40]  = bitset<nb_msg> (string("10011101000111011000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00355                 lambda[41]  = bitset<nb_msg> (string("11000000100000000100000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00356                 lambda[42]  = bitset<nb_msg> (string("01100000010000000010000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00357                 lambda[43]  = bitset<nb_msg> (string("00110000001000000001000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00358                 lambda[44]  = bitset<nb_msg> (string("00011000000100000000100000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00359                 lambda[45]  = bitset<nb_msg> (string("00001100000010000000010000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00360                 lambda[46]  = bitset<nb_msg> (string("00000110000001000000001000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00361                 lambda[47]  = bitset<nb_msg> (string("00000011000000100000000100000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00362                 lambda[48]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000100111010001110110000000"));
00363                 lambda[49]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000110000001000000001000000"));
00364                 lambda[50]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000011000000100000000100000"));
00365                 lambda[51]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000001100000010000000010000"));
00366                 lambda[52]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000110000001000000001000"));
00367                 lambda[53]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000011000000100000000100"));
00368                 lambda[54]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000001100000010000000010"));
00369                 lambda[55]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000110000001000000001"));
00370                 lambda[56]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000001000000010000000100111010001110100000000000000000000000000000000"));
00371                 lambda[57]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000100000001000000110000001000000000000000000000000000000000000000"));
00372                 lambda[58]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000010000000100000011000000100000000000000000000000000000000000000"));
00373                 lambda[59]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000001000000010000001100000010000000000000000000000000000000000000"));
00374                 lambda[60]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000100000001000000110000001000000000000000000000000000000000000"));
00375                 lambda[61]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000010000000100000011000000100000000000000000000000000000000000"));
00376                 lambda[62]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000001000000010000001100000010000000000000000000000000000000000"));
00377                 lambda[63]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000100000001000000110000001000000000000000000000000000000000"));
00378                 lambda[64]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000001110110000000100000001001110100000000000000000000000000000000"));
00379                 lambda[65]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000001000000001000000010000001100000000000000000000000000000000000000"));
00380                 lambda[66]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000100000000100000001000000110000000000000000000000000000000000000"));
00381                 lambda[67]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000010000000010000000100000011000000000000000000000000000000000000"));
00382                 lambda[68]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000001000000001000000010000001100000000000000000000000000000000000"));
00383                 lambda[69]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000100000000100000001000000110000000000000000000000000000000000"));
00384                 lambda[70]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000010000000010000000100000011000000000000000000000000000000000"));
00385                 lambda[71]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000001000000001000000010000001100000000000000000000000000000000"));
00386                 lambda[72]  = bitset<nb_msg> (string("00000000000000000000000000000000100111010001110110000000100000000000000000000000000000000000000000000000000000000000000000000000"));
00387                 lambda[73]  = bitset<nb_msg> (string("00000000000000000000000000000000110000001000000001000000010000000000000000000000000000000000000000000000000000000000000000000000"));
00388                 lambda[74]  = bitset<nb_msg> (string("00000000000000000000000000000000011000000100000000100000001000000000000000000000000000000000000000000000000000000000000000000000"));
00389                 lambda[75]  = bitset<nb_msg> (string("00000000000000000000000000000000001100000010000000010000000100000000000000000000000000000000000000000000000000000000000000000000"));
00390                 lambda[76]  = bitset<nb_msg> (string("00000000000000000000000000000000000110000001000000001000000010000000000000000000000000000000000000000000000000000000000000000000"));
00391                 lambda[77]  = bitset<nb_msg> (string("00000000000000000000000000000000000011000000100000000100000001000000000000000000000000000000000000000000000000000000000000000000"));
00392                 lambda[78]  = bitset<nb_msg> (string("00000000000000000000000000000000000001100000010000000010000000100000000000000000000000000000000000000000000000000000000000000000"));
00393                 lambda[79]  = bitset<nb_msg> (string("00000000000000000000000000000000000000110000001000000001000000010000000000000000000000000000000000000000000000000000000000000000"));
00394                 lambda[80]  = bitset<nb_msg> (string("10000000100111010001110110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00395                 lambda[81]  = bitset<nb_msg> (string("01000000110000001000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00396                 lambda[82]  = bitset<nb_msg> (string("00100000011000000100000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00397                 lambda[83]  = bitset<nb_msg> (string("00010000001100000010000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00398                 lambda[84]  = bitset<nb_msg> (string("00001000000110000001000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00399                 lambda[85]  = bitset<nb_msg> (string("00000100000011000000100000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00400                 lambda[86]  = bitset<nb_msg> (string("00000010000001100000010000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00401                 lambda[87]  = bitset<nb_msg> (string("00000001000000110000001000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00402                 lambda[88]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000100000001001110100011101"));
00403                 lambda[89]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000010000001100000010000000"));
00404                 lambda[90]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000001000000110000001000000"));
00405                 lambda[91]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000100000011000000100000"));
00406                 lambda[92]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000010000001100000010000"));
00407                 lambda[93]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000001000000110000001000"));
00408                 lambda[94]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000100000011000000100"));
00409                 lambda[95]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000010000001100000010"));
00410                 lambda[96]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011101100000001000000010011101"));
00411                 lambda[97]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000010000000100000011000000"));
00412                 lambda[98]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000001000000010000001100000"));
00413                 lambda[99]  = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000100000001000000110000"));
00414                 lambda[100] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000010000000100000011000"));
00415                 lambda[101] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000001000000010000001100"));
00416                 lambda[102] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000100000001000000110"));
00417                 lambda[103] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000010000000100000011"));
00418                 lambda[104] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000001001110100011101100000001000000000000000000000000000000000000000"));
00419                 lambda[105] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000001100000010000000010000000100000000000000000000000000000000000000"));
00420                 lambda[106] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000110000001000000001000000010000000000000000000000000000000000000"));
00421                 lambda[107] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000011000000100000000100000001000000000000000000000000000000000000"));
00422                 lambda[108] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000001100000010000000010000000100000000000000000000000000000000000"));
00423                 lambda[109] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000110000001000000001000000010000000000000000000000000000000000"));
00424                 lambda[110] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000011000000100000000100000001000000000000000000000000000000000"));
00425                 lambda[111] = bitset<nb_msg> (string("00000000000000000000000000000000000000000000000000000000000000000000001100000010000000010000000100000000000000000000000000000000"));
00426                 lambda[112] = bitset<nb_msg> (string("00000000000000000000000000000000100000001001110100011101100000000000000000000000000000000000000000000000000000000000000000000000"));
00427                 lambda[113] = bitset<nb_msg> (string("00000000000000000000000000000000010000001100000010000000010000000000000000000000000000000000000000000000000000000000000000000000"));
00428                 lambda[114] = bitset<nb_msg> (string("00000000000000000000000000000000001000000110000001000000001000000000000000000000000000000000000000000000000000000000000000000000"));
00429                 lambda[115] = bitset<nb_msg> (string("00000000000000000000000000000000000100000011000000100000000100000000000000000000000000000000000000000000000000000000000000000000"));
00430                 lambda[116] = bitset<nb_msg> (string("00000000000000000000000000000000000010000001100000010000000010000000000000000000000000000000000000000000000000000000000000000000"));
00431                 lambda[117] = bitset<nb_msg> (string("00000000000000000000000000000000000001000000110000001000000001000000000000000000000000000000000000000000000000000000000000000000"));
00432                 lambda[118] = bitset<nb_msg> (string("00000000000000000000000000000000000000100000011000000100000000100000000000000000000000000000000000000000000000000000000000000000"));
00433                 lambda[119] = bitset<nb_msg> (string("00000000000000000000000000000000000000010000001100000010000000010000000000000000000000000000000000000000000000000000000000000000"));
00434                 lambda[120] = bitset<nb_msg> (string("10000000100000001001110100011101000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00435                 lambda[121] = bitset<nb_msg> (string("01000000010000001100000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00436                 lambda[122] = bitset<nb_msg> (string("00100000001000000110000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00437                 lambda[123] = bitset<nb_msg> (string("00010000000100000011000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00438                 lambda[124] = bitset<nb_msg> (string("00001000000010000001100000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00439                 lambda[125] = bitset<nb_msg> (string("00000100000001000000110000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00440                 lambda[126] = bitset<nb_msg> (string("00000010000000100000011000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00441                 lambda[127] = bitset<nb_msg> (string("00000001000000010000001100000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
00442                 */
00443                 //c = Bunny<nb_msg,nb_key,nb_sbox,nround>::shiftRows(c) ;
00444                 //c = Bunny<nb_msg,nb_key,nb_sbox,nround>::mixColumns(c) ;
00445         }
00446 
00447 
00448 
00449         return c ;
00450 }
00451 
00455 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00456 inline
00457 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::msgType
00458 Bunny<nb_msg,nb_key,nb_sbox,nround>::mixingLayerInverse (msgType m ){
00459         bitset<nb_msg> lambda[nb_msg] ;
00460         msgType c ;
00461         //creazione di lambda
00462         if (m.size() == 24){
00463                 lambda[0]  = bitset<nb_msg> (string("010100111011001100100010"));
00464                 lambda[1]  = bitset<nb_msg> (string("001010110000000110010001"));
00465                 lambda[2]  = bitset<nb_msg> (string("000101011000000011100101"));
00466                 lambda[3]  = bitset<nb_msg> (string("101111001100101100111111"));
00467                 lambda[4]  = bitset<nb_msg> (string("111010000110010110110010"));
00468                 lambda[5]  = bitset<nb_msg> (string("011101000011001011011001"));
00469                 lambda[6]  = bitset<nb_msg> (string("010101001011011110100101"));
00470                 lambda[7]  = bitset<nb_msg> (string("100111101000001111111111"));
00471                 lambda[8]  = bitset<nb_msg> (string("111110010100101010110010"));
00472                 lambda[9]  = bitset<nb_msg> (string("011111001010010101011001"));
00473                 lambda[10] = bitset<nb_msg> (string("100010000101100111100001"));
00474                 lambda[11] = bitset<nb_msg> (string("010001101111111110111101"));
00475                 lambda[12] = bitset<nb_msg> (string("001101111000010011000001"));
00476                 lambda[13] = bitset<nb_msg> (string("101011011100100100101101"));
00477                 lambda[14] = bitset<nb_msg> (string("111000001110010010111011"));
00478                 lambda[15] = bitset<nb_msg> (string("011100000111001001110000"));
00479                 lambda[16] = bitset<nb_msg> (string("001110101110101001011000"));
00480                 lambda[17] = bitset<nb_msg> (string("000111010111111001001100"));
00481                 lambda[18] = bitset<nb_msg> (string("101100101000100001100110"));
00482                 lambda[19] = bitset<nb_msg> (string("010110010100111101010011"));
00483                 lambda[20] = bitset<nb_msg> (string("001011001010110011100100"));
00484                 lambda[21] = bitset<nb_msg> (string("101000000101110100010010"));
00485                 lambda[22] = bitset<nb_msg> (string("010100101111011010001001"));
00486                 lambda[23] = bitset<nb_msg> (string("001010111010001101101001"));
00487         }
00488         else if (m.size() == 128){
00489                         /*
00490                         lambda[0]  = bitset<nb_msg> (string("01010011000000000000000000000000000000001111010000000000000000000000000000000000110011100000000000000000000000000000000011101001"));
00491                         lambda[1]  = bitset<nb_msg> (string("10100111000000000000000000000000000000000111101000000000000000000000000000000000011001110000000000000000000000000000000011111010"));
00492                         lambda[2]  = bitset<nb_msg> (string("11011101000000000000000000000000000000000011110100000000000000000000000000000000101111010000000000000000000000000000000001111101"));
00493                         lambda[3]  = bitset<nb_msg> (string("11100000000000000000000000000000000000001001000000000000000000000000000000000000110100000000000000000000000000000000000010110000"));
00494                         lambda[4]  = bitset<nb_msg> (string("01110000000000000000000000000000000000000100100000000000000000000000000000000000011010000000000000000000000000000000000001011000"));
00495                         lambda[5]  = bitset<nb_msg> (string("00111000000000000000000000000000000000000010010000000000000000000000000000000000001101000000000000000000000000000000000000101100"));
00496                         lambda[6]  = bitset<nb_msg> (string("00011100000000000000000000000000000000000001001000000000000000000000000000000000000110100000000000000000000000000000000000010110"));
00497                         lambda[7]  = bitset<nb_msg> (string("00001110000000000000000000000000000000000000100100000000000000000000000000000000000011010000000000000000000000000000000000001011"));
00498                         lambda[8]  = bitset<nb_msg> (string("11101001000000000000000000000000000000000101001100000000000000000000000000000000111101000000000000000000000000000000000011001110"));
00499                         lambda[9]  = bitset<nb_msg> (string("11111010000000000000000000000000000000001010011100000000000000000000000000000000011110100000000000000000000000000000000001100111"));
00500                         lambda[10] = bitset<nb_msg> (string("01111101000000000000000000000000000000001101110100000000000000000000000000000000001111010000000000000000000000000000000010111101"));
00501                         lambda[11] = bitset<nb_msg> (string("10110000000000000000000000000000000000001110000000000000000000000000000000000000100100000000000000000000000000000000000011010000"));
00502                         lambda[12] = bitset<nb_msg> (string("01011000000000000000000000000000000000000111000000000000000000000000000000000000010010000000000000000000000000000000000001101000"));
00503                         lambda[13] = bitset<nb_msg> (string("00101100000000000000000000000000000000000011100000000000000000000000000000000000001001000000000000000000000000000000000000110100"));
00504                         lambda[14] = bitset<nb_msg> (string("00010110000000000000000000000000000000000001110000000000000000000000000000000000000100100000000000000000000000000000000000011010"));
00505                         lambda[15] = bitset<nb_msg> (string("00001011000000000000000000000000000000000000111000000000000000000000000000000000000010010000000000000000000000000000000000001101"));
00506                         lambda[16] = bitset<nb_msg> (string("11001110000000000000000000000000000000001110100100000000000000000000000000000000010100110000000000000000000000000000000011110100"));
00507                         lambda[17] = bitset<nb_msg> (string("01100111000000000000000000000000000000001111101000000000000000000000000000000000101001110000000000000000000000000000000001111010"));
00508                         lambda[18] = bitset<nb_msg> (string("10111101000000000000000000000000000000000111110100000000000000000000000000000000110111010000000000000000000000000000000000111101"));
00509                         lambda[19] = bitset<nb_msg> (string("11010000000000000000000000000000000000001011000000000000000000000000000000000000111000000000000000000000000000000000000010010000"));
00510                         lambda[20] = bitset<nb_msg> (string("01101000000000000000000000000000000000000101100000000000000000000000000000000000011100000000000000000000000000000000000001001000"));
00511                         lambda[21] = bitset<nb_msg> (string("00110100000000000000000000000000000000000010110000000000000000000000000000000000001110000000000000000000000000000000000000100100"));
00512                         lambda[22] = bitset<nb_msg> (string("00011010000000000000000000000000000000000001011000000000000000000000000000000000000111000000000000000000000000000000000000010010"));
00513                         lambda[23] = bitset<nb_msg> (string("00001101000000000000000000000000000000000000101100000000000000000000000000000000000011100000000000000000000000000000000000001001"));
00514                         lambda[24] = bitset<nb_msg> (string("11110100000000000000000000000000000000001100111000000000000000000000000000000000111010010000000000000000000000000000000001010011"));
00515                         lambda[25] = bitset<nb_msg> (string("01111010000000000000000000000000000000000110011100000000000000000000000000000000111110100000000000000000000000000000000010100111"));
00516                         lambda[26] = bitset<nb_msg> (string("00111101000000000000000000000000000000001011110100000000000000000000000000000000011111010000000000000000000000000000000011011101"));
00517                         lambda[27] = bitset<nb_msg> (string("10010000000000000000000000000000000000001101000000000000000000000000000000000000101100000000000000000000000000000000000011100000"));
00518                         lambda[28] = bitset<nb_msg> (string("01001000000000000000000000000000000000000110100000000000000000000000000000000000010110000000000000000000000000000000000001110000"));
00519                         lambda[29] = bitset<nb_msg> (string("00100100000000000000000000000000000000000011010000000000000000000000000000000000001011000000000000000000000000000000000000111000"));
00520                         lambda[30] = bitset<nb_msg> (string("00010010000000000000000000000000000000000001101000000000000000000000000000000000000101100000000000000000000000000000000000011100"));
00521                         lambda[31] = bitset<nb_msg> (string("00001001000000000000000000000000000000000000110100000000000000000000000000000000000010110000000000000000000000000000000000001110"));
00522                         lambda[32] = bitset<nb_msg> (string("00000000000000000000000011101001010100110000000000000000000000000000000011110100000000000000000000000000000000001100111000000000"));
00523                         lambda[33] = bitset<nb_msg> (string("00000000000000000000000011111010101001110000000000000000000000000000000001111010000000000000000000000000000000000110011100000000"));
00524                         lambda[34] = bitset<nb_msg> (string("00000000000000000000000001111101110111010000000000000000000000000000000000111101000000000000000000000000000000001011110100000000"));
00525                         lambda[35] = bitset<nb_msg> (string("00000000000000000000000010110000111000000000000000000000000000000000000010010000000000000000000000000000000000001101000000000000"));
00526                         lambda[36] = bitset<nb_msg> (string("00000000000000000000000001011000011100000000000000000000000000000000000001001000000000000000000000000000000000000110100000000000"));
00527                         lambda[37] = bitset<nb_msg> (string("00000000000000000000000000101100001110000000000000000000000000000000000000100100000000000000000000000000000000000011010000000000"));
00528                         lambda[38] = bitset<nb_msg> (string("00000000000000000000000000010110000111000000000000000000000000000000000000010010000000000000000000000000000000000001101000000000"));
00529                         lambda[39] = bitset<nb_msg> (string("00000000000000000000000000001011000011100000000000000000000000000000000000001001000000000000000000000000000000000000110100000000"));
00530                         lambda[40] = bitset<nb_msg> (string("00000000000000000000000011001110111010010000000000000000000000000000000001010011000000000000000000000000000000001111010000000000"));
00531                         lambda[41] = bitset<nb_msg> (string("00000000000000000000000001100111111110100000000000000000000000000000000010100111000000000000000000000000000000000111101000000000"));
00532                         lambda[42] = bitset<nb_msg> (string("00000000000000000000000010111101011111010000000000000000000000000000000011011101000000000000000000000000000000000011110100000000"));
00533                         lambda[43] = bitset<nb_msg> (string("00000000000000000000000011010000101100000000000000000000000000000000000011100000000000000000000000000000000000001001000000000000"));
00534                         lambda[44] = bitset<nb_msg> (string("00000000000000000000000001101000010110000000000000000000000000000000000001110000000000000000000000000000000000000100100000000000"));
00535                         lambda[45] = bitset<nb_msg> (string("00000000000000000000000000110100001011000000000000000000000000000000000000111000000000000000000000000000000000000010010000000000"));
00536                         lambda[46] = bitset<nb_msg> (string("00000000000000000000000000011010000101100000000000000000000000000000000000011100000000000000000000000000000000000001001000000000"));
00537                         lambda[47] = bitset<nb_msg> (string("00000000000000000000000000001101000010110000000000000000000000000000000000001110000000000000000000000000000000000000100100000000"));
00538                         lambda[48] = bitset<nb_msg> (string("00000000000000000000000011110100110011100000000000000000000000000000000011101001000000000000000000000000000000000101001100000000"));
00539                         lambda[49] = bitset<nb_msg> (string("00000000000000000000000001111010011001110000000000000000000000000000000011111010000000000000000000000000000000001010011100000000"));
00540                         lambda[50] = bitset<nb_msg> (string("00000000000000000000000000111101101111010000000000000000000000000000000001111101000000000000000000000000000000001101110100000000"));
00541                         lambda[51] = bitset<nb_msg> (string("00000000000000000000000010010000110100000000000000000000000000000000000010110000000000000000000000000000000000001110000000000000"));
00542                         lambda[52] = bitset<nb_msg> (string("00000000000000000000000001001000011010000000000000000000000000000000000001011000000000000000000000000000000000000111000000000000"));
00543                         lambda[53] = bitset<nb_msg> (string("00000000000000000000000000100100001101000000000000000000000000000000000000101100000000000000000000000000000000000011100000000000"));
00544                         lambda[54] = bitset<nb_msg> (string("00000000000000000000000000010010000110100000000000000000000000000000000000010110000000000000000000000000000000000001110000000000"));
00545                         lambda[55] = bitset<nb_msg> (string("00000000000000000000000000001001000011010000000000000000000000000000000000001011000000000000000000000000000000000000111000000000"));
00546                         lambda[56] = bitset<nb_msg> (string("00000000000000000000000001010011111101000000000000000000000000000000000011001110000000000000000000000000000000001110100100000000"));
00547                         lambda[57] = bitset<nb_msg> (string("00000000000000000000000010100111011110100000000000000000000000000000000001100111000000000000000000000000000000001111101000000000"));
00548                         lambda[58] = bitset<nb_msg> (string("00000000000000000000000011011101001111010000000000000000000000000000000010111101000000000000000000000000000000000111110100000000"));
00549                         lambda[59] = bitset<nb_msg> (string("00000000000000000000000011100000100100000000000000000000000000000000000011010000000000000000000000000000000000001011000000000000"));
00550                         lambda[60] = bitset<nb_msg> (string("00000000000000000000000001110000010010000000000000000000000000000000000001101000000000000000000000000000000000000101100000000000"));
00551                         lambda[61] = bitset<nb_msg> (string("00000000000000000000000000111000001001000000000000000000000000000000000000110100000000000000000000000000000000000010110000000000"));
00552                         lambda[62] = bitset<nb_msg> (string("00000000000000000000000000011100000100100000000000000000000000000000000000011010000000000000000000000000000000000001011000000000"));
00553                         lambda[63] = bitset<nb_msg> (string("00000000000000000000000000001110000010010000000000000000000000000000000000001101000000000000000000000000000000000000101100000000"));
00554                         lambda[64] = bitset<nb_msg> (string("00000000000000001100111000000000000000000000000000000000111010010101001100000000000000000000000000000000111101000000000000000000"));
00555                         lambda[65] = bitset<nb_msg> (string("00000000000000000110011100000000000000000000000000000000111110101010011100000000000000000000000000000000011110100000000000000000"));
00556                         lambda[66] = bitset<nb_msg> (string("00000000000000001011110100000000000000000000000000000000011111011101110100000000000000000000000000000000001111010000000000000000"));
00557                         lambda[67] = bitset<nb_msg> (string("00000000000000001101000000000000000000000000000000000000101100001110000000000000000000000000000000000000100100000000000000000000"));
00558                         lambda[68] = bitset<nb_msg> (string("00000000000000000110100000000000000000000000000000000000010110000111000000000000000000000000000000000000010010000000000000000000"));
00559                         lambda[69] = bitset<nb_msg> (string("00000000000000000011010000000000000000000000000000000000001011000011100000000000000000000000000000000000001001000000000000000000"));
00560                         lambda[70] = bitset<nb_msg> (string("00000000000000000001101000000000000000000000000000000000000101100001110000000000000000000000000000000000000100100000000000000000"));
00561                         lambda[71] = bitset<nb_msg> (string("00000000000000000000110100000000000000000000000000000000000010110000111000000000000000000000000000000000000010010000000000000000"));
00562                         lambda[72] = bitset<nb_msg> (string("00000000000000001111010000000000000000000000000000000000110011101110100100000000000000000000000000000000010100110000000000000000"));
00563                         lambda[73] = bitset<nb_msg> (string("00000000000000000111101000000000000000000000000000000000011001111111101000000000000000000000000000000000101001110000000000000000"));
00564                         lambda[74] = bitset<nb_msg> (string("00000000000000000011110100000000000000000000000000000000101111010111110100000000000000000000000000000000110111010000000000000000"));
00565                         lambda[75] = bitset<nb_msg> (string("00000000000000001001000000000000000000000000000000000000110100001011000000000000000000000000000000000000111000000000000000000000"));
00566                         lambda[76] = bitset<nb_msg> (string("00000000000000000100100000000000000000000000000000000000011010000101100000000000000000000000000000000000011100000000000000000000"));
00567                         lambda[77] = bitset<nb_msg> (string("00000000000000000010010000000000000000000000000000000000001101000010110000000000000000000000000000000000001110000000000000000000"));
00568                         lambda[78] = bitset<nb_msg> (string("00000000000000000001001000000000000000000000000000000000000110100001011000000000000000000000000000000000000111000000000000000000"));
00569                         lambda[79] = bitset<nb_msg> (string("00000000000000000000100100000000000000000000000000000000000011010000101100000000000000000000000000000000000011100000000000000000"));
00570                         lambda[80] = bitset<nb_msg> (string("00000000000000000101001100000000000000000000000000000000111101001100111000000000000000000000000000000000111010010000000000000000"));
00571                         lambda[81] = bitset<nb_msg> (string("00000000000000001010011100000000000000000000000000000000011110100110011100000000000000000000000000000000111110100000000000000000"));
00572                         lambda[82] = bitset<nb_msg> (string("00000000000000001101110100000000000000000000000000000000001111011011110100000000000000000000000000000000011111010000000000000000"));
00573                         lambda[83] = bitset<nb_msg> (string("00000000000000001110000000000000000000000000000000000000100100001101000000000000000000000000000000000000101100000000000000000000"));
00574                         lambda[84] = bitset<nb_msg> (string("00000000000000000111000000000000000000000000000000000000010010000110100000000000000000000000000000000000010110000000000000000000"));
00575                         lambda[85] = bitset<nb_msg> (string("00000000000000000011100000000000000000000000000000000000001001000011010000000000000000000000000000000000001011000000000000000000"));
00576                         lambda[86] = bitset<nb_msg> (string("00000000000000000001110000000000000000000000000000000000000100100001101000000000000000000000000000000000000101100000000000000000"));
00577                         lambda[87] = bitset<nb_msg> (string("00000000000000000000111000000000000000000000000000000000000010010000110100000000000000000000000000000000000010110000000000000000"));
00578                         lambda[88] = bitset<nb_msg> (string("00000000000000001110100100000000000000000000000000000000010100111111010000000000000000000000000000000000110011100000000000000000"));
00579                         lambda[89] = bitset<nb_msg> (string("00000000000000001111101000000000000000000000000000000000101001110111101000000000000000000000000000000000011001110000000000000000"));
00580                         lambda[90] = bitset<nb_msg> (string("00000000000000000111110100000000000000000000000000000000110111010011110100000000000000000000000000000000101111010000000000000000"));
00581                         lambda[91] = bitset<nb_msg> (string("00000000000000001011000000000000000000000000000000000000111000001001000000000000000000000000000000000000110100000000000000000000"));
00582                         lambda[92] = bitset<nb_msg> (string("00000000000000000101100000000000000000000000000000000000011100000100100000000000000000000000000000000000011010000000000000000000"));
00583                         lambda[93] = bitset<nb_msg> (string("00000000000000000010110000000000000000000000000000000000001110000010010000000000000000000000000000000000001101000000000000000000"));
00584                         lambda[94] = bitset<nb_msg> (string("00000000000000000001011000000000000000000000000000000000000111000001001000000000000000000000000000000000000110100000000000000000"));
00585                         lambda[95] = bitset<nb_msg> (string("00000000000000000000101100000000000000000000000000000000000011100000100100000000000000000000000000000000000011010000000000000000"));
00586                         lambda[96] = bitset<nb_msg> (string("00000000111101000000000000000000000000000000000011001110000000000000000000000000000000001110100101010011000000000000000000000000"));
00587                         lambda[97] = bitset<nb_msg> (string("00000000011110100000000000000000000000000000000001100111000000000000000000000000000000001111101010100111000000000000000000000000"));
00588                         lambda[98] = bitset<nb_msg> (string("00000000001111010000000000000000000000000000000010111101000000000000000000000000000000000111110111011101000000000000000000000000"));
00589                         lambda[99] = bitset<nb_msg> (string("00000000100100000000000000000000000000000000000011010000000000000000000000000000000000001011000011100000000000000000000000000000"));
00590                         lambda[100]= bitset<nb_msg> (string("00000000010010000000000000000000000000000000000001101000000000000000000000000000000000000101100001110000000000000000000000000000"));
00591                         lambda[101]= bitset<nb_msg> (string("00000000001001000000000000000000000000000000000000110100000000000000000000000000000000000010110000111000000000000000000000000000"));
00592                         lambda[102]= bitset<nb_msg> (string("00000000000100100000000000000000000000000000000000011010000000000000000000000000000000000001011000011100000000000000000000000000"));
00593                         lambda[103]= bitset<nb_msg> (string("00000000000010010000000000000000000000000000000000001101000000000000000000000000000000000000101100001110000000000000000000000000"));
00594                         lambda[104]= bitset<nb_msg> (string("00000000010100110000000000000000000000000000000011110100000000000000000000000000000000001100111011101001000000000000000000000000"));
00595                         lambda[105]= bitset<nb_msg> (string("00000000101001110000000000000000000000000000000001111010000000000000000000000000000000000110011111111010000000000000000000000000"));
00596                         lambda[106]= bitset<nb_msg> (string("00000000110111010000000000000000000000000000000000111101000000000000000000000000000000001011110101111101000000000000000000000000"));
00597                         lambda[107]= bitset<nb_msg> (string("00000000111000000000000000000000000000000000000010010000000000000000000000000000000000001101000010110000000000000000000000000000"));
00598                         lambda[108]= bitset<nb_msg> (string("00000000011100000000000000000000000000000000000001001000000000000000000000000000000000000110100001011000000000000000000000000000"));
00599                         lambda[109]= bitset<nb_msg> (string("00000000001110000000000000000000000000000000000000100100000000000000000000000000000000000011010000101100000000000000000000000000"));
00600                         lambda[110]= bitset<nb_msg> (string("00000000000111000000000000000000000000000000000000010010000000000000000000000000000000000001101000010110000000000000000000000000"));
00601                         lambda[111]= bitset<nb_msg> (string("00000000000011100000000000000000000000000000000000001001000000000000000000000000000000000000110100001011000000000000000000000000"));
00602                         lambda[112]= bitset<nb_msg> (string("00000000111010010000000000000000000000000000000001010011000000000000000000000000000000001111010011001110000000000000000000000000"));
00603                         lambda[113]= bitset<nb_msg> (string("00000000111110100000000000000000000000000000000010100111000000000000000000000000000000000111101001100111000000000000000000000000"));
00604                         lambda[114]= bitset<nb_msg> (string("00000000011111010000000000000000000000000000000011011101000000000000000000000000000000000011110110111101000000000000000000000000"));
00605                         lambda[115]= bitset<nb_msg> (string("00000000101100000000000000000000000000000000000011100000000000000000000000000000000000001001000011010000000000000000000000000000"));
00606                         lambda[116]= bitset<nb_msg> (string("00000000010110000000000000000000000000000000000001110000000000000000000000000000000000000100100001101000000000000000000000000000"));
00607                         lambda[117]= bitset<nb_msg> (string("00000000001011000000000000000000000000000000000000111000000000000000000000000000000000000010010000110100000000000000000000000000"));
00608                         lambda[118]= bitset<nb_msg> (string("00000000000101100000000000000000000000000000000000011100000000000000000000000000000000000001001000011010000000000000000000000000"));
00609                         lambda[119]= bitset<nb_msg> (string("00000000000010110000000000000000000000000000000000001110000000000000000000000000000000000000100100001101000000000000000000000000"));
00610                         lambda[120]= bitset<nb_msg> (string("00000000110011100000000000000000000000000000000011101001000000000000000000000000000000000101001111110100000000000000000000000000"));
00611                         lambda[121]= bitset<nb_msg> (string("00000000011001110000000000000000000000000000000011111010000000000000000000000000000000001010011101111010000000000000000000000000"));
00612                         lambda[122]= bitset<nb_msg> (string("00000000101111010000000000000000000000000000000001111101000000000000000000000000000000001101110100111101000000000000000000000000"));
00613                         lambda[123]= bitset<nb_msg> (string("00000000110100000000000000000000000000000000000010110000000000000000000000000000000000001110000010010000000000000000000000000000"));
00614                         lambda[124]= bitset<nb_msg> (string("00000000011010000000000000000000000000000000000001011000000000000000000000000000000000000111000001001000000000000000000000000000"));
00615                         lambda[125]= bitset<nb_msg> (string("00000000001101000000000000000000000000000000000000101100000000000000000000000000000000000011100000100100000000000000000000000000"));
00616                         lambda[126]= bitset<nb_msg> (string("00000000000110100000000000000000000000000000000000010110000000000000000000000000000000000001110000010010000000000000000000000000"));
00617                         lambda[127]= bitset<nb_msg> (string("00000000000011010000000000000000000000000000000000001011000000000000000000000000000000000000111000001001000000000000000000000000"));
00618                         */
00619         }
00620 
00621         // To acces element (I,J) of matrix lambda use:
00622         // lambda(I,J) = lambda[I+J*nb_msg]
00623         //vector x matrix PRODUCT
00624         for ( unsigned i = 0 ; i < nb_msg ; ++i ){
00625                 c[i] = 0 ;
00626                 for ( unsigned j = 0 ; j < nb_msg ; ++j ) {
00627                         c[i] = c[i] ^ ( m[j] & lambda[nb_msg-j-1][i] ) ;
00628                 }
00629         }
00630         /*for ( unsigned i = 0 ; i < nb_msg ; ++i ){
00631                 c[i] = 0 ;
00632                 for ( unsigned j = 0 ; j < nb_msg ; ++j ) {
00633                         c[i] = c[i] ^ ( m[j] & lambda[i+j*nb_msg] ) ;
00634                 }
00635         }*/
00636 
00637         return c ;
00638 }
00639 
00643 
00666 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00667 inline
00668 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::sboxType
00669 Bunny<nb_msg,nb_key,nb_sbox,nround>::s1 (sboxType x){
00670         int s1_table [64] = { 0,  1, 45, 54, 59, 18, 27, 30, 48, 10,  9, 49, 32, 62, 15, 14,
00671                                                         24, 51,  5, 58, 41, 56, 53, 35, 16, 50, 31,  6, 42, 38,  7, 26,
00672                                                         12, 63, 52, 23, 47, 61, 29, 43, 57, 20, 28, 39, 55,  2, 60, 36,
00673                                                         8, 11, 25, 17, 34, 22,  3, 44, 21, 40, 19,  4, 46, 37, 13, 33 };
00674         return sboxType ( s1_table[x.to_ulong()] );
00675 }
00679 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00680 inline
00681 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::sboxType
00682 Bunny<nb_msg,nb_key,nb_sbox,nround>::s1Inv (sboxType x){
00683         int s1Inv_table [64] = { 0,  1, 45, 54, 59, 18, 27, 30, 48, 10,  9, 49, 32, 62, 15, 14,
00684                                                         24, 51,  5, 58, 41, 56, 53, 35, 16, 50, 31,  6, 42, 38,  7, 26,
00685                                                         12, 63, 52, 23, 47, 61, 29, 43, 57, 20, 28, 39, 55,  2, 60, 36,
00686                                                         8, 11, 25, 17, 34, 22,  3, 44, 21, 40, 19,  4, 46, 37, 13, 33 };
00687         return sboxType ( s1Inv_table[x.to_ulong()] );
00688 }
00710 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00711 inline
00712 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::sboxType
00713 Bunny<nb_msg,nb_key,nb_sbox,nround>::s2 (sboxType x){
00714         int s2_table [64] = {    0,  1, 32, 51, 49,  3, 63, 31, 36,  4, 59,  9, 62, 45, 15, 14,
00715                                                                 7,  5, 54, 38,  8, 57, 23, 52, 30, 61, 16, 33, 58, 42, 26, 24,
00716                                                         13, 43, 22, 34, 41, 60, 28, 27, 55, 48, 19,  6, 56, 12, 50, 20,
00717                                                         47, 10, 37, 18, 53, 35, 17, 21, 40, 44, 29, 11, 25, 46,  2, 39 };
00718         return sboxType ( s2_table[x.to_ulong()] );
00719 }
00723 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00724 inline
00725 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::sboxType
00726 Bunny<nb_msg,nb_key,nb_sbox,nround>::s2Inv (sboxType x){
00727         int s2Inv_table [64] = { 0,  1, 62,  5,  9, 17, 43, 16, 20, 11, 49, 59, 45, 32, 15, 14,
00728                                                         26, 54, 51, 42, 47, 55, 34, 22, 31, 60, 30, 39, 38, 58, 24,  7,
00729                                                                 2, 27, 35, 53,  8, 50, 19, 63, 56, 36, 29, 33, 57, 13, 61, 48,
00730                                                         41,  4, 46,  3, 23, 52, 18, 40, 44, 21, 28, 10, 37, 25,  12, 6  };
00731         return sboxType ( s2Inv_table[x.to_ulong()] );
00732 }
00733 
00747 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00748 inline
00749 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::sboxType
00750 Bunny<nb_msg,nb_key,nb_sbox,nround>::s3 (sboxType x){
00751         int s3_table [64] = {    0,  1, 38, 54, 37, 18, 43, 13, 20, 50, 25, 46, 42, 58, 15, 14,
00752                                                         32, 51,  5,  7, 47, 10, 34, 22, 12, 56,  2, 39, 24, 26, 62, 45,
00753                                                         28, 27, 35, 53,  8, 57, 31, 63,  4, 36, 16, 33, 11, 29, 55, 48,
00754                                                         41, 60, 21, 17, 23, 52,  3, 49,  9, 59, 30, 61, 44, 40, 19,  6 };
00755         return sboxType ( s3_table[x.to_ulong()] );
00756 }
00760 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00761 inline
00762 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::sboxType
00763 Bunny<nb_msg,nb_key,nb_sbox,nround>::s3Inv (sboxType x){
00764         int s3Inv_table [64] = {  0,  1, 26, 54, 40, 18, 63, 19, 36, 56, 21, 44, 24,  7, 15, 14,
00765                                                                 42, 51,  5, 62,  8, 50, 23, 52, 28, 10, 29, 33, 32, 45, 58, 38,
00766                                                                 16, 43, 22, 34, 41,  4,  2, 27, 61, 48, 12,  6, 60, 31, 11, 20,
00767                                                                 47, 55,  9, 17, 53, 35,  3, 46, 25, 37, 13, 57, 49, 59, 30, 39 };
00768         return sboxType ( s3Inv_table[x.to_ulong()] );
00769 }
00770 
00784 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00785 inline
00786 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::sboxType
00787 Bunny<nb_msg,nb_key,nb_sbox,nround>::s4 (sboxType x){
00788         int s4_table [64] = {    4,  5, 34, 50, 33, 22, 47,  9, 16, 54, 29, 42, 46, 62, 11, 10,
00789                                                         36, 55,  1,  3, 43, 14, 38, 18,  8, 60,  6, 35, 28, 30, 58, 41,
00790                                                         24, 31, 39, 49, 12, 61, 27, 59,  0, 32, 20, 37, 15, 25, 51, 52,
00791                                                         45, 56, 17, 21, 19, 48,  7, 53, 13, 63, 26, 57, 40, 44, 23,  2 };
00792         return sboxType ( s4_table[x.to_ulong()] );
00793 }
00797 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00798 inline
00799 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::sboxType
00800 Bunny<nb_msg,nb_key,nb_sbox,nround>::s4Inv (sboxType x){
00801         int s4Inv_table [64] = { 40, 18, 63, 19,  0,  1, 26, 54, 24,  7, 15, 14, 36, 56, 21, 44,
00802                                                                 8, 50, 23, 52, 42, 51,  5, 62, 32, 45, 58, 38, 28, 10, 29, 33,
00803                                                                 41,  4,  2, 27, 16, 43, 22, 34, 60, 31, 11, 20, 61, 48, 12,  6,
00804                                                                 53, 35,  3, 46, 47, 55,  9, 17, 49, 59, 30, 39, 25, 37, 13, 57 };
00805         return sboxType ( s4Inv_table[x.to_ulong()] );
00806 }
00807 
00808 
00812 
00816 
00821 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00822 inline
00823 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::sboxType
00824 Bunny<nb_msg,nb_key,nb_sbox,nround>::AES_sbox (sboxType x){
00825         int AES_sbox_table [256] = {  99,124,119,123,242,107,111,197, 48,  1,103, 43,254,215,171,118,
00826                                                                 202,130,201,125,250, 89, 71,240,173,212,162,175,156,164,114,192,
00827                                                                 183,253,147, 38, 54, 63,247,204, 52,165,229,241,113,216, 49, 21,
00828                                                                 4,199, 35,195, 24,150,  5,154,  7, 18,128,226,235, 39,178,117,
00829                                                                 9,131, 44, 26, 27,110, 90,160, 82, 59,214,179, 41,227, 47,132,
00830                                                                 83,209,  0,237, 32,252,177, 91,106,203,190, 57, 74, 76, 88,207,
00831                                                                 208,239,170,251, 67, 77, 51,133, 69,249,  2,127, 80, 60,159,168,
00832                                                                 81,163, 64,143,146,157, 56,245,188,182,218, 33, 16,255,243,210,
00833                                                                 205, 12, 19,236, 95,151, 68, 23,196,167,126, 61,100, 93, 25,115,
00834                                                                 96,129, 79,220, 34, 42,144,136, 70,238,184, 20,222, 94, 11,219,
00835                                                                 224, 50, 58, 10, 73,  6, 36, 92,194,211,172, 98,145,149,228,121,
00836                                                                 231,200, 55,109,141,213, 78,169,108, 86,244,234,101,122,174,  8,
00837                                                                 186,120, 37, 46, 28,166,180,198,232,221,116, 31, 75,189,139,138,
00838                                                                 112, 62,181,102, 72,  3,246, 14, 97, 53, 87,185,134,193, 29,158,
00839                                                                 225,248,152, 17,105,217,142,148,155, 30,135,233,206, 85, 40,223,
00840                                                                 140,161,137, 13,191,230, 66,104, 65,153, 45, 15,176, 84,187, 22 };
00841         return sboxType ( AES_sbox_table[x.to_ulong()] );
00842 }
00843 
00847 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00848 inline
00849 typename Bunny<nb_msg,nb_key,nb_sbox,nround>::sboxType
00850 Bunny<nb_msg,nb_key,nb_sbox,nround>::AES_sbox_Inv (sboxType x){
00851         int AES_sbox_Inv_table [256] = {  82,9,106,213,48,54,165,56,191,64,163,158,129,243,215,251,124,227,57,130,155,47,255,135,52,142,67,68,196,222,233,203,84,123,148,50,166,194,35,61,238,76,149,11,66,250,195,78,8,46,161,102,40,217,36,178,118,91,162,73,109,139,209,37,114,248,246,100,134,104,152,22,212,164,92,204,93,101,182,146,108,112,72,80,253,237,185,218,94,21,70,87,167,141,157,132,144,216,171,0,140,188,211,10,247,228,88,5,184,179,69,6,208,44,30,143,202,63,15,2,193,175,189,3,1,19,138,107,58,145,17,65,79,103,220,234,151,242,207,206,240,180,230,115,150,172,116,34,231,173,53,133,226,249,55,232,28,117,223,110,71,241,26,113,29,41,197,137,111,183,98,14,170,24,190,27,252,86,62,75,198,210,121,32,154,219,192,254,120,205,90,244,31,221,168,51,136,7,199,49,177,18,16,89,39,128,236,95,96,81,127,169,25,181,74,13,45,229,122,159,147,201,156,239,160,224,59,77,174,42,245,176,200,235,187,60,131,83,153,97,23,43,4,126,186,119,214,38,225,105,20,99,85,33,12,125, };
00852         return sboxType ( AES_sbox_Inv_table[x.to_ulong()] );
00853 }
00855 
00856 
00857 
00858 
00862 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00863 inline
00864 void Bunny<nb_msg,nb_key,nb_sbox,nround>::printParameter() {
00865                 std::cout << "-------------------------------\n" ;
00866                 std::cout << "| BUNNY's PARAMETERS are:  " << setw (5) <<            "|\n" ;
00867                 std::cout << "|       S-box size:      "   << setw (5) << nb_sbox << "|\n" ;
00868                 std::cout << "|       Message size:    "   << setw (5) << nb_msg  << "|\n" ;
00869                 std::cout << "|       Key size:        "   << setw (5) << nb_key  << "|\n" ;
00870                 std::cout << "|       Number of Rounds:"   << setw (5) << nround  << "|\n" ;
00871                 std::cout << "-------------------------------\n" ;
00872 }
00873 
00874 //CONSTRUCTOR
00878 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00879 inline
00880 Bunny<nb_msg,nb_key,nb_sbox,nround>::Bunny(){
00881         rk.resize(nround+1) ; // allocates memory for the round keys
00882 }
00883 
00887 /*This class is inehritated from Bunny*/
00888 
00889 
00890 
00891 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00892 void
00893 BunnyAES<nb_msg,nb_key,nb_sbox,nround>::tryvirtual() {
00894         cout << "Yes, you are in AES class!!" << endl ;
00895 }
00896 
00897 //CONSTRUCTOR
00901 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00902 inline
00903 BunnyAES<nb_msg,nb_key,nb_sbox,nround>::BunnyAES(){
00904         rk.resize(nround+1) ; // allocates memory for the round keys
00905 }
00906 
00914 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00915 inline
00916 typename BunnyAES<nb_msg,nb_key,nb_sbox,nround>::msgType
00917 BunnyAES<nb_msg,nb_key,nb_sbox,nround>::encode( msgType m, keyType k ) {
00918         msgType c ;
00919         c = m ;
00920         BunnyAES<nb_msg,nb_key,nb_sbox,nround>::keySchedule(k) ; //use BunnyAES keyschedule
00921 
00922         //Round 0, a-tipical
00923         c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::addRoundKey(c,rk[0]) ;
00924         //cout << "state at round: 0 --> " << bitsetToHex(c) << endl ;
00925 
00926         //TYPICAL rounds
00927         for (unsigned i = 1 ; i < nround ; ++i){
00928                 //AES sBox
00929                 c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::sBox(c) ;
00930                 //cout << "state after sBox: --> " << bitsetToHex(c) << endl ;
00931 
00932                 // AES mixing layer
00933                 c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::shiftRows(c) ;
00934                 c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::mixColumns(c) ;
00935                 //cout << "state after mixL: --> " << bitsetToHex(c) << endl ;
00936 
00937                 //AES add round key
00938                 c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::addRoundKey(c,rk[i]) ;
00939                 //cout << "state at round: " << i <<  " --> " << bitsetToHex(c) << endl ;
00940         }
00941         //AES sBox
00942         c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::sBox(c) ;
00943         //cout << "state after sBox: --> " << bitsetToHex(c) << endl ;
00944 
00945         // AES mixing layer - ATYPICAL (no mixColumns)
00946         c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::shiftRows(c) ;
00947         //cout << "state after mixL: --> " << bitsetToHex(c) << endl ;
00948 
00949         //AES add round key
00950         c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::addRoundKey(c,rk[nround]) ;
00951         //cout << "state at round: " << nround <<  " --> " << bitsetToHex(c) << endl ;
00952 
00953         return c ;
00954 }
00955 
00963 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
00964 inline
00965 typename BunnyAES<nb_msg,nb_key,nb_sbox,nround>::msgType
00966 BunnyAES<nb_msg,nb_key,nb_sbox,nround>::decode( msgType m, keyType k ) {
00967         msgType c ;
00968         c = m ;
00969         BunnyAES<nb_msg,nb_key,nb_sbox,nround>::keySchedule(k) ; //use BunnyAES keyschedule
00970 
00971         //Round 0, a-tipical (no mixColumns Inverse)
00972         c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::addRoundKey(c,rk[nround]) ;
00973 
00974         // AES mixing layer - ATYPICAL (no mixColumns)
00975         c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::shiftRowsInv(c) ;
00976 
00977         //AES sBox
00978         c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::sBoxInverse(c) ;
00979 
00980         //TYPICAL rounds
00981         for (unsigned i = nround - 1 ; i > 0 ; --i){
00982                 //AES add round key
00983                 c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::addRoundKey(c,rk[i]) ;
00984 
00985                 // AES mixing layer
00986                 c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::mixColumnsInv(c) ;
00987                 c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::shiftRowsInv(c) ;
00988 
00989                 //AES sBox
00990                 c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::sBoxInverse(c) ;
00991         }
00992 
00993         //AES add round key
00994         c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::addRoundKey(c,rk[0]) ;
00995 
00996         return c ;
00997 }
00998 
01002 
01009 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
01010 inline
01011 void BunnyAES<nb_msg,nb_key,nb_sbox,nround>::keySchedule(keyType k) {
01012         //AES128 needs 11 round keys
01013         //AES128 needs 13 round keys
01014         //AES128 needs 15 round keys
01015         //nround is the number of rounds without counting the first whitening
01016         unsigned int n, b ;
01017         sboxType temp ;
01018         bitset<32> rcon[16] ; // Constant assigned to each keyschedule round
01019 
01020         rcon[0]  = bitset<32> (string("10001101000000000000000000000000"));
01021         rcon[1]  = bitset<32> (string("00000001000000000000000000000000"));
01022         rcon[2]  = bitset<32> (string("00000010000000000000000000000000"));
01023         rcon[3]  = bitset<32> (string("00000100000000000000000000000000"));
01024         rcon[4]  = bitset<32> (string("00001000000000000000000000000000"));
01025         rcon[5]  = bitset<32> (string("00010000000000000000000000000000"));
01026         rcon[6]  = bitset<32> (string("00100000000000000000000000000000"));
01027         rcon[7]  = bitset<32> (string("01000000000000000000000000000000"));
01028         rcon[8]  = bitset<32> (string("10000000000000000000000000000000"));
01029         rcon[9]  = bitset<32> (string("00011011000000000000000000000000"));
01030         rcon[10] = bitset<32> (string("00110110000000000000000000000000"));
01031         rcon[11] = bitset<32> (string("01101100000000000000000000000000"));
01032 
01033         unsigned icon = 1 ; // index to count the costant rcon for each round
01034         b = (nround+1)*16 ; //16 bytes * 11,13,15 rounds = 176,208,240
01035         if (nb_key == 128) {
01036                 n = 16 ;
01037         } else if (nb_key == 192) {
01038                 n = 24 ;
01039         } else if (nb_key == 256) {
01040                 n = 32 ;
01041         }
01042 
01043         //number of 32-bit-words generated
01044         unsigned nword = (nround+1) * 4 ;// (nround+1) * 4
01045 
01046         //i.e.: nrow round keys at a time are filled
01047         //unsigned ncol = nb_msg/nb_sbox ;
01048         //unsigned nrow = nb_msg/nb_sbox + 1 ;
01049 
01050         vector<bitset<nb_sbox*4> > w ; //w will contains 32 bits words
01051 
01052         w.resize(nword) ; // initialize a vector of nword elements of type sboxType, set to 00...0
01053 
01054         //CREATE w, a vector of nwords words
01055         //put the key bits in the first 16 words
01056         for (unsigned i = 0 ; i < 4 ; ++i){
01057                 w[i] = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::extractWord(i*nb_sbox*4,k) ;
01058         }
01059 
01060         for (unsigned i = 4 ; i < nword ; ++i){
01061                 if ( i % 4 == 0){
01062                         w[i] = w[i-1] ;
01063                         //Rotate the word w[i] 8 bits to the left
01064                         w[i] = rotLeft(w[i],8) ;
01065                         //Apply the sBoxes to w[i]
01066                         for (unsigned j = 0 ; j < 4 ; ++j){
01067                                 temp = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::extractFromWordToSboxType(j*nb_sbox,w[i]) ; // extract nb_sbox bits starting from left to right
01068                                 temp = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::AES_sbox(temp) ; // elaborate the nb_sbox bits extracted
01069                                 w[i] = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::copyIntoWord(w[i],j*nb_sbox,temp) ; // put nb_bit bits in the position i*nb_sbox of the message c
01070                         }
01071                         //Exor w[i-4] and rcon[i]
01072                         w[i] = w[i] ^ rcon[icon] ^ w[i-4] ;
01073                         ++icon ;
01074                         //cout << "w[" << i << "] = "<< w[i] << endl ;
01075                 }
01076                 else {
01077                         w[i] = w[i-1] ^ w[i-4] ;
01078                         //cout << "w[" << i << "] = "<< w[i] << endl ;
01079                 }
01080         }
01081 
01082         //CREATE the ROUND KEYS
01083         for (unsigned i = 0 ; i <= nround ; ++i){
01084                 for (unsigned j = 0 ; j < 4 ; ++j){
01085                         rk[i] = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::copyIntoKey(rk[i],j*32,w[i*4+j]) ;
01086                 }
01087                 //cout << "rk[" << i << "] = " << rk[i] << endl ;
01088         }
01089         return ;
01090 }
01091 
01092 
01093 
01103 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
01104 inline
01105 typename BunnyAES<nb_msg,nb_key,nb_sbox,nround>::msgType
01106 BunnyAES<nb_msg,nb_key,nb_sbox,nround>::shiftRows (msgType m ){
01107         // Shift second row
01108         MoveBits(m, 112, 80, 8) ;
01109         MoveBits(m, 80, 48, 8) ;
01110         MoveBits(m, 48, 16, 8) ;
01111         // Shift third row
01112         MoveBits(m, 104, 40, 8) ;
01113         MoveBits(m, 72, 8, 8) ;
01114         // Shift fourth row
01115         MoveBits(m, 32, 0, 8) ;
01116         MoveBits(m, 64, 32, 8) ;
01117         MoveBits(m, 96, 64, 8) ;
01118         return m ;
01119 }
01120 
01126 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
01127 inline
01128 typename BunnyAES<nb_msg,nb_key,nb_sbox,nround>::msgType
01129 BunnyAES<nb_msg,nb_key,nb_sbox,nround>::shiftRowsInv (msgType m ){
01130         // Shift second row
01131         MoveBits(m, 16, 48, 8) ;
01132         MoveBits(m, 80, 48, 8) ;
01133         MoveBits(m, 112, 80, 8) ;
01134         // Shift third row
01135         MoveBits(m, 104, 40, 8) ;
01136         MoveBits(m, 72, 8, 8) ;
01137         // Shift fourth row
01138         MoveBits(m, 96, 64, 8) ;
01139         MoveBits(m, 64, 32, 8) ;
01140         MoveBits(m, 32, 0, 8) ;
01141         return m ;
01142 }
01143 
01153 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
01154 inline
01155 typename BunnyAES<nb_msg,nb_key,nb_sbox,nround>::msgType
01156 BunnyAES<nb_msg,nb_key,nb_sbox,nround>::mixColumns (msgType m ){
01157         unsigned char col[4] ;
01158         msgType c ;
01159         string msgStr = bitsetToHex(m) ;
01160         string tmp ;
01161 
01162         for (unsigned i = 0 ; i < 4 ; ++i){     //for each column do
01163                 tmp.assign(msgStr,i*8,8) ;              // put in tmp a column as a string
01164                 stringToUchar(tmp,col) ;                // put in col a column as unsigned char
01165                 gmix_column(col) ;                              // mix the column
01166                                                                                 // put in tmp the column mixed
01167                 tmp.assign("") ;
01168                 for (unsigned j = 0 ; j < sizeof(col) ; ++j)
01169                         tmp.append(ucharToString(col[j])) ;
01170                                                                                 //replace the msg
01171                 msgStr.replace(i*8,8,tmp) ;
01172         }
01173         return msgType (hexTo<bitset<128> >(msgStr)) ;
01174 }
01175 
01181 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
01182 inline
01183 typename BunnyAES<nb_msg,nb_key,nb_sbox,nround>::msgType
01184 BunnyAES<nb_msg,nb_key,nb_sbox,nround>::mixColumnsInv (msgType m ){
01185         unsigned char col[4] ;
01186         string  msgStr = bitsetToHex(m) ;
01187         string tmp ;
01188 
01189         for (unsigned i = 0 ; i < 4 ; ++i){     //for each column do
01190                 tmp.assign(msgStr,i*8,8) ;              // put in tmp a column as a string
01191                 stringToUchar(tmp,col) ;                // put in col a column as unsigned char
01192                 gmix_columnInv(col) ;                           // mix the column
01193                                                                                 // put in tmp the column mixed
01194                 tmp.assign("") ;
01195                 for (unsigned j = 0 ; j < sizeof(col) ; ++j)
01196                         tmp.append(ucharToString(col[j])) ;
01197                                                                                 //replace the msg
01198                 msgStr.replace(i*8,8,tmp) ;
01199         }
01200         return msgType (hexTo<bitset<nb_msg> >(msgStr)) ;
01201 }
01202 
01206 
01217 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
01218 inline
01219 typename BunnyAES<nb_msg,nb_key,nb_sbox,nround>::msgType
01220 BunnyAES<nb_msg,nb_key,nb_sbox,nround>::sBox (msgType m){
01221         msgType c ;
01222         c = m ;
01223         sboxType s ;
01224 
01225         unsigned n = nb_msg / nb_sbox ;
01226         for (unsigned i = 0 ; i < n ; ++i){
01227                 s = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::extract(i*nb_sbox,m) ; // extract nb_sbox bits starting from left to right
01228                 //For AES
01229                 s = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::AES_sbox(s) ; // elaborate the nb_sbox bits extracted
01230                 c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::copy(c,i*nb_sbox,s) ; // put nb_bit bits in the position i*nb_sbox of the message c
01231         }
01232         return c;
01233 }
01234 
01238 template <unsigned nb_msg, unsigned nb_key, unsigned nb_sbox, unsigned nround>
01239 inline
01240 typename BunnyAES<nb_msg,nb_key,nb_sbox,nround>::msgType
01241 BunnyAES<nb_msg,nb_key,nb_sbox,nround>::sBoxInverse (msgType m){
01242         msgType c ;
01243         c = m ;
01244         sboxType s ;
01245 
01246         unsigned n = nb_msg / nb_sbox ;
01247         for (unsigned i = 0 ; i < n ; ++i){
01248                 s = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::extract(i*nb_sbox,m) ; // extract nb_sbox bits starting from left to right
01249                 //For AES
01250                 s = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::AES_sbox_Inv(s) ; // elaborate the nb_sbox bits extracted
01251                 c = BunnyAES<nb_msg,nb_key,nb_sbox,nround>::copy(c,i*nb_sbox,s) ; // put nb_bit bits in the position i*nb_sbox of the message c
01252         }
01253         return c;
01254 }
01255 
 All Classes Functions Variables Typedefs