OneRoundIoT/Delta/scprng.cpp~

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <stdint.h>
   4 #include <sys/time.h>
   5
   6
   7 typedef unsigned char uchar;
   8
   9
  10
  11
  12 typedef uint64_t u8;
  13
  14
  15
  16 typedef struct sfcctx { u8 a; u8 b; u8 c; u8 count; } sfcctx;
  17 #define rot64(x,k) (((x)<<(k))|((x)>>(64-(k))))
  18
  19 #define rotation  24
  20 #define right_shift 11
  21 #define left_shift 3
  22
  23
  24 static inline u8 sfc( sfcctx *x ) {
  25   u8 tmp = x->a + x->b + x->count++;
  26   x->a = x->b ^ (x->b >> right_shift);
  27   x->b = x->c + (x->c << left_shift);
  28   x->c = rot64(x->c, rotation) + tmp;
  29   return tmp;
  30 }
  31
  32 static inline void sfcinit(sfcctx *x, uint64_t seed) {
  33   x->a = seed;
  34   x->b = seed;
  35   x->c = seed;
  36   x->count = 1;
  37   for(int i=0;i<12;i++)
  38     sfc(x);
  39 }
  40
  41
  42
  43 typedef struct ranctx { u8 a; u8 b; u8 c; u8 d; } ranctx;
  44
  45
  46
  47 static inline u8 jsf( ranctx *x ) {
  48   u8 e = x->a - rot64(x->b, 7);
  49   x->a = x->b ^ rot64(x->c, 13);
  50   x->b = x->c + rot64(x->d, 37);
  51   x->c = x->d + e;
  52   x->d = e + x->a;
  53   return x->d;
  54 }
  55
  56 static inline void jsfinit(ranctx *x, uint64_t seed) {
  57   x->a = 0xf1ea5eed, x->b = x->c = x->d = seed;
  58 }
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68 inline uint64_t xorshift64( const uint64_t state)
  69 {
  70   uint64_t x = state;
  71   x^= x << 13;
  72   x^= x >> 7;
  73   x^= x << 17;
  74   return x;
  75 }
  76
  77 static inline uint64_t splitmix64_stateless(uint64_t index) {
  78   uint64_t z = (index + UINT64_C(0x9E3779B97F4A7C15));
  79   z = (z ^ (z >> 30)) * UINT64_C(0xBF58476D1CE4E5B9);
  80   z = (z ^ (z >> 27)) * UINT64_C(0x94D049BB133111EB);
  81   return z ^ (z >> 31);
  82 }
  83
  84
  85 struct sulong2  {
  86   uint64_t x;
  87   uint64_t y;
  88 };
  89
  90 typedef struct sulong2 ulong2;
  91
  92 static inline uint64_t rotl(const uint64_t x, int k) {
  93   return (x << k) | (x >> (64 - k));
  94 }
  95
  96 // call this one before calling xoroshiro128plus
  97 static inline void xoroshiro128plus_seed(ulong2 *xoro,uint64_t seed) {
  98   xoro->x = splitmix64_stateless(seed);
  99   xoro->y = splitmix64_stateless(seed + 1);
 100 }
 101
 102 // returns random number, modifies xoroshiro128plus_s
 103 static inline uint64_t xoroshiro128plus(ulong2 *xoro) {
 104   const uint64_t s0 = xoro->x;
 105   uint64_t s1 = xoro->y;
 106   const uint64_t result = s0 + s1;
 107
 108   s1 ^= s0;
 109   xoro->x = rotl(s0, 55) ^ s1 ^ (s1 << 14); // a, b
 110   xoro->y = rotl(s1, 36);                   // c
 111
 112   return result;
 113 }
 114
 115
 116
 117
 118
 119
 120 double TimeStart()
 121 {
 122   struct timeval tstart;
 123   gettimeofday(&tstart,0);
 124   return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) );
 125 }
 126
 127 double TimeStop(double t)
 128 {
 129   struct timeval tend;
 130
 131   gettimeofday(&tend,0);
 132   t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t;
 133   return (t);
 134 }
 135
 136
 137 uint xorshift32(const uint t)
 138 {
 139   /* Algorithm "xor" from p. 4 of Marsaglia, "Xorshift RNGs" */
 140   uint x = t;
 141   x ^= x << 13;
 142   x ^= x >> 17;
 143   x ^= x << 5;
 144   return x;
 145 }
 146
 147
 148
 149
 150
 151 void rc4key(uchar *key, uchar *sc, int size_DK) {
 152
 153   for(int i=0;i<256;i++) {
 154     sc[i]=i;
 155   }
 156
 157
 158   uchar j0 = 0;
 159   for(int i0=0; i0<256; i0++) {
 160     j0 = (j0 + sc[i0] + key[i0%size_DK] )&0xFF;
 161     uchar tmp = sc[i0];
 162     sc[i0] = sc[j0 ];
 163     sc[j0] = tmp;
 164   }
 165 }
 166
 167
 168 void rc4keyperm(uchar *key,int len, int rp,int *sc, int size_DK) {
 169
 170   //sc=1:len;
 171
 172
 173
 174   for (int i=0;i<len;i++) {
 175     sc[i]=i;
 176   }
 177   for (int it = 0; it < rp; it++) {
 178     int j0 = 1;
 179     for(int i0 = 0; i0<len; i0++) {
 180       j0 = (j0 + sc[i0] + sc[j0] + key[i0%size_DK] )% len;
 181       int tmp = sc[i0];
 182       sc[i0] = sc[j0];
 183       sc[j0] = tmp;
 184     }
 185
 186   }
 187 }
 188
 189
 190 int main() {
 191   printf("%d %d \n",sizeof(__uint64_t),sizeof(ulong));
 192
 193
 194   uint64_t val=1021;
 195   uint64_t val2=1021;
 196
 197   uint r1=21,r2=93;
 198
 199   uchar DK[64];
 200   for(int i=0;i<64;i++)
 201     DK[i]=splitmix64_stateless(i);
 202
 203
 204   uchar Sbox1[256];
 205   uchar Sbox2[256];
 206   rc4key(DK, Sbox1, 8);
 207   rc4key(&DK[8], Sbox2, 8);
 208
 209   const int bufsize=128;
 210   int Pbox[bufsize];
 211   int Pbox2[bufsize];
 212   rc4keyperm(&DK[16], bufsize, 1, Pbox, 16);
 213   rc4keyperm(&DK[32], bufsize, 1, Pbox2, 16);
 214
 215
 216   int plain[bufsize];
 217   int cipher[bufsize];
 218
 219   ulong2 xoro[bufsize];
 220
 221   ranctx ctx[bufsize];
 222   sfcctx sfcd[bufsize];
 223
 224
 225   uint64_t Val[bufsize];
 226   for(int i=0;i<bufsize;i++) {
 227     Val[Pbox[i]]=splitmix64_stateless(i+DK[i&63]);
 228     plain[i]=0;
 229     xoroshiro128plus_seed(&xoro[i],Val[Pbox[i]]);
 230     jsfinit(&ctx[i],1000+i*100+DK[i&63]);
 231     sfcinit(&sfcd[i],1000+i*100+DK[i&63]);
 232
 233   }
 234
 235
 236   int delta=8;
 237
 238
 239   int size=1000*64*10;
 240   double t=TimeStart();
 241   int update=0;
 242   for(int iter=0;iter<size;iter++) {
 243     for(int j=0;j<bufsize;j++) {
 244       //Val[j]=splitmix64_stateless(Val[j])^Val[Pbox[j]];
 245       //Val[j]=xorshift64(Val[j])^Val[Pbox[j]];  //fail
 246       Val[j]=xorshift64(Val[j])^Val[Pbox[j]]^Val[Pbox2[j]];
 247       //Val[j]=xoroshiro128plus(&xoro[j])^Val[Pbox[j]];
 248       //Val[j]=jsf(&ctx[j])^Val[Pbox[j]];  //good
 249       //Val[j]=sfc(&sfcd[j])^Val[Pbox[j]];  //good
 250     }
 251
 252     for(int j=0;j<bufsize;j++) {
 253       cipher[j]=Val[j]^plain[j];
 254     }
 255
 256
 257
 258
 259     if(update==delta) {
 260       update=0;
 261       uchar *ptr=(uchar*)Val;
 262       for(int j=0;j<bufsize*8;j++)
 263         ptr[j]^=Sbox2[Sbox1[ptr[j]+DK[j&63]]];
 264       rc4keyperm(ptr, bufsize, 1, Pbox, 64);
 265       //only for xorshift
 266       rc4keyperm(&ptr[32], bufsize, 1, Pbox2, 64);
 267
 268
 269       rc4key(ptr, Sbox1, 64);
 270       rc4key(&ptr[64], Sbox2, 64);
 271     }
 272     else
 273       update++;
 274   }
 275
 276   double time=TimeStop(t);
 277   printf("time %e\n",size*bufsize*8/time);
 278 }