AES Encryption (Simplified) - Problem

Implement a simplified version of the AES (Advanced Encryption Standard) encryption algorithm. Your implementation should include the four main transformation steps:

1. SubBytes: Replace each byte in the state matrix using a substitution box (S-box)

2. ShiftRows: Cyclically shift the rows of the state matrix left

3. MixColumns: Mix the data within each column of the state matrix

4. AddRoundKey: XOR the state matrix with a round key

Given a 4x4 state matrix and a 4x4 round key, perform one round of AES encryption and return the resulting encrypted state matrix.

Note: This is a simplified educational version focusing on the core transformations. Use the provided S-box values for SubBytes transformation.

Input & Output

Example 1 — Basic AES Round

$ Input: state = [[50,67,246,168],[136,90,48,141],[49,49,152,162],[224,34,76,90]], roundKey = [[43,126,21,22],[40,174,210,166],[171,247,21,136],[9,207,79,60]]

› Output: [[124,119,123,242],[107,111,197,48],[168,71,27,20],[138,10,91,109]]

💡 Note: Apply SubBytes using S-box, shift rows left by 0,1,2,3 positions, mix columns using matrix multiplication, and XOR with round key to get final encrypted state.

Example 2 — Different Input Values

$ Input: state = [[25,160,154,233],[61,244,198,248],[227,226,141,148],[190,4,86,155]], roundKey = [[162,217,206,182],[113,175,102,207],[208,227,175,230],[16,106,38,235]]

› Output: [[46,251,108,142],[242,58,47,15],[209,165,78,134],[93,168,140,212]]

💡 Note: Each byte gets substituted via S-box, rows cyclically shift, columns mix through Galois field operations, and final XOR with key produces encrypted result.

Example 3 — Edge Case with Zero Values

$ Input: state = [[0,0,0,0],[1,1,1,1],[255,255,255,255],[128,128,128,128]], roundKey = [[0,0,0,0],[255,255,255,255],[1,1,1,1],[128,128,128,128]]

› Output: [[99,124,119,123],[109,80,232,78],[98,251,108,142],[93,168,140,212]]

💡 Note: Edge case showing behavior with boundary values (0, 1, 255, 128). S-box transforms 0→99, row shifts apply, mix columns processes each value, and AddRoundKey completes encryption.

Constraints

4x4 state matrix with values 0 ≤ state[i][j] ≤ 255
4x4 round key matrix with values 0 ≤ roundKey[i][j] ≤ 255
All values represent bytes (0-255 range)
Fixed S-box values as per AES specification

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 I IBM 18 GS Goldman Sachs 8

The key insight is understanding that AES encryption applies four distinct transformations sequentially: SubBytes for confusion, ShiftRows and MixColumns for diffusion, and AddRoundKey for key incorporation. Best approach is the optimized in-place implementation. Time: O(1), Space: O(1)

Common Approaches

✓ In-Place Optimized Implementation

⏱️ Time: O(1) Space: O(1)

Reduce memory overhead by performing all transformations directly on the input matrix without creating intermediate copies, using efficient bit operations and lookup tables.

Step-by-Step Manual Implementation

⏱️ Time: O(1) Space: O(1)

Implement each of the four AES steps (SubBytes, ShiftRows, MixColumns, AddRoundKey) as separate functions and apply them sequentially to transform the state matrix.

In-Place Optimized Implementation — Algorithm Steps

Step 1: Create optimized S-box lookup with bit manipulation
Step 2: Perform SubBytes and ShiftRows in single pass
Step 3: Apply MixColumns with optimized Galois field operations
Step 4: Complete with in-place AddRoundKey XOR

Visualization

Tap to expand

Step-by-Step Walkthrough

Flat S-box Lookup

Single array lookup instead of 2D indexing

Combined Operations

Multiple assignments for efficient row shifting

In-Place MixColumns

Direct column processing without temporary matrix

Final XOR

Complete encryption with optimized key addition

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void solution(int state[4][4], int roundKey[4][4]) {
    // Optimized S-box as flat array
    int sBox[] = {
        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
    };
    
    // SubBytes with optimized lookup
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            state[i][j] = sBox[state[i][j]];
        }
    }
    
    // Optimized ShiftRows with direct swaps
    int temp;
    
    // Row 1: left shift by 1
    temp = state[1][0];
    state[1][0] = state[1][1];
    state[1][1] = state[1][2];
    state[1][2] = state[1][3];
    state[1][3] = temp;
    
    // Row 2: left shift by 2
    temp = state[2][0];
    state[2][0] = state[2][2];
    state[2][2] = temp;
    temp = state[2][1];
    state[2][1] = state[2][3];
    state[2][3] = temp;
    
    // Row 3: left shift by 3 (same as right shift by 1)
    temp = state[3][3];
    state[3][3] = state[3][2];
    state[3][2] = state[3][1];
    state[3][1] = state[3][0];
    state[3][0] = temp;
    
    // Optimized in-place MixColumns
    for (int col = 0; col < 4; col++) {
        int a = state[0][col], b = state[1][col], c = state[2][col], d = state[3][col];
        state[0][col] = (2*a + 3*b + c + d) & 0xFF;
        state[1][col] = (a + 2*b + 3*c + d) & 0xFF;
        state[2][col] = (a + b + 2*c + 3*d) & 0xFF;
        state[3][col] = (3*a + b + c + 2*d) & 0xFF;
    }
    
    // In-place AddRoundKey
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            state[i][j] ^= roundKey[i][j];
        }
    }
}

int main() {
    int state[4][4], roundKey[4][4];
    char line[1000];
    
    // Parse state matrix
    fgets(line, sizeof(line), stdin);
    char *ptr = line + 1;
    for (int i = 0; i < 4; i++) {
        ptr = strchr(ptr, '[') + 1;
        for (int j = 0; j < 4; j++) {
            state[i][j] = strtol(ptr, &ptr, 10);
            if (j < 3) ptr++;
        }
        ptr++;
    }
    
    // Parse round key matrix
    fgets(line, sizeof(line), stdin);
    ptr = line + 1;
    for (int i = 0; i < 4; i++) {
        ptr = strchr(ptr, '[') + 1;
        for (int j = 0; j < 4; j++) {
            roundKey[i][j] = strtol(ptr, &ptr, 10);
            if (j < 3) ptr++;
        }
        ptr++;
    }
    
    solution(state, roundKey);
    
    // Print result
    printf("[");
    for (int i = 0; i < 4; i++) {
        printf("[");
        for (int j = 0; j < 4; j++) {
            printf("%d", state[i][j]);
            if (j < 3) printf(",");
        }
        printf("]");
        if (i < 3) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Same fixed 4x4 operations but with optimized implementation

✓ Linear Growth

Space Complexity

O(1)

In-place transformations, no intermediate matrices

✓ Linear Space

107.9K Views

Medium Frequency

~35 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

AES Encryption (Simplified) - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

In-Place Optimized Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler