AES-ECB vs AES-CBC Encryption and Decryption

Encryption and Decryption #

A comparison of AES-ECB and AES-CBC encryption modes, and implementation of a key generation algortihm for symmetric encryption/decryption with RSA.

Task 1: Encryption mode: ECB vs CBC#

This task involves encrypting the following image with AES-ECB and AES-CBC encryption modes and comparing them.

Image to encrypt

To encrypt this image, I used openssl enc with the following commands.

For ECB encryption:

1
openssl enc -aes-128-ecb -e -in test.bmp -out encrypted -p

For CBC encryption:

1
openssl enc -aes-128-cbc -e -in test.bmp -out encrypted -p

Then by overwriting the header of the encrypted files with the header from the unencrypted file, we can view the encrypted images.

Using the following commands to overwrite the header:

1
head -c 54 test.bmp > header
2
tail -c +55 encrypted > body
3
cat header body > encrypted.bmp

We can now view the encrypted files as images.

The image encrypted with ECB looks like:

ECB Encryption

The image encrypted with CBC looks like:

CBC Encryption

This isn’t particularly suprising, considering what we learned about ECB and CBC in class.

While ECB adds some ‘noise’ to the image, you can clearly make out the circle and the square that make up the original unencrypted image. You can even make out the colors of the original image. This is because ECB applies the exact same encryption operation to all ‘blocks’, which means that parts of the plaintext that are identical result in identical ciphertext.

In contrast, using CBC makes the entire image ‘noise’, preventing you from learning any information about the original unencrypted image. This is becasue CBC doesn’t apply the exact same encryption operation to each block, instead the encryption of the current block relies on the previous block, hence the name ‘Chained Block Cipher’. This results in identical plaintext blocks having different results as ciphertext.

Task 2: Calculating Keys for RSA#

Using the following code:

1
#include <stdio.h>
2
#include <openssl/bn.h>
3

4
#define NBITS 128
5

6
void printBN(char *msg, BIGNUM * a)
7
{
8
   /* Use BN_bn2hex(a) for hex string
9
    * Use BN_bn2dec(a) for decimal string */
10
   char * number_str = BN_bn2hex(a);
11
   printf("%s %s\n", msg, number_str);
12
   OPENSSL_free(number_str);
13
}
14

15
int main ()
16
{
17
  BN_CTX *ctx = BN_CTX_new();
18

19
  BIGNUM *p = BN_new();
20
  BIGNUM *q = BN_new();
21
  BIGNUM *e = BN_new();
22

23
  BN_hex2bn(&p,"F7E75FDC469067FFDC4E847C51F452DF");
24
  BN_hex2bn(&q,"E85CED54AF57E53E092113E62F436F4F");
25
  BN_hex2bn(&e,"0D88C3");
26

27
  BIGNUM *n = BN_new();
28
  // n = p * q
29
  BN_mul(n, p, q, ctx);
30
  printBN("n = ", n);
31

32
  BIGNUM *phi = BN_new();
33
  // phi = (p-1) * (q-1)
34
  BIGNUM *p_one = BN_new();
35
  BN_hex2bn(&p_one, "F7E75FDC469067FFDC4E847C51F452DE");
36
  BIGNUM *q_one = BN_new();
37
  BN_hex2bn(&q_one, "E85CED54AF57E53E092113E62F436F4E");
38

39
  BN_mul(phi, p_one, q_one, ctx);
40

41
  // find 'd', the modular inverse of e and phi s.t. e*d % phi == 1
42

43
  BIGNUM *d = BN_new();
44
  BN_mod_inverse(d, e, phi, ctx);
45
  printBN("d = ", d);
46

47
  return 0;
48
}

We get the output:

1
n =  E103ABD94892E3E74AFD724BF28E78366D9676BCCC70118BD0AA1968DBB143D1
2
d =  3587A24598E5F2A21DB007D89D18CC50ABA5075BA19A33890FE7C28A9B496AEB

Which is then verified by using the code for Task 3 and 4 to encrypt and decrypt the message “A top secret!”

Firstly using the values:

1
"A top secret!".encode("utf-8").hex()) in python gives:
2
'4120746f702073656372657421'
3

4
a = 4120746f702073656372657421
5
b = 0D88C3
6
n = E103ABD94892E3E74AFD724BF28E78366D9676BCCC70118BD0AA1968DBB143D1

For a ^ b % n in the code below.

We get the ciphertext:

1
90A81343DFE08415EDF79337CDE00457BAB56AFFA1B0CE5647BF9025665B396A

