]> AND Private Git Repository - Cipher_code.git/blob - OneRoundIoT/OneRound/rc4_hash2.cpp
Logo AND Algorithmique Numérique Distribuée

Private GIT Repository
rc4_hash2
[Cipher_code.git] / OneRoundIoT / OneRound / rc4_hash2.cpp
1 //gcc pixmap_io.c  -c 
2 //g++ -O3 one_round_hash_new.cpp pixmap_io.o  -o one_round_hash_new -std=c++11   
3
4 //
5
6
7 #include <iostream>
8 #include <list>
9 #include<math.h>
10 #include<stdlib.h>
11 #include<stdio.h>
12 #include<string.h>
13 #include <fstream>
14 #include <sys/time.h>
15
16 /*#include <cryptopp/hex.h>
17 #include <cryptopp/sha.h>
18 #include <cryptopp/osrng.h>
19 #include <cryptopp/secblock.h>
20 */
21
22
23 extern "C" {
24   int load_RGB_pixmap(char *filename, int *width, int *height, unsigned char**R_data, unsigned char**G_data, unsigned char**B_data);
25   void store_RGB_pixmap(char *filename, unsigned char *R_data, unsigned char *G_data, unsigned char *B_data, int width, int height);
26 }
27
28
29 //using namespace CryptoPP;
30 using namespace std;
31
32
33 int key_size=256;
34 int nb_test=1;
35 int ctr=0;
36
37
38
39
40
41
42
43 typedef unsigned char   uchar;
44
45
46 double TimeStart()
47 {
48   struct timeval tstart;
49   gettimeofday(&tstart,0);
50   return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) );
51 }
52
53 double TimeStop(double t)
54 {
55   struct timeval tend;
56
57   gettimeofday(&tend,0);
58   t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t;
59   return (t);
60 }
61
62
63
64
65
66
67 void inverse_tables(uchar *tab, int size_tab,uchar *inv_perm_tabs) {
68
69   for(int i=0;i<size_tab;i++) {
70     inv_perm_tabs[tab[i]] = i;
71   }
72
73 }
74
75 void inverse_tables_int(int *tab, int size_tab,int *inv_perm_tabs) {
76
77   for(int i=0;i<size_tab;i++) {
78     inv_perm_tabs[tab[i]] = i;
79   }
80
81 }
82
83
84
85 void rc4key(uchar *key, uchar *sc, int size_DK) {
86
87   for(int i=0;i<256;i++) {
88     sc[i]=i;
89   }
90
91
92   uchar j0 = 0;
93   for(int i0=0; i0<256; i0++) {
94     j0 = (j0 + sc[i0] + key[i0%size_DK] )&0xFF;
95     uchar tmp = sc[i0];
96     sc[i0] = sc[j0 ];
97     sc[j0] = tmp;
98   }
99 }
100
101
102
103 void rc4keyperm(uchar *key,int len, int rp,int *sc, int size_DK) {
104
105   //sc=1:len;
106
107
108   
109   for (int i=0;i<len;i++) {
110     sc[i]=i;
111   }
112   for (int it = 0; it < rp; it++) {
113     int j0 = 1;
114     for(int i0 = 0; i0<len; i0++) {
115       j0 = (j0 + sc[i0] + sc[j0] + key[i0%size_DK] )% len;
116       int tmp = sc[i0];
117       sc[i0] = sc[j0];
118       sc[j0] = tmp;
119     }
120
121   }
122 }
123
124 void prga(uchar *sc, uchar *X, int ldata, uchar *r, int h) {
125   uchar i0=0;
126   uchar j0=0;
127
128   for (int it=0; it<ldata; it++) {
129     i0 = X[(i0+1)&(h-1)];
130     j0 = (j0 + sc[i0]);
131     uchar tmp = sc[i0];
132     sc[i0] = sc[j0];
133     sc[j0] = tmp;
134     r[it]=sc[i0];//sc[(sc[i0]+sc[j0])&255];
135   }
136 }
137
138 inline uchar  circ(uchar x,int n) {return (x << n) | (x >> (8 - n));}
139
140
141 uint64_t xorshift64( const uint64_t state)
142 {
143   uint64_t x = state;
144   x^= x << 13;
145   x^= x >> 7;
146   x^= x << 17;
147   return x;
148 }
149
150
151 static inline uint64_t splitmix64(uint64_t index) {
152   uint64_t z = (index + UINT64_C(0x9E3779B97F4A7C15));
153   z = (z ^ (z >> 30)) * UINT64_C(0xBF58476D1CE4E5B9);
154   z = (z ^ (z >> 27)) * UINT64_C(0x94D049BB133111EB);
155   return z ^ (z >> 31);
156 }
157
158
159
160
161
162
163
164 //the proposed hash function, which is based on DSD structure. Sensitivity is ensured by employing the binary diffusion
165
166 void hash_DSD_BIN(uchar* seq_in, uchar* RM1,int len, uchar *S, int h) {
167
168
169   // Goal: Calculate the hash value
170   // Output: RM (hash value)
171
172 //  uchar *X=new uchar[h2];
173 //  uchar *fX=new uchar[h2];
174   uchar X[h];
175   int ind1,ind2;
176
177
178   uint64_t *rm=(uint64_t*)RM1;
179   uint64_t *xx=(uint64_t*)X;
180   uint64_t *ss=(uint64_t*)seq_in;
181
182
183   
184   for(int it=0;it<len;it++) {
185     //ind1=Pbox[it]*h;
186     //ind2=Pbox[(it+len/2)]*h;
187
188     ind1=it*h/8;
189     // Mix with dynamic RM
190     uint64_t sum=0;
191     /*     for(int a=0;a<h;a+=4) {
192        X[a]=RM1[a]^seq_in[ind1+a];
193        X[a+1]=RM1[a+1]^seq_in[ind1+a+1];
194        X[a+2]=RM1[a+2]^seq_in[ind1+a+2];
195        X[a+3]=RM1[a+3]^seq_in[ind1+a+3];
196      }
197     */
198
199     
200      for(int a=0;a<h/8;a++) {
201        xx[a]=rm[a]^ss[ind1+a];
202        sum+=xx[a];
203      }
204
205
206
207
208      rm[0]=xorshift64(sum);
209      for(int a=1;a<h/8;a++) {
210        rm[a]^=xorshift64(rm[a-1]);
211      }
212
213
214   }
215
216  
217 }
218
219
220
221
222
223   
224
225
226
227   
228 int main(int argc, char** argv) {
229
230
231   int h=16;
232   int lena=0;
233   int size_buf=1;
234   int change=0;
235
236   
237   for(int i=1; i<argc; i++){
238     if(strncmp(argv[i],"nb",2)==0)    nb_test = atoi(&(argv[i][2]));    //nb of test         
239     if(strncmp(argv[i],"h",1)==0) h = atoi(&(argv[i][1]));          //size of block
240     if(strncmp(argv[i],"sizebuf",7)==0) size_buf = atoi(&(argv[i][7]));          //SIZE of the buffer
241     if(strncmp(argv[i],"lena",4)==0) lena = atoi(&(argv[i][4]));          //Use Lena or buffer
242     if(strncmp(argv[i],"c",1)==0) change = atoi(&(argv[i][1]));          //Use Lena or buffer
243   }
244
245
246   cout<<size_buf<<endl;
247   int seed=12;//time(NULL);
248   cout<<seed<<endl;
249   srand48(seed);
250
251   uchar Secretkey[key_size];
252
253   uchar counter[key_size];
254
255   for(int i=0;i<key_size;i++) {
256     Secretkey[i]=lrand48()&0xFF;
257     counter[i]=lrand48()&0xFF;
258   }
259   
260   int size = 64;
261   uchar DK[size];
262
263
264
265
266   int width;
267   int height;
268
269   uchar *data_R, *data_G, *data_B;
270   int imsize;
271   uchar *buffer;
272   
273   if(lena==1) {
274     load_RGB_pixmap("lena.ppm", &width, &height, &data_R, &data_G, &data_B);
275     imsize=width*height*3;
276 //  load_RGB_pixmap("No_ecb_mode_picture.ppm", &width, &height, &data_R, &data_G, &data_B);
277   }
278   else {
279     imsize=size_buf;
280     buffer=new uchar[imsize];
281     for(int i=0;i<imsize;i++) {
282       buffer[i]=lrand48();
283     }
284   }
285
286
287   
288   
289   uchar* seq= new uchar[imsize];
290   uchar* seq2= new uchar[imsize];
291
292   int oneD;
293   if(lena) {
294     oneD=width*height;
295     for(int i=0;i<oneD;i++) {
296       seq[i]=data_R[i];
297       seq[oneD+i]=data_G[i];
298       seq[2*oneD+i]=data_B[i];
299     }
300   }
301   else {
302     oneD=imsize;
303     for(int i=0;i<oneD;i++) {
304       seq[i]=buffer[i];
305     }
306   }
307
308   printf("seq 4 %d\n",seq[4]);
309   if(change==1) {
310     
311     seq[4]++;
312   }
313   if(change==2) {
314     
315     seq[9]++;
316   }
317
318   printf("seq 4 %d\n",seq[4]);
319
320   
321   
322
323   int total_len=imsize;
324   int rp=1;
325   int len= total_len/h;
326   cout<<len<<endl;
327
328   
329   uchar *mix=new uchar[256];
330
331
332
333     
334   for (int i = 0; i < 256 ; i++) {
335     mix[i]=Secretkey[i]^counter[i];
336   }
337
338   
339 //  cout<<"hash "<<endl;
340   for (int i = 0; i < 64 ; i++) {
341 //    DK[i]=digest[i];
342     DK[i]=mix[i];
343     //cout<<(int)DK[i]<<" ";
344   }
345   //cout<<endl;
346
347
348
349
350
351   uchar Sbox1[256];
352   uchar sc[256];  
353   uchar RM1[h];
354
355
356
357   double time=0;
358   double t=TimeStart();  
359   rc4key(DK, Sbox1, 8);
360   
361   rc4key(&DK[16], sc, 8);
362   
363
364
365   
366   prga(sc, sc,h,RM1,h);
367   
368   
369   
370
371   
372   time+=TimeStop(t);
373   cout<<"Time initializaton "<<time<<endl;
374
375
376
377   cout<<"imsize "<<imsize<<endl;
378   
379 /*  for(int i=0;i<imsize;i++){
380     cout<<(int)seq[i]<<" ";
381   }
382   cout<<endl;
383 */
384
385
386   
387   time=0;
388   t=TimeStart();
389   for(int i=0;i<nb_test;i++)
390   {
391     hash_DSD_BIN(seq, RM1,len,Sbox1,h);
392   }
393
394
395   
396   
397   time+=TimeStop(t);
398   cout<<"Hash Time  "<<time<<endl;
399   cout<<(double)imsize*nb_test/time<<"\t";
400
401   for(int i=0;i<h;i++){
402     cout<<(int)RM1[i]<<" ";
403   }
404   cout<<endl;
405
406   //  cout<<splitmix64(2490)<<endl;
407   // cout<<splitmix64(2489)<<endl;
408   
409
410   return 0;
411 }