OneRoundIoT/openssl/openssl_evp_ctr.c

   1 //gcc pixmap_io.c  -c
   2 //gcc openssl_evp_ctr.c pixmap_io.o -o  openssl_evp_ctr -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
  17 double TimeStart()
  18 {
  19   struct timeval tstart;
  20   gettimeofday(&tstart,0);
  21   return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) );
  22 }
  23
  24 double TimeStop(double t)
  25 {
  26   struct timeval tend;
  27
  28   gettimeofday(&tend,0);
  29   t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t;
  30   return (t);
  31 }
  32
  33
  34 void handleErrors(void)
  35 {
  36   ERR_print_errors_fp(stderr);
  37   abort();
  38 }
  39
  40
  41 int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
  42   unsigned char *iv, unsigned char *ciphertext)
  43 {
  44   EVP_CIPHER_CTX *ctx;
  45
  46   int len;
  47
  48   int ciphertext_len;
  49
  50   /* Create and initialise the context */
  51   if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
  52
  53   /* Initialise the encryption operation. IMPORTANT - ensure you use a key
  54    * and IV size appropriate for your cipher
  55    * In this example we are using 256 bit AES (i.e. a 256 bit key). The
  56    * IV size for *most* modes is the same as the block size. For AES this
  57    * is 128 bits */
  58
  59   //256
  60   //avant ecb
  61   if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_128_ctr(), NULL, key, iv))
  62     handleErrors();
  63
  64 //  int cipherBlockSize = EVP_CIPHER_CTX_block_size(ctx);
  65 //  printf("INFO(evp_encrypt): block size: %d\n", cipherBlockSize);
  66
  67
  68   /* Provide the message to be encrypted, and obtain the encrypted output.
  69    * EVP_EncryptUpdate can be called multiple times if necessary
  70    */
  71
  72   if(1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))
  73     handleErrors();
  74   ciphertext_len = len;
  75
  76
  77
  78
  79
  80
  81
  82   /* Finalise the encryption. Further ciphertext bytes may be written at
  83    * this stage.
  84    */
  85   if(1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len)) handleErrors();
  86   ciphertext_len += len;
  87
  88   /* Clean up */
  89   EVP_CIPHER_CTX_free(ctx);
  90
  91   return ciphertext_len;
  92 }
  93
  94 int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key,
  95   unsigned char *iv, unsigned char *plaintext)
  96 {
  97   EVP_CIPHER_CTX *ctx;
  98
  99   int len;
 100
 101   int plaintext_len;
 102
 103   /* Create and initialise the context */
 104   if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors();
 105
 106   /* Initialise the decryption operation. IMPORTANT - ensure you use a key
 107    * and IV size appropriate for your cipher
 108    * In this example we are using 256 bit AES (i.e. a 256 bit key). The
 109    * IV size for *most* modes is the same as the block size. For AES this
 110    * is 128 bits */
 111
 112   //256
 113
 114   //avant => ecb
 115   if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_128_ctr(), NULL, key, iv))
 116     handleErrors();
 117
 118   /* Provide the message to be decrypted, and obtain the plaintext output.
 119    * EVP_DecryptUpdate can be called multiple times if necessary
 120    */
 121
 122
 123   if(1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len))
 124     handleErrors();
 125   plaintext_len = len;
 126
 127   /* Finalise the decryption. Further plaintext bytes may be written at
 128    * this stage.
 129    */
 130   if(1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len)) handleErrors();
 131   plaintext_len += len;
 132
 133   /* Clean up */
 134   EVP_CIPHER_CTX_free(ctx);
 135
 136   return plaintext_len;
 137 }
 138
 139
 140 int main (int argc, char** argv)
 141 {
 142   /* Set up the key and iv. Do I need to say to not hard code these in a
 143    * real application? :-)
 144    */
 145
 146   /* A 256 bit key */
 147 //  unsigned char *key = (unsigned char *)"01234567890123456789012345678901";
 148   unsigned char *key = (unsigned char *)"0123456789012345";
 149
 150   /* A 128 bit IV */
 151   unsigned char *iv = (unsigned char *)"0123456789012345";
 152
 153   /* Message to be encrypted */
 154
 155
 156
 157   int nb_test=1;
 158   if(argc==2)
 159     nb_test=atoi(argv[1]);
 160   if(nb_test<=0 || nb_test>10000) {
 161     printf("nb tests is not correct\n");
 162     exit(0);
 163   }
 164   else
 165     printf("nb tests = %d\n\n",nb_test);
 166
 167
 168
 169   /* Buffer for ciphertext. Ensure the buffer is long enough for the
 170    * ciphertext which may be longer than the plaintext, dependant on the
 171    * algorithm and mode
 172    */
 173
 174   int width;
 175   int height;
 176   uchar *data_R, *data_G, *data_B;
 177   load_RGB_pixmap("lena.ppm", &width, &height, &data_R, &data_G, &data_B);
 178
 179
 180 //  load_RGB_pixmap("No_ecb_mode_picture.ppm", &width, &height, &data_R, &data_G, &data_B);
 181 //  load_RGB_pixmap("4096.ppm", &width, &height, &data_R, &data_G, &data_B);
 182   int size=width*height*3;
 183
 184   int oneD=width*height;
 185   uchar *plaintext = malloc(size);
 186
 187
 188   for(int i=0;i<oneD;i++) {
 189     plaintext[i]=data_R[i];
 190     plaintext[oneD+i]=data_G[i];
 191     plaintext[2*oneD+i]=data_B[i];
 192   }
 193
 194
 195
 196   uchar *ciphertext = malloc(size);
 197
 198   /* Buffer for the decrypted text */
 199   uchar *decryptedtext = malloc(size);
 200
 201   int decryptedtext_len, ciphertext_len;
 202
 203   /* Initialise the library */
 204 /*  ERR_load_crypto_strings();
 205   OpenSSL_add_all_algorithms();
 206   OPENSSL_config(NULL);
 207 */
 208    double time=0;
 209   double t=TimeStart();
 210
 211
 212   /* Encrypt the plaintext */
 213
 214
 215   int i;
 216
 217   for(i=0;i<nb_test;i++)
 218   {
 219     ciphertext_len = encrypt (plaintext, size, key, iv,
 220                               ciphertext);
 221   }
 222
 223  time+=TimeStop(t);
 224
 225  printf("Time encrypt %f\n",time);
 226
 227
 228  for(int i=0;i<oneD;i++) {
 229     data_R[i]=ciphertext[i];
 230     data_G[i]=ciphertext[oneD+i];
 231     data_B[i]=ciphertext[2*oneD+i];
 232   }
 233   store_RGB_pixmap("lena2.ppm", data_R, data_G, data_B, width, height);
 234
 235
 236   time=0;
 237   t=0;
 238   t=TimeStart();
 239
 240   for(int i=0;i<nb_test;i++)
 241   {
 242     /* Decrypt the ciphertext */
 243     decryptedtext_len = decrypt(ciphertext, ciphertext_len, key, iv,
 244                                 decryptedtext);
 245   }
 246
 247  time+=TimeStop(t);
 248
 249  printf("Time decrypt %f\n",time);
 250
 251
 252   for(int i=0;i<oneD;i++) {
 253     data_R[i]=decryptedtext[i];
 254     data_G[i]=decryptedtext[oneD+i];
 255     data_B[i]=decryptedtext[2*oneD+i];
 256   }
 257   store_RGB_pixmap("lena3.ppm", data_R, data_G, data_B, width, height);
 258
 259
 260
 261   /* Clean up */
 262   EVP_cleanup();
 263   ERR_free_strings();
 264
 265   return 0;
 266 }