Then decrypting it with the values:

1
a = 90A81343DFE08415EDF79337CDE00457BAB56AFFA1B0CE5647BF9025665B396A
2
b = 3587A24598E5F2A21DB007D89D18CC50ABA5075BA19A33890FE7C28A9B496AEB
3
n = E103ABD94892E3E74AFD724BF28E78366D9676BCCC70118BD0AA1968DBB143D1

We get the resulting decrypted hex:

1
4120746f702073656372657421

Which we can then verify in python:

1
bytes.fromhex("4120746F702073656372657421").decode()
2

3
'A top secret!'

Thus concluding that our calculated d value is correct.

I initially tried implementing a naive algorithm in python to compute ‘d’, but it was just taking forever. It took so long that I was able to create the code above in C to calculate ‘d’ and finished the task before my python code finished calculating ‘d’.

Task 3 and 4: Encrypting and Decrypting a Message#

Both of theses tasks are done with the following C code to utilize the BIGNUM openssl library.

1
#include <stdio.h>
2
#include <openssl/bn.h>
3

4
#define NBITS 128
5

6
void printBN(char *msg, BIGNUM * a)
7
{
8
   /* Use BN_bn2hex(a) for hex string
9
    * Use BN_bn2dec(a) for decimal string */
10
   char * number_str = BN_bn2hex(a);
11
   printf("%s %s\n", msg, number_str);
12
   OPENSSL_free(number_str);
13
}
14

15
int main ()
16
{
17
  BN_CTX *ctx = BN_CTX_new();
18

19
  BIGNUM *a = BN_new();
20
  BIGNUM *b = BN_new();
21
  BIGNUM *n = BN_new();
22
  BIGNUM *res = BN_new();
23
  // Initialize a, b, n
24
  BN_hex2bn(&a, "4120746f702073656372657421");
25
  BN_hex2bn(&b, "010001");
26
  BN_hex2bn(&n, "DCBFFE3E51F62E09CE7032E2677A78946A849DC4CDDE3A4D0CB81629242FB1A5");
27

28
  BN_mod_exp(res, a, b, n, ctx);
29
  printBN("a^b mod n = ", res);
30

31
  return 0;
32
}

For task 3:#

a, b, and n are set to the following values:

After running "A top secret!".encode("utf-8").hex()) in python we get the value for ‘a’

1
a = "4120746f702073656372657421"
2
b = "010001"
3
n = "DCBFFE3E51F62E09CE7032E2677A78946A849DC4CDDE3A4D0CB81629242FB1A5"

Then, simply compiling and running the code outputs:

1
a^b mod n =  6FB078DA550B2650832661E14F4F8D2CFAEF475A0DF3A75CACDC5DE5CFC5FADC

To validate this, we can then take this result and plug it in for ‘a’, along with a new value for ‘b’:

1
a = "6FB078DA550B2650832661E14F4F8D2CFAEF475A0DF3A75CACDC5DE5CFC5FADC"
2
b = "74D806F9F3A62BAE331FFE3F0A68AFE35B3D2E4794148AACBC26AA381CD7D30D"

Then by compiling and running the code again we get:

1
a^b mod n =  4120746F702073656372657421

We can then run bytes.fromhex("4120746F702073656372657421").decode() in python to get the result:

1
"A top secret!"

One thing I would like to point out is the sheer efficiency of the openssl BIGNUM library.

I was able to encrypt the plaintext instantly with python, but attempting to decrypt the ciphertext with m = (c ** d) % n ran excessively long - around 10 minutes before I gave up.

This is most likely due to the fact that the ‘d’ value is almost as long as the ciphertext itself, resulting in a very large number to the power of another very large number. No doubt there would be a more efficient way to implement this in python, but it was easier just to use the given BIGNUM sample code to create a C implementation.

For task 4:#

Using the same code as before, setting the a,b, and n values to:

1
a = "8C0F971DF2F3672B28811407E2DABBE1DA0FEBBBDFC7DCB67396567EA1E2493F"
2
b = "74D806F9F3A62BAE331FFE3F0A68AFE35B3D2E4794148AACBC26AA381CD7D30D"
3
n = "DCBFFE3E51F62E09CE7032E2677A78946A849DC4CDDE3A4D0CB81629242FB1A5"

Compiling and running the code results in:

1
a^b mod n =  50617373776F72642069732064656573

And by converting the hex with python, we get:

1
'Password is dees'

Which isn’t much of a suprise, considering we’ve already used this same code to encrypt and decrypt successfully.