EE8084: Cyber Security

Group No : T55

Deadline : Fri Apr 9, 16:30

Topic : AES Encryption

Group leader Matric Contact Section

number number
Reinardus Surya U0920088C 83612737 - Demo
Pradhitya - Conclusion
Group members
William Kho U0920176B 98942848 - Intro
- Theory
- Conclusion
Ryan William U0920207D 93902571 - Abstract
- Theory
- Conclusion
Ezra Andhika U0920827A 85088927 - Source
Code
- Conclusion
Julianto Johannes U0920114J 92956791 - Theory
- Conclusion

Word Count: 2637 (max 3000 words,

excluding Title Page and References)

Abstract
 This report is about the AES Encryption which we mainly use password to encrypt

texts, images, or other types of data which can be decrypted back by using the original

encryption key.

In this report, there will be a brief definition about what is an AES Encryption and

the process of making it, they are all summarized in the ‘Literature Review’ section.

In addition, on the ‘Result and Discussion’ section, we will thoroughly explain about

the AES encryption process step by step through a demo program to encrypt data using C++

language. We will provide printed screens of the process and explanations of each step.
 1. Introduction

Encryption is a process where information is manipulated using cipher algorithm so that

the encrypted message can only be understood by those with the encryption key.

Advanced Encryption Standard (AES) is 128-bit block size encryption standard with 128,

192 and 256 bits key sizes respectively. These large key lengths make forced attempts to

crack the encrypted message infeasible.

2. Literature Review

1. Definition of Advanced Encryption Standard

Advanced Encryption Standard/AES is a type of encryption that is already standardized that

is mainly used for encrypting texts which can be decrypted with the original encryption key.

Advanced Encryption Standard (AES) was invented and declared for the first time by

National Institute of Standards Technology (NIST).

This invention was based on the Rijndael algorithm and was evaluated and selected after a 5

year standardization process from a design competition. The Rijndael cipher which is the

process of making the encrypted text, was first developed by the Belgians cryptographer.

The algorithm specified in this topic which follows the standard will be pointed as “AES

algorithm”. There are three different key lengths of cipher algorithm that can be used, they

are the AES-256, AES-192 and AES-128.

1.1. Input and Output of AES Encryption Algorithm

In the AES algorithm, the file that is input to the program will be encrypted into several

lengths/sequences (128,192,256 bits). These bits of data refer to the length of the output after

the encryption process. Output other than those three values are not permitted as they do not

follow the standard.

Starting at 0, the bits of the sequences will be attached and it is going to end one step before

the sequence length. Based on the block length and key length, number i will be marked to a

bit which is known as its index, it ranges from 0 ≤ i < 128, 0 ≤ i < 192 or 0 ≤ i < 256.

1.2. Bytes

There is also a term called Bytes which is an order of eight bits medicated as a single entity.

AES algorithm uses bytes as its basic processing unit. By dividing the input, output, and key

sequences into group of eight bits, they can be processed as array of bytes.

At the input and output or cipher key marked by a, the bytes in the array resulted will be

referenced by using an or a[n] where n is one of these ranges:

For key length of 128 bits, 0 ≤ n < 16;

For key length of 192 bits, 0 ≤ n < 24;

For key length of 256 bits, 0 ≤ n < 32.

2. Cipher process

There are several steps used in the encryption algorithm. It is divided into four main steps

which are: key expansion, initial round, rounds, and final round.

AES implements on a 4x4 array of bytes which is known as the state. The overall process of

encrypting in Advanced Encryption Standard is divided into steps below:

2.1. Key Expansion:

This step is as preparation for the main cipher steps. In this step, key schedule is made from

expanding the key or password using a series of word substitution with a constant

Substitution Box (SBOX), rotation of cells, and xor-ing. The example is as following

Step 1: Initialize with password

Step 2: Rotation

Step 3: Substitution

Step 3: xor-ing
*The grey box is from Rijndael’s constant field RCON
Step 4: For any part which is not multiple of four, just xor it

2.2. Chipering

It consists of three parts. Initial Round, Rounds,

