Bunny2.0
|
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