]> AND Private Git Repository - Cipher_code.git/blob - OneRoundIoT/openssl/openssl_evp.c
Logo AND Algorithmique Numérique Distribuée

Private GIT Repository
new
[Cipher_code.git] / OneRoundIoT / openssl / openssl_evp.c
1 //gcc pixmap_io.c  -c
2 //gcc openssl_evp.c pixmap_io.o -o  openssl_evp -I /usr/include/openssl/ -lcrypto -O3 -std=c99 
3
4
5 #include <openssl/conf.h>
6 #include <openssl/evp.h>
7 #include <openssl/err.h>
8 #include <openssl/ssl.h>
9 #include <openssl/bio.h>
10 #include <string.h>
11 #include <sys/time.h>
12 #include "pixmap_io.h"
13
14 typedef unsigned char   uchar;
15
16 int nb_test=1;
17 int ctr=0;
18
19 double TimeStart()
20 {
21   struct timeval tstart;
22   gettimeofday(&tstart,0);
23   return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) );
24 }
25
26 double TimeStop(double t)
27 {
28   struct timeval tend;
29
30   gettimeofday(&tend,0);
31   t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t;
32   return (t);
33 }
34
35
36 void handleErrors(void)
37 {
38   ERR_print_errors_fp(stderr);
39   abort();
40 }
41
42
43 int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
44             unsigned char *iv, unsigned char *ciphertext, int ctr)
45 {
46   EVP_CIPHER_CTX *ctx;
47
48   int len;
49
50   int ciphertext_len;
51
52   /* Create and initialise the context */
53   if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
54
55   /* Initialise the encryption operation. IMPORTANT - ensure you use a key
56    * and IV size appropriate for your cipher
57    * In this example we are using 256 bit AES (i.e. a 256 bit key). The
58    * IV size for *most* modes is the same as the block size. For AES this
59    * is 128 bits */
60
61   //256
62   //avant ecb
63   if(ctr) {
64     if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_128_ctr(), NULL, key, iv))
65       handleErrors();
66   }
67   else
68       if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv))
69         handleErrors();
70
71 //  int cipherBlockSize = EVP_CIPHER_CTX_block_size(ctx);  
72 //  printf("INFO(evp_encrypt): block size: %d\n", cipherBlockSize);
73
74   
75   /* Provide the message to be encrypted, and obtain the encrypted output.
76    * EVP_EncryptUpdate can be called multiple times if necessary
77    */
78
79   if(1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))
80     handleErrors();
81   ciphertext_len = len;
82
83   
84
85
86
87
88   
89   /* Finalise the encryption. Further ciphertext bytes may be written at
90    * this stage.
91    */
92   if(1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) handleErrors();
93   ciphertext_len += len;
94
95   /* Clean up */
96   EVP_CIPHER_CTX_free(ctx);
97
98   return ciphertext_len;
99 }
100
101 int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key,
102             unsigned char *iv, unsigned char *plaintext, int ctr)
103 {
104   EVP_CIPHER_CTX *ctx;
105
106   int len;
107
108   int plaintext_len;
109
110   /* Create and initialise the context */
111   if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
112
113   /* Initialise the decryption operation. IMPORTANT - ensure you use a key
114    * and IV size appropriate for your cipher
115    * In this example we are using 256 bit AES (i.e. a 256 bit key). The
116    * IV size for *most* modes is the same as the block size. For AES this
117    * is 128 bits */
118
119   //256
120
121   //avant => ecb
122   if(ctr) {
123     if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_128_ctr(), NULL, key, iv))
124       handleErrors();
125   }
126   else
127       if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv))
128     handleErrors();
129
130   /* Provide the message to be decrypted, and obtain the plaintext output.
131    * EVP_DecryptUpdate can be called multiple times if necessary
132    */
133   
134  
135   if(1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len))
136     handleErrors();
137   plaintext_len = len;
138
139   /* Finalise the decryption. Further plaintext bytes may be written at
140    * this stage.
141    */
142   if(1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len)) handleErrors();
143   plaintext_len += len;
144
145   /* Clean up */
146   EVP_CIPHER_CTX_free(ctx);
147
148   return plaintext_len;
149 }
150
151
152 int main (int argc, char** argv)
153 {
154   /* Set up the key and iv. Do I need to say to not hard code these in a
155    * real application? :-)
156    */
157
158   int size_buf=1;
159   int lena=0;
160
161    
162   for(int i=1; i<argc; i++){
163     if(strncmp(argv[i],"nb",2)==0)    nb_test = atoi(&(argv[i][2]));    //nb of test         
164     if(strncmp(argv[i],"ctr",3)==0) ctr = atoi(&(argv[i][3]));          //CTR ? 1  otherwise CBC like
165     if(strncmp(argv[i],"sizebuf",7)==0) size_buf = atoi(&(argv[i][7]));          //SIZE of the buffer
166     if(strncmp(argv[i],"lena",4)==0) lena = atoi(&(argv[i][4]));          //Use Lena or buffer
167   }
168
169   printf("nb times %d\n",nb_test);
170   printf("ctr %d\n",ctr);
171   printf("lena %d\n",lena);
172   printf("size_buf %d\n",size_buf);
173
174
175
176
177   
178   /* A 256 bit key */
179 //  unsigned char *key = (unsigned char *)"01234567890123456789012345678901";
180   unsigned char *key = (unsigned char *)"0123456789012345";
181   
182   /* A 128 bit IV */
183   unsigned char *iv = (unsigned char *)"0123456789012345";
184
185   /* Message to be encrypted */
186
187   /* Buffer for ciphertext. Ensure the buffer is long enough for the
188    * ciphertext which may be longer than the plaintext, dependant on the
189    * algorithm and mode
190    */
191
192   int width;
193   int height;
194   uchar *data_R, *data_G, *data_B;
195   int imsize;
196   uchar *buffer;
197
198
199   if(lena==1) {
200     load_RGB_pixmap("lena.ppm", &width, &height, &data_R, &data_G, &data_B);
201     imsize=width*height*3;
202 //  load_RGB_pixmap("No_ecb_mode_picture.ppm", &width, &height, &data_R, &data_G, &data_B);
203   }
204   else {
205     width=height=size_buf;
206     imsize=width*height;
207     buffer=malloc(imsize*sizeof(uchar));
208     for(int i=0;i<imsize;i++) {
209       buffer[i]=lrand48();
210     }
211   }
212   
213
214
215   int oneD=width*height;
216   uchar *plaintext = malloc(imsize);
217   if(lena) {
218     for(int i=0;i<oneD;i++) {
219       plaintext[i]=data_R[i];
220       plaintext[oneD+i]=data_G[i];
221       plaintext[2*oneD+i]=data_B[i];
222     }
223   }
224   else
225   {
226      for(int i=0;i<oneD;i++) {
227        plaintext[i]=buffer[i];
228     }
229   }
230
231   
232
233   uchar *ciphertext = malloc(imsize);
234
235   /* Buffer for the decrypted text */
236   uchar *decryptedtext = malloc(imsize);
237
238   int decryptedtext_len, ciphertext_len;
239
240   /* Initialise the library */
241 /*  ERR_load_crypto_strings();
242   OpenSSL_add_all_algorithms();
243   OPENSSL_config(NULL);
244 */
245    double time=0;
246   double t=TimeStart();
247
248   
249   /* Encrypt the plaintext */
250
251
252   int i;
253
254   for(i=0;i<nb_test;i++)
255   {  
256     ciphertext_len = encrypt (plaintext, imsize, key, iv,
257                               ciphertext, ctr);
258   }
259
260  time+=TimeStop(t);
261
262  printf("Time encrypt %f\n",time);
263
264  if(lena) {
265    for(int i=0;i<oneD;i++) {
266      data_R[i]=ciphertext[i];
267      data_G[i]=ciphertext[oneD+i];
268      data_B[i]=ciphertext[2*oneD+i];
269    }
270    store_RGB_pixmap("lena2.ppm", data_R, data_G, data_B, width, height);
271  }
272  
273   
274   time=0;
275   t=0;
276   t=TimeStart();
277
278   for(int i=0;i<nb_test;i++)
279   {  
280     /* Decrypt the ciphertext */
281     decryptedtext_len = decrypt(ciphertext, ciphertext_len, key, iv,
282                                 decryptedtext,ctr);
283   }
284
285  time+=TimeStop(t);
286
287  printf("Time decrypt %f\n",time);
288
289  if(lena) {
290    for(int i=0;i<oneD;i++) {
291      data_R[i]=decryptedtext[i];
292      data_G[i]=decryptedtext[oneD+i];
293      data_B[i]=decryptedtext[2*oneD+i];
294    }
295    store_RGB_pixmap("lena3.ppm", data_R, data_G, data_B, width, height);
296  }
297  else {
298    int equal=1;
299    for(int i=0;i<imsize;i++) {
300      //cout<<(int)buffer[i]<<endl;
301      if(buffer[i]!=decryptedtext[i]) {
302        equal=0;
303      }
304    }
305    printf("RESULT CORRECT: %d\n",equal);
306  }
307   
308
309   /* Clean up */
310   EVP_cleanup();
311   ERR_free_strings();
312
313   return 0;
314 }