SHA-256 Implementation - Problem

Implement the SHA-256 cryptographic hash algorithm from scratch following the official NIST FIPS 180-4 specification.

SHA-256 (Secure Hash Algorithm 256-bit) is a cryptographic hash function that takes an input message and produces a 256-bit (32-byte) hash value, typically rendered as a 64-character hexadecimal string.

Your implementation must handle:

Message preprocessing (padding)
Parsing the message into 512-bit chunks
Hash computation using the SHA-256 compression function
Producing the final hash digest

The function should take a string input and return the SHA-256 hash as a lowercase hexadecimal string.

Note: This is an educational exercise. In production, always use well-tested cryptographic libraries.

Input & Output

Example 1 — Simple Input

$ Input: message = "abc"

› Output: ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

💡 Note: The string 'abc' is converted to bytes, padded according to SHA-256 specification, processed through 64 rounds of hash computation, and produces the standard SHA-256 hash for 'abc'.

Example 2 — Empty String

$ Input: message = ""

› Output: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855

💡 Note: An empty string gets padded to 512 bits (just the padding bit and length) and produces the well-known SHA-256 hash of empty input.

Example 3 — Longer Input

$ Input: message = "hello world"

› Output: b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9

💡 Note: The phrase 'hello world' demonstrates SHA-256 processing a longer input that still fits within a single 512-bit block after padding.

Constraints

0 ≤ message.length ≤ 10⁶
Message contains only ASCII characters
Output must be lowercase hexadecimal

Visualization

Tap to expand

Asked in

M Microsoft 15 IBM IBM 12 C Coinbase 8 P PayPal 6

The key insight is implementing the SHA-256 cryptographic hash function following the NIST specification with proper message padding, 512-bit block processing, and 64 rounds of compression. Best approach uses direct implementation with optimizations. Time: O(n), Space: O(1)

Common Approaches

✓ Direct Implementation

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

Implement SHA-256 by directly following the official algorithm: preprocess message with padding, parse into 512-bit blocks, apply 64 rounds of compression function with constants and logical operations.

Optimized Implementation

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

Implement SHA-256 with small optimizations like pre-calculating constants, using bit manipulation tricks, and optimizing memory access patterns for better cache performance.

Direct Implementation — Algorithm Steps

Step 1: Pad message to multiple of 512 bits
Step 2: Parse into 512-bit message blocks
Step 3: Initialize hash values and constants
Step 4: Process each block through 64 rounds
Step 5: Produce final hash digest

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Processing

Convert 'abc' to bytes and add padding

Block Processing

Process 512-bit blocks through 64 rounds

Hash Output

Produce final 256-bit digest

Code -

solution.c — C

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

static const uint32_t K[64] = {
    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};

#define ROTR(x, n) (((x) >> (n)) | ((x) << (32 - (n))))
#define CH(x, y, z) (((x) & (y)) ^ (~(x) & (z)))
#define MAJ(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
#define SIG0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
#define SIG1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
#define GAMMA0(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ ((x) >> 3))
#define GAMMA1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ ((x) >> 10))

char* solution(const char* message) {
    // Initial hash values
    uint32_t H[8] = {
        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
    };
    
    size_t msgLen = strlen(message);
    size_t paddedLen = msgLen + 1;
    
    // Calculate padded length
    while ((paddedLen % 64) != 56) {
        paddedLen++;
    }
    paddedLen += 8;
    
    // Create padded message
    uint8_t* paddedMsg = (uint8_t*)calloc(paddedLen, 1);
    memcpy(paddedMsg, message, msgLen);
    paddedMsg[msgLen] = 0x80;
    
    // Append length as 64-bit big-endian
    uint64_t bitLen = msgLen * 8;
    for (int i = 0; i < 8; i++) {
        paddedMsg[paddedLen - 8 + i] = (bitLen >> (8 * (7 - i))) & 0xff;
    }
    
    // Process message in 512-bit chunks
    for (size_t chunkStart = 0; chunkStart < paddedLen; chunkStart += 64) {
        uint32_t W[64];
        
        // Break chunk into sixteen 32-bit big-endian words
        for (int i = 0; i < 16; i++) {
            W[i] = (paddedMsg[chunkStart + i*4] << 24) |
                   (paddedMsg[chunkStart + i*4 + 1] << 16) |
                   (paddedMsg[chunkStart + i*4 + 2] << 8) |
                   paddedMsg[chunkStart + i*4 + 3];
        }
        
        // Extend the sixteen 32-bit words into sixty-four 32-bit words
        for (int i = 16; i < 64; i++) {
            W[i] = GAMMA1(W[i-2]) + W[i-7] + GAMMA0(W[i-15]) + W[i-16];
        }
        
        // Initialize working variables
        uint32_t a = H[0], b = H[1], c = H[2], d = H[3];
        uint32_t e = H[4], f = H[5], g = H[6], h = H[7];
        
        // Main loop
        for (int i = 0; i < 64; i++) {
            uint32_t T1 = h + SIG1(e) + CH(e, f, g) + K[i] + W[i];
            uint32_t T2 = SIG0(a) + MAJ(a, b, c);
            h = g;
            g = f;
            f = e;
            e = d + T1;
            d = c;
            c = b;
            b = a;
            a = T1 + T2;
        }
        
        // Update hash values
        H[0] += a;
        H[1] += b;
        H[2] += c;
        H[3] += d;
        H[4] += e;
        H[5] += f;
        H[6] += g;
        H[7] += h;
    }
    
    // Produce final hash value
    char* result = (char*)malloc(65);
    sprintf(result, "%08x%08x%08x%08x%08x%08x%08x%08x",
            H[0], H[1], H[2], H[3], H[4], H[5], H[6], H[7]);
    
    free(paddedMsg);
    return result;
}

int main() {
    char message[1000];
    fgets(message, sizeof(message), stdin);
    message[strcspn(message, "\n")] = 0;
    
    char* result = solution(message);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Linear in message length - each 512-bit block requires 64 constant-time operations

✓ Linear Growth

Space Complexity

O(1)

Uses fixed-size arrays for hash values, constants, and temporary variables regardless of input size

✓ Linear Space

8.5K Views

Medium Frequency

~45 min Avg. Time

230 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

SHA-256 Implementation - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler