Old_one_round/one_round_light.cpp

   1 //gcc pixmap_io.c  -c
   2 //g++ -O3 one_round_light.cpp pixmap_io.o  -o one_round_light -std=c++11
   3
   4 #include <iostream>
   5 #include <list>
   6 #include<math.h>
   7 #include<stdlib.h>
   8 #include<stdio.h>
   9 #include <fstream>
  10 #include <sys/time.h>
  11
  12 /*#include <cryptopp/hex.h>
  13 #include <cryptopp/sha.h>
  14 #include <cryptopp/osrng.h>
  15 #include <cryptopp/secblock.h>
  16 */
  17
  18
  19 extern "C" {
  20   int load_RGB_pixmap(char *filename, int *width, int *height, unsigned char**R_data, unsigned char**G_data, unsigned char**B_data);
  21   void store_RGB_pixmap(char *filename, unsigned char *R_data, unsigned char *G_data, unsigned char *B_data, int width, int height);
  22 }
  23
  24
  25 //using namespace CryptoPP;
  26 using namespace std;
  27
  28
  29 int key_size=256;
  30
  31
  32 const int h=64;
  33 const int h2=h*h;
  34
  35
  36
  37 typedef unsigned char   uchar;
  38
  39
  40 double TimeStart()
  41 {
  42   struct timeval tstart;
  43   gettimeofday(&tstart,0);
  44   return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) );
  45 }
  46
  47 double TimeStop(double t)
  48 {
  49   struct timeval tend;
  50
  51   gettimeofday(&tend,0);
  52   t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t;
  53   return (t);
  54 }
  55
  56
  57
  58
  59
  60
  61 void inverse_tables(uchar *tab, int size_tab,uchar *inv_perm_tabs) {
  62
  63   for(int i=0;i<size_tab;i++) {
  64     inv_perm_tabs[tab[i]] = i;
  65   }
  66
  67 }
  68
  69
  70 void inverse_tables2(int *tab, int size_tab,int *inv_perm_tabs) {
  71
  72   for(int i=0;i<size_tab;i++) {
  73     inv_perm_tabs[tab[i]] = i;
  74   }
  75
  76 }
  77
  78
  79 void rc4key(uchar *key, uchar *sc, int size_DK) {
  80
  81   for(int i=0;i<256;i++) {
  82     sc[i]=i;
  83   }
  84
  85
  86   uchar j0 = 0;
  87   for(int i0=0; i0<256; i0++) {
  88     j0 = (j0 + sc[i0] + key[i0%size_DK] )&0xFF;
  89     uchar tmp = sc[i0];
  90     sc[i0] = sc[j0 ];
  91     sc[j0] = tmp;
  92   }
  93 }
  94
  95
  96
  97 void rc4keyperm(uchar *key,int len, int rp,int *sc, int size_DK) {
  98
  99   //sc=1:len;
 100
 101
 102
 103   for (int i=0;i<len;i++) {
 104     sc[i]=i;
 105   }
 106   for (int it = 0; it < rp; it++) {
 107     int j0 = 1;
 108     for(int i0 = 0; i0<len; i0++) {
 109       j0 = (j0 + sc[i0] + sc[j0] + key[i0%size_DK] )% len;
 110       int tmp = sc[i0];
 111       sc[i0] = sc[j0];
 112       sc[j0] = tmp;
 113     }
 114
 115   }
 116 }
 117
 118 void prga(uchar *sc, int ldata, uchar *r) {
 119   uchar i0=0;
 120   uchar j0=0;
 121
 122   for (int it=0; it<ldata; it++) {
 123     i0 = ((i0+1)%255);
 124     j0 = (j0 + sc[i0])&0xFF;
 125     uchar tmp = sc[i0];
 126     sc[i0] = sc[j0];
 127     sc[j0] = tmp;
 128     r[it]=sc[(sc[i0]+sc[j0])&0xFF];
 129   }
 130 }
 131
 132
 133
 134
 135
 136
 137
 138 void encrypt(uchar* seq,int len,uchar* RM1,uchar *RM2,uchar *RM3,int *Pbox, uchar *Sbox1, uchar *Sbox2, int debug) {
 139
 140
 141   uchar *X=new uchar[h2];
 142   uchar *Y=new uchar[h2];
 143   uchar *fX=new uchar[h2];
 144   uchar *gY=new uchar[h2];
 145
 146   for(int it=0;it<len;it++) {
 147     int ind1=it*h2;
 148     int ind2=Pbox[it]*h2;
 149
 150     uchar *p1=X;
 151     uchar *p2=&seq[ind1];
 152     for(int a=0;a<h2;a++) {
 153       X[a]=seq[ind1+a];
 154       //*p1++=*p2++;
 155     }
 156
 157 //    memcpy(p1,p2,h2);
 158
 159     p1=Y;
 160     p2=&seq[ind2];
 161     for(int a=0;a<h2;a++) {
 162       Y[a]=seq[ind2+a];
 163       //*p1++=*p2++;
 164       }
 165     //memcpy(p1,p2,h2);
 166
 167     p1=fX;
 168     p2=X;
 169     for(int a=0;a<h2;a++){
 170       fX[a]=Sbox1[X[a]];
 171       //*p1++=Sbox1[*p2++];
 172     }
 173
 174     for(int a=0;a<h2;a++){
 175       gY[a]=Sbox2[Y[a]];
 176     }
 177     for(int a=0;a<h2;a++) {
 178       fX[a]=fX[a]^RM1[a]^Y[a];
 179     }
 180     for(int a=0;a<h2;a++){
 181       gY[a]=gY[a]^RM3[a];
 182     }
 183
 184     for(int a=0;a<h2;a++) {
 185       seq[ind1+a]=Sbox2[fX[a]];
 186     }
 187     for(int a=0;a<h2;a++){
 188       seq[ind2+a]=Sbox1[gY[a]];
 189     }
 190   }
 191
 192
 193 }
 194
 195
 196 /*
 197 void decrypt(uchar* seq,int len,uchar* RM1,uchar *RM2,uchar *RM3,int *Pbox, uchar *Sbox1, uchar *Sbox2, int debug) {
 198
 199
 200   uchar *fX=new uchar[h2];
 201   uchar *gY=new uchar[h2];
 202
 203
 204    uchar *Inv_Sbox1=new uchar[256];
 205    inverse_tables(Sbox1,256,Inv_Sbox1);
 206
 207   uchar *Inv_Sbox2=new uchar[256];
 208   inverse_tables(Sbox2,256,Inv_Sbox2);
 209
 210
 211
 212
 213   for(int it=len-1;it>=0;it--) {
 214     int ind1=it*h2;
 215     int ind2=Pbox[it]*h2;
 216
 217
 218
 219     for(int a=0;a<h2;a++) {
 220       fX[a]=seq[ind1+a];
 221     }
 222
 223
 224     for(int a=0;a<h2;a++) {
 225       fX[a]=Inv_Sbox2[fX[a]];
 226     }
 227
 228     for(int a=0;a<h2;a++) {
 229       fX[a]=fX[a]^RM1[a];
 230     }
 231
 232
 233     for(int a=0;a<h2;a++) {
 234       gY[a]=seq[ind2+a];
 235     }
 236
 237     for(int a=0;a<h2;a++) {
 238       gY[a]=Inv_Sbox1[gY[a]];
 239     }
 240     for(int a=0;a<h2;a++) {
 241       gY[a]=gY[a]^RM3[a];
 242     }
 243
 244 //    for(int a=0;a<h2;a++) {
 245 //      gY[a]=Inv_Sbox2[gY[a]];
 246 //    }
 247
 248     for(int a=0;a<h2;a++) {
 249       fX[a]=fX[a]^gY[a];
 250     }
 251
 252      for(int a=0;a<h2;a++) {
 253       seq[ind1+a]=Inv_Sbox1[fX[a]];
 254     }
 255     for(int a=0;a<h2;a++) {
 256       seq[ind2+a]=Inv_Sbox2[gY[a]];
 257     }
 258   }
 259
 260
 261 }
 262
 263
 264 */
 265
 266
 267 void decrypt(uchar* seq,int len,uchar* RM1,uchar *RM2,uchar *RM3,int *Pbox, uchar *Sbox1, uchar *Sbox2, int debug) {
 268
 269
 270   uchar *fX=new uchar[h2];
 271   uchar *gY=new uchar[h2];
 272
 273
 274   uchar *Inv_Sbox1=new uchar[256];
 275   inverse_tables(Sbox1,256,Inv_Sbox1);
 276
 277   uchar *Inv_Sbox2=new uchar[256];
 278   inverse_tables(Sbox2,256,Inv_Sbox2);
 279
 280 /*  int *Inv_Pbox=new int[len];
 281   inverse_tables2(Pbox,len,Inv_Pbox);
 282
 283   for(int i=0;i<len;i++) {
 284     cout<<Pbox[Inv_Pbox[i]]<<" ";
 285   }
 286   exit(0);
 287 */
 288
 289
 290
 291   for(int it=len-1;it>=0;it--) {
 292     int ind1=it*h2;
 293     int ind2=Pbox[it]*h2;
 294
 295
 296
 297
 298
 299     for(int a=0;a<h2;a++) {
 300       fX[a]=Inv_Sbox2[seq[ind1+a]];
 301     }
 302
 303     for(int a=0;a<h2;a++) {
 304       fX[a]=fX[a]^RM1[a];
 305     }
 306
 307
 308     for(int a=0;a<h2;a++) {
 309       gY[a]=Inv_Sbox1[seq[ind2+a]];
 310     }
 311     for(int a=0;a<h2;a++) {
 312       gY[a]=Inv_Sbox2[gY[a]^RM3[a]];
 313     }
 314
 315
 316     for(int a=0;a<h2;a++) {
 317       fX[a]=fX[a]^gY[a];
 318     }
 319
 320      for(int a=0;a<h2;a++) {
 321       seq[ind1+a]=Inv_Sbox1[fX[a]];
 322     }
 323
 324
 325     for(int a=0;a<h2;a++) {
 326       seq[ind2+a]=gY[a];
 327     }
 328   }
 329
 330
 331 }
 332
 333
 334
 335 void Dynamickeygenerationnew(uchar *Secretkey, uchar *counter) {
 336   int size = 64;
 337   uchar DK[size];
 338
 339
 340
 341
 342   int width;
 343   int height;
 344   uchar *data_R, *data_G, *data_B;
 345   load_RGB_pixmap("lena.ppm", &width, &height, &data_R, &data_G, &data_B);
 346
 347
 348
 349
 350
 351   int imsize=width*height*3;
 352   uchar* seq= new uchar[imsize];
 353
 354   int oneD=width*height;
 355   for(int i=0;i<oneD;i++) {
 356     seq[i]=data_R[i];
 357     seq[oneD+i]=data_G[i];
 358     seq[2*oneD+i]=data_B[i];
 359   }
 360
 361
 362
 363
 364
 365   int total_len=imsize;
 366   int rp=1;
 367   int len= total_len/h2;
 368
 369
 370
 371   uchar *mix=new uchar[256];
 372
 373
 374
 375
 376   for (int i = 0; i < 256 ; i++) {
 377 //      mix[i]=(int)secret_key.BytePtr()[i]^(int)mycounter.BytePtr()[i];
 378     mix[i]=Secretkey[i]^counter[i];
 379   }
 380
 381 /*  byte digest[64];
 382   SHA512().CalculateDigest(digest, mix, 256);
 383 */
 384
 385
 386   cout<<"hash "<<endl;
 387   for (int i = 0; i < 64 ; i++) {
 388 //    DK[i]=digest[i];
 389     DK[i]=mix[i];
 390   }
 391
 392
 393
 394
 395   uchar Sbox1[256];
 396   rc4key(DK, Sbox1, 16);
 397
 398   uchar Sbox2[256];
 399   rc4key(&DK[16], Sbox2, 16);
 400
 401
 402
 403   uchar sc[256];
 404   rc4key(&DK[32], sc, 16);
 405
 406   uchar outd[2*(h * h)];
 407   prga(sc, 2*(h * h), outd);
 408
 409
 410   uchar RM1[h*h];
 411   uchar RM2[h*h];
 412   uchar RM3[h*h];
 413   for(int i=0;i<h2;i++){
 414     RM1[i]=outd[i];
 415     RM2[i]=outd[i+h2];
 416     RM3[i]=RM1[i]^RM2[i];
 417   }
 418
 419
 420
 421
 422
 423
 424   uchar keyp[16];
 425   for (int i = 48; i < 64; i++)
 426     keyp[i-48] = DK[i];
 427
 428   cout<<len<<endl;
 429   int *Pbox=new int[len];
 430
 431   rc4keyperm(keyp, len, rp, Pbox, 16);
 432
 433
 434
 435
 436  double time=0;
 437   double t=TimeStart();
 438
 439   int i;
 440   for(i=0;i<100;i++)
 441   {
 442     encrypt(seq,len,RM1,RM2,RM3,Pbox,Sbox1,Sbox2,0);
 443   }
 444
 445   time+=TimeStop(t);
 446   cout<<"Time encrypt "<<time<<endl;
 447
 448
 449   for(int i=0;i<oneD;i++) {
 450     data_R[i]=seq[i];
 451     data_G[i]=seq[oneD+i];
 452     data_B[i]=seq[2*oneD+i];
 453   }
 454   store_RGB_pixmap("lena2.ppm", data_R, data_G, data_B, width, height);
 455
 456
 457   time=0;
 458   t=TimeStart();
 459   for(i=0;i<100;i++) {
 460     decrypt(seq,len,RM1,RM2,RM3,Pbox,Sbox1,Sbox2,0);
 461   }
 462
 463   time+=TimeStop(t);
 464   cout<<"Time decrypt "<<time<<endl;
 465
 466
 467   for(int i=0;i<oneD;i++) {
 468     data_R[i]=seq[i];
 469     data_G[i]=seq[oneD+i];
 470     data_B[i]=seq[2*oneD+i];
 471   }
 472   store_RGB_pixmap("lena3.ppm", data_R, data_G, data_B, width, height);
 473
 474
 475
 476
 477
 478 }
 479
 480
 481
 482 int main() {
 483   cout << "Hello, World!" << endl;
 484
 485
 486
 487
 488
 489   int seed=time(NULL);
 490   cout<<seed<<endl;
 491   srand48(seed);
 492
 493   uchar Secretkey[key_size];
 494
 495   uchar counter[key_size];
 496
 497   for(int i=0;i<key_size;i++) {
 498     Secretkey[i]=lrand48()&0xFF;
 499     counter[i]=lrand48()&0xFF;
 500   }
 501
 502   Dynamickeygenerationnew(Secretkey, counter);
 503
 504   return 0;
 505 }