How to Approach and Solve AES Implementation Assignments in C

Understanding the Core Requirements of AES Assignments

AES-128 assignments usually include several well-defined requirements. Before starting to code, it is essential to fully understand what you are expected to deliver.

Breaking Down the Problem Statement

The first step in solving such assignments is to carefully read the instructions.

Most AES assignments, like the one we are considering, ask you to:

• Implement two main functions, aes_encrypt_block() and aes_decrypt_block().
• Accept 16-byte plaintext/ciphertext blocks and a 16-byte key as inputs.
• Return dynamically allocated blocks as outputs.
• Avoid third-party AES libraries or CPU AES instructions—implement everything manually.

This breakdown gives you clarity on what your program should look like in the end. Students often rush into coding without digesting these requirements, which leads to mistakes like incorrect block sizes, improper memory allocation, or missing deallocation logic.

Mapping Requirements to C Programming Concepts

Each requirement can be mapped to specific C programming knowledge:

• Pointer usage: Understanding how to manipulate arrays of bytes via pointers.
• Memory management: Using malloc() and free() correctly for heap allocation.
• Data structures: Representing a 4x4 byte matrix (AES state) in row-major or column-major order.
• Functions: Writing modular helper functions (e.g., sub_bytes(), shift_rows(), mix_columns()).

Once you map requirements to skills, the assignment becomes less intimidating and more structured.

Identifying Deliverables Beyond Code

Most modern assignments also require unit testing and CI setup.

This means your deliverables are not limited to working C code—you also need:

• A GitHub repository with a clean project structure.
• A Makefile for compilation.
• GitHub Actions workflow to automatically test on every commit.
• Clear and readable comments/documentation.

Understanding these deliverables early ensures you don’t waste time scrambling to meet grading criteria at the last minute.

Step-by-Step Approach to Implementing AES in C

Now that we know what needs to be done, let’s explore a structured plan of action for implementing AES in C.

Implementing the Core AES Transformations

AES encryption involves four key transformations applied in multiple rounds:

1. SubBytes: Replace each byte with its corresponding value from the S-box.
2. ShiftRows: Cyclically shift the rows of the state matrix.
3. MixColumns: Multiply each column of the state matrix by a fixed polynomial.
4. AddRoundKey: XOR the state with the round key.

To tackle these steps:

• Implement each transformation as a separate C function.
• Use a test-driven approach: write small test cases for each transformation before moving to the next.
• For example, test that SubBytes correctly replaces bytes for a known input.

This modular method prevents overwhelming complexity and allows you to debug issues in isolation.

Handling Key Expansion

AES-128 uses a key expansion algorithm to derive 11 round keys from the original 128-bit key. A common mistake students make is trying to calculate round keys on the fly.

Instead, it is far easier to:

• Write an expand_key() function.
• Store all round keys in a 176-byte array (11 × 16 bytes).
• Access the correct round key using offsets (&round_keys[i*16]).

This makes both encryption and decryption loops cleaner and less error-prone.

Assembling the Rounds

Once you have the transformations and round keys, the next step is to write the “glue code” that assembles everything into 10 rounds of AES encryption:

• Round 0: AddRoundKey.
• Rounds 1–9: SubBytes → ShiftRows → MixColumns → AddRoundKey.
• Round 10: SubBytes → ShiftRows → AddRoundKey (no MixColumns).

For decryption, implement the inverse transformations: InvSubBytes, InvShiftRows, InvMixColumns, and apply them in reverse order.

This stage is where integration testing becomes important—you’ll need to confirm that encryption and decryption are exact inverses of each other.

Building and Testing the AES Library

Once your AES functions are in place, the assignment requires you to build them into a usable C library and verify correctness.

Writing Unit Tests

Unit testing is crucial in cryptographic assignments.

A recommended approach is:

1. Write tests for each transformation (sub_bytes, shift_rows, etc.).
2. Compare outputs against a known good implementation (Python AES, OpenSSL reference, etc.).
3. Generate random plaintexts and keys, encrypt them with both your implementation and the reference, and compare results.

This prevents “silent failures,” where your code compiles but produces incorrect ciphertext.

Using Python for Validation

Many assignments encourage the use of Python’s ctypes to load the compiled C library (rijndael.so) and test it.

This allows you to:

• Reuse the existing Python AES implementation as a ground truth.
• Automate the testing process by writing Python scripts.
• Quickly run multiple randomized tests without rewriting everything in C.

Example workflow:

import ctypes, os # Load the shared library rijndael = ctypes.CDLL('./rijndael.so') # Create test buffers plaintext = (ctypes.c_ubyte * 16)(*range(16)) key = (ctypes.c_ubyte * 16)(*range(16)) # Call C function ciphertext = rijndael.aes_encrypt_block(plaintext, key) # Compare with Python AES implementation...

This approach ensures correctness and demonstrates professional testing practices.

Managing the Assignment as a Software Project

Assignments like these are not just programming challenges—they are also software engineering exercises. Treating them as a full project improves both grades and learning outcomes.

Version Control with GitHub

Instead of coding everything locally and uploading at the last minute, students should:

• Create a GitHub repository.
• Push changes frequently.
• Use meaningful commit messages (e.g., “Implemented SubBytes step” instead of “Update code”).
• Keep code modular and avoid dumping everything into a single .c file.

This mirrors real-world practices and is often part of grading rubrics.

Setting Up Continuous Integration (CI)

Most AES assignments require CI with GitHub Actions.

A simple .github/workflows/build.yml file can:

• Compile your C code with make.
• Run your unit tests automatically on every commit.
• Prevent broken code from being pushed unnoticed.

Students often underestimate how much these practices impress instructors—it shows maturity as a programmer.

Practical Tips and Common Mistakes

Assignments involving cryptography and C can be tricky. Here are some practical tips to avoid common pitfalls.

Debugging in Small Steps

Never attempt to write the entire AES at once. Debug each transformation independently before combining them. Use printf() statements or debuggers like GDB/VSCode Debugger to inspect intermediate states.

Memory Management Issues

Since functions return heap-allocated memory, always ensure you free() what you allocate. Memory leaks may not break your program immediately but will be penalized during evaluation.

Code Readability

Instructors look for well-commented code. Explain why each step exists, not just what it does. For example, when writing mix_columns(), add a comment about Galois field multiplication.

Final Thoughts: Turning an Assignment into a Learning Experience

AES assignments are not designed to test your ability to memorize cryptographic details—they are about learning how to:

• Break a complex problem into smaller, testable modules.
• Use version control and CI pipelines like a professional developer.
• Understand memory management and modularity in C.
• Apply test-driven development using both C and Python.

By treating the assignment as a complete mini software project, you not only secure good grades but also develop skills that employers value in real-world programming.