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