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, int index)
  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   //static double  time=0;
  61   //double t=0;
  62   //t=TimeStart();
  63   //256
  64   //avant ecb
  65     for(int i=0;i<nb_test;i++)
  66   {
  67
  68   if(ctr) {
  69     if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_128_ctr(), NULL, key, iv))
  70       handleErrors();
  71   }
  72   else
  73       if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv))
  74         handleErrors();
  75
  76   //time+=TimeStop(t);
  77   //printf("Time init %f\n",time);
  78
  79
  80 //  int cipherBlockSize = EVP_CIPHER_CTX_block_size(ctx);
  81 //  printf("INFO(evp_encrypt): block size: %d\n", cipherBlockSize);
  82
  83
  84   /* Provide the message to be encrypted, and obtain the encrypted output.
  85    * EVP_EncryptUpdate can be called multiple times if necessary
  86    */
  87
  88 /*
  89   static double  time=0;
  90   double t=0;
  91   t=TimeStart();
  92 */
  93
  94       if(1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))
  95       handleErrors();
  96     ciphertext_len = len;
  97
  98
  99 /*  time+=TimeStop(t);
 100   // if(index==nb_test-1)
 101   printf("Time encrypt %f\n",time);
 102
 103 */
 104
 105
 106   /* Finalise the encryption. Further ciphertext bytes may be written at
 107    * this stage.
 108    */
 109   if(1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) handleErrors();
 110   ciphertext_len += len;
 111   }
 112   /* Clean up */
 113   EVP_CIPHER_CTX_free(ctx);
 114
 115   return ciphertext_len;
 116 }
 117
 118 int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key,
 119             unsigned char *iv, unsigned char *plaintext, int ctr, int index)
 120 {
 121   EVP_CIPHER_CTX *ctx;
 122
 123   int len;
 124
 125   int plaintext_len;
 126
 127   /* Create and initialise the context */
 128   if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
 129
 130   /* Initialise the decryption operation. IMPORTANT - ensure you use a key
 131    * and IV size appropriate for your cipher
 132    * In this example we are using 256 bit AES (i.e. a 256 bit key). The
 133    * IV size for *most* modes is the same as the block size. For AES this
 134    * is 128 bits */
 135
 136   //256
 137
 138   for(int i=0;i<nb_test;i++)
 139   {
 140
 141   //avant => ecb
 142   if(ctr) {
 143     if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_128_ctr(), NULL, key, iv))
 144       handleErrors();
 145   }
 146   else
 147       if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv))
 148     handleErrors();
 149
 150   /* Provide the message to be decrypted, and obtain the plaintext output.
 151    * EVP_DecryptUpdate can be called multiple times if necessary
 152    */
 153
 154 /*  static double time=0;
 155   double t=0;
 156   t=TimeStart();
 157 */
 158
 159     plaintext_len = 0;
 160     if(1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len))
 161       handleErrors();
 162     plaintext_len = len;
 163
 164 /*  time+=TimeStop(t);
 165 //  if(index==nb_test-1)
 166     printf("Time decrypt %f\n",time);
 167 */
 168
 169
 170   /* Finalise the decryption. Further plaintext bytes may be written at
 171    * this stage.
 172    */
 173   if(1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len)) handleErrors();
 174   plaintext_len += len;
 175   }
 176
 177
 178   /* Clean up */
 179   EVP_CIPHER_CTX_free(ctx);
 180
 181   return plaintext_len;
 182 }
 183
 184
 185 int main (int argc, char** argv)
 186 {
 187   /* Set up the key and iv. Do I need to say to not hard code these in a
 188    * real application? :-)
 189    */
 190
 191   int size_buf=1;
 192   int lena=0;
 193
 194
 195   for(int i=1; i<argc; i++){
 196     if(strncmp(argv[i],"nb",2)==0)    nb_test = atoi(&(argv[i][2]));    //nb of test
 197     if(strncmp(argv[i],"ctr",3)==0) ctr = atoi(&(argv[i][3]));          //CTR ? 1  otherwise CBC like
 198     if(strncmp(argv[i],"sizebuf",7)==0) size_buf = atoi(&(argv[i][7]));          //SIZE of the buffer
 199     if(strncmp(argv[i],"lena",4)==0) lena = atoi(&(argv[i][4]));          //Use Lena or buffer
 200   }
 201
 202 /*  printf("nb times %d\n",nb_test);
 203   printf("ctr %d\n",ctr);
 204   printf("lena %d\n",lena);
 205   printf("size_buf %d\n",size_buf);
 206 */
 207
 208
 209
 210
 211   /* A 256 bit key */
 212 //  unsigned char *key = (unsigned char *)"01234567890123456789012345678901";
 213   unsigned char *key = (unsigned char *)"0123456789012345";
 214
 215   /* A 128 bit IV */
 216   unsigned char *iv = (unsigned char *)"0123456789012345";
 217
 218   /* Message to be encrypted */
 219
 220   /* Buffer for ciphertext. Ensure the buffer is long enough for the
 221    * ciphertext which may be longer than the plaintext, dependant on the
 222    * algorithm and mode
 223    */
 224
 225   int width;
 226   int height;
 227   uchar *data_R, *data_G, *data_B;
 228   int imsize;
 229   uchar *buffer;
 230
 231
 232   if(lena==1) {
 233     load_RGB_pixmap("lena.ppm", &width, &height, &data_R, &data_G, &data_B);
 234     imsize=width*height*3;
 235 //  load_RGB_pixmap("No_ecb_mode_picture.ppm", &width, &height, &data_R, &data_G, &data_B);
 236   }
 237   else {
 238     width=size_buf;
 239     height=size_buf;
 240     imsize=width*height;
 241     buffer=malloc(imsize*sizeof(uchar));
 242     for(int i=0;i<imsize;i++) {
 243       buffer[i]=lrand48();
 244     }
 245   }
 246
 247
 248
 249   int oneD=width*height;
 250   uchar *plaintext = malloc(imsize+1000);   //add that for cbc
 251   if(lena) {
 252     for(int i=0;i<oneD;i++) {
 253       plaintext[i]=data_R[i];
 254       plaintext[oneD+i]=data_G[i];
 255       plaintext[2*oneD+i]=data_B[i];
 256     }
 257   }
 258   else
 259   {
 260      for(int i=0;i<oneD;i++) {
 261        plaintext[i]=buffer[i];
 262     }
 263   }
 264
 265
 266
 267   uchar *ciphertext = malloc(imsize+1000); //add that for cbc
 268
 269   /* Buffer for the decrypted text */
 270   uchar *decryptedtext = malloc(imsize+1000); //add that for cbc
 271
 272   int decryptedtext_len, ciphertext_len;
 273
 274   /* Initialise the library */
 275 /*  ERR_load_crypto_strings();
 276   OpenSSL_add_all_algorithms();
 277   OPENSSL_config(NULL);
 278 */
 279
 280
 281   double time_encrypt=0;
 282   double time_decrypt=0;
 283   double t=TimeStart();
 284
 285
 286   /* Encrypt the plaintext */
 287
 288
 289   int i;
 290
 291 //  for(i=0;i<nb_test;i++)
 292   {
 293     ciphertext_len = encrypt (plaintext, imsize, key, iv,
 294                               ciphertext, ctr, i );
 295   }
 296
 297  time_encrypt+=TimeStop(t);
 298
 299 // printf("Time encrypt %f\n",time);
 300  printf("%f\t",(double)imsize*nb_test/time_encrypt);
 301
 302  if(lena) {
 303    for(int i=0;i<oneD;i++) {
 304      data_R[i]=ciphertext[i];
 305      data_G[i]=ciphertext[oneD+i];
 306      data_B[i]=ciphertext[2*oneD+i];
 307    }
 308    store_RGB_pixmap("lena2.ppm", data_R, data_G, data_B, width, height);
 309  }
 310
 311
 312   t=0;
 313   t=TimeStart();
 314
 315   //for(int i=0;i<nb_test;i++)
 316   {
 317     /* Decrypt the ciphertext */
 318     decryptedtext_len = decrypt(ciphertext, ciphertext_len, key, iv,
 319                                 decryptedtext,ctr, i);
 320   }
 321
 322  time_decrypt+=TimeStop(t);
 323
 324  //printf("Time decrypt %f\n",time);
 325  printf("%f\t",(double)imsize*nb_test/time_decrypt);
 326
 327  if(lena) {
 328    for(int i=0;i<oneD;i++) {
 329      data_R[i]=decryptedtext[i];
 330      data_G[i]=decryptedtext[oneD+i];
 331      data_B[i]=decryptedtext[2*oneD+i];
 332    }
 333    store_RGB_pixmap("lena3.ppm", data_R, data_G, data_B, width, height);
 334  }
 335  else {
 336    int equal=1;
 337    for(int i=0;i<imsize;i++) {
 338      //cout<<(int)buffer[i]<<endl;
 339      if(buffer[i]!=decryptedtext[i]) {
 340        equal=0;
 341      }
 342    }
 343 //   printf("RESULT CORRECT: %d\n",equal);
 344  }
 345
 346
 347   /* Clean up */
 348   EVP_cleanup();
 349   ERR_free_strings();
 350
 351   return 0;
 352 }