From: Ira W. Snyder <devel@irasnyder.com>
Date: Fri, 19 Oct 2007 17:43:52 +0000 (-0700)
Subject: Initial commit
X-Git-Tag: unoptimized
X-Git-Url: https://www.irasnyder.com/gitweb/?a=commitdiff_plain;h=c22feadcd68a2702846bc5d9542f171b64d0ecd2;p=aes.git

Initial commit

Signed-off-by: Ira W. Snyder <devel@irasnyder.com>
---

c22feadcd68a2702846bc5d9542f171b64d0ecd2
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..7e77240
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,29 @@
+CC=g++
+CFLAGS=-march=athlon-xp -O2
+
+all: problem2 problem3
+
+aes_test: aes.o aes_test.o
+	$(CC) $(CFLAGS) -o $@ $^
+
+problem2: aes.o problem2.o
+	$(CC) $(CFLAGS) -o $@ $^
+
+problem3: aes.o problem3.o
+	$(CC) $(CFLAGS) -o $@ $^
+
+clean:
+	rm -f *.o aes_test problem2 problem3
+
+.cpp.o:
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+run: run_p2 run_p3
+
+run_p2: problem2
+	@cat Problem2.in | ./$<
+
+run_p3: problem3
+	@./$<
+
+.PHONY: run all clean
diff --git a/Problem2.in b/Problem2.in
new file mode 100644
index 0000000..5afe35d
--- /dev/null
+++ b/Problem2.in
@@ -0,0 +1,55 @@
+#PN*3kUAprThcbB]
+                                      .M
+                                 .:AMMO:
+                        .:AMMMMMHIIIHMMM.
+             ....   .AMMMMMMMMMMMHHHMHHMMMML:AMF"
+             .:MMMMMLAMMMMMMMHMMMMMMHHIHHIIIHMMMML.
+                 "WMMMMMMMMMMMMMMMMMMH:::::HMMMMMMHII:.
+            .AMMMMMMMHHHMMMMMMMMMMHHHHHMMMMMMMMMAMMMHHHHL.
+          .MMMMMMMMMMHHMMMMMMMMHHHHMMMMMMMMMMMMMHTWMHHHHHML
+         .MMMMMMMMMMMMMMMMMMMHHHHHHHHHMHMMHHHHIII:::HMHHHHMM.
+         .MMMMMMMMMMMMMMMMMMMMMMHHHHHHMHHHHHHIIIIIIIIHMHHHHHM.
+         MMMMMMMMMMMMMMMMMHHMMHHHHHIIIHHH::IIHHII:::::IHHHHHHHL
+         "MMMMMMMMMMMMMMMMHIIIHMMMMHHIIHHLI::IIHHHHIIIHHHHHHHHML
+         .MMMMMMMMMMMMMM"WMMMHHHMMMMMMMMMMMLHHHMMMMMMHHHHHHHHHHH
+        .MMMMMMMMMMMWWMW""YYHMMMMMMMMMMMMF""HMMMMMMMMMHHHHHHHH.
+        .MMMMMMMMMM W" V                         W"WMMMMMHHHHHHHHHH
+       "MMMMMMMMMM".                                 "WHHHMH"HHHHHHL
+       MMMMMMMMMMF  .                                         IHHHHH.
+       MMMMMMMMMM .                                  .        HHHHHHH
+       MMMMMMMMMF. .                               .  .       HHHHHHH.
+       MMMMMMMMM .     ,AWMMMMML.              ..    .  .     HHHHHHH.
+     :MMMMMMMMM".  .  F"'    'WM:.         ,::HMMA, .  .      HHHHMMM
+     :MMMMMMMMF.  . ."         WH..      AMM"'     "  .  .    HHHMMMM
+      MMMMMMMM . .     ,;AAAHHWL"..     .:'                   HHHHHHH
+      MMMMMMM:. . .   -MK"OTO L :I..    ...:HMA-.             "HHHHHH
+ ,:IIIILTMMMMI::.      L,,,,.  ::I..    .. K"OTO"ML           'HHHHHH
+ LHT::LIIIIMMI::. .      '""'.IHH:..    .. :.,,,,           '  HMMMH: HLI'
+ ILTT::"IIITMII::.  .         .IIII.     . '""""             ' MMMFT:::.
+ HML:::WMIINMHI:::.. .          .:I.     .   . .  .        '  .M"'.....I.
+ "HWHINWI:.'.HHII::..          .HHI     .II.    .  .      . . :M.',, ..I:
+  "MLI"ML': :HHII::...        MMHHL     :::::  . :..      .'.'.'HHTML.II:
+   "MMLIHHWL:IHHII::....:I:" :MHHWHI:...:W,,"  '':::.      ..'  ":.HH:II:
+     "MMMHITIIHHH:::::IWF"    """T99"'  '""    '.':II:..'.'..'  I'.HHIHI'
+       YMMHII:IHHHH:::IT..     . .   ...  . .    ''THHI::.'.' .;H.""."H"
+         HHII:MHHI"::IWWL     . .     .    .  .     HH"HHHIIHHH":HWWM"
+          """ MMHI::HY""ML,          ...     . ..  :"  :HIIIIIILTMH"
+               MMHI:.'    'HL,,,,,,,,..,,,......,:" . ''::HH "HWW
+               'MMH:..   . 'MMML,: """MM""""MMM"      .'.IH'"MH"
+                "MMHL..   .. "MMMMMML,MM,HMMMF    .   .IHM"
+                  "MMHHL    .. "MMMMMMMMMMMM"  . .  '.IHF'
+                    'MMMML    .. "MMMMMMMM"  .     .'HMF
+                     HHHMML.                    .'MMF"
+                    IHHHHHMML.               .'HMF"
+                    HHHHHHITMML.           .'IF..
+                    "HHHHHHIITML,.       ..:F...
+                     'HHHHHHHHHMMWWWWWW::"......
+                       HHHHHHHMMMMMMF"'........
+                        HHHHHHHHHH............
+                          HHHHHHHH...........
+                           HHHHIII..........
+                            HHIII..........
+                             HII.........
+                              "H........
+                                ......
+
diff --git a/Problem3.out b/Problem3.out
new file mode 100644
index 0000000..276f784
Binary files /dev/null and b/Problem3.out differ
diff --git a/aes.cpp b/aes.cpp
new file mode 100644
index 0000000..1aa92c4
--- /dev/null
+++ b/aes.cpp
@@ -0,0 +1,523 @@
+#include "aes.hpp"
+
+/* static function prototypes */
+static byteArray word2bytes (word input);
+static word bytes2word (byte b0, byte b1, byte b2, byte b3);
+static void circular_left_shift (byteArray &bytes, int shift_amt);
+static void circular_right_shift (byteArray &bytes, int shift_amt);
+static byte mult (const byte ax, const byte bx);
+static byte xtimes (const byte bx);
+static void printState (byteArray &bytes, std::string name);
+
+AES::AES (const byteArray& key)
+	: Nb(4)					// This is constant in AES
+	, Nk(key.size() / 4)	// This can be either 4, 6, or 8 (128, 192, or 256 bit)
+	, Nr(Nk + Nb + 2)
+	, keySchedule(Nb * (Nr+1), 0x00000000)
+{
+	// Check the arguments
+	if (!(Nk == 4 || Nk == 6 || Nk == 8))
+		throw incorrectKeySizeException();
+
+	// Generate the Key Schedule
+	KeyExpansion (key, keySchedule);
+
+#if 0
+	std::printf ("Key Schedule\n");
+	for (int i=0; i<keySchedule.size()/4; ++i)
+	{
+		for (int j=0; j<4; ++j)
+		{
+			byteArray temp = word2bytes (keySchedule.at(i*4+j));
+			std::printf ("%.2x %.2x %.2x %.2x ", temp[0], temp[1], temp[2], temp[3]);
+		}
+		std::printf ("\n");
+	}
+#endif
+}
+
+byteArray AES::encrypt (const byteArray& plaintext) const
+{
+	// Make sure that the plaintext size is a multiple of 16
+	if (plaintext.size() != 16)
+		throw incorrectTextSizeException ();
+
+	int round;
+	byteArray state (plaintext);
+
+	/* Round 0 */
+	//std::printf ("Round 0\n");
+	//printState (state, "input");
+	AddRoundKey (state, GetRoundKey (0));
+
+	/* Round 1 to Nr-1 */
+	for (round=1; round<Nr; ++round)
+	{
+		//std::printf ("Round %d\n", round);
+		//printState (state, "start");
+		SubBytes (state);
+		//printState (state, "sbyte");
+		ShiftRows (state);
+		//printState (state, "srows");
+		MixColumns (state);
+		//printState (state, "mcols");
+		AddRoundKey (state, GetRoundKey (round));
+	}
+
+	/* Round Nr */
+	//std::printf ("Round %d\n", round);
+	//printState (state, "start");
+	SubBytes (state);
+	//printState (state, "sbyte");
+	ShiftRows (state);
+	//printState (state, "srows");
+	AddRoundKey (state, GetRoundKey (round));
+
+	return state;
+}
+
+byteArray AES::decrypt (const byteArray& ciphertext) const
+{
+	// Make sure that the plaintext size is a multiple of 16
+	if (ciphertext.size() != 16)
+		throw incorrectTextSizeException ();
+
+	int round = Nr;
+	byteArray state (ciphertext);
+
+	/* Round Nr-1 */
+	AddRoundKey (state, GetRoundKey (round));
+
+	/* Round Nr-2 to 1 */
+	for (round=Nr-1; round>0; --round)
+	{
+		InvShiftRows (state);
+		InvSubBytes (state);
+		AddRoundKey (state, GetRoundKey (round));
+		InvMixColumns (state);
+	}
+
+	/* Round 0 */
+	InvShiftRows (state);
+	InvSubBytes (state);
+	AddRoundKey (state, GetRoundKey (round));
+
+	return state;
+}
+
+void AES::KeyExpansion (const byteArray& key, wordArray& w) const
+{
+	const static word Rcon[] = {
+			0x00000000,
+			0x01000000,
+			0x02000000,
+			0x04000000,
+			0x08000000,
+			0x10000000,
+			0x20000000,
+			0x40000000,
+			0x80000000,
+			0x1b000000,
+			0x36000000,
+	};
+
+
+	int i;
+	word temp;
+
+	/* Copy the key bits into the beginning of the word array */
+	for (i=0; i<Nk; ++i)
+		w[i] = bytes2word (key[i*4+0], key[i*4+1], key[i*4+2], key[i*4+3]);
+
+	for (i=Nk; i < (Nb * (Nr+1)); ++i)
+	{
+		temp = w[i-1]; // copy the previous word into temp
+
+		if (i % Nk == 0)
+			temp = SubWord (RotWord (temp)) ^ Rcon[i/Nk];
+		else if (Nk > 6 && i % Nk == 4)
+			temp = SubWord (temp);
+
+		w[i] = w[i-Nk] ^ temp;
+	}
+}
+
+void AES::SubBytes (byteArray &state) const
+{
+	int i;
+	static const byte sbox[] = {
+			/* 0     1     2     3     4     5     6     7     8     9     A     B     C     D     E     F */
+			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,
+	};
+
+	for (i=0; i<state.size(); ++i)
+		state[i] = sbox[state[i]];
+}
+
+void AES::InvSubBytes (byteArray& state) const
+{
+	if (state.size() != Nb * 4)
+		throw badStateArrayException ();
+
+	int i;
+	static const byte inv_sbox[] = {
+			/* 0     1     2     3     4     5     6     7     8     9     A     B     C     D     E     F */
+			0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
+			0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
+			0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
+			0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
+			0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
+			0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
+			0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
+			0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
+			0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
+			0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
+			0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
+			0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
+			0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
+			0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
+			0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
+			0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d,
+	};
+
+	for (i=0; i<state.size(); ++i)
+		state[i] = inv_sbox[state[i]];
+}
+
+
+void AES::ShiftRows (byteArray& state) const
+{
+	if (state.size() != Nb * 4)
+		throw badStateArrayException ();
+
+	int r, c;
+	byteArray temp (Nb, 0);
+
+	for (r=0; r<state.size()/4; ++r)
+	{
+		// Copy into temp
+		for (c=0; c<Nb; ++c)
+			temp.at(c) = state.at ((c*state.size()/4)+r);
+
+#if 0
+		std::printf ("before cls(%d)=", r);
+		for (c=0; c<Nb; ++c)
+			std::printf ("%.2x", temp.at(c));
+		std::printf (" -- ");
+#endif
+
+		// CLS 0, 1, 2, 3
+		circular_left_shift (temp, r);
+
+#if 0
+		std::printf ("after cls(%d)=", r);
+		for (c=0; c<Nb; ++c)
+			std::printf ("%.2x", temp.at(c));
+		std::printf ("\n");
+#endif
+
+		// Copy back to state matrix
+		for (c=0; c<Nb; ++c)
+			state.at((c*state.size()/4)+r) = temp.at(c);
+	}
+}
+
+void AES::InvShiftRows (byteArray& state) const
+{
+	if (state.size() != Nb * 4)
+		throw badStateArrayException ();
+
+	int r, c;
+	byteArray temp (Nb, 0);
+
+	for (r=0; r<4; ++r)
+	{
+		// Copy into temp
+		for (c=0; c<temp.size(); ++c)
+			temp[c] = state[(c*4)+r];
+
+		// CRS 0, 1, 2, 3
+		circular_right_shift (temp, r);
+
+		// Copy back to state matrix
+		for (c=0; c<temp.size(); ++c)
+			state.at((c*4)+r) = temp.at(c);
+	}
+}
+
+void AES::MixColumns (byteArray& state) const
+{
+	if (state.size() != Nb * 4)
+		throw badStateArrayException ();
+
+	const static byte transform[] = {
+			0x02, 0x03, 0x01, 0x01,
+			0x01, 0x02, 0x03, 0x01,
+			0x01, 0x01, 0x02, 0x03,
+			0x03, 0x01, 0x01, 0x02,
+	};
+
+	int r, c, i, j;
+	byteArray temp (Nb, 0);
+	byteArray result (Nb, 0);
+	byte total;
+
+	for (r=0; r<4; ++r)
+	{
+		/* Get this column */
+		for (c=0; c<Nb; ++c)
+			temp[c] = state[(r*4)+c];
+
+		/* Do the Multiply */
+		for (i=0; i<4; ++i)
+		{
+			result[i] = 0x00;
+
+			for (j=0; j<4; ++j)
+				result[i] = result[i] ^ mult (transform[i*4+j], temp[j]);
+		}
+
+		/* Copy back into state matrix */
+		for (c=0; c<Nb; ++c)
+			state[(r*4)+c] = result[c];
+	}
+}
+
+void AES::InvMixColumns (byteArray& state) const
+{
+	if (state.size() != Nb * 4)
+		throw badStateArrayException ();
+
+	const static byte transform_inv[] = {
+			0x0e, 0x0b, 0x0d, 0x09,
+			0x09, 0x0e, 0x0b, 0x0d,
+			0x0d, 0x09, 0x0e, 0x0b,
+			0x0b, 0x0d, 0x09, 0x0e,
+	};
+
+	int r, c, i, j;
+	byteArray temp (Nb, 0);
+	byteArray result (Nb, 0);
+	byte total;
+
+	for (r=0; r<4; ++r)
+	{
+		/* Get this column */
+		for (c=0; c<Nb; ++c)
+			temp[c] = state[(r*4)+c];
+
+		/* Do the Multiply */
+		for (i=0; i<4; ++i)
+		{
+			result[i] = 0x00;
+
+			for (j=0; j<4; ++j)
+				result[i] ^= mult (transform_inv[(i*4)+j], temp[j]);
+		}
+
+		/* Copy back into state matrix */
+		for (c=0; c<Nb; ++c)
+			state[(r*4)+c] = result[c];
+	}
+}
+
+word AES::SubWord (const word& input) const
+{
+	byteArray bInput = word2bytes (input);
+
+	SubBytes (bInput);
+
+	return bytes2word (bInput[0], bInput[1], bInput[2], bInput[3]);
+}
+
+word AES::RotWord (const word& input) const
+{
+	byteArray bInput = word2bytes (input);
+
+	circular_left_shift (bInput, 1);
+
+	return bytes2word (bInput[0], bInput[1], bInput[2], bInput[3]);
+}
+
+wordArray AES::GetRoundKey (const int round) const
+{
+	wordArray temp (4, 0);
+
+	temp[0] = keySchedule.at (round*Nb + 0);
+	temp[1] = keySchedule.at (round*Nb + 1);
+	temp[2] = keySchedule.at (round*Nb + 2);
+	temp[3] = keySchedule.at (round*Nb + 3);
+
+#if 0
+	std::printf ("ksch%d   ", round);
+	for (int i=0; i<4; ++i)
+	{
+		byteArray btemp = word2bytes (temp[i]);
+		std::printf ("%.2x%.2x%.2x%.2x", btemp[0], btemp[1], btemp[2], btemp[3]);
+	}
+	std::printf ("\n");
+#endif
+
+	return temp;
+}
+
+void AES::AddRoundKey (byteArray& state, const wordArray& w) const
+{
+	int i, j;
+
+	for (i=0; i<w.size(); ++i)
+	{
+		byteArray wBytes = word2bytes (w[i]);
+
+		for (j=0; j<Nb; ++j)
+		{
+			//std::printf ("state.at(%d) ^= wBytes.at(%d) -- %.2x ^ %.2x = %.2x\n", i*Nb+j, j, state.at (i*Nb+j), wBytes.at(j), state.at(i*Nb+j) ^ wBytes.at(j));
+			state.at(i*Nb+j) ^= wBytes.at(j);
+		}
+	}
+}
+
+/******************************************************************************
+ *                              STATIC FUNCTIONS                              *
+ ******************************************************************************/
+
+static word bytes2word (const byte b0, const byte b1, const byte b2, const byte b3)
+{
+	word output;
+	output = (0x00000000)  | b0;
+	output = (output << 8) | b1;
+	output = (output << 8) | b2;
+	output = (output << 8) | b3;
+
+	return output;
+}
+
+static byteArray word2bytes (const word input)
+{
+	byteArray output (4, 0x00);
+	output[0] = (input & 0xff000000) >> 24;
+	output[1] = (input & 0x00ff0000) >> 16;
+	output[2] = (input & 0x0000ff00) >> 8;
+	output[3] = (input & 0x000000ff) >> 0;
+
+	return output;
+}
+
+static int ring_mod (const int number, const int mod_amt)
+{
+	int temp = number;
+
+	while (temp < 0)
+		temp += mod_amt;
+
+	return temp;
+}
+
+/* ROL all of the bytes in @bytes by @shift_amt */
+static void circular_left_shift (byteArray &bytes, int shift_amt)
+{
+	int i;
+	byteArray temp (bytes.size(), 0);
+
+#if 0
+	std::printf ("BEFORE CLS(%d): ", shift_amt);
+	for (i=0; i<bytes.size(); ++i)
+		std::printf ("%.2x", bytes[i]);
+	std::printf ("\n");
+#endif
+
+	for (i=0; i<temp.size(); ++i)
+	{
+		int tindex = i;
+		int bindex = (i+shift_amt) % bytes.size();
+		//std::printf ("temp[%d] = bytes[%d] = %.2x\n", tindex, bindex, bytes[bindex]);
+		temp[i] = bytes[(i+shift_amt) % bytes.size()];
+	}
+
+#if 0
+	std::printf ("AFTER CLS(%d): ", shift_amt);
+	for (i=0; i<temp.size(); ++i)
+		std::printf ("%.2x", temp[i]);
+	std::printf ("\n");
+#endif
+
+	for (i=0; i<bytes.size(); ++i)
+		bytes.at(i) = temp.at(i);
+}
+
+/* ROR all of the bytes in @bytes by @shift_amt */
+static void circular_right_shift (byteArray &bytes, int shift_amt)
+{
+	int i;
+	byteArray temp (bytes.size(), 0);
+
+	for (i=0; i<temp.size(); ++i)
+		temp[i] = bytes[ring_mod (i-shift_amt, bytes.size())];
+
+	for (i=0; i<bytes.size(); ++i)
+		bytes[i] = temp[i];
+}
+
+static byte xtimes (const byte bx)
+{
+	const byte mx = 0x1b; /* x^8 + x^4 + x^3 + x + 1 */
+
+	/* See Notes Pg 36. This is if b7 == 1 */
+	if (bx & 0x80)
+		return (bx << 1) ^ mx;
+
+	/* This is if b7 == 0 */
+	return (bx << 1);
+}
+
+static byte mult (const byte ax, const byte bx)
+{
+	int i;
+	byte xibx = bx;
+	byte ai;
+	byte total = 0x00;
+
+	for (i=0; i<8; ++i)
+	{
+		/* Find a0 through a7 */
+		ai = ax & (1 << i);
+
+		/* If ai is not zero, add it into the total */
+		if (ai)
+			total ^= xibx;
+
+		/* Update x^i * b(x) */
+		xibx = xtimes (xibx);
+	}
+
+	return total;
+}
+
+static void printState (byteArray &bytes, std::string name)
+{
+	int i;
+
+	std::cout << name << ":  ";
+	for (i=0; i<16; ++i)
+		std::printf ("%.2x", bytes.at(i));
+
+	std::printf ("\n");
+}
+
+
+/* vim: set ts=4 sts=4 sw=4 noet tw=112 nowrap: */
diff --git a/aes.hpp b/aes.hpp
new file mode 100644
index 0000000..43808d4
--- /dev/null
+++ b/aes.hpp
@@ -0,0 +1,56 @@
+#ifndef AES_HPP
+#define AES_HPP
+
+#include <vector>
+#include <cstdio>
+#include <string>
+#include <iostream>
+using namespace std;
+
+// Byte and Byte Array types
+typedef unsigned char byte;
+typedef std::vector<byte> byteArray;
+
+// Word and Word Array types
+typedef unsigned int word;
+typedef std::vector<word> wordArray;
+
+// Exceptions
+class incorrectKeySizeException { };
+class incorrectTextSizeException { };
+class badStateArrayException { };
+
+class AES
+{
+	public:
+		AES (const byteArray& key);
+
+		byteArray encrypt (const byteArray& plaintext) const;
+		byteArray decrypt (const byteArray& ciphertext) const;
+
+	private:
+		unsigned int Nb;
+		unsigned int Nk;
+		unsigned int Nr;
+
+		wordArray keySchedule;
+
+		void KeyExpansion (const byteArray& key, wordArray& w) const;
+		word SubWord (const word& input) const;
+		word RotWord (const word& input) const;
+		wordArray GetRoundKey (const int round) const;
+
+		void SubBytes (byteArray& state) const;
+		void ShiftRows (byteArray& state) const;
+		void MixColumns (byteArray& state) const;
+		void AddRoundKey (byteArray& state, const wordArray& w) const;
+
+		void InvSubBytes (byteArray& state) const;
+		void InvShiftRows (byteArray& state) const;
+		void InvMixColumns (byteArray& state) const;
+
+};
+
+#endif /* AES_HPP */
+
+/* vim: set ts=4 sts=4 sw=4 noet tw=112: */
diff --git a/aes_test.cpp b/aes_test.cpp
new file mode 100644
index 0000000..c3a0543
--- /dev/null
+++ b/aes_test.cpp
@@ -0,0 +1,146 @@
+#include "aes.hpp"
+#include <iostream>
+#include <fstream>
+
+static void print_by_16s (const byteArray b, std::string name)
+{
+	int i, j;
+
+	std::cout << "Printing: " << name << "\n" << std::endl;
+
+	for (i=0; i<b.size()/16; ++i)
+	{
+		for (j=0; j<16; ++j)
+			std::printf ("%.2x ", b.at(i*16+j));
+
+		std::printf ("\n");
+	}
+}
+
+
+int main (int argc, char *argv[])
+{
+
+//#define DEBUG 1
+//#define MY_TEST2 1
+//#define PROBLEM2 1
+//#define PROBLEM3 1
+
+#if PROBLEM2
+	int i;
+
+	/* Read the Key */
+	byteArray key;
+
+	for (i=0; i<16; ++i)
+		key.push_back (getchar());
+
+	/* Create the AES object */
+	AES aes (key);
+
+	/* Read all characters of input */
+	byteArray input;
+
+	for (char c=getchar(); c != EOF; c=getchar())
+	{
+		input.push_back (c);
+
+		if (input.size() == 16)
+		{
+			byteArray ciphertext = aes.encrypt (input);
+			byteArray plaintext  = aes.decrypt (ciphertext);
+
+			/* Print it */
+			for (i=0; i<plaintext.size(); ++i)
+				std::printf ("%c", plaintext.at(i));
+
+			input.clear();
+		}
+
+	}
+#endif // PROBLEM2
+
+#if PROBLEM3
+	std::ifstream fin ("Problem3.out", ios::binary);
+	int i;
+
+	byteArray key;
+
+	for (i=0; i<24; ++i)
+		key.push_back (fin.get());
+
+	/* Create the AES Object */
+	AES aes (key);
+
+	byteArray input;
+
+	/* Read the input and decrypt */
+	for (char c=fin.get(); !fin.eof(); c=fin.get())
+	{
+		input.push_back (c);
+
+		if (input.size() == 16)
+		{
+			byteArray plaintext = aes.decrypt (input);
+
+			/* Print it */
+			for (i=0; i<plaintext.size(); ++i)
+				std::printf ("%c", plaintext.at(i));
+
+		input.clear();
+		}
+	}
+#endif //PROBLEM3
+
+#if MY_TEST
+	const int inputSize = 4096;
+
+	byteArray key (16, 2);
+	byteArray input (inputSize, 0);
+	int i, j;
+
+	for (i=0; i<inputSize; ++i)
+		input.at (i) = i;
+
+	AES aes (key);
+
+	print_by_16s (input, "Input");
+
+	byteArray ciphertext = aes.encrypt (input);
+
+	print_by_16s (ciphertext, "Ciphertext");
+
+	byteArray plaintext  = aes.decrypt (ciphertext);
+
+	print_by_16s (plaintext, "Plaintext");
+#endif
+
+#if MY_TEST2
+	int i;
+
+	byteArray key (16, 0);
+
+	for (i=0; i<16; ++i)
+		key.at (i) = i;
+
+	print_by_16s (key, "Key");
+
+	byteArray plaintext (16, 0);
+
+	for (i=0; i<16; ++i)
+		plaintext.at (i) = (i << 4) | i;
+
+	print_by_16s (plaintext, "Plaintext");
+
+	AES aes (key);
+
+	byteArray ciphertext = aes.encrypt (plaintext);
+
+	print_by_16s (ciphertext, "Ciphertext");
+#endif // MY_TEST2
+
+	return 0;
+
+}
+
+/* vim: set ts=4 sts=4 sw=4 noet tw=120 nowrap: */
diff --git a/problem2.cpp b/problem2.cpp
new file mode 100644
index 0000000..83b53c2
--- /dev/null
+++ b/problem2.cpp
@@ -0,0 +1,41 @@
+#include "aes.hpp"
+#include <cstdio>
+
+int main (int argc, char *argv[])
+{
+	int i;
+
+	/* Read the Key */
+	byteArray key;
+
+	for (i=0; i<16; ++i)
+		key.push_back (getchar());
+
+	/* Create the AES object */
+	AES aes (key);
+
+	/* Read all characters of input */
+	byteArray input;
+
+	for (char c=getchar(); c != EOF; c=getchar())
+	{
+		input.push_back (c);
+
+		if (input.size() == 16)
+		{
+			byteArray ciphertext = aes.encrypt (input);
+			byteArray plaintext  = aes.decrypt (ciphertext);
+
+			/* Print it */
+			for (i=0; i<plaintext.size(); ++i)
+				std::printf ("%c", plaintext.at(i));
+
+			input.clear();
+		}
+
+	}
+
+	return 0;
+}
+
+/* vim: set ts=4 sts=4 sw=4 noet tw=120 nowrap: */
diff --git a/problem3.cpp b/problem3.cpp
new file mode 100644
index 0000000..df343bd
--- /dev/null
+++ b/problem3.cpp
@@ -0,0 +1,40 @@
+#include "aes.hpp"
+#include <fstream>
+#include <cstdio>
+
+int main (int argc, char *argv[])
+{
+	std::ifstream fin ("Problem3.out", ios::binary);
+	int i;
+
+	byteArray key;
+
+	for (i=0; i<24; ++i)
+		key.push_back (fin.get());
+
+	/* Create the AES Object */
+	AES aes (key);
+
+	byteArray input;
+
+	/* Read the input and decrypt */
+	for (char c=fin.get(); !fin.eof(); c=fin.get())
+	{
+		input.push_back (c);
+
+		if (input.size() == 16)
+		{
+			byteArray plaintext = aes.decrypt (input);
+
+			/* Print it */
+			for (i=0; i<plaintext.size(); ++i)
+				std::printf ("%c", plaintext.at(i));
+
+		input.clear();
+		}
+	}
+
+	return 0;
+}
+
+/* vim: set ts=4 sts=4 sw=4 noet tw=120 nowrap: */