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