OneRoundIoT/EnhancedOneRound/test_substitution.cpp

   1 //gcc pixmap_io.c  -c
   2 //g++ -O3 one_round_new.cpp pixmap_io.o  -o one_round_new -std=c++11
   3
   4 #include <iostream>
   5 #include <list>
   6 #include<math.h>
   7 #include<stdlib.h>
   8 #include<stdio.h>
   9 #include<string.h>
  10 #include <fstream>
  11 #include <sys/time.h>
  12
  13 using namespace std;
  14
  15
  16 int key_size=256;
  17 int nb_test=1;
  18 int cbcprng=0;
  19 int cbcrm=0;
  20 int ecbrm=0;
  21 int ecbprng=0;
  22
  23
  24
  25 typedef __uint64_t mylong;
  26
  27
  28 typedef unsigned char   uchar;
  29
  30
  31 double TimeStart()
  32 {
  33   struct timeval tstart;
  34   gettimeofday(&tstart,0);
  35   return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) );
  36 }
  37
  38 double TimeStop(double t)
  39 {
  40   struct timeval tend;
  41
  42   gettimeofday(&tend,0);
  43   t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t;
  44   return (t);
  45 }
  46
  47
  48
  49
  50 uint xorshift32(const uint t)
  51 {
  52   /* Algorithm "xor" from p. 4 of Marsaglia, "Xorshift RNGs" */
  53   uint x = t;
  54   x ^= x << 13;
  55   x ^= x >> 17;
  56   x ^= x << 5;
  57   return x;
  58 }
  59
  60
  61 mylong xorseed;
  62
  63 mylong xorshift64()
  64 {
  65         /* Algorithm "xor" from p. 4 of Marsaglia, "Xorshift RNGs" */
  66         mylong x = xorseed;
  67         x ^= x >> 12; // a
  68         x ^= x << 25; // b
  69         x ^= x >> 27; // c
  70
  71
  72         return xorseed=x;
  73 }
  74
  75 /*
  76 __uint128_t g_lehmer64_state;
  77
  78 inline uint64_t splitmix64_stateless(uint64_t index) {
  79   uint64_t z = (index + UINT64_C(0x9E3779B97F4A7C15));
  80   z = (z ^ (z >> 30)) * UINT64_C(0xBF58476D1CE4E5B9);
  81   z = (z ^ (z >> 27)) * UINT64_C(0x94D049BB133111EB);
  82   return z ^ (z >> 31);
  83 }
  84
  85
  86 inline void lehmer64_seed(uint64_t seed) {
  87   g_lehmer64_state = (((__uint128_t)splitmix64_stateless(seed)) << 64) +
  88                      splitmix64_stateless(seed + 1);
  89 }
  90
  91 inline uint64_t lehmer64() {
  92   g_lehmer64_state *= UINT64_C(0xda942042e4dd58b5);
  93   ;
  94   return g_lehmer64_state >> 64;
  95 }
  96
  97 */
  98
  99
 100
 101 void inverse_tables(uchar *tab, int size_tab,uchar *inv_perm_tabs) {
 102
 103   for(int i=0;i<size_tab;i++) {
 104     inv_perm_tabs[tab[i]] = i;
 105   }
 106
 107 }
 108
 109 void inverse_tables_int(int *tab, int size_tab,int *inv_perm_tabs) {
 110
 111   for(int i=0;i<size_tab;i++) {
 112     inv_perm_tabs[tab[i]] = i;
 113   }
 114
 115 }
 116
 117
 118
 119 void rc4key(uchar *key, uchar *sc, int size_DK) {
 120
 121   for(int i=0;i<256;i++) {
 122     sc[i]=i;
 123   }
 124
 125
 126   uchar j0 = 0;
 127   for(int i0=0; i0<256; i0++) {
 128     j0 = (j0 + sc[i0] + key[i0%size_DK] )&0xFF;
 129     uchar tmp = sc[i0];
 130     sc[i0] = sc[j0 ];
 131     sc[j0] = tmp;
 132   }
 133 }
 134
 135
 136
 137 void rc4keyperm(uchar *key,int len, int rp,int *sc, int size_DK) {
 138
 139   //sc=1:len;
 140
 141
 142
 143   for (int i=0;i<len;i++) {
 144     sc[i]=i;
 145   }
 146   for (int it = 0; it < rp; it++) {
 147     int j0 = 1;
 148     for(int i0 = 0; i0<len; i0++) {
 149       j0 = (j0 + sc[i0] + sc[j0] + key[i0%size_DK] )% len;
 150       int tmp = sc[i0];
 151       sc[i0] = sc[j0];
 152       sc[j0] = tmp;
 153     }
 154
 155   }
 156 }
 157
 158 void prga(uchar *sc, int ldata, uchar *r) {
 159   uchar i0=0;
 160   uchar j0=0;
 161
 162   for (int it=0; it<ldata; it++) {
 163     i0 = ((i0+1)%255);
 164     j0 = (j0 + sc[i0])&0xFF;
 165     uchar tmp = sc[i0];
 166     sc[i0] = sc[j0];
 167     sc[j0] = tmp;
 168     r[it]=sc[(sc[i0]+sc[j0])&0xFF];
 169   }
 170 }
 171
 172
 173
 174
 175
 176
 177
 178
 179 int main(int argc, char** argv) {
 180
 181   int nb_test=100000;
 182
 183   int seed=time(NULL);
 184
 185   srand48(seed);
 186
 187   uchar Secretkey[key_size];
 188
 189   uchar counter[key_size];
 190
 191
 192   int size = 128;
 193   uchar DK[size];
 194
 195   for(int i=0;i<key_size;i++) {
 196     DK[i]=lrand48()&0xFF;
 197   }
 198
 199
 200
 201
 202
 203
 204
 205
 206
 207
 208   uchar Sbox1[256];
 209   uchar Sbox2[256];
 210   uchar Temp[256];
 211
 212
 213
 214   double time=0;
 215
 216
 217   rc4key(DK, Sbox1, 8);
 218
 219
 220   rc4key(&DK[8], Sbox2, 8);
 221
 222   double t=TimeStart();
 223
 224
 225
 226   for(int nb=0;nb<nb_test;nb++) {
 227
 228     for(int i=0;i<256;i++) {
 229       Temp[i]=Sbox1[i];
 230     }
 231
 232     for(int i=0;i<256;i++) {
 233       Sbox1[i]=Sbox1[Sbox2[i]];
 234     }
 235
 236     for(int i=0;i<256;i++) {
 237       Sbox2[i]=Sbox2[Temp[i]];
 238     }
 239
 240
 241   }
 242
 243   time+=TimeStop(t);
 244   cout<<"Time sub nb times "<<nb_test<<"   = "<<time<<endl;
 245
 246
 247
 248   return 0;
 249 }