and Final Round. The sequence of this step is

as following:
Definition of each part and functions:

 Initial

AddRoundKey: Using bitwise xor to integrate every byte of the state with the round key.

The state will be integrated with the sub key in this step. In every round, Rijndael’s key

schedule is used to show a sub key from the main key, with every sub key within the same

size acting as the state. By integrating every byte of the state with the corresponding byte of

the sub key by applying bitwise XOR, the sub key is added.

 Rounds

The number of rounds is 10/12/14 for (128/192/256) bit encryption

 SubBytes:

Every byte in the state will be substituted with its entry in a fixed 8-bit lookup table in this

step. By applying an 8-bit substitution box, the Rijndael S-box, every byte in the array will be

updated.The S-box is used to make the cipher non linear.

 ShiftRows:

Each byte in every row of the state will be shifted to the left in different offsets for every row

in this step. In AES, the first row will be left unchanged while every byte in the second row
will be shifted one to the left.Then, the third and fourth rows will be shifted by offsets of two

and three respectively.

 MixColumns:

In this step, invertible linear transformation will be used to integrate each of the four bytes in

every column of the state. The function will input and output in four bytes where every input

byte will affect all for output bytes. Every column will also be multiplied by a known matrix

in this operation. For example:

The multiplication operation is defined as: multiplication by 1 means leaving unchanged,

multiplication by 2 means shifting byte to the left and multiplication by 3 means shifting to

the left and then performing xor with the initial unshifted value.

Together with ShiftRows step, MixColumns provides diffusion in the cipher.

 Final Round

In this round, the SubBytes, ShiftRows, and AddRoundKey process is repeated without

undergoing the MixColumns

3. Cipher modes of operation

There are actually couples of methods that can be used to code the encryption program, they

are :
  Electronic Code Book (ECB)

In this method, the original message (the plaintext) is divided into several blocks. The blocks

are then encrypted separately. Each identical plaintext block will be encrypted into an

identical cipher block which makes this method is not secure enough to be used.

 Cipher Block Chaining

In this method, every plaintext block will be XOR-ed with an initialization vector for the first

step which then in the next step will be XOR-ed with the previous cipher text block before

being encrypted. This method is secure enough because each cipher text block depends on all

previous plaintext blocks processed.

 Propagating Cipher Block Chaining

This method is created to cause minor changes in the cipher text to spread indefinitely when

decrypting or encrypting. In this method, every plaintext block will be XOR-ed with its

cipher text after encryption. The resultant is then used to XOR the next plaintext block before

being encrypted.

 Cipher Feedback

The first step of this method is an initialization vector will be encrypted which then will be

XOR-ed by the first plaintext block to result to a cipher text block. Each of the cipher text

will then be encrypted and XOR-ed by the plaintext block.

 Output Feedback

From this method, a synchronous stream cipher will be created from a block cipher. This

method produces key stream blocks, which will then be XOR-ed by the plaintext blocks to

result to the cipher text. If a bit is flipped in the cipher text, it will lead to a flipped bit in the
plaintext at the same place. Thus, a lot of error correcting codes will function normally even

when applied before encryption.

 Counter

This method will create a stream cipher from a block cipher. This method will encrypt

successive values of a “counter” to produce the next key stream block. “Counter” means any

function which generates a sequence which will not repeat for a long time, although the

simplest and the most renowned one is an actual counter.

*The ‘Counter’ method is the method implemented in the making of the encryption program

in this report.
 3. Result and Discussion  Demo

1. The software and environment

For demo on the topic: “Advanced Encryption Standard”, we create a program that operates

AES. This program is “text-file AES encrypter/decrypter”. Actually this program also works

on any other file (although we didn’t do many further research on that)

The source code:

- C++ program aes_final.cpp

- 321 lines (including last blank line, some comments, and blank lines between

functions) with size of 10706 bytes

- Coding environment is Notepad++ v5.6.4, open source

The compiler:

- .cpp compiler: G++ v3.4.2

- using command line: g++ -o aes aes_final.cpp

- producing binary file aes.exe with size of 557313 bytes

2. Readme

To use the program:

1. Double click aes.exe. A terminal window will show up

2. If you want to encrypt, type 1 and press enter
3. Place the file you want to encrypt on the same directory as aes.exe. For example,

the name is file.txt

4. Back to the terminal, type the name of the file, and then press enter
5. Input the password you want to use to encrypt this file (the password will be

necessary to decrypt the file), and then press enter. For example, the password is:

a_BIG_53cr37
6. The program will write the encrypted text in binary mode into a new text file with

the same name but with additional prefix: enc_. So in this example, the file is

enc_file.txt. Try opening it to see what happen

7. Back to the menu, to decrypt, type 2 and press enter
8. Place the file you want to decrypt on the same directory as aes.exe. So in this

example, it is the enc_file.txt. Type the name of the file and press enter

9. Input the password that has been used to encrypt this file. In this example, it is:

a_BIG_53cr37
 10. The program will write the encrypted text in binary mode into a new text file with

the same name but with additional prefix: dec_. So in this example the file is

dec_file.txt. Try opening it to see what happen

3. Methodology and Design

The methodology of this software is procedural / modular programming. This program has

functions, each of which is responsible for a specific job. The design of functions are as

follow:

1. First group of functions is responsible for creating a key schedule. There are

KeyExpansion(), RotWord(), SubWord(), SubBytes(), ShiftRows(),

MixColumns(), AddRoundKey(), Cipher() in this group.

 2. Second group of functions is responsible for accepting plaintext and converting it

into ciphertext (encrypting) or vice versa (decrypting). There are function

encrypt() and decrypt() in this group

3. Third group of functions is the main program, which interacts with user’s input.

There are menu() and main() in this group

4. Algorithm

We will divide the explanation on algorithm in pseudocode into three important parts,

KeyExpansion(), Cipher(), and Encrypt/Decrypt

A. KeyExpansion()

---PSEUDOCODE---
Let SBOX[] be (5)
{0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16};
Let RCON[][] be (6)
{{0x00, 0x00, 0x00, 0x00},
{0x01, 0x00, 0x00, 0x00},
{0x02, 0x00, 0x00, 0x00},
{0x04, 0x00, 0x00, 0x00},
{0x08, 0x00, 0x00, 0x00},
{0x10, 0x00, 0x00, 0x00},
{0x20, 0x00, 0x00, 0x00},
{0x40, 0x00, 0x00, 0x00},
{0x80, 0x00, 0x00, 0x00},
{0x1b, 0x00, 0x00, 0x00},
{0x36, 0x00, 0x00, 0x00} };

function KeyExpansion(KEY) {
Let W be an array with size [60][4]
Fill the first 32 bit (8 rows, 0~7) of W with KEY (1)
To fill the other rows, iterate FOR 8<=I<60 (2)
Let TEMP = w[i-1]
IF I is multiple of 8
do SubWord after RotWord to TEMP
TEMP = TEMP xor W[i/8]
END IF
ELSE IF I is multiple of 4 but not multiple of 8
do SubWord to TEMP
END IF
W[i]=w[i-8] xor TEMP
END FOR
return W
}

function SubWord(W) {
Substitute every element of W with value in corresponding index of SBOX (3)
return W
}

function RotWord(W) {
Circular-shift W to the left once (4)
return W
}
B. Cipher()
---PSEUDOCODE---
function Cipher(INPUT, W) {
Let STATE be an array with size [4][4]
FOR 0<ROUND<14 because it is 256-bit cipher (1)
do SubBytes to STATE
do ShiftRows to STATE
do MixColumns to STATE
STATE=AddRoundKey(STATE,W,ROUND,4)
END FOR
do SubBytes to state
do ShiftRows to state
STATE=AddRoundKey(STATE,W,14,4)
return STATE in form of one dimensional array (2)
}

function SubBytes(S, NB) {

Substitute every element of S with value in corresponding index of SBOX (3)
}

function ShiftRows(S, int NB) {

//S is two-dimensional
FOR each row 0<=R<4 (4)
Circular-shift S to the left (R % 4) times
END FOR
return S
}

function MixColumns(S, Nb) {

Modify columns using Rijndael finite field gf(2^8) (5)
return S
}

function AddRoundKey(STATE, W, RND, NB) {

xor STATE with W (6)
return STATE
}
 C. Encrypt() / Decrypt()

---PSEUDOCODE---
function encrypt(PLAINTEXT, PASSWORD, NBITS) {
Let BLOCKSIZE be 16
Let NBYTES be 32
Let KEY be password
Let COUNTERBLOCK be an array with size [16]
Set the first 8 bytes of COUNTERBLOCK with random number (1)
Set the last 8 bytes of COUNTERBLOCK with 0, as a counter
Let CTRTXT be the first 8 bytes of COUNTERBLOCK
Create KEYSCHEDULE with KeyExpansion(KEY) (2)
Divide PLAINTEXT into BLOCKCOUNT parts of size BLOCKSIZE
Concatenate the random number CTRTXT to the front of CIPHERTEXT (3)
Process all parts B, FOR 0<=B<BLOCKCOUNT (4)
Increase the last 8 bit of COUNTERBLOCK. Starting is 00000000
Create CIPHERCNTR=Cipher(COUNTERBLOCK,KEYSCHEDULE)
CIPHERTEXT += CIPHERCNTR xor PLAINTEXT[B*BLOCKSIZE]
END FOR
return CIPHERTEXT in form of one dimensional array (5)
}

function decrypt(CIPHERTEXT, PASSWORD, NBITS) {

Let BLOCKSIZE be 16
Let NBYTES be 32
Let KEY be PASSWORD
Let COUNTERBLOCK be an array with size [16]
Set the first 8 bytes of COUNTERBLOCK with the first 8 bytes of CIPHERTEXT (6)
Set the last 8 bytes of COUNTERBLOCK with 0, as a counter
Let CTRTXT be the first 8 bytes of CIPHERTEXT
Create KEYSCHEDULE with KeyExpansion(KEY) (7)
Divide PLAINTEXT less the first 8 bytes into BLOCKCOUNT parts of size BLOCKSIZE
Let CT be an array containing all parts of divided PLAINTEXT (8)
Process all parts B, FOR 0<=B<BLOCKCOUNT (9)
Increase the last 8 bit of COUNTERBLOCK. Starting is 00000000
Create CIPHERCNTR=Cipher(COUNTERBLOCK,KEYSCHEDULE)
 PLAINTEXT += CIPHERCNTR xor CT[B]
END FOR
return PLAINTEXT in form of one dimensional array (10)
}
*Points to note:

- This program can encrypt/decrypt any files

- This program uses 256-bit cipher

- This program uses counter-method

- The time complexity of this program is linear to the number of characters in the
input file

- This program includes error handling in bad input file, and bad user’s input
 4. CONCLUSIONS AND RECOMMENDATIONS
Advanced Encryption Standard is widely used as a encryption standard in ciphering. The
ciphering is useful to modify information into a form that can only be understood using a key
to decipher it.

The Advanced Encryption Standard is the most recent standard of encryption to date. It is
being used in a large variety of sectors including national security, education, and banking. In
the future, it may be used in a broader area, such as encrypting personal information or
confidential information exchange such as emails, bank account information, and passwords.

This demo has succesfully shown the process of encypting and decrypting using the
Advanced Encryption Standard. It has shown how an information is transformed into
encrypted data and how to decrypt it back to a coherent information.

Reference
F.S. Tsai and C.K. Chan (Eds), Cyber Security, Pearson Education, 2006

http://en.wikipedia.org/wiki/Advanced_Encryption_Standard

http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf

Veness, Chris, http://www.movable-type.co.uk/scripts/aes.html, October 2009

Styer, Eugene, http://people.eku.edu/styere/index.html, 27 October 2006

Carvalho, Jaqueline Lima Soares, and Vanessa Ferreira Tornich de Freitas

http://blog.ultrassecreto.com/wp-content/uploads/2009/06/projetofinal.html