Arduino/With_Duc/version_linux.c

   1 //version to test the performance of our code with message of size 16 to 240
   2 //in order to make test with Duc
   3
   4 //the size of the message can be changed
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <stdint.h>
   9 #include<string.h>
  10
  11 #include <sys/time.h>
  12
  13 const int  h=2;
  14 const int h2=h*h;
  15
  16
  17
  18 double TimeStart()
  19 {
  20   struct timeval tstart;
  21   gettimeofday(&tstart,0);
  22   return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) );
  23 }
  24
  25 double TimeStop(double t)
  26 {
  27   struct timeval tend;
  28
  29   gettimeofday(&tend,0);
  30   t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t;
  31   return (t);
  32 }
  33
  34
  35
  36
  37 typedef uint8_t uchar;
  38 typedef uint8_t byte;
  39 //typedef unsigned long uint;
  40
  41 uint seed=123;
  42
  43 #define SKEY 64
  44
  45
  46 #define STATIC_KEY
  47
  48 //#define STATIC_KEY
  49 //#define STATIC_KEY_256q
  50 //#define STATIC_KEY_128
  51 //#define STATIC_KEY_64
  52 //#define STATIC_KEY_32
  53 #define STATIC_KEY_64
  54
  55 //dynamic key
  56 uchar DK[SKEY];
  57
  58 #ifdef STATIC_KEY
  59
  60 #ifdef STATIC_KEY_256
  61
  62 uchar Nonce[256] = {
  63   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  64   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  65   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  66   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  67   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  68   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  69   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  70   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  71   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  72   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  73   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  74   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  75   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  76   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  77   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  78   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
  79 };
  80
  81
  82 #elif defined STATIC_KEY_128
  83
  84 uchar Nonce[64] = {
  85   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  86   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  87   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  88   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  89   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  90   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  91   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
  92   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
  93 };
  94
  95
  96 #elif defined STATIC_KEY_64
  97
  98 uchar Nonce[64] = {
  99   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
 100   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
 101   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
 102   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 103 };
 104
 105 #elif defined STATIC_KEY_32
 106
 107 uchar Nonce[32] = {
 108   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C,
 109   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 110 };
 111
 112 #elif defined STATIC_KEY_16
 113
 114 uchar Nonce[16] = {
 115   0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
 116 };
 117
 118 #endif
 119
 120 #else
 121
 122 uchar Nonce[SKEY];
 123
 124 #endif
 125
 126 int rp=1;
 127
 128 //number of blocks
 129
 130
 131 uint xorshift32(const uint t)
 132 {
 133    /* Algorithm "xor" from p. 4 of Marsaglia, "Xorshift RNGs" */
 134         uint x = t;
 135         x ^= (x << 13);
 136         x ^= (x >> 17);
 137         x ^= (x << 5);
 138         return x;
 139 }
 140
 141 void rc4key(uchar *key, uchar *sc, int size_DK) {
 142
 143   for(int i=0;i<256;i+=4) {
 144     sc[i]=i;
 145     sc[i+1]=i+1;
 146     sc[i+2]=i+2;
 147     sc[i+3]=i+3;
 148   }
 149
 150   uchar j0 = 0;
 151   for(int i0=0; i0<256; i0++) {
 152     j0 = (j0 + sc[i0] + key[i0&(size_DK-1)] );
 153     uchar tmp = sc[i0];
 154     sc[i0] = sc[j0 ];
 155     sc[j0] = tmp;
 156   }
 157 }
 158
 159 void rc4keyperm(uchar *key,int len, int rp,uchar *sc, int size_DK) {
 160
 161   //sc=1:len;
 162
 163   for (int i=0;i<len;i++) {
 164     sc[i]=i;
 165   }
 166
 167   for (int it = 0; it < rp; it++) {
 168     int j0 = 1;
 169     for(int i0 = 0; i0<len; i0++) {
 170       j0 = (j0 + sc[i0] + sc[j0] + key[i0%size_DK] )% len;
 171       int tmp = sc[i0];
 172       sc[i0] = sc[j0];
 173       sc[j0] = tmp;
 174     }
 175   }
 176 }
 177
 178 void prga(uchar *sc, int ldata, uchar *r) {
 179   uchar i0=0;
 180   uchar j0=0;
 181
 182   for (int it=0; it<ldata; it++) {
 183     i0 = ((i0+1)%255);
 184     j0 = (j0 + sc[i0])&0xFF;
 185     uchar tmp = sc[i0];
 186     sc[i0] = sc[j0];
 187     sc[j0] = tmp;
 188     r[it]=sc[(sc[i0]+sc[j0])&0xFF];
 189   }
 190 }
 191
 192 void encrypt_ctr(uchar* seq_in, uchar *seq_out, int len,uchar* RM1, uchar *PboxRM, uchar *Sbox1, uchar *Sbox2,uint myrand,int enc) {
 193
 194   uchar X[h2];
 195
 196
 197   int ind=0;
 198
 199   for(int a=0;a<h2;a+=4) {
 200
 201     uint mm=myrand;
 202
 203     X[a]=Sbox1[RM1[a]^(mm&255)];           //Warning according to the size of h2, we can be outsize of Sbox1[a]
 204     mm>>=8;
 205     X[a+1]=Sbox2[RM1[a+1]^(mm&255)];
 206     mm>>=8;
 207     X[a+2]=Sbox1[RM1[a+2]^(mm&255)];
 208     mm>>=8;
 209     X[a+3]=Sbox2[RM1[a+3]^(mm&255)];
 210
 211
 212 /*      uint32_t val=*((uint32_t*)&RM1[a])^mm;
 213       uchar *val2=(uchar*)&val;
 214       X[a]=Sbox1[val2[0]];
 215       X[a+1]=Sbox2[val2[1]];
 216       X[a+2]=Sbox1[val2[2]];
 217       X[a+3]=Sbox2[val2[3]];
 218 */
 219
 220
 221
 222   }
 223
 224   for(int it=0;it<len;it++) {
 225
 226     for(int a=0;a<h2;a+=4) {
 227       myrand=xorshift32(myrand);
 228       uint mm=myrand;
 229       X[a]=Sbox2[X[a]^RM1[a]^(mm&255)];
 230       mm>>=8;
 231       X[a+1]=Sbox1[X[a+1]^RM1[a+1]^(mm&255)];
 232       mm>>=8;
 233       X[a+2]=Sbox2[X[a+2]^RM1[a+2]^(mm&255)];
 234       mm>>=8;
 235       X[a+3]=Sbox1[X[a+3]^RM1[a+3]^(mm&255)];
 236
 237 /*      uint32_t val=*((uint32_t*)&X[a])^*((uint32_t*)&RM1[a])^mm;
 238       uchar *val2=(uchar*)&val;
 239       X[a]=Sbox2[val2[0]];
 240       X[a+1]=Sbox1[val2[1]];
 241       X[a+2]=Sbox2[val2[2]];
 242       X[a+3]=Sbox1[val2[3]];
 243 */
 244     }
 245
 246
 247
 248     for(int a=0;a<h2;a+=4) {
 249       seq_out[ind+a]=X[a]^seq_in[ind+a];
 250       seq_out[ind+a+1]=X[a+1]^seq_in[ind+a+1];
 251       seq_out[ind+a+2]=X[a+2]^seq_in[ind+a+2];
 252       seq_out[ind+a+3]=X[a+3]^seq_in[ind+a+3];
 253     }
 254
 255     for(int a=0;a<h2;a+=4) {
 256 /*      RM1[a]=Sbox2[RM1[PboxRM[a]]];
 257       RM1[a+1]=Sbox1[RM1[PboxRM[a+1]]];
 258       RM1[a+2]=Sbox2[RM1[PboxRM[a+2]]];
 259       RM1[a+3]=Sbox1[RM1[PboxRM[a+3]]];
 260 */
 261       uchar w0=Sbox2[RM1[PboxRM[a]]];
 262       uchar w1=Sbox1[RM1[PboxRM[a+1]]];
 263       uchar w2=Sbox2[RM1[PboxRM[a+2]]];
 264       uchar w3=Sbox1[RM1[PboxRM[a+3]]];
 265
 266                         RM1[a]=w0;
 267                         RM1[a+1]=w1;
 268                         RM1[a+2]=w2;
 269                         RM1[a+3]=w3;
 270
 271
 272
 273     }
 274
 275     ind+=h2;
 276   }
 277 }
 278
 279 void printArray(byte *mes, int n) {
 280   for (byte i = 0; i < n; i++) {
 281     printf("%d ",mes[i]);
 282   }
 283   printf("\n");
 284 }
 285
 286 int main (int argc, char ** argv)
 287 {
 288
 289
 290   //  const int  h=2;
 291   //const int h2=h*h;
 292   int size_buf=1;
 293   int nb_test=1;
 294
 295   for(int i=1; i<argc; i++){
 296     if(strncmp(argv[i],"nb",2)==0)    nb_test = atoi(&(argv[i][2]));    //nb of test
 297     if(strncmp(argv[i],"sizebuf",7)==0) size_buf = atoi(&(argv[i][7]));          //SIZE of the buffer
 298   }
 299
 300
 301   size_buf=size_buf*size_buf;
 302
 303   int size_mesg=size_buf;
 304
 305
 306   int len=(size_mesg+h2-1)/h2;
 307
 308
 309   uchar sc[256];
 310   uchar PboxRM[h2];
 311   uchar Sbox1[256];
 312   uchar Sbox2[256];
 313
 314   uchar RM1[h2];
 315   uchar RM2[h2];
 316
 317   uint myrand;
 318
 319   byte plain[len*h2];
 320   byte cipher[len*h2];
 321   byte check[len*h2];
 322
 323
 324
 325   int bits=128;
 326
 327 //  delay(2000);
 328
 329   //initialization of the key
 330   for(int i=0;i<SKEY;i+=4) {
 331      seed=xorshift32(seed);
 332      uint val=seed;
 333      DK[i]=val&0xFF;
 334      val>>=8;
 335      DK[i+1]=val&0xFF;
 336      val>>=8;
 337      DK[i+2]=val&0xFF;
 338      val>>=8;
 339      DK[i+3]=val&0xFF;
 340   }
 341
 342   //  printf("TOTO\n");
 343
 344 #ifndef STATIC_KEY
 345
 346   for(int i=0;i<256;i+=4) {
 347      seed=xorshift32(seed);
 348      uint val=seed;
 349      Nonce[i]=val&0xFF;
 350      val>>=8;
 351      Nonce[i+1]=val&0xFF;
 352      val>>=8;
 353      Nonce[i+2]=val&0xFF;
 354      val>>=8;
 355      Nonce[i+3]=val&0xFF;
 356   }
 357
 358 #endif
 359
 360   //printf("DK\n");
 361   for(int i=0;i<SKEY;i++) {
 362     DK[i]^=Nonce[i];
 363   }
 364
 365
 366
 367
 368   //computation of sbox and other dynamic tables
 369   rc4key(&DK[0], sc, SKEY/4);
 370   prga(sc, h2, RM1);
 371   rc4keyperm(&DK[SKEY/4], h2, rp, PboxRM, SKEY/4);
 372   rc4key(&DK[SKEY/2], Sbox1, SKEY/4);
 373   rc4key(&DK[(SKEY/4)*3], Sbox2, SKEY/4);
 374
 375
 376
 377   myrand=0;
 378   for(int i=0;i<32;i++) {
 379     myrand|=DK[i]&1;
 380     myrand<<=1;
 381   }
 382
 383  /* plain = malloc(max_size_mesg*sizeof(byte));
 384   cipher=malloc(max_size_mesg*sizeof(byte));
 385   check=malloc(max_size_mesg*sizeof(byte));
 386 */
 387
 388   //  printf("len %d\n",len);
 389
 390   //we keep the same message or not
 391   //randomSeed(334);
 392   for(int i=0;i<size_mesg;i++) {
 393     seed=xorshift32(seed);
 394     plain[i]=seed&0xFF;
 395   }
 396
 397   myrand=0;
 398   for(int i=0;i<32;i++) {
 399     myrand|=DK[i]&1;
 400     myrand<<=1;
 401   }
 402
 403
 404   //RM1 is changed in the encryption so we make a copy for the decryption
 405   for(int i=0;i<h2;i++){
 406     RM2[i]=RM1[i];
 407   }
 408
 409
 410   //  unsigned long ms1 = micros ();
 411 double   t=TimeStart();
 412   for(int i=0;i<nb_test;i++)
 413     {
 414       encrypt_ctr(plain, cipher,len,RM1,PboxRM,Sbox1,Sbox2,myrand,1);
 415     }
 416 double  time_encrypt=TimeStop(t);
 417  printf("%e \t",(double)size_buf*nb_test/time_encrypt);
 418
 419 t=TimeStart();
 420   for(int i=0;i<nb_test;i++)
 421     {
 422   encrypt_ctr(cipher, check,len,RM2,PboxRM,Sbox1,Sbox2,myrand,0);
 423  }
 424 double  time_decrypt=TimeStop(t);
 425  printf("%e \t",(double)size_buf*nb_test/time_decrypt);
 426
 427
 428   /*
 429   int equal=1;
 430
 431   for(int i=0;i<size_mesg;i++) {
 432
 433       if(check[i]!=plain[i]) {
 434         equal=0;
 435       }
 436     }
 437
 438   printf("CHECK %d\n",equal);
 439   */
 440
 441
 442 }
 443
 444