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