├── decrypt
├── encrypt
├── keyfile
├── message.aes
├── README.md
├── encrypt.cpp
├── decrypt.cpp
└── structures.h


/decrypt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ceceww/aes/HEAD/decrypt


--------------------------------------------------------------------------------
/encrypt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ceceww/aes/HEAD/encrypt


--------------------------------------------------------------------------------
/keyfile:
--------------------------------------------------------------------------------
1 | 01 04 02 03 01 03 04 0A 09 0B 07 0F 0F 06 03 00
2 | 


--------------------------------------------------------------------------------
/message.aes:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ceceww/aes/HEAD/message.aes


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # 128-bit AES
 2 | 
 3 | ## Synopsis
 4 | Encryption and decryption programs written in C++ to improve my understanding of the 128-bit AES cipher.
 5 | 
 6 | ## File Details
 7 | - encrypt.cpp - Source file for encryption utility. 
 8 | - decrypt.cpp - Source file for decryption utility.
 9 | - structures.h - Provides the structures and Key Expansion functions for use in the main program files.
10 | - keyfile - Specify the encryption key in this file. Key must be a 128-bit key in hexadecimal format with a space between each hex value, example: 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10
11 | - message.aes - Generated by encryption tool, stores the encrypted message. Read in and decrypted by decryption tool.
12 | 
13 | ## Compilation
14 | If using the g++ compiler you can do:   
15 | **g++ encrypt.cpp -o encrypt**  
16 | **g++ decrypt.cpp -o decrypt**
17 | 
18 | ## Usage
19 | To run the encryption utility simply do **./encrypt** after compilation.   
20 | To run the decryption utility simply do **./decrypt** after compilation.
21 | 
22 | 


