SHA-3 Array Transformations Tutorial for CSCI 181 Homework 4

Understanding SHA-3 Array Mappings

In modern cryptography, the SHA-3 hash function relies on a unique 3D array representation of the state. For students tackling CSCI 181 Homework 4, mastering the transformation between 1D and 3D arrays is crucial. This guide will walk you through the inputSHA3 and outputSHA3 functions, plus the θ step, using clear explanations and verification strategies. With the current date of May 25, 2026, these concepts remain foundational for secure hashing in blockchain, AI data integrity, and secure app development.

The SHA-3 State: From 1D to 3D

SHA-3 operates on a state of 1600 bits, organized as a 3D array a[5][5][64]. The mapping formula given in the assignment is:

a[i][j][k] = v[64*(5*j + i) + k]

This means bits are read from the 1D array v in a specific order. For example, the first 64 bits of v (indices 0-63) go into a[0][0][0..63]. The next 64 bits (indices 64-127) go into a[1][0][0..63], and so on. Think of it like organizing a music playlist on a streaming app: you group songs into albums (the 64-bit lanes), then arrange albums by artist (the j index) and track number (the i index).

Implementing inputSHA3()

To implement inputSHA3(), you'll loop over the 3D array indices and compute the corresponding 1D index. Here's a pseudocode approach:

for i in 0..4:
  for j in 0..4:
    for k in 0..63:
      a[i][j][k] = v[64*(5*j + i) + k]

Notice the order: 5*j + i ensures that the i index increments fastest, then j. This is the standard SHA-3 mapping. A common mistake is swapping i and j, which leads to incorrect outputs. To verify, test with a small known input: for v where all bits are 0 except the first bit set to 1, a[0][0][0] should be 1.

Implementing outputSHA3()

The inverse function outputSHA3() reverses the mapping:

v[64*(5*j + i) + k] = a[i][j][k]

This is straightforward: for each 3D coordinate, assign to the correct 1D position. Together, these functions allow you to convert between representations, similar to how a video game renders a 3D world onto a 2D screen—but here it's purely bit manipulation.

The θ Step: A Core SHA-3 Operation

The θ step is one of the five permutation steps in SHA-3. It introduces diffusion by combining columns. The algorithm for θ is:

// Step 1: Compute parity of each column
for i in 0..4:
  for k in 0..63:
    C[i][k] = a[i][0][k] ^ a[i][1][k] ^ a[i][2][k] ^ a[i][3][k] ^ a[i][4][k]

// Step 2: Compute D array
for i in 0..4:
  for k in 0..63:
    D[i][k] = C[(i+4)%5][k] ^ C[(i+1)%5][(k+63)%64]

// Step 3: Update aout
for i in 0..4:
  for j in 0..4:
    for k in 0..63:
      aout[i][j][k] = a[i][j][k] ^ D[i][k]

This might look intimidating, but it's just XOR operations. The parity C is the XOR of all bits in a column (fixed i and k). Then D combines two neighboring columns with a rotation. Finally, each bit is XORed with the corresponding D value. It's like a team relay race: each runner (bit) passes information to the next lane.

Verification with the Provided Input

The assignment states that applying θ to the input file should yield aout[4][3][9..18] = 0011011000. To verify your implementation, read the 1600-bit input from sha3in.txt, convert to 3D using inputSHA3(), apply θ, then extract those ten bits. For your writeup, you need to list aout[3][1][15..24]. This is a common check to ensure your code is correct.

One tip: Use a debugger or print statements to examine intermediate arrays. For example, after computing C and D, verify they match expected values from known SHA-3 test vectors. This step is essential because errors in θ propagate to later functions ρ and π.

Connecting to Real-World Trends

SHA-3 is not just academic; it's used in blockchain networks like Ethereum (though they use Keccak, a variant) and in AI systems to verify model integrity. In 2026, with the rise of decentralized AI apps, understanding SHA-3 array transformations is a valuable skill. Think of the 3D state as a 5x5x64 Rubik's Cube—each step twists the cube in a specific way to mix the bits thoroughly.

Common Pitfalls and Debugging Strategies

Indexing errors: Mixing i and j leads to incorrect mapping. Always double-check the formula.
Off-by-one errors: In the rotation for D, (k+63)%64 is equivalent to (k-1)%64. Ensure you use modulo 64.
Bit order: The input file is a string of '0' and '1' characters? Or binary data? Clarify with your instructor. Typically, it's a text file with 1600 '0'/'1' characters.
Verification: Use the provided check bits to validate each step. If your output doesn't match, trace back through C and D.

Looking Ahead: ρ and π

Future assignments will ask you to implement ρ (rotation) and π (permutation). The ρ step uses a rotation matrix to shift bits within each lane. The π step permutes the lanes themselves. Mastering inputSHA3 and outputSHA3 now will make those tasks easier. Consider creating a modular program where each step is a separate function, making debugging a breeze.

Remember: The goal is not just to get the right answer, but to understand how SHA-3 achieves its security. Each transformation is designed to create a strong avalanche effect—a small change in input drastically changes the output. This property is why SHA-3 is used in digital signatures and password hashing.

By breaking down the problem into small, testable pieces, you'll not only ace Homework 4 but also build a solid foundation for advanced cryptography topics. Good luck!