OneRoundIoT/openssl/openssl_evp_ccm.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
  20
  21
  22
  23 double TimeStart()
  24 {
  25   struct timeval tstart;
  26   gettimeofday(&tstart,0);
  27   return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) );
  28 }
  29
  30 double TimeStop(double t)
  31 {
  32   struct timeval tend;
  33
  34   gettimeofday(&tend,0);
  35   t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t;
  36   return (t);
  37 }
  38
  39
  40 void handleErrors(void)
  41 {
  42   ERR_print_errors_fp(stderr);
  43   abort();
  44 }
  45
  46
  47 int encryptccm(unsigned char *plaintext, int plaintext_len, unsigned char *aad,
  48         int aad_len, unsigned char *key, unsigned char *iv,
  49         unsigned char *ciphertext, unsigned char *tag)
  50 {
  51         EVP_CIPHER_CTX *ctx;
  52
  53         int len;
  54
  55         int ciphertext_len;
  56
  57
  58         /* Create and initialise the context */
  59         if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
  60
  61         /* Initialise the encryption operation. */
  62         if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_ccm(), NULL, NULL, NULL))
  63                 handleErrors();
  64
  65         /* Setting IV len to 7. Not strictly necessary as this is the default
  66          * but shown here for the purposes of this example */
  67         if(1 != EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, 7, NULL))
  68                 handleErrors();
  69
  70         /* Set tag length */
  71         EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, 16, NULL);
  72
  73         /* Initialise key and IV */
  74         if(1 != EVP_EncryptInit_ex(ctx, NULL, NULL, key, iv)) handleErrors();
  75
  76         /* Provide the total plaintext length
  77          */
  78         if(1 != EVP_EncryptUpdate(ctx, NULL, &len, NULL, plaintext_len))
  79                 handleErrors();
  80
  81         /* Provide any AAD data. This can be called zero or one times as
  82          * required
  83          */
  84         if(1 != EVP_EncryptUpdate(ctx, NULL, &len, aad, aad_len))
  85                 handleErrors();
  86
  87         /* Provide the message to be encrypted, and obtain the encrypted output.
  88          * EVP_EncryptUpdate can only be called once for this
  89          */
  90         if(1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))
  91                 handleErrors();
  92         ciphertext_len = len;
  93
  94         /* Finalise the encryption. Normally ciphertext bytes may be written at
  95          * this stage, but this does not occur in CCM mode
  96          */
  97         if(1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) handleErrors();
  98         ciphertext_len += len;
  99
 100         /* Get the tag */
 101         if(1 != EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, 16, tag))
 102                 handleErrors();
 103
 104         /* Clean up */
 105         EVP_CIPHER_CTX_free(ctx);
 106
 107         return ciphertext_len;
 108 }
 109
 110
 111 int decryptccm(unsigned char *ciphertext, int ciphertext_len, unsigned char *aad,
 112         int aad_len, unsigned char *tag, unsigned char *key, unsigned char *iv,
 113         unsigned char *plaintext)
 114 {
 115         EVP_CIPHER_CTX *ctx;
 116         int len;
 117         int plaintext_len;
 118         int ret;
 119
 120         /* Create and initialise the context */
 121         if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
 122
 123         /* Initialise the decryption operation. */
 124         if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_ccm(), NULL, NULL, NULL))
 125                 handleErrors();
 126
 127         /* Setting IV len to 7. Not strictly necessary as this is the default
 128          * but shown here for the purposes of this example */
 129         if(1 != EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, 7, NULL))
 130                 handleErrors();
 131
 132  for(int i=0;i<16;i++) {
 133     printf("%d ",tag[i]);
 134   }
 135   printf("\n");
 136
 137         /* Set expected tag value. */
 138         if(1 != EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, 16, tag))
 139                 handleErrors();
 140  for(int i=0;i<16;i++) {
 141     printf("%d ",tag[i]);
 142   }
 143   printf("\n");
 144         /* Initialise key and IV */
 145         if(1 != EVP_DecryptInit_ex(ctx, NULL, NULL, key, iv)) handleErrors();
 146
 147
 148         /* Provide the total ciphertext length
 149          */
 150         if(1 != EVP_DecryptUpdate(ctx, NULL, &len, NULL, ciphertext_len))
 151                 handleErrors();
 152
 153         /* Provide any AAD data. This can be called zero or more times as
 154          * required
 155          */
 156         if(1 != EVP_DecryptUpdate(ctx, NULL, &len, aad, aad_len))
 157                 handleErrors();
 158
 159         /* Provide the message to be decrypted, and obtain the plaintext output.
 160          * EVP_DecryptUpdate can be called multiple times if necessary
 161          */
 162         ret = EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len);
 163
 164         printf("RET %d len %d\n",ret,len);
 165
 166         plaintext_len = len;
 167
 168         /* Clean up */
 169         EVP_CIPHER_CTX_free(ctx);
 170
 171         if(ret > 0)
 172         {
 173                 /* Success */
 174                 return plaintext_len;
 175         }
 176         else
 177         {
 178                 /* Verify failed */
 179                 return -1;
 180         }
 181 }
 182
 183
 184
 185
 186 /* int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key, */
 187 /*          unsigned char *iv, unsigned char *ciphertext, int ctr, int index) */
 188 /* { */
 189 /*   EVP_CIPHER_CTX *ctx; */
 190
 191 /*   int len; */
 192
 193 /*   int ciphertext_len; */
 194
 195 /*   /\* Create and initialise the context *\/ */
 196 /*   if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors(); */
 197
 198 /*   /\* Initialise the encryption operation. IMPORTANT - ensure you use a key */
 199 /*    * and IV size appropriate for your cipher */
 200 /*    * In this example we are using 256 bit AES (i.e. a 256 bit key). The */
 201 /*    * IV size for *most* modes is the same as the block size. For AES this */
 202 /*    * is 128 bits *\/ */
 203 /*   //static double  time=0; */
 204 /*   //double t=0; */
 205 /*   //t=TimeStart(); */
 206 /*   //256 */
 207 /*   //avant ecb */
 208 /*   if(ctr) { */
 209 /*     if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_128_ctr(), NULL, key, iv)) */
 210 /*       handleErrors(); */
 211 /*   } */
 212 /*   else */
 213 /*       if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv)) */
 214 /*      handleErrors(); */
 215
 216 /*   //time+=TimeStop(t); */
 217 /*   //printf("Time init %f\n",time); */
 218
 219
 220 /* //  int cipherBlockSize = EVP_CIPHER_CTX_block_size(ctx);   */
 221 /* //  printf("INFO(evp_encrypt): block size: %d\n", cipherBlockSize); */
 222
 223
 224 /*   /\* Provide the message to be encrypted, and obtain the encrypted output. */
 225 /*    * EVP_EncryptUpdate can be called multiple times if necessary */
 226 /*    *\/ */
 227
 228 /* /\* */
 229 /*   static double  time=0; */
 230 /*   double t=0; */
 231 /*   t=TimeStart(); */
 232 /* *\/ */
 233 /*   for(int i=0;i<nb_test;i++) */
 234 /*   {   */
 235
 236 /*       if(1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len)) */
 237 /*       handleErrors(); */
 238 /*     ciphertext_len = len; */
 239
 240 /*   } */
 241 /* /\*  time+=TimeStop(t); */
 242 /*   // if(index==nb_test-1) */
 243 /*   printf("Time encrypt %f\n",time); */
 244
 245 /* *\/ */
 246
 247
 248 /*   /\* Finalise the encryption. Further ciphertext bytes may be written at */
 249 /*    * this stage. */
 250 /*    *\/ */
 251 /*   if(1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) handleErrors(); */
 252 /*   ciphertext_len += len; */
 253
 254 /*   /\* Clean up *\/ */
 255 /*   EVP_CIPHER_CTX_free(ctx); */
 256
 257 /*   return ciphertext_len; */
 258 /* } */
 259
 260 /* int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key, */
 261 /*          unsigned char *iv, unsigned char *plaintext, int ctr, int index) */
 262 /* { */
 263 /*   EVP_CIPHER_CTX *ctx; */
 264
 265 /*   int len; */
 266
 267 /*   int plaintext_len; */
 268
 269 /*   /\* Create and initialise the context *\/ */
 270 /*   if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors(); */
 271
 272 /*   /\* Initialise the decryption operation. IMPORTANT - ensure you use a key */
 273 /*    * and IV size appropriate for your cipher */
 274 /*    * In this example we are using 256 bit AES (i.e. a 256 bit key). The */
 275 /*    * IV size for *most* modes is the same as the block size. For AES this */
 276 /*    * is 128 bits *\/ */
 277
 278 /*   //256 */
 279
 280 /*   //avant => ecb */
 281 /*   if(ctr) { */
 282 /*     if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_128_ctr(), NULL, key, iv)) */
 283 /*       handleErrors(); */
 284 /*   } */
 285 /*   else */
 286 /*       if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv)) */
 287 /*     handleErrors(); */
 288
 289 /*   /\* Provide the message to be decrypted, and obtain the plaintext output. */
 290 /*    * EVP_DecryptUpdate can be called multiple times if necessary */
 291 /*    *\/ */
 292
 293 /* /\*  static double time=0; */
 294 /*   double t=0; */
 295 /*   t=TimeStart(); */
 296 /* *\/ */
 297 /*   for(int i=0;i<nb_test;i++) */
 298 /*   {   */
 299 /*     plaintext_len = 0; */
 300 /*     if(1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len)) */
 301 /*       handleErrors(); */
 302 /*     plaintext_len = len; */
 303 /*   } */
 304 /* /\*  time+=TimeStop(t); */
 305 /* //  if(index==nb_test-1) */
 306 /*     printf("Time decrypt %f\n",time); */
 307 /* *\/ */
 308
 309
 310 /*   /\* Finalise the decryption. Further plaintext bytes may be written at */
 311 /*    * this stage. */
 312 /*    *\/ */
 313 /*   if(1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len)) handleErrors(); */
 314 /*   plaintext_len += len; */
 315
 316
 317
 318 /*   /\* Clean up *\/ */
 319 /*   EVP_CIPHER_CTX_free(ctx); */
 320
 321 /*   return plaintext_len; */
 322 /* } */
 323
 324
 325
 326
 327 int main (int argc, char** argv)
 328 {
 329   /* Set up the key and iv. Do I need to say to not hard code these in a
 330    * real application? :-)
 331    */
 332
 333   int size_buf=1;
 334   int lena=0;
 335
 336
 337   for(int i=1; i<argc; i++){
 338     if(strncmp(argv[i],"nb",2)==0)    nb_test = atoi(&(argv[i][2]));    //nb of test
 339     if(strncmp(argv[i],"ctr",3)==0) ctr = atoi(&(argv[i][3]));          //CTR ? 1  otherwise CBC like
 340     if(strncmp(argv[i],"sizebuf",7)==0) size_buf = atoi(&(argv[i][7]));          //SIZE of the buffer
 341     if(strncmp(argv[i],"lena",4)==0) lena = atoi(&(argv[i][4]));          //Use Lena or buffer
 342   }
 343
 344 /*  printf("nb times %d\n",nb_test);
 345   printf("ctr %d\n",ctr);
 346   printf("lena %d\n",lena);
 347   printf("size_buf %d\n",size_buf);
 348 */
 349
 350
 351
 352
 353   /* A 256 bit key */
 354 //  unsigned char *key = (unsigned char *)"01234567890123456789012345678901";
 355   unsigned char *key = (unsigned char *)"01234567890123450123456789012345";
 356
 357   /* A 128 bit IV */
 358   unsigned char *iv = (unsigned char *)"0123456789012345";
 359
 360   unsigned char *tag=  malloc(16);
 361
 362   /* Message to be encrypted */
 363
 364   /* Buffer for ciphertext. Ensure the buffer is long enough for the
 365    * ciphertext which may be longer than the plaintext, dependant on the
 366    * algorithm and mode
 367    */
 368
 369   int width;
 370   int height;
 371   uchar *data_R, *data_G, *data_B;
 372   int imsize;
 373   uchar *buffer;
 374
 375
 376   if(lena==1) {
 377     load_RGB_pixmap("lena.ppm", &width, &height, &data_R, &data_G, &data_B);
 378     imsize=width*height*3;
 379 //  load_RGB_pixmap("No_ecb_mode_picture.ppm", &width, &height, &data_R, &data_G, &data_B);
 380   }
 381   else {
 382     width=size_buf;
 383     height=size_buf;
 384     imsize=width*height;
 385     buffer=malloc(imsize*sizeof(uchar));
 386     for(int i=0;i<imsize;i++) {
 387       buffer[i]=lrand48();
 388     }
 389   }
 390
 391
 392
 393   int oneD=width*height;
 394   uchar *plaintext = malloc(imsize+1000);   //add that for cbc
 395   if(lena) {
 396     for(int i=0;i<oneD;i++) {
 397       plaintext[i]=data_R[i];
 398       plaintext[oneD+i]=data_G[i];
 399       plaintext[2*oneD+i]=data_B[i];
 400     }
 401   }
 402   else
 403   {
 404      for(int i=0;i<oneD;i++) {
 405        plaintext[i]=buffer[i];
 406     }
 407   }
 408
 409
 410
 411   uchar *ciphertext = malloc(imsize+1000); //add that for cbc
 412
 413   /* Buffer for the decrypted text */
 414   uchar *decryptedtext = malloc(imsize+1000); //add that for cbc
 415
 416   int decryptedtext_len, ciphertext_len;
 417
 418   /* Initialise the library */
 419 /*  ERR_load_crypto_strings();
 420   OpenSSL_add_all_algorithms();
 421   OPENSSL_config(NULL);
 422 */
 423
 424
 425   double time_encrypt=0;
 426   double time_decrypt=0;
 427   double t=TimeStart();
 428
 429
 430   /* Encrypt the plaintext */
 431
 432
 433   int i;
 434
 435
 436
 437   for(int i=0;i<16;i++)
 438     printf("%d ",tag[i]);
 439   printf("\n");
 440
 441 //  for(i=0;i<nb_test;i++)
 442   {
 443     ciphertext_len = encryptccm (plaintext, imsize, plaintext, imsize, key, iv,
 444                               ciphertext, tag);
 445   }
 446   for(int i=0;i<16;i++) {
 447     printf("%d ",tag[i]);
 448   }
 449   printf("\n");
 450  time_encrypt+=TimeStop(t);
 451
 452 // printf("Time encrypt %f\n",time);
 453  printf("%f\t",(double)imsize*nb_test/time_encrypt);
 454
 455  if(lena) {
 456    for(int i=0;i<oneD;i++) {
 457      data_R[i]=ciphertext[i];
 458      data_G[i]=ciphertext[oneD+i];
 459      data_B[i]=ciphertext[2*oneD+i];
 460    }
 461    store_RGB_pixmap("lena2.ppm", data_R, data_G, data_B, width, height);
 462  }
 463
 464
 465   t=0;
 466   t=TimeStart();
 467
 468
 469
 470   //for(int i=0;i<nb_test;i++)
 471   {
 472     /* Decrypt the ciphertext */
 473     decryptedtext_len = decryptccm(ciphertext, ciphertext_len,ciphertext, ciphertext_len,tag,  key, iv,
 474                                 decryptedtext);
 475   }
 476
 477  time_decrypt+=TimeStop(t);
 478
 479  //printf("Time decrypt %f\n",time);
 480  printf("%f\t",(double)imsize*nb_test/time_decrypt);
 481
 482  if(lena) {
 483    for(int i=0;i<oneD;i++) {
 484      data_R[i]=decryptedtext[i];
 485      data_G[i]=decryptedtext[oneD+i];
 486      data_B[i]=decryptedtext[2*oneD+i];
 487    }
 488    store_RGB_pixmap("lena3.ppm", data_R, data_G, data_B, width, height);
 489  }
 490  else {
 491    int equal=1;
 492    for(int i=0;i<imsize;i++) {
 493      //cout<<(int)buffer[i]<<endl;
 494      if(buffer[i]!=decryptedtext[i]) {
 495        equal=0;
 496      }
 497    }
 498 //   printf("RESULT CORRECT: %d\n",equal);
 499  }
 500
 501
 502   /* Clean up */
 503   EVP_cleanup();
 504   ERR_free_strings();
 505
 506   return 0;
 507 }