--------------------------------------------------------------------------------
/encrypt.cpp:
--------------------------------------------------------------------------------
  1 | /* encrypt.cpp
  2 |  * Performs encryption using AES 128-bit
  3 |  * @author Cecelia Wisniewska
  4 |  */
  5 | 
  6 | #include <iostream>
  7 | #include <cstring>
  8 | #include <fstream>
  9 | #include <sstream>
 10 | #include "structures.h"
 11 | 
 12 | using namespace std;
 13 | 
 14 | /* Serves as the initial round during encryption
 15 |  * AddRoundKey is simply an XOR of a 128-bit block with the 128-bit key.
 16 |  */
 17 | void AddRoundKey(unsigned char * state, unsigned char * roundKey) {
 18 | 	for (int i = 0; i < 16; i++) {
 19 | 		state[i] ^= roundKey[i];
 20 | 	}
 21 | }
 22 | 
 23 | /* Perform substitution to each of the 16 bytes
 24 |  * Uses S-box as lookup table 
 25 |  */
 26 | void SubBytes(unsigned char * state) {
 27 | 	for (int i = 0; i < 16; i++) {
 28 | 		state[i] = s[state[i]];
 29 | 	}
 30 | }
 31 | 
 32 | // Shift left, adds diffusion
 33 | void ShiftRows(unsigned char * state) {
 34 | 	unsigned char tmp[16];
 35 | 
 36 | 	/* Column 1 */
 37 | 	tmp[0] = state[0];
 38 | 	tmp[1] = state[5];
 39 | 	tmp[2] = state[10];
 40 | 	tmp[3] = state[15];
 41 | 	
 42 | 	/* Column 2 */
 43 | 	tmp[4] = state[4];
 44 | 	tmp[5] = state[9];
 45 | 	tmp[6] = state[14];
 46 | 	tmp[7] = state[3];
 47 | 
 48 | 	/* Column 3 */
 49 | 	tmp[8] = state[8];
 50 | 	tmp[9] = state[13];
 51 | 	tmp[10] = state[2];
 52 | 	tmp[11] = state[7];
 53 | 	
 54 | 	/* Column 4 */
 55 | 	tmp[12] = state[12];
 56 | 	tmp[13] = state[1];
 57 | 	tmp[14] = state[6];
 58 | 	tmp[15] = state[11];
 59 | 
 60 | 	for (int i = 0; i < 16; i++) {
 61 | 		state[i] = tmp[i];
 62 | 	}
 63 | }
 64 | 
 65 |  /* MixColumns uses mul2, mul3 look-up tables
 66 |   * Source of diffusion
 67 |   */
 68 | void MixColumns(unsigned char * state) {
 69 | 	unsigned char tmp[16];
 70 | 
 71 | 	tmp[0] = (unsigned char) mul2[state[0]] ^ mul3[state[1]] ^ state[2] ^ state[3];
 72 | 	tmp[1] = (unsigned char) state[0] ^ mul2[state[1]] ^ mul3[state[2]] ^ state[3];
 73 | 	tmp[2] = (unsigned char) state[0] ^ state[1] ^ mul2[state[2]] ^ mul3[state[3]];
 74 | 	tmp[3] = (unsigned char) mul3[state[0]] ^ state[1] ^ state[2] ^ mul2[state[3]];
 75 | 
 76 | 	tmp[4] = (unsigned char)mul2[state[4]] ^ mul3[state[5]] ^ state[6] ^ state[7];
 77 | 	tmp[5] = (unsigned char)state[4] ^ mul2[state[5]] ^ mul3[state[6]] ^ state[7];
 78 | 	tmp[6] = (unsigned char)state[4] ^ state[5] ^ mul2[state[6]] ^ mul3[state[7]];
 79 | 	tmp[7] = (unsigned char)mul3[state[4]] ^ state[5] ^ state[6] ^ mul2[state[7]];
 80 | 
 81 | 	tmp[8] = (unsigned char)mul2[state[8]] ^ mul3[state[9]] ^ state[10] ^ state[11];
 82 | 	tmp[9] = (unsigned char)state[8] ^ mul2[state[9]] ^ mul3[state[10]] ^ state[11];
 83 | 	tmp[10] = (unsigned char)state[8] ^ state[9] ^ mul2[state[10]] ^ mul3[state[11]];
 84 | 	tmp[11] = (unsigned char)mul3[state[8]] ^ state[9] ^ state[10] ^ mul2[state[11]];
 85 | 
 86 | 	tmp[12] = (unsigned char)mul2[state[12]] ^ mul3[state[13]] ^ state[14] ^ state[15];
 87 | 	tmp[13] = (unsigned char)state[12] ^ mul2[state[13]] ^ mul3[state[14]] ^ state[15];
 88 | 	tmp[14] = (unsigned char)state[12] ^ state[13] ^ mul2[state[14]] ^ mul3[state[15]];
 89 | 	tmp[15] = (unsigned char)mul3[state[12]] ^ state[13] ^ state[14] ^ mul2[state[15]];
 90 | 
 91 | 	for (int i = 0; i < 16; i++) {
 92 | 		state[i] = tmp[i];
 93 | 	}
 94 | }
 95 | 
 96 | /* Each round operates on 128 bits at a time
 97 |  * The number of rounds is defined in AESEncrypt()
 98 |  */
 99 | void Round(unsigned char * state, unsigned char * key) {
100 | 	SubBytes(state);
101 | 	ShiftRows(state);
102 | 	MixColumns(state);
103 | 	AddRoundKey(state, key);
104 | }
105 | 
106 |  // Same as Round() except it doesn't mix columns
107 | void FinalRound(unsigned char * state, unsigned char * key) {
108 | 	SubBytes(state);
109 | 	ShiftRows(state);
110 | 	AddRoundKey(state, key);
111 | }
112 | 
113 | /* The AES encryption function
114 |  * Organizes the confusion and diffusion steps into one function
115 |  */
116 | void AESEncrypt(unsigned char * message, unsigned char * expandedKey, unsigned char * encryptedMessage) {
117 | 	unsigned char state[16]; // Stores the first 16 bytes of original message
118 | 
119 | 	for (int i = 0; i < 16; i++) {
120 | 		state[i] = message[i];
121 | 	}
122 | 
123 | 	int numberOfRounds = 9;
124 | 
125 | 	AddRoundKey(state, expandedKey); // Initial round
126 | 
127 | 	for (int i = 0; i < numberOfRounds; i++) {
128 | 		Round(state, expandedKey + (16 * (i+1)));
129 | 	}
130 | 
131 | 	FinalRound(state, expandedKey + 160);
132 | 
133 | 	// Copy encrypted state to buffer
134 | 	for (int i = 0; i < 16; i++) {
135 | 		encryptedMessage[i] = state[i];
136 | 	}
137 | }
138 | 
139 | int main() {
140 | 
141 | 	cout << "=============================" << endl;
142 | 	cout << " 128-bit AES Encryption Tool   " << endl;
143 | 	cout << "=============================" << endl;
144 | 
145 | 	char message[1024];
146 | 
147 | 	cout << "Enter the message to encrypt: ";
148 | 	cin.getline(message, sizeof(message));
149 | 	cout << message << endl;
150 | 
151 | 	// Pad message to 16 bytes
152 | 	int originalLen = strlen((const char *)message);
153 | 
154 | 	int paddedMessageLen = originalLen;
155 | 
156 | 	if ((paddedMessageLen % 16) != 0) {
157 | 		paddedMessageLen = (paddedMessageLen / 16 + 1) * 16;
158 | 	}
159 | 
160 | 	unsigned char * paddedMessage = new unsigned char[paddedMessageLen];
161 | 	for (int i = 0; i < paddedMessageLen; i++) {
162 | 		if (i >= originalLen) {
163 | 			paddedMessage[i] = 0;
164 | 		}
165 | 		else {
166 | 			paddedMessage[i] = message[i];
167 | 		}
168 | 	}
169 | 
170 | 	unsigned char * encryptedMessage = new unsigned char[paddedMessageLen];
171 | 
172 | 	string str;
173 | 	ifstream infile;
174 | 	infile.open("keyfile", ios::in | ios::binary);
175 | 
176 | 	if (infile.is_open())
177 | 	{
178 | 		getline(infile, str); // The first line of file should be the key
179 | 		infile.close();
180 | 	}
181 | 
182 | 	else cout << "Unable to open file";
183 | 
184 | 	istringstream hex_chars_stream(str);
185 | 	unsigned char key[16];
186 | 	int i = 0;
187 | 	unsigned int c;
188 | 	while (hex_chars_stream >> hex >> c)
189 | 	{
190 | 		key[i] = c;
191 | 		i++;
192 | 	}
193 | 
194 | 	unsigned char expandedKey[176];
195 | 
196 | 	KeyExpansion(key, expandedKey);
197 | 
198 | 	for (int i = 0; i < paddedMessageLen; i += 16) {
199 | 		AESEncrypt(paddedMessage+i, expandedKey, encryptedMessage+i);
200 | 	}
201 | 
202 | 	cout << "Encrypted message in hex:" << endl;
203 | 	for (int i = 0; i < paddedMessageLen; i++) {
204 | 		cout << hex << (int) encryptedMessage[i];
205 | 		cout << " ";
206 | 	}
207 | 
208 | 	cout << endl;
209 | 
210 | 	// Write the encrypted string out to file "message.aes"
211 | 	ofstream outfile;
212 | 	outfile.open("message.aes", ios::out | ios::binary);
213 | 	if (outfile.is_open())
214 | 	{
215 | 		outfile << encryptedMessage;
216 | 		outfile.close();
217 | 		cout << "Wrote encrypted message to file message.aes" << endl;
218 | 	}
219 | 
220 | 	else cout << "Unable to open file";
221 | 
222 | 	// Free memory
223 | 	delete[] paddedMessage;
224 | 	delete[] encryptedMessage;
225 | 
226 | 	return 0;
227 | }


