Arduino/sketch_One_Round/sketch_One_Round.ino

   1  #include <AES.h>
   2 //#include "./printf.h"
   3
   4
   5
   6 //#include <ESP8266WiFi.h>
   7
   8 const int size_mesg=16;
   9
  10
  11
  12
  13 const int sleepTimeS = 10;
  14
  15
  16 const int h=2;
  17 const int h2=h*h;
  18 byte DK[64];
  19 int rp=1;
  20
  21 const int len=size_mesg/h2;
  22
  23
  24
  25 typedef byte   uchar;
  26 typedef unsigned int   uint;
  27
  28 int Pbox[len];
  29   int PboxRM[h2];
  30   uchar Sbox1[256];
  31   uchar Sbox2[256];
  32   uchar RM1_cpy[h2];
  33
  34
  35 struct  ulong2{
  36       unsigned long int x, y;
  37 };
  38
  39 typedef struct ulong2 ulong2;
  40 typedef unsigned long int ulong;
  41
  42
  43
  44 uint xorshift32(const uint t)
  45 {
  46    /* Algorithm "xor" from p. 4 of Marsaglia, "Xorshift RNGs" */
  47         uint x = t;
  48         x ^= x << 13;
  49         x ^= x >> 17;
  50         x ^= x << 5;
  51         return x;
  52 }
  53
  54
  55
  56
  57 uint pcg32_random_r(ulong2* rng)
  58 {
  59         //      pcg32_random_t *rng=(pcg32_random_t*)rng2;
  60   ulong oldstate = rng->x;
  61         // Advance internal state
  62         rng->x = oldstate * 6364136223846793005ULL + (rng->y|1);
  63         // Calculate output function (XSH RR), uses old state for max ILP
  64         uint xorshifted = ((oldstate >> 18u) ^ oldstate) >> 27u;
  65   uint rot = oldstate >> 59u;
  66         return (xorshifted >> rot) | (xorshifted << ((-rot) & 31));
  67 }
  68
  69
  70
  71
  72 void inverse_tables(uchar *tab, int size_tab,uchar *inv_perm_tabs) {
  73
  74   for(int i=0;i<size_tab;i++) {
  75     inv_perm_tabs[tab[i]] = i;
  76   }
  77
  78 }
  79
  80 void inverse_tables_int(int *tab, int size_tab,int *inv_perm_tabs) {
  81
  82   for(int i=0;i<size_tab;i++) {
  83     inv_perm_tabs[tab[i]] = i;
  84   }
  85
  86 }
  87
  88
  89
  90 void rc4key(uchar *key, uchar *sc, int size_DK) {
  91
  92   for(int i=0;i<256;i++) {
  93     sc[i]=i;
  94   }
  95
  96
  97   uchar j0 = 0;
  98   for(int i0=0; i0<256; i0++) {
  99     j0 = (j0 + sc[i0] + key[i0%size_DK] )&0xFF;
 100     uchar tmp = sc[i0];
 101     sc[i0] = sc[j0 ];
 102     sc[j0] = tmp;
 103   }
 104 }
 105
 106
 107
 108 void rc4keyperm(uchar *key,int len, int rp,int *sc, int size_DK) {
 109
 110   //sc=1:len;
 111
 112
 113
 114   for (int i=0;i<len;i++) {
 115     sc[i]=i;
 116   }
 117   for (int it = 0; it < rp; it++) {
 118     int j0 = 1;
 119     for(int i0 = 0; i0<len; i0++) {
 120       j0 = (j0 + sc[i0] + sc[j0] + key[i0%size_DK] )% len;
 121       int tmp = sc[i0];
 122       sc[i0] = sc[j0];
 123       sc[j0] = tmp;
 124     }
 125
 126   }
 127 }
 128
 129 void prga(uchar *sc, int ldata, uchar *r) {
 130   uchar i0=0;
 131   uchar j0=0;
 132
 133   for (int it=0; it<ldata; it++) {
 134     i0 = ((i0+1)&0xFE); //%255);
 135     j0 = (j0 + sc[i0])&0xFF;
 136     uchar tmp = sc[i0];
 137     sc[i0] = sc[j0];
 138     sc[j0] = tmp;
 139     r[it]=sc[(sc[i0]+sc[j0])&0xFF];
 140   }
 141 }
 142
 143
 144
 145 void encrypt_ctr(const uchar* seq_in, uchar *seq_out, int len,uchar* RM1,const int *Pbox, const int *PboxRM, const uchar *Sbox1, const uchar *Sbox2, int enc) {
 146
 147  //printArray(seq_out,16);
 148   uchar X[h2];
 149   uchar fX[h2];
 150
 151   int ind1,ind2;
 152
 153
 154    for(int a=0;a<h2;a++) {
 155      X[a]=Sbox1[a];           //Warning according to the size of h2, we can be outsize of Sbox1[a]
 156    }
 157
 158
 159   for(int it=0;it<len;it++) {
 160     if(enc) {
 161       ind1=it*h2;
 162       ind2=Pbox[it]*h2;
 163     }
 164     else {
 165       ind2=it*h2;
 166       ind1=Pbox[it]*h2;
 167     }
 168
 169
 170    for(int a=0;a<h2;a+=4) {
 171       X[a]=X[Sbox1[a]];
 172       X[a+1]=X[Sbox1[a+1]];
 173       X[a+2]=X[Sbox1[a+2]];
 174       X[a+3]=X[Sbox1[a+3]];
 175     }
 176
 177     for(int a=0;a<h2;a+=4){
 178       fX[a]=X[a];
 179       fX[a+1]=X[a+1];
 180       fX[a+2]=X[a+2];
 181       fX[a+3]=X[a+3];
 182     }
 183
 184
 185
 186     //printf("fx %d\n",fX[0] );
 187
 188   /*
 189     for(int a=0;a<h2;a+=16) {
 190       *(int*)&fX[a]^=it;
 191       *(int*)&fX[a+4]^=it;
 192       *(int*)&fX[a+8]^=it;
 193       *(int*)&fX[a+12]^=it;
 194     }
 195    */
 196
 197
 198
 199
 200     for(int a=0;a<h2;a+=4) {
 201       fX[a]=fX[a]^RM1[a];
 202       fX[a+1]=fX[a+1]^RM1[a+1];
 203       fX[a+2]=fX[a+2]^RM1[a+2];
 204       fX[a+3]=fX[a+3]^RM1[a+3];
 205     }
 206
 207
 208     for(int a=0;a<h2;a+=4) {
 209       fX[a]=Sbox2[fX[a]];
 210       fX[a+1]=Sbox2[fX[a+1]];
 211       fX[a+2]=Sbox2[fX[a+2]];
 212       fX[a+3]=Sbox2[fX[a+3]];
 213     }
 214
 215
 216
 217
 218      for(int a=0;a<h2;a+=4) {
 219       fX[a]=fX[a]^seq_in[ind2+a];
 220       fX[a+1]=fX[a+1]^seq_in[ind2+a+1];
 221       fX[a+2]=fX[a+2]^seq_in[ind2+a+2];
 222       fX[a+3]=fX[a+3]^seq_in[ind2+a+3];
 223     }
 224
 225
 226
 227     for(int a=0;a<h2;a+=4) {
 228       seq_out[ind1+a]=fX[a];
 229       seq_out[ind1+a+1]=fX[a+1];
 230       seq_out[ind1+a+2]=fX[a+2];
 231       seq_out[ind1+a+3]=fX[a+3];
 232     }
 233
 234     for(int a=0;a<h2;a+=4) {
 235       RM1[a]=RM1[PboxRM[a]];
 236       RM1[a+1]=RM1[PboxRM[a+1]];
 237       RM1[a+2]=RM1[PboxRM[a+2]];
 238       RM1[a+3]=RM1[PboxRM[a+3]];
 239     }
 240
 241
 242
 243   }
 244
 245 //  printf("size mes %d\n",size_mesg);
 246 //  printf("len %d\n",len);
 247
 248
 249 //printArray(seq_out,16);
 250
 251 }
 252
 253
 254
 255 void printArray(byte *mes, int n) {
 256   for (byte i = 0; i < n; i++) {
 257     Serial.print(mes[i]);
 258     Serial.print(" ");
 259   }
 260   Serial.println();
 261 }
 262
 263
 264 void setup ()
 265 {
 266   Serial.begin (57600) ;
 267 //  printf_begin();
 268   delay(500);
 269   printf("\n===testng mode\n") ;
 270
 271
 272
 273
 274
 275
 276   uchar sc[256];
 277
 278   uchar RM1[h2];
 279   uchar RM2[h2];
 280
 281   randomSeed(14);
 282
 283   for(byte i=0;i<64;i++) {
 284     DK[i]=random(255);
 285   }
 286   rc4key(DK, Sbox1, 8);
 287
 288
 289   rc4key(&DK[8], Sbox2, 8);
 290
 291   rc4key(&DK[16], sc, 16);
 292
 293
 294   prga(sc, h2, RM1);
 295
 296
 297   rc4keyperm(&DK[32], len, rp, Pbox, 16);
 298
 299
 300   rc4keyperm(&DK[48], h2, rp, PboxRM, 16);
 301
 302   for(int i=0;i<h2;i++){
 303     RM2[i]=RM1[i];
 304     RM1_cpy[i]=RM1[i];
 305   }
 306
 307  //  WiFi.mode( WIFI_OFF );
 308
 309 Serial.println("END OF INIT");
 310
 311
 312
 313 //  otfly_test () ;
 314 //  otfly_test256 () ;
 315 }
 316
 317 void loop ()
 318 {
 319   prekey_test () ;
 320   delay(1000);
 321
 322 //  Serial.println("ESP8266 in sleep mode");
 323  // ESP.deepSleep(sleepTimeS * 1000000, WAKE_RF_DISABLED );
 324   delay(1000);
 325 //  Serial.println("ESP8266 in normal mode");
 326 }
 327
 328 void prekey (int bits)
 329 {
 330
 331 unsigned int res=21;
 332  unsigned long msms = micros ();
 333   ulong2 pcg;
 334   pcg.x=190812;
 335   pcg.y=20911;
 336   for(int i=0;i<100;i++) {
 337     res=random(255);
 338     //res=xorshift32(res);
 339     //res=pcg32_random_r(&pcg);
 340
 341   }
 342   unsigned long res2=micros() - msms;
 343   Serial.print("rand");
 344   Serial.println(res2);
 345   Serial.println(res);
 346
 347
 348
 349   byte plain[size_mesg];
 350   byte cipher [size_mesg] ;
 351   byte check [size_mesg] ;
 352
 353   randomSeed(334);
 354   for(int i=0;i<size_mesg;i++) {
 355     plain[i]=random(255);
 356   }
 357
 358   uchar RM1[h2];
 359   uchar RM2[h2];
 360
 361   for(int i=0;i<h2;i++){
 362     RM1[i]=RM1_cpy[i];
 363     RM2[i]=RM1_cpy[i];
 364   }
 365
 366
 367   printArray(RM1,16);
 368   printArray(Sbox1,16);
 369   printArray(Sbox2,16);
 370   //printArray(Pbox,16);
 371   delay(100);
 372
 373   unsigned long ms1 = micros ();
 374   encrypt_ctr(plain, cipher,len,RM1,Pbox,PboxRM,Sbox1,Sbox2,1);
 375   Serial.print("ONE   Encryption took: ");
 376   Serial.println(micros() - ms1);
 377
 378   ms1 = micros ();
 379   encrypt_ctr(cipher, check,len,RM2,Pbox,PboxRM,Sbox1,Sbox2,0);
 380   Serial.print("ONE   Decryption took: ");
 381   Serial.println(micros() - ms1);
 382
 383   printf("\n\nPLAIN :");
 384   printArray(plain,16);
 385   printf("\nCIPHER:");
 386   printArray(cipher,16);
 387   printf("\nCHECK :");
 388   printArray(check,16);
 389
 390   bool equal=true;
 391   for(int i=0;i<size_mesg;i++) {
 392
 393       if(check[i]!=plain[i]) {
 394         equal=false;
 395       }
 396     }
 397   Serial.print("CHECK ");
 398   Serial.println(equal);
 399
 400 }
 401
 402 void prekey_test ()
 403 {
 404   prekey (128) ;
 405 }
 406
 407