From: couturie <couturie@extinction.home> Date: Wed, 3 Nov 2021 12:56:33 +0000 (+0100) Subject: new X-Git-Url: https://bilbo.iut-bm.univ-fcomte.fr/and/gitweb/Cipher_code.git/commitdiff_plain/3ed2f4b380f0d9f49ff45bf6accf8a55c511a353 new --- diff --git a/OneRoundIoT/openssl/Makefile b/OneRoundIoT/openssl/Makefile index 34b74d2..b88f1c9 100644 --- a/OneRoundIoT/openssl/Makefile +++ b/OneRoundIoT/openssl/Makefile @@ -6,6 +6,7 @@ OBJ3 = pixmap_io.o openssl_evp_ccm.o OBJ4 = pixmap_io.o aesccm.o OBJ5 = pixmap_io.o openssl_evp_gcm.o OBJ6 = pixmap_io.o openssl_evp_hmac.o +OBJ7 = pixmap_io.o openssl_evp_ocb.o openssl_evp: $(OBJ) $(C) -o $@ $^ $(CFLAGS) @@ -26,11 +27,14 @@ openssl_evp_gcm: $(OBJ5) openssl_evp_hmac: $(OBJ6) $(C) -o $@ $^ $(CFLAGS) +openssl_evp_ocb: $(OBJ7) + $(C) -o $@ $^ $(CFLAGS) + %.o: %.c $(C) -c -o $@ $< -O3 clean: - rm -rf $(OBJ) openssl_evp openssl_evp_cmac openssl_evp_ccm + rm -rf $(OBJ) openssl_evp openssl_evp_cmac openssl_evp_ccm openssl_evp_ocb diff --git a/OneRoundIoT/openssl/openssl_evp_ocb.c b/OneRoundIoT/openssl/openssl_evp_ocb.c new file mode 100755 index 0000000..480df1e --- /dev/null +++ b/OneRoundIoT/openssl/openssl_evp_ocb.c @@ -0,0 +1,371 @@ +//gcc pixmap_io.c -c +//gcc openssl_evp.c pixmap_io.o -o openssl_evp -I /usr/include/openssl/ -lcrypto -O3 -std=c99 + + +#include <openssl/conf.h> +#include <openssl/evp.h> +#include <openssl/err.h> +#include <openssl/ssl.h> +#include <openssl/bio.h> +#include <openssl/cmac.h> +#include <string.h> +#include <sys/time.h> +#include "pixmap_io.h" + +typedef unsigned char uchar; + +int nb_test=1; +int ctr=0; + +double TimeStart() +{ + struct timeval tstart; + gettimeofday(&tstart,0); + return( (double) (tstart.tv_sec + tstart.tv_usec*1e-6) ); +} + +double TimeStop(double t) +{ + struct timeval tend; + + gettimeofday(&tend,0); + t = (double) (tend.tv_sec + tend.tv_usec*1e-6) - t; + return (t); +} + + +void printBytes(unsigned char *buf, size_t len) { + for(int i=0; i<len; i++) { + printf("%02x ", buf[i]); + } + printf("\n"); +} + + +void handleErrors(void) +{ + ERR_print_errors_fp(stderr); + abort(); +} + + +int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key, + unsigned char *iv, unsigned char *ciphertext, int ctr, int index) +{ + CMAC_CTX *ctx; + + int len; + + int ciphertext_len; + + /* Create and initialise the context */ + if(!(ctx = CMAC_CTX_new())) handleErrors(); + + /* Initialise the encryption operation. IMPORTANT - ensure you use a key + * and IV size appropriate for your cipher + * In this example we are using 256 bit AES (i.e. a 256 bit key). The + * IV size for *most* modes is the same as the block size. For AES this + * is 128 bits */ + //static double time=0; + //double t=0; + //t=TimeStart(); + //256 + //avant ecb + if(ctr) { + if(1 != CMAC_Init(ctx, key, 16, EVP_aes_128_ocb(), NULL)) + handleErrors(); + } + else + if(1 != CMAC_Init(ctx, key, 16, EVP_aes_128_ocb(), NULL)) + handleErrors(); + size_t mactlen; +unsigned char mact[16] = {0}; + //time+=TimeStop(t); + //printf("Time init %f\n",time); + + +// int cipherBlockSize = EVP_CIPHER_CTX_block_size(ctx); +// printf("INFO(evp_encrypt): block size: %d\n", cipherBlockSize); + + + /* Provide the message to be encrypted, and obtain the encrypted output. + * EVP_EncryptUpdate can be called multiple times if necessary + */ + +/* + static double time=0; + double t=0; + t=TimeStart(); +*/ + for(int i=0;i<nb_test;i++) + { + + if(1 != CMAC_Update(ctx, plaintext, plaintext_len)) + handleErrors(); + ciphertext_len = len; + + } +/* time+=TimeStop(t); + // if(index==nb_test-1) + printf("Time encrypt %f\n",time); + +*/ + + + /* Finalise the encryption. Further ciphertext bytes may be written at + * this stage. + */ + if(1 != CMAC_Final(ctx, mact, &mactlen)) handleErrors(); + ciphertext_len += len; + + // printBytes(mact, mactlen); + + /* Clean up */ + CMAC_CTX_free(ctx); + + return ciphertext_len; +} + +int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key, + unsigned char *iv, unsigned char *plaintext, int ctr, int index) +{ + EVP_CIPHER_CTX *ctx; + + int len; + + int plaintext_len; + + /* Create and initialise the context */ + if(!(ctx = EVP_CIPHER_CTX_new())) handleErrors(); + + /* Initialise the decryption operation. IMPORTANT - ensure you use a key + * and IV size appropriate for your cipher + * In this example we are using 256 bit AES (i.e. a 256 bit key). The + * IV size for *most* modes is the same as the block size. For AES this + * is 128 bits */ + + //256 + + //avant => ecb + if(ctr) { + if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_128_ocb(), NULL, key, iv)) + handleErrors(); + } + else + if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_128_ocb(), NULL, key, iv)) + handleErrors(); + + /* Provide the message to be decrypted, and obtain the plaintext output. + * EVP_DecryptUpdate can be called multiple times if necessary + */ + +/* static double time=0; + double t=0; + t=TimeStart(); +*/ + for(int i=0;i<nb_test;i++) + { + plaintext_len = 0; + if(1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len)) + handleErrors(); + plaintext_len = len; + } +/* time+=TimeStop(t); +// if(index==nb_test-1) + printf("Time decrypt %f\n",time); +*/ + + + /* Finalise the decryption. Further plaintext bytes may be written at + * this stage. + */ + if(1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len)) handleErrors(); + plaintext_len += len; + + + + /* Clean up */ + EVP_CIPHER_CTX_free(ctx); + + return plaintext_len; +} + + +int main (int argc, char** argv) +{ + /* Set up the key and iv. Do I need to say to not hard code these in a + * real application? :-) + */ + + int size_buf=1; + int lena=0; + int change=0; + + for(int i=1; i<argc; i++){ + if(strncmp(argv[i],"nb",2)==0) nb_test = atoi(&(argv[i][2])); //nb of test + if(strncmp(argv[i],"ctr",3)==0) ctr = atoi(&(argv[i][3])); //CTR ? 1 otherwise CBC like + if(strncmp(argv[i],"sizebuf",7)==0) size_buf = atoi(&(argv[i][7])); //SIZE of the buffer + if(strncmp(argv[i],"lena",4)==0) lena = atoi(&(argv[i][4])); //Use Lena or buffer + if(strncmp(argv[i],"c",1)==0) change = atoi(&(argv[i][1])); //Use Lena or buffer + } + +/* printf("nb times %d\n",nb_test); + printf("ctr %d\n",ctr); + printf("lena %d\n",lena); + printf("size_buf %d\n",size_buf); +*/ + + + + + /* A 256 bit key */ +// unsigned char *key = (unsigned char *)"01234567890123456789012345678901"; + unsigned char *key = (unsigned char *)"0123456789012345"; + + /* A 128 bit IV */ + unsigned char *iv = (unsigned char *)"0123456789012345"; + + /* Message to be encrypted */ + + /* Buffer for ciphertext. Ensure the buffer is long enough for the + * ciphertext which may be longer than the plaintext, dependant on the + * algorithm and mode + */ + + int width; + int height; + uchar *data_R, *data_G, *data_B; + int imsize; + uchar *buffer; + + + if(lena==1) { + load_RGB_pixmap("lena.ppm", &width, &height, &data_R, &data_G, &data_B); + imsize=width*height*3; +// load_RGB_pixmap("No_ecb_mode_picture.ppm", &width, &height, &data_R, &data_G, &data_B); + } + else { + width=size_buf; + height=size_buf; + imsize=width*height; + buffer=malloc(imsize*sizeof(uchar)); + for(int i=0;i<imsize;i++) { + buffer[i]=lrand48(); + } + } + + + + int oneD=width*height; + uchar *plaintext = malloc(imsize+1000); //add that for cbc + if(lena) { + for(int i=0;i<oneD;i++) { + plaintext[i]=data_R[i]; + plaintext[oneD+i]=data_G[i]; + plaintext[2*oneD+i]=data_B[i]; + } + } + else + { + for(int i=0;i<oneD;i++) { + plaintext[i]=buffer[i]; + } + } + + if(change==1) { + + plaintext[4]++; + } + if(change==2) { + + plaintext[9]++; + } + + + uchar *ciphertext = malloc(imsize+1000); //add that for cbc + + /* Buffer for the decrypted text */ + uchar *decryptedtext = malloc(imsize+1000); //add that for cbc + + int decryptedtext_len, ciphertext_len; + + /* Initialise the library */ +/* ERR_load_crypto_strings(); + OpenSSL_add_all_algorithms(); + OPENSSL_config(NULL); +*/ + + + double time_encrypt=0; + double time_decrypt=0; + double t=TimeStart(); + + + /* Encrypt the plaintext */ + + + int i; + +// for(i=0;i<nb_test;i++) + { + ciphertext_len = encrypt (plaintext, imsize, key, iv, + ciphertext, ctr, i ); + } + + time_encrypt+=TimeStop(t); + +// printf("Time encrypt %f\n",time); + printf("%e\t",(double)imsize*nb_test/time_encrypt); + + /* + if(lena) { + for(int i=0;i<oneD;i++) { + data_R[i]=ciphertext[i]; + data_G[i]=ciphertext[oneD+i]; + data_B[i]=ciphertext[2*oneD+i]; + } + store_RGB_pixmap("lena2.ppm", data_R, data_G, data_B, width, height); + } + */ +/* + t=0; + t=TimeStart(); + + //for(int i=0;i<nb_test;i++) + { + // Decrypt the ciphertext + decryptedtext_len = decrypt(ciphertext, ciphertext_len, key, iv, + decryptedtext,ctr, i); + } + + time_decrypt+=TimeStop(t); + + //printf("Time decrypt %f\n",time); + printf("%f\t",(double)imsize*nb_test/time_decrypt); + + if(lena) { + for(int i=0;i<oneD;i++) { + data_R[i]=decryptedtext[i]; + data_G[i]=decryptedtext[oneD+i]; + data_B[i]=decryptedtext[2*oneD+i]; + } + store_RGB_pixmap("lena3.ppm", data_R, data_G, data_B, width, height); + } + else { + int equal=1; + for(int i=0;i<imsize;i++) { + //cout<<(int)buffer[i]<<endl; + if(buffer[i]!=decryptedtext[i]) { + equal=0; + } + } +// printf("RESULT CORRECT: %d\n",equal); + } +*/ + + /* Clean up */ + EVP_cleanup(); + ERR_free_strings(); + + return 0; +}