--------------------------------------------------------------------------------
/decrypt.cpp:
--------------------------------------------------------------------------------
  1 | /* decrypt.cpp
  2 |  * Performs decryption using AES 128-bit
  3 |  * @author Cecelia Wisniewska
  4 |  */
  5 | #include <iostream>
  6 | #include <cstring>
  7 | #include <fstream>
  8 | #include <sstream>
  9 | #include "structures.h"
 10 | 
 11 | using namespace std;
 12 | 
 13 | /* Used in Round() and serves as the final round during decryption
 14 |  * SubRoundKey is simply an XOR of a 128-bit block with the 128-bit key.
 15 |  * So basically does the same as AddRoundKey in the encryption
 16 |  */
 17 | void SubRoundKey(unsigned char * state, unsigned char * roundKey) {
 18 | 	for (int i = 0; i < 16; i++) {
 19 | 		state[i] ^= roundKey[i];
 20 | 	}
 21 | }
 22 | 
 23 | /* InverseMixColumns uses mul9, mul11, mul13, mul14 look-up tables
 24 |  * Unmixes the columns by reversing the effect of MixColumns in encryption
 25 |  */
 26 | void InverseMixColumns(unsigned char * state) {
 27 | 	unsigned char tmp[16];
 28 | 
 29 | 	tmp[0] = (unsigned char)mul14[state[0]] ^ mul11[state[1]] ^ mul13[state[2]] ^ mul9[state[3]];
 30 | 	tmp[1] = (unsigned char)mul9[state[0]] ^ mul14[state[1]] ^ mul11[state[2]] ^ mul13[state[3]];
 31 | 	tmp[2] = (unsigned char)mul13[state[0]] ^ mul9[state[1]] ^ mul14[state[2]] ^ mul11[state[3]];
 32 | 	tmp[3] = (unsigned char)mul11[state[0]] ^ mul13[state[1]] ^ mul9[state[2]] ^ mul14[state[3]];
 33 | 
 34 | 	tmp[4] = (unsigned char)mul14[state[4]] ^ mul11[state[5]] ^ mul13[state[6]] ^ mul9[state[7]];
 35 | 	tmp[5] = (unsigned char)mul9[state[4]] ^ mul14[state[5]] ^ mul11[state[6]] ^ mul13[state[7]];
 36 | 	tmp[6] = (unsigned char)mul13[state[4]] ^ mul9[state[5]] ^ mul14[state[6]] ^ mul11[state[7]];
 37 | 	tmp[7] = (unsigned char)mul11[state[4]] ^ mul13[state[5]] ^ mul9[state[6]] ^ mul14[state[7]];
 38 | 
 39 | 	tmp[8] = (unsigned char)mul14[state[8]] ^ mul11[state[9]] ^ mul13[state[10]] ^ mul9[state[11]];
 40 | 	tmp[9] = (unsigned char)mul9[state[8]] ^ mul14[state[9]] ^ mul11[state[10]] ^ mul13[state[11]];
 41 | 	tmp[10] = (unsigned char)mul13[state[8]] ^ mul9[state[9]] ^ mul14[state[10]] ^ mul11[state[11]];
 42 | 	tmp[11] = (unsigned char)mul11[state[8]] ^ mul13[state[9]] ^ mul9[state[10]] ^ mul14[state[11]];
 43 | 
 44 | 	tmp[12] = (unsigned char)mul14[state[12]] ^ mul11[state[13]] ^ mul13[state[14]] ^ mul9[state[15]];
 45 | 	tmp[13] = (unsigned char)mul9[state[12]] ^ mul14[state[13]] ^ mul11[state[14]] ^ mul13[state[15]];
 46 | 	tmp[14] = (unsigned char)mul13[state[12]] ^ mul9[state[13]] ^ mul14[state[14]] ^ mul11[state[15]];
 47 | 	tmp[15] = (unsigned char)mul11[state[12]] ^ mul13[state[13]] ^ mul9[state[14]] ^ mul14[state[15]];
 48 | 
 49 | 	for (int i = 0; i < 16; i++) {
 50 | 		state[i] = tmp[i];
 51 | 	}
 52 | }
 53 | 
 54 | // Shifts rows right (rather than left) for decryption
 55 | void ShiftRows(unsigned char * state) {
 56 | 	unsigned char tmp[16];
 57 | 
 58 | 	/* Column 1 */
 59 | 	tmp[0] = state[0];
 60 | 	tmp[1] = state[13];
 61 | 	tmp[2] = state[10];
 62 | 	tmp[3] = state[7];
 63 | 
 64 | 	/* Column 2 */
 65 | 	tmp[4] = state[4];
 66 | 	tmp[5] = state[1];
 67 | 	tmp[6] = state[14];
 68 | 	tmp[7] = state[11];
 69 | 
 70 | 	/* Column 3 */
 71 | 	tmp[8] = state[8];
 72 | 	tmp[9] = state[5];
 73 | 	tmp[10] = state[2];
 74 | 	tmp[11] = state[15];
 75 | 
 76 | 	/* Column 4 */
 77 | 	tmp[12] = state[12];
 78 | 	tmp[13] = state[9];
 79 | 	tmp[14] = state[6];
 80 | 	tmp[15] = state[3];
 81 | 
 82 | 	for (int i = 0; i < 16; i++) {
 83 | 		state[i] = tmp[i];
 84 | 	}
 85 | }
 86 | 
 87 | /* Perform substitution to each of the 16 bytes
 88 |  * Uses inverse S-box as lookup table
 89 |  */
 90 | void SubBytes(unsigned char * state) {
 91 | 	for (int i = 0; i < 16; i++) { // Perform substitution to each of the 16 bytes
 92 | 		state[i] = inv_s[state[i]];
 93 | 	}
 94 | }
 95 | 
 96 | /* Each round operates on 128 bits at a time
 97 |  * The number of rounds is defined in AESDecrypt()
 98 |  * Not surprisingly, the steps are the encryption steps but reversed
 99 |  */
100 | void Round(unsigned char * state, unsigned char * key) {
101 | 	SubRoundKey(state, key);
102 | 	InverseMixColumns(state);
103 | 	ShiftRows(state);
104 | 	SubBytes(state);
105 | }
106 | 
107 | // Same as Round() but no InverseMixColumns
108 | void InitialRound(unsigned char * state, unsigned char * key) {
109 | 	SubRoundKey(state, key);
110 | 	ShiftRows(state);
111 | 	SubBytes(state);
112 | }
113 | 
114 | /* The AES decryption function
115 |  * Organizes all the decryption steps into one function
116 |  */
117 | void AESDecrypt(unsigned char * encryptedMessage, unsigned char * expandedKey, unsigned char * decryptedMessage)
118 | {
119 | 	unsigned char state[16]; // Stores the first 16 bytes of encrypted message
120 | 
121 | 	for (int i = 0; i < 16; i++) {
122 | 		state[i] = encryptedMessage[i];
123 | 	}
124 | 
125 | 	InitialRound(state, expandedKey+160);
126 | 
127 | 	int numberOfRounds = 9;
128 | 
129 | 	for (int i = 8; i >= 0; i--) {
130 | 		Round(state, expandedKey + (16 * (i + 1)));
131 | 	}
132 | 
133 | 	SubRoundKey(state, expandedKey); // Final round
134 | 
135 | 	// Copy decrypted state to buffer
136 | 	for (int i = 0; i < 16; i++) {
137 | 		decryptedMessage[i] = state[i];
138 | 	}
139 | }
140 | 
141 | int main() {
142 | 
143 | 	cout << "=============================" << endl;
144 | 	cout << " 128-bit AES Decryption Tool " << endl;
145 | 	cout << "=============================" << endl;
146 | 
147 | 	// Read in the message from message.aes
148 | 	string msgstr;
149 | 	ifstream infile;
150 | 	infile.open("message.aes", ios::in | ios::binary);
151 | 
152 | 	if (infile.is_open())
153 | 	{
154 | 		getline(infile, msgstr); // The first line of file is the message
155 | 		cout << "Read in encrypted message from message.aes" << endl;
156 | 		infile.close();
157 | 	}
158 | 
159 | 	else cout << "Unable to open file";
160 | 
161 | 	char * msg = new char[msgstr.size()+1];
162 | 
163 | 	strcpy(msg, msgstr.c_str());
164 | 
165 | 	int n = strlen((const char*)msg);
166 | 
167 | 	unsigned char * encryptedMessage = new unsigned char[n];
168 | 	for (int i = 0; i < n; i++) {
169 | 		encryptedMessage[i] = (unsigned char)msg[i];
170 | 	}
171 | 
172 | 	// Free memory
173 | 	delete[] msg;
174 | 
175 | 	// Read in the key
176 | 	string keystr;
177 | 	ifstream keyfile;
178 | 	keyfile.open("keyfile", ios::in | ios::binary);
179 | 
180 | 	if (keyfile.is_open())
181 | 	{
182 | 		getline(keyfile, keystr); // The first line of file should be the key
183 | 		cout << "Read in the 128-bit key from keyfile" << endl;
184 | 		keyfile.close();
185 | 	}
186 | 
187 | 	else cout << "Unable to open file";
188 | 
189 | 	istringstream hex_chars_stream(keystr);
190 | 	unsigned char key[16];
191 | 	int i = 0;
192 | 	unsigned int c;
193 | 	while (hex_chars_stream >> hex >> c)
194 | 	{
195 | 		key[i] = c;
196 | 		i++;
197 | 	}
198 | 
199 | 	unsigned char expandedKey[176];
200 | 
201 | 	KeyExpansion(key, expandedKey);
202 | 	
203 | 	int messageLen = strlen((const char *)encryptedMessage);
204 | 
205 | 	unsigned char * decryptedMessage = new unsigned char[messageLen];
206 | 
207 | 	for (int i = 0; i < messageLen; i += 16) {
208 | 		AESDecrypt(encryptedMessage + i, expandedKey, decryptedMessage + i);
209 | 	}
210 | 
211 | 	cout << "Decrypted message in hex:" << endl;
212 | 	for (int i = 0; i < messageLen; i++) {
213 | 		cout << hex << (int)decryptedMessage[i];
214 | 		cout << " ";
215 | 	}
216 | 	cout << endl;
217 | 	cout << "Decrypted message: ";
218 | 	for (int i = 0; i < messageLen; i++) {
219 | 		cout << decryptedMessage[i];
220 | 	}
221 | 	cout << endl;
222 | 
223 | 	return 0;
224 | }


--------------------------------------------------------------------------------
/structures.h:
--------------------------------------------------------------------------------
  1 | /* "structures.h" defines the look-up tables and KeyExpansion function 
  2 |  * used in encrypt.cpp and decrypt.cpp
  3 |  */
  4 | #ifndef STRUCTURES_H
  5 | #define STRUCTURES_H
  6 | 
  7 | // Encryption: Forward Rijndael S-box 
  8 | unsigned char s[256] =
  9 | {
 10 | 	0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
 11 | 	0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
 12 | 	0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
 13 | 	0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
 14 | 	0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
 15 | 	0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
 16 | 	0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
 17 | 	0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
 18 | 	0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
 19 | 	0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
 20 | 	0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
 21 | 	0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
 22 | 	0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
 23 | 	0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
 24 | 	0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
 25 | 	0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
 26 | };
 27 | 
 28 | // Encryption: Multiply by 2 for MixColumns
 29 | unsigned char mul2[] =
 30 | {
 31 | 	0x00,0x02,0x04,0x06,0x08,0x0a,0x0c,0x0e,0x10,0x12,0x14,0x16,0x18,0x1a,0x1c,0x1e,
 32 | 	0x20,0x22,0x24,0x26,0x28,0x2a,0x2c,0x2e,0x30,0x32,0x34,0x36,0x38,0x3a,0x3c,0x3e,
 33 | 	0x40,0x42,0x44,0x46,0x48,0x4a,0x4c,0x4e,0x50,0x52,0x54,0x56,0x58,0x5a,0x5c,0x5e,
 34 | 	0x60,0x62,0x64,0x66,0x68,0x6a,0x6c,0x6e,0x70,0x72,0x74,0x76,0x78,0x7a,0x7c,0x7e,
 35 | 	0x80,0x82,0x84,0x86,0x88,0x8a,0x8c,0x8e,0x90,0x92,0x94,0x96,0x98,0x9a,0x9c,0x9e,
 36 | 	0xa0,0xa2,0xa4,0xa6,0xa8,0xaa,0xac,0xae,0xb0,0xb2,0xb4,0xb6,0xb8,0xba,0xbc,0xbe,
 37 | 	0xc0,0xc2,0xc4,0xc6,0xc8,0xca,0xcc,0xce,0xd0,0xd2,0xd4,0xd6,0xd8,0xda,0xdc,0xde,
 38 | 	0xe0,0xe2,0xe4,0xe6,0xe8,0xea,0xec,0xee,0xf0,0xf2,0xf4,0xf6,0xf8,0xfa,0xfc,0xfe,
 39 | 	0x1b,0x19,0x1f,0x1d,0x13,0x11,0x17,0x15,0x0b,0x09,0x0f,0x0d,0x03,0x01,0x07,0x05,
 40 | 	0x3b,0x39,0x3f,0x3d,0x33,0x31,0x37,0x35,0x2b,0x29,0x2f,0x2d,0x23,0x21,0x27,0x25,
 41 | 	0x5b,0x59,0x5f,0x5d,0x53,0x51,0x57,0x55,0x4b,0x49,0x4f,0x4d,0x43,0x41,0x47,0x45,
 42 | 	0x7b,0x79,0x7f,0x7d,0x73,0x71,0x77,0x75,0x6b,0x69,0x6f,0x6d,0x63,0x61,0x67,0x65,
 43 | 	0x9b,0x99,0x9f,0x9d,0x93,0x91,0x97,0x95,0x8b,0x89,0x8f,0x8d,0x83,0x81,0x87,0x85,
 44 | 	0xbb,0xb9,0xbf,0xbd,0xb3,0xb1,0xb7,0xb5,0xab,0xa9,0xaf,0xad,0xa3,0xa1,0xa7,0xa5,
 45 | 	0xdb,0xd9,0xdf,0xdd,0xd3,0xd1,0xd7,0xd5,0xcb,0xc9,0xcf,0xcd,0xc3,0xc1,0xc7,0xc5,
 46 | 	0xfb,0xf9,0xff,0xfd,0xf3,0xf1,0xf7,0xf5,0xeb,0xe9,0xef,0xed,0xe3,0xe1,0xe7,0xe5
 47 | };
 48 | 
 49 | // Encryption: Multiply by 3 for MixColumns
 50 | unsigned char mul3[] =
 51 | {
 52 | 	0x00,0x03,0x06,0x05,0x0c,0x0f,0x0a,0x09,0x18,0x1b,0x1e,0x1d,0x14,0x17,0x12,0x11,
 53 | 	0x30,0x33,0x36,0x35,0x3c,0x3f,0x3a,0x39,0x28,0x2b,0x2e,0x2d,0x24,0x27,0x22,0x21,
 54 | 	0x60,0x63,0x66,0x65,0x6c,0x6f,0x6a,0x69,0x78,0x7b,0x7e,0x7d,0x74,0x77,0x72,0x71,
 55 | 	0x50,0x53,0x56,0x55,0x5c,0x5f,0x5a,0x59,0x48,0x4b,0x4e,0x4d,0x44,0x47,0x42,0x41,
 56 | 	0xc0,0xc3,0xc6,0xc5,0xcc,0xcf,0xca,0xc9,0xd8,0xdb,0xde,0xdd,0xd4,0xd7,0xd2,0xd1,
 57 | 	0xf0,0xf3,0xf6,0xf5,0xfc,0xff,0xfa,0xf9,0xe8,0xeb,0xee,0xed,0xe4,0xe7,0xe2,0xe1,
 58 | 	0xa0,0xa3,0xa6,0xa5,0xac,0xaf,0xaa,0xa9,0xb8,0xbb,0xbe,0xbd,0xb4,0xb7,0xb2,0xb1,
 59 | 	0x90,0x93,0x96,0x95,0x9c,0x9f,0x9a,0x99,0x88,0x8b,0x8e,0x8d,0x84,0x87,0x82,0x81,
 60 | 	0x9b,0x98,0x9d,0x9e,0x97,0x94,0x91,0x92,0x83,0x80,0x85,0x86,0x8f,0x8c,0x89,0x8a,
 61 | 	0xab,0xa8,0xad,0xae,0xa7,0xa4,0xa1,0xa2,0xb3,0xb0,0xb5,0xb6,0xbf,0xbc,0xb9,0xba,
 62 | 	0xfb,0xf8,0xfd,0xfe,0xf7,0xf4,0xf1,0xf2,0xe3,0xe0,0xe5,0xe6,0xef,0xec,0xe9,0xea,
 63 | 	0xcb,0xc8,0xcd,0xce,0xc7,0xc4,0xc1,0xc2,0xd3,0xd0,0xd5,0xd6,0xdf,0xdc,0xd9,0xda,
 64 | 	0x5b,0x58,0x5d,0x5e,0x57,0x54,0x51,0x52,0x43,0x40,0x45,0x46,0x4f,0x4c,0x49,0x4a,
 65 | 	0x6b,0x68,0x6d,0x6e,0x67,0x64,0x61,0x62,0x73,0x70,0x75,0x76,0x7f,0x7c,0x79,0x7a,
 66 | 	0x3b,0x38,0x3d,0x3e,0x37,0x34,0x31,0x32,0x23,0x20,0x25,0x26,0x2f,0x2c,0x29,0x2a,
 67 | 	0x0b,0x08,0x0d,0x0e,0x07,0x04,0x01,0x02,0x13,0x10,0x15,0x16,0x1f,0x1c,0x19,0x1a
 68 | };
 69 | 
 70 | // Used in KeyExpansion
 71 | unsigned char rcon[256] = {
 72 | 	0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
 73 | 	0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,
 74 | 	0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
 75 | 	0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
 76 | 	0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
 77 | 	0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
 78 | 	0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
 79 | 	0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
 80 | 	0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
 81 | 	0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
 82 | 	0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
 83 | 	0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
 84 | 	0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
 85 | 	0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
 86 | 	0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
 87 | 	0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d
 88 | };
 89 | 
 90 | // Decryption: Inverse Rijndael S-box
 91 | unsigned char inv_s[256] =
 92 | {
 93 | 	0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
 94 | 	0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
 95 | 	0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
 96 | 	0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
 97 | 	0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
 98 | 	0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
 99 | 	0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
100 | 	0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
101 | 	0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
102 | 	0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
103 | 	0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
104 | 	0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
105 | 	0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
106 | 	0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
107 | 	0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
108 | 	0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
109 | };
110 | 
111 | // Decryption: Multiply by 9 for InverseMixColumns
112 | unsigned char mul9[256] =
113 | {
114 | 	0x00,0x09,0x12,0x1b,0x24,0x2d,0x36,0x3f,0x48,0x41,0x5a,0x53,0x6c,0x65,0x7e,0x77,
115 | 	0x90,0x99,0x82,0x8b,0xb4,0xbd,0xa6,0xaf,0xd8,0xd1,0xca,0xc3,0xfc,0xf5,0xee,0xe7,
116 | 	0x3b,0x32,0x29,0x20,0x1f,0x16,0x0d,0x04,0x73,0x7a,0x61,0x68,0x57,0x5e,0x45,0x4c,
117 | 	0xab,0xa2,0xb9,0xb0,0x8f,0x86,0x9d,0x94,0xe3,0xea,0xf1,0xf8,0xc7,0xce,0xd5,0xdc,
118 | 	0x76,0x7f,0x64,0x6d,0x52,0x5b,0x40,0x49,0x3e,0x37,0x2c,0x25,0x1a,0x13,0x08,0x01,
119 | 	0xe6,0xef,0xf4,0xfd,0xc2,0xcb,0xd0,0xd9,0xae,0xa7,0xbc,0xb5,0x8a,0x83,0x98,0x91,
120 | 	0x4d,0x44,0x5f,0x56,0x69,0x60,0x7b,0x72,0x05,0x0c,0x17,0x1e,0x21,0x28,0x33,0x3a,
121 | 	0xdd,0xd4,0xcf,0xc6,0xf9,0xf0,0xeb,0xe2,0x95,0x9c,0x87,0x8e,0xb1,0xb8,0xa3,0xaa,
122 | 	0xec,0xe5,0xfe,0xf7,0xc8,0xc1,0xda,0xd3,0xa4,0xad,0xb6,0xbf,0x80,0x89,0x92,0x9b,
123 | 	0x7c,0x75,0x6e,0x67,0x58,0x51,0x4a,0x43,0x34,0x3d,0x26,0x2f,0x10,0x19,0x02,0x0b,
124 | 	0xd7,0xde,0xc5,0xcc,0xf3,0xfa,0xe1,0xe8,0x9f,0x96,0x8d,0x84,0xbb,0xb2,0xa9,0xa0,
125 | 	0x47,0x4e,0x55,0x5c,0x63,0x6a,0x71,0x78,0x0f,0x06,0x1d,0x14,0x2b,0x22,0x39,0x30,
126 | 	0x9a,0x93,0x88,0x81,0xbe,0xb7,0xac,0xa5,0xd2,0xdb,0xc0,0xc9,0xf6,0xff,0xe4,0xed,
127 | 	0x0a,0x03,0x18,0x11,0x2e,0x27,0x3c,0x35,0x42,0x4b,0x50,0x59,0x66,0x6f,0x74,0x7d,
128 | 	0xa1,0xa8,0xb3,0xba,0x85,0x8c,0x97,0x9e,0xe9,0xe0,0xfb,0xf2,0xcd,0xc4,0xdf,0xd6,
129 | 	0x31,0x38,0x23,0x2a,0x15,0x1c,0x07,0x0e,0x79,0x70,0x6b,0x62,0x5d,0x54,0x4f,0x46
130 | };
131 | 
132 | // Decryption: Multiply by 11 for InverseMixColumns
133 | unsigned char mul11[256] =
134 | {
135 | 	0x00,0x0b,0x16,0x1d,0x2c,0x27,0x3a,0x31,0x58,0x53,0x4e,0x45,0x74,0x7f,0x62,0x69,
136 | 	0xb0,0xbb,0xa6,0xad,0x9c,0x97,0x8a,0x81,0xe8,0xe3,0xfe,0xf5,0xc4,0xcf,0xd2,0xd9,
137 | 	0x7b,0x70,0x6d,0x66,0x57,0x5c,0x41,0x4a,0x23,0x28,0x35,0x3e,0x0f,0x04,0x19,0x12,
138 | 	0xcb,0xc0,0xdd,0xd6,0xe7,0xec,0xf1,0xfa,0x93,0x98,0x85,0x8e,0xbf,0xb4,0xa9,0xa2,
139 | 	0xf6,0xfd,0xe0,0xeb,0xda,0xd1,0xcc,0xc7,0xae,0xa5,0xb8,0xb3,0x82,0x89,0x94,0x9f,
140 | 	0x46,0x4d,0x50,0x5b,0x6a,0x61,0x7c,0x77,0x1e,0x15,0x08,0x03,0x32,0x39,0x24,0x2f,
141 | 	0x8d,0x86,0x9b,0x90,0xa1,0xaa,0xb7,0xbc,0xd5,0xde,0xc3,0xc8,0xf9,0xf2,0xef,0xe4,
142 | 	0x3d,0x36,0x2b,0x20,0x11,0x1a,0x07,0x0c,0x65,0x6e,0x73,0x78,0x49,0x42,0x5f,0x54,
143 | 	0xf7,0xfc,0xe1,0xea,0xdb,0xd0,0xcd,0xc6,0xaf,0xa4,0xb9,0xb2,0x83,0x88,0x95,0x9e,
144 | 	0x47,0x4c,0x51,0x5a,0x6b,0x60,0x7d,0x76,0x1f,0x14,0x09,0x02,0x33,0x38,0x25,0x2e,
145 | 	0x8c,0x87,0x9a,0x91,0xa0,0xab,0xb6,0xbd,0xd4,0xdf,0xc2,0xc9,0xf8,0xf3,0xee,0xe5,
146 | 	0x3c,0x37,0x2a,0x21,0x10,0x1b,0x06,0x0d,0x64,0x6f,0x72,0x79,0x48,0x43,0x5e,0x55,
147 | 	0x01,0x0a,0x17,0x1c,0x2d,0x26,0x3b,0x30,0x59,0x52,0x4f,0x44,0x75,0x7e,0x63,0x68,
148 | 	0xb1,0xba,0xa7,0xac,0x9d,0x96,0x8b,0x80,0xe9,0xe2,0xff,0xf4,0xc5,0xce,0xd3,0xd8,
149 | 	0x7a,0x71,0x6c,0x67,0x56,0x5d,0x40,0x4b,0x22,0x29,0x34,0x3f,0x0e,0x05,0x18,0x13,
150 | 	0xca,0xc1,0xdc,0xd7,0xe6,0xed,0xf0,0xfb,0x92,0x99,0x84,0x8f,0xbe,0xb5,0xa8,0xa3
151 | };
152 | 
153 | // Decryption: Multiply by 13 for InverseMixColumns
154 | unsigned char mul13[256] =
155 | {
156 | 	0x00,0x0d,0x1a,0x17,0x34,0x39,0x2e,0x23,0x68,0x65,0x72,0x7f,0x5c,0x51,0x46,0x4b,
157 | 	0xd0,0xdd,0xca,0xc7,0xe4,0xe9,0xfe,0xf3,0xb8,0xb5,0xa2,0xaf,0x8c,0x81,0x96,0x9b,
158 | 	0xbb,0xb6,0xa1,0xac,0x8f,0x82,0x95,0x98,0xd3,0xde,0xc9,0xc4,0xe7,0xea,0xfd,0xf0,
159 | 	0x6b,0x66,0x71,0x7c,0x5f,0x52,0x45,0x48,0x03,0x0e,0x19,0x14,0x37,0x3a,0x2d,0x20,
160 | 	0x6d,0x60,0x77,0x7a,0x59,0x54,0x43,0x4e,0x05,0x08,0x1f,0x12,0x31,0x3c,0x2b,0x26,
161 | 	0xbd,0xb0,0xa7,0xaa,0x89,0x84,0x93,0x9e,0xd5,0xd8,0xcf,0xc2,0xe1,0xec,0xfb,0xf6,
162 | 	0xd6,0xdb,0xcc,0xc1,0xe2,0xef,0xf8,0xf5,0xbe,0xb3,0xa4,0xa9,0x8a,0x87,0x90,0x9d,
163 | 	0x06,0x0b,0x1c,0x11,0x32,0x3f,0x28,0x25,0x6e,0x63,0x74,0x79,0x5a,0x57,0x40,0x4d,
164 | 	0xda,0xd7,0xc0,0xcd,0xee,0xe3,0xf4,0xf9,0xb2,0xbf,0xa8,0xa5,0x86,0x8b,0x9c,0x91,
165 | 	0x0a,0x07,0x10,0x1d,0x3e,0x33,0x24,0x29,0x62,0x6f,0x78,0x75,0x56,0x5b,0x4c,0x41,
166 | 	0x61,0x6c,0x7b,0x76,0x55,0x58,0x4f,0x42,0x09,0x04,0x13,0x1e,0x3d,0x30,0x27,0x2a,
167 | 	0xb1,0xbc,0xab,0xa6,0x85,0x88,0x9f,0x92,0xd9,0xd4,0xc3,0xce,0xed,0xe0,0xf7,0xfa,
168 | 	0xb7,0xba,0xad,0xa0,0x83,0x8e,0x99,0x94,0xdf,0xd2,0xc5,0xc8,0xeb,0xe6,0xf1,0xfc,
169 | 	0x67,0x6a,0x7d,0x70,0x53,0x5e,0x49,0x44,0x0f,0x02,0x15,0x18,0x3b,0x36,0x21,0x2c,
170 | 	0x0c,0x01,0x16,0x1b,0x38,0x35,0x22,0x2f,0x64,0x69,0x7e,0x73,0x50,0x5d,0x4a,0x47,
171 | 	0xdc,0xd1,0xc6,0xcb,0xe8,0xe5,0xf2,0xff,0xb4,0xb9,0xae,0xa3,0x80,0x8d,0x9a,0x97
172 | };
173 | 
174 | // Decryption: Multiply by 14 for InverseMixColumns
175 | unsigned char mul14[256] =
176 | {
177 | 	0x00,0x0e,0x1c,0x12,0x38,0x36,0x24,0x2a,0x70,0x7e,0x6c,0x62,0x48,0x46,0x54,0x5a,
178 | 	0xe0,0xee,0xfc,0xf2,0xd8,0xd6,0xc4,0xca,0x90,0x9e,0x8c,0x82,0xa8,0xa6,0xb4,0xba,
179 | 	0xdb,0xd5,0xc7,0xc9,0xe3,0xed,0xff,0xf1,0xab,0xa5,0xb7,0xb9,0x93,0x9d,0x8f,0x81,
180 | 	0x3b,0x35,0x27,0x29,0x03,0x0d,0x1f,0x11,0x4b,0x45,0x57,0x59,0x73,0x7d,0x6f,0x61,
181 | 	0xad,0xa3,0xb1,0xbf,0x95,0x9b,0x89,0x87,0xdd,0xd3,0xc1,0xcf,0xe5,0xeb,0xf9,0xf7,
182 | 	0x4d,0x43,0x51,0x5f,0x75,0x7b,0x69,0x67,0x3d,0x33,0x21,0x2f,0x05,0x0b,0x19,0x17,
183 | 	0x76,0x78,0x6a,0x64,0x4e,0x40,0x52,0x5c,0x06,0x08,0x1a,0x14,0x3e,0x30,0x22,0x2c,
184 | 	0x96,0x98,0x8a,0x84,0xae,0xa0,0xb2,0xbc,0xe6,0xe8,0xfa,0xf4,0xde,0xd0,0xc2,0xcc,
185 | 	0x41,0x4f,0x5d,0x53,0x79,0x77,0x65,0x6b,0x31,0x3f,0x2d,0x23,0x09,0x07,0x15,0x1b,
186 | 	0xa1,0xaf,0xbd,0xb3,0x99,0x97,0x85,0x8b,0xd1,0xdf,0xcd,0xc3,0xe9,0xe7,0xf5,0xfb,
187 | 	0x9a,0x94,0x86,0x88,0xa2,0xac,0xbe,0xb0,0xea,0xe4,0xf6,0xf8,0xd2,0xdc,0xce,0xc0,
188 | 	0x7a,0x74,0x66,0x68,0x42,0x4c,0x5e,0x50,0x0a,0x04,0x16,0x18,0x32,0x3c,0x2e,0x20,
189 | 	0xec,0xe2,0xf0,0xfe,0xd4,0xda,0xc8,0xc6,0x9c,0x92,0x80,0x8e,0xa4,0xaa,0xb8,0xb6,
190 | 	0x0c,0x02,0x10,0x1e,0x34,0x3a,0x28,0x26,0x7c,0x72,0x60,0x6e,0x44,0x4a,0x58,0x56,
191 | 	0x37,0x39,0x2b,0x25,0x0f,0x01,0x13,0x1d,0x47,0x49,0x5b,0x55,0x7f,0x71,0x63,0x6d,
192 | 	0xd7,0xd9,0xcb,0xc5,0xef,0xe1,0xf3,0xfd,0xa7,0xa9,0xbb,0xb5,0x9f,0x91,0x83,0x8d
193 | };
194 | 
195 | // Auxiliary function for KeyExpansion
196 | void KeyExpansionCore(unsigned char * in, unsigned char i) {
197 | 	// Rotate left by one byte: shift left 
198 | 	unsigned char t = in[0];
199 | 	in[0] = in[1];
200 | 	in[1] = in[2];
201 | 	in[2] = in[3];
202 | 	in[3] = t;
203 | 
204 | 	// S-box 4 bytes 
205 | 	in[0] = s[in[0]];
206 | 	in[1] = s[in[1]];
207 | 	in[2] = s[in[2]];
208 | 	in[3] = s[in[3]];
209 | 
210 | 	// RCon
211 | 	in[0] ^= rcon[i];
212 | }
213 | 
214 | /* The main KeyExpansion function
215 |  * Generates additional keys using the original key
216 |  * Total of 11 128-bit keys generated, including the original
217 |  * Keys are stored one after the other in expandedKeys
218 |  */
219 | void KeyExpansion(unsigned char inputKey[16], unsigned char expandedKeys[176]) {
220 | 	// The first 128 bits are the original key
221 | 	for (int i = 0; i < 16; i++) {
222 | 		expandedKeys[i] = inputKey[i];
223 | 	}
224 | 
225 | 	int bytesGenerated = 16; // Bytes we've generated so far
226 | 	int rconIteration = 1; // Keeps track of rcon value
227 | 	unsigned char tmpCore[4]; // Temp storage for core
228 | 
229 | 	while (bytesGenerated < 176) {
230 | 		/* Read 4 bytes for the core
231 | 		* They are the previously generated 4 bytes
232 | 		* Initially, these will be the final 4 bytes of the original key
233 | 		*/
234 | 		for (int i = 0; i < 4; i++) {
235 | 			tmpCore[i] = expandedKeys[i + bytesGenerated - 4];
236 | 		}
237 | 
238 | 		// Perform the core once for each 16 byte key
239 | 		if (bytesGenerated % 16 == 0) {
240 | 			KeyExpansionCore(tmpCore, rconIteration++);
241 | 		}
242 | 
243 | 		for (unsigned char a = 0; a < 4; a++) {
244 | 			expandedKeys[bytesGenerated] = expandedKeys[bytesGenerated - 16] ^ tmpCore[a];
245 | 			bytesGenerated++;
246 | 		}
247 | 
248 | 	}
249 | }
250 | 
251 | #endif /* STRUCTURES_H */
252 | 


--------------------------------------------------------------------------------