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