Getting Started with SHA-224

Introduction to SHA-224

SHA-224 is a cryptographic hash function that generates a 224-bit (28-byte) hash value. It belongs to the SHA-2 family of hash functions, which was designed by the National Security Agency (NSA) and published by the National Institute of Standards and Technology (NIST).

This guide will help you get started with implementing SHA-224 in your applications. We'll cover:

• What SHA-224 is and how it works
• When you should use SHA-224
• Different implementation methods
• Code examples in popular programming languages
• Best practices and security considerations

Understanding SHA-224

What is SHA-224?

SHA-224 is essentially a truncated version of SHA-256 with a different initialization vector. It produces a 224-bit (28-byte) digest, making it slightly more efficient in terms of storage and transmission compared to SHA-256, while still maintaining a high level of security.

Key Properties

• Fixed Output Size: Always produces a 224-bit (28-byte) hash value, regardless of input size
• Deterministic: The same input will always produce the same output
• Fast Computation: Efficiently computes hash values even for large inputs
• Avalanche Effect: Small changes in input produce significantly different outputs
• Pre-image Resistance: Given a hash value, it's computationally infeasible to find an input that produces that hash
• Collision Resistance: It's difficult to find two different inputs that produce the same hash

Comparison with Other Hash Functions

For more details about SHA-224 vs. other hash functions, see our Hash Function Comparison and SHA-224 vs. SHA-256 pages.

When to Use SHA-224

SHA-224 is a versatile cryptographic hash function with numerous applications. Here's when you should consider using it:

When to Choose SHA-224 over Other Hash Functions

• Over MD5/SHA-1: Always choose SHA-224 over these older hash functions, as they are no longer considered secure.
• Over SHA-256: When you need to reduce storage or transmission overhead by ~12.5% without a significant security trade-off.
• Over SHA-384/512: When you don't need the extra security margin and want better performance.
• Over SHA-3: When you're working in environments with established SHA-2 support and don't require SHA-3's specific resilience properties.

Implementation Methods

There are several ways to implement SHA-224 in your applications. Choose the method that best fits your requirements and constraints:

Language Examples

Here are examples of how to implement SHA-224 in various programming languages using both built-in libraries and the SHA224.com SDKs:

// In Node.js
const crypto = require('crypto');

function sha224Hash(input) {
    const hash = crypto.createHash('sha224');
    hash.update(input);
    return hash.digest('hex');
}

// Example usage
const text = 'Hello, world!';
const hash = sha224Hash(text);
console.log(`SHA-224 hash of "${text}": ${hash}`);
// Output: SHA-224 hash of "Hello, world!": 8552d8b7a7dc5476cb9e25dee69a8091290764b7f2a64fe6e78e9568

// In modern browsers using Web Crypto API
async function sha224Hash(input) {
    // Convert the input string to an ArrayBuffer
    const encoder = new TextEncoder();
    const data = encoder.encode(input);
    
    // Compute the hash
    const hashBuffer = await crypto.subtle.digest('SHA-224', data);
    
    // Convert the hash to hex string
    const hashArray = Array.from(new Uint8Array(hashBuffer));
    const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
    
    return hashHex;
}

// Example usage
sha224Hash('Hello, world!').then(hash => {
    console.log(`SHA-224 hash: ${hash}`);
});

// Install with: npm install @sha224/js
import { sha224 } from '@sha224/js';

// Simple hashing
const hash = await sha224('Hello, world!');
console.log(`Hash: ${hash}`);

// Incremental hashing
import { SHA224Hash } from '@sha224/js';

const hasher = new SHA224Hash();
hasher.update('Hello, ');
hasher.update('world!');
const incrementalHash = await hasher.digest();
console.log(`Incremental hash: ${incrementalHash}`);

// File hashing
const fileInput = document.getElementById('fileInput');
fileInput.addEventListener('change', async (event) => {
    const file = event.target.files[0];
    const fileHash = await sha224.hashFile(file, {
        onProgress: (progress) => {
            console.log(`Progress: ${Math.round(progress * 100)}%`);
        }
    });
    console.log(`File hash: ${fileHash}`);
});

import hashlib

def sha224_hash(input_str):
    # Convert string to bytes if it isn't already
    if isinstance(input_str, str):
        input_bytes = input_str.encode('utf-8')
    else:
        input_bytes = input_str
    
    # Compute the hash
    hash_obj = hashlib.sha224(input_bytes)
    return hash_obj.hexdigest()

# Example usage
text = "Hello, world!"
hash_value = sha224_hash(text)
print(f'SHA-224 hash of "{text}": {hash_value}')
# Output: SHA-224 hash of "Hello, world!": 8552d8b7a7dc5476cb9e25dee69a8091290764b7f2a64fe6e78e9568

# Incremental hashing
hash_obj = hashlib.sha224()
hash_obj.update(b"Hello, ")
hash_obj.update(b"world!")
incremental_hash = hash_obj.hexdigest()
print(f"Incremental hash: {incremental_hash}")

# Hashing a file
def hash_file(file_path):
    h = hashlib.sha224()
    with open(file_path, 'rb') as file:
        chunk = file.read(4096)
        while chunk:
            h.update(chunk)
            chunk = file.read(4096)
    return h.hexdigest()

file_hash = hash_file('example.txt')
print(f"File hash: {file_hash}")

# Install with: pip install sha224
from sha224 import sha224, SHA224Hash

# Simple hashing
hash_value = sha224("Hello, world!")
print(f"Hash: {hash_value}")

# Incremental hashing
hasher = SHA224Hash()
hasher.update("Hello, ")
hasher.update("world!")
incremental_hash = hasher.hexdigest()
print(f"Incremental hash: {incremental_hash}")

# File hashing
file_hash = sha224.file("example.txt")
print(f"File hash: {file_hash}")

# Large file with progress tracking
import os

def hash_large_file(file_path):
    file_size = os.path.getsize(file_path)
    bytes_read = 0
    hasher = SHA224Hash()
    
    with open(file_path, "rb") as file:
        while True:
            data = file.read(65536)  # 64KB chunks
            if not data:
                break
                
            hasher.update(data)
            bytes_read += len(data)
            progress = bytes_read / file_size * 100
            print(f"Progress: {progress:.2f}%")
    
    return hasher.hexdigest()

large_file_hash = hash_large_file("large_file.bin")
print(f"Large file hash: {large_file_hash}")

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class SHA224Example {
    public static String sha224Hash(String input) throws NoSuchAlgorithmException {
        // Get SHA-224 MessageDigest instance
        MessageDigest digest = MessageDigest.getInstance("SHA-224");
        
        // Update with input bytes
        byte[] hashBytes = digest.digest(input.getBytes(StandardCharsets.UTF_8));
        
        // Convert to hex string
        StringBuilder hexString = new StringBuilder();
        for (byte b : hashBytes) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        
        return hexString.toString();
    }
    
    public static void main(String[] args) {
        try {
            String text = "Hello, world!";
            String hash = sha224Hash(text);
            System.out.println("SHA-224 hash of \"" + text + "\": " + hash);
            
            // Incremental hashing
            MessageDigest incrementalDigest = MessageDigest.getInstance("SHA-224");
            incrementalDigest.update("Hello, ".getBytes(StandardCharsets.UTF_8));
            incrementalDigest.update("world!".getBytes(StandardCharsets.UTF_8));
            
            byte[] incrementalHashBytes = incrementalDigest.digest();
            StringBuilder incrementalHexString = new StringBuilder();
            for (byte b : incrementalHashBytes) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) {
                    incrementalHexString.append('0');
                }
                incrementalHexString.append(hex);
            }
            
            System.out.println("Incremental hash: " + incrementalHexString.toString());
            
        } catch (NoSuchAlgorithmException e) {
            System.err.println("SHA-224 algorithm not available: " + e.getMessage());
        }
    }
}

// Add dependency to pom.xml:
// <dependency>
//     <groupId>com.sha224</groupId>
//     <artifactId>sha224-java</artifactId>
//     <version>1.2.3</version>
// </dependency>

import com.sha224.SHA224;
import com.sha224.SHA224Digest;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class SHA224Example {
    public static void main(String[] args) {
        // Simple hashing
        String text = "Hello, world!";
        String hash = SHA224.hash(text);
        System.out.println("Hash: " + hash);
        
        // Incremental hashing
        SHA224Digest digest = new SHA224Digest();
        digest.update("Hello, ".getBytes());
        digest.update("world!".getBytes());
        String incrementalHash = digest.hexDigest();
        System.out.println("Incremental hash: " + incrementalHash);
        
        // File hashing
        try {
            String fileHash = SHA224.hash(new File("example.txt"));
            System.out.println("File hash: " + fileHash);
            
            // Large file with progress
            File largeFile = new File("large_file.bin");
            long fileSize = largeFile.length();
            
            SHA224Digest largeFileDigest = new SHA224Digest();
            FileInputStream fis = new FileInputStream(largeFile);
            byte[] buffer = new byte[8192]; // 8KB buffer
            int bytesRead;
            long totalBytesRead = 0;
            
            while ((bytesRead = fis.read(buffer)) != -1) {
                largeFileDigest.update(buffer, 0, bytesRead);
                totalBytesRead += bytesRead;
                
                double progress = (double) totalBytesRead / fileSize * 100;
                System.out.printf("Progress: %.2f%%\n", progress);
            }
            
            fis.close();
            String largeFileHash = largeFileDigest.hexDigest();
            System.out.println("Large file hash: " + largeFileHash);
            
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        }
    }
}

package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "os"
)

// SHA-224 is using SHA-256 with a different initial value and truncated output
func sha224Hash(input []byte) string {
    h := sha256.New224()
    h.Write(input)
    sum := h.Sum(nil)
    return hex.EncodeToString(sum)
}

func main() {
    // Simple hashing
    text := "Hello, world!"
    hash := sha224Hash([]byte(text))
    fmt.Printf("SHA-224 hash of %q: %s\n", text, hash)
    
    // Incremental hashing
    h := sha256.New224()
    h.Write([]byte("Hello, "))
    h.Write([]byte("world!"))
    incrementalHash := hex.EncodeToString(h.Sum(nil))
    fmt.Printf("Incremental hash: %s\n", incrementalHash)
    
    // File hashing
    file, err := os.Open("example.txt")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()
    
    fileHasher := sha256.New224()
    if _, err := io.Copy(fileHasher, file); err != nil {
        fmt.Println("Error hashing file:", err)
        return
    }
    
    fileHash := hex.EncodeToString(fileHasher.Sum(nil))
    fmt.Printf("File hash: %s\n", fileHash)
}

// Install with: go get github.com/sha224-org/sha224-go
package main

import (
    "fmt"
    "github.com/sha224-org/sha224-go"
    "os"
)

func main() {
    // Simple hashing
    hash := sha224.SumString("Hello, world!")
    fmt.Printf("Hash: %x\n", hash)
    
    // Incremental hashing
    h := sha224.New()
    h.Write([]byte("Hello, "))
    h.Write([]byte("world!"))
    incrementalHash := h.Sum(nil)
    fmt.Printf("Incremental hash: %x\n", incrementalHash)
    
    // File hashing
    fileHash, err := sha224.SumFile("example.txt")
    if err != nil {
        fmt.Println("Error hashing file:", err)
        return
    }
    fmt.Printf("File hash: %x\n", fileHash)
    
    // Large file with progress
    file, err := os.Open("large_file.bin")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()
    
    fileInfo, err := file.Stat()
    if err != nil {
        fmt.Println("Error getting file info:", err)
        return
    }
    
    hash, err = sha224.SumReaderWithProgress(file, fileInfo.Size(), func(bytesRead, totalSize int64) {
        progress := float64(bytesRead) / float64(totalSize) * 100
        fmt.Printf("Progress: %.2f%%\n", progress)
    })
    if err != nil {
        fmt.Println("Error hashing file:", err)
        return
    }
    
    fmt.Printf("Large file hash: %x\n", hash)
}

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

class SHA224Example
{
    // SHA-224 is not directly available in .NET, we need to use SHA256 and truncate
    static string SHA224Hash(string input)
    {
        // Convert the input string to a byte array
        byte[] inputBytes = Encoding.UTF8.GetBytes(input);
        
        // Compute the hash
        using (SHA256 sha256 = SHA256.Create())
        {
            byte[] hashBytes = sha256.ComputeHash(inputBytes);
            
            // Truncate to 28 bytes (224 bits)
            byte[] sha224Bytes = new byte[28];
            Array.Copy(hashBytes, sha224Bytes, 28);
            
            // Convert the byte array to a hexadecimal string
            StringBuilder sb = new StringBuilder();
            foreach (byte b in sha224Bytes)
            {
                sb.Append(b.ToString("x2"));
            }
            
            return sb.ToString();
        }
    }
    
    static void Main()
    {
        string text = "Hello, world!";
        string hash = SHA224Hash(text);
        Console.WriteLine($"SHA-224 hash of \"{text}\": {hash}");
        
        // File hashing
        string filePath = "example.txt";
        using (FileStream stream = File.OpenRead(filePath))
        {
            using (SHA256 sha256 = SHA256.Create())
            {
                byte[] hashBytes = sha256.ComputeHash(stream);
                
                // Truncate to 28 bytes (224 bits)
                byte[] sha224Bytes = new byte[28];
                Array.Copy(hashBytes, sha224Bytes, 28);
                
                // Convert the byte array to a hexadecimal string
                StringBuilder sb = new StringBuilder();
                foreach (byte b in sha224Bytes)
                {
                    sb.Append(b.ToString("x2"));
                }
                
                Console.WriteLine($"File hash: {sb.ToString()}");
            }
        }
        
        // Note: In a real implementation, you would use a custom SHA224Managed class
        // that implements the SHA-224 algorithm directly.
    }
}

// Install via NuGet: Install-Package SHA224.NET
using System;
using System.IO;
using SHA224.NET;

class Program
{
    static void Main()
    {
        // Simple hashing
        string text = "Hello, world!";
        string hash = SHA224Hasher.ComputeHash(text);
        Console.WriteLine($"Hash: {hash}");
        
        // Incremental hashing
        SHA224IncrementalHasher hasher = new SHA224IncrementalHasher();
        hasher.Update("Hello, ");
        hasher.Update("world!");
        string incrementalHash = hasher.GetHashAndReset();
        Console.WriteLine($"Incremental hash: {incrementalHash}");
        
        // File hashing
        string fileHash = SHA224Hasher.ComputeFileHash("example.txt");
        Console.WriteLine($"File hash: {fileHash}");
        
        // Large file with progress
        string largeFilePath = "large_file.bin";
        long fileSize = new FileInfo(largeFilePath).Length;
        
        SHA224IncrementalHasher largeFileHasher = new SHA224IncrementalHasher();
        using (FileStream fs = File.OpenRead(largeFilePath))
        {
            byte[] buffer = new byte[8192]; // 8KB buffer
            int bytesRead;
            long totalBytesRead = 0;
            
            while ((bytesRead = fs.Read(buffer, 0, buffer.Length)) > 0)
            {
                largeFileHasher.Update(buffer, 0, bytesRead);
                totalBytesRead += bytesRead;
                
                double progress = (double)totalBytesRead / fileSize * 100;
                Console.WriteLine($"Progress: {progress:F2}%");
            }
        }
        
        string largeFileHash = largeFileHasher.GetHashAndReset();
        Console.WriteLine($"Large file hash: {largeFileHash}");
    }
}

<?php
// Simple hashing
function sha224Hash($input) {
    return hash('sha224', $input);
}

$text = 'Hello, world!';
$hash = sha224Hash($text);
echo "SHA-224 hash of \"$text\": $hash\n";

// Incremental hashing
$context = hash_init('sha224');
hash_update($context, 'Hello, ');
hash_update($context, 'world!');
$incrementalHash = hash_final($context);
echo "Incremental hash: $incrementalHash\n";

// File hashing
function hashFile($filePath) {
    return hash_file('sha224', $filePath);
}

$fileHash = hashFile('example.txt');
echo "File hash: $fileHash\n";

// Large file with progress (basic implementation)
function hashLargeFile($filePath) {
    $fileSize = filesize($filePath);
    $file = fopen($filePath, 'rb');
    $context = hash_init('sha224');
    $bytesRead = 0;
    
    while (!feof($file)) {
        $data = fread($file, 8192); // 8KB chunks
        hash_update($context, $data);
        $bytesRead += strlen($data);
        $progress = ($bytesRead / $fileSize) * 100;
        echo "Progress: " . number_format($progress, 2) . "%\n";
    }
    
    fclose($file);
    return hash_final($context);
}

$largeFileHash = hashLargeFile('large_file.bin');
echo "Large file hash: $largeFileHash\n";
?>

<?php
// Install with: composer require sha224/sha224-php
require 'vendor/autoload.php';

use SHA224\Hasher;
use SHA224\IncrementalHasher;

// Simple hashing
$text = 'Hello, world!';
$hash = Hasher::hash($text);
echo "Hash: $hash\n";

// Incremental hashing
$hasher = new IncrementalHasher();
$hasher->update('Hello, ');
$hasher->update('world!');
$incrementalHash = $hasher->getHash();
echo "Incremental hash: $incrementalHash\n";

// File hashing
$fileHash = Hasher::hashFile('example.txt');
echo "File hash: $fileHash\n";

// Large file with progress
$largeFileHash = Hasher::hashFileWithProgress('large_file.bin', function($bytesRead, $totalSize) {
    $progress = ($bytesRead / $totalSize) * 100;
    echo "Progress: " . number_format($progress, 2) . "%\n";
});
echo "Large file hash: $largeFileHash\n";

// API Client
use SHA224\API\Client;

$apiClient = new Client('YOUR_API_KEY');
$apiHash = $apiClient->hashText('Hello, world!');
echo "API hash: $apiHash\n";
?>

require 'digest'

# Simple hashing
def sha224_hash(input)
  Digest::SHA2.new(224).hexdigest(input)
end

text = "Hello, world!"
hash = sha224_hash(text)
puts "SHA-224 hash of \"#{text}\": #{hash}"

# Incremental hashing
digest = Digest::SHA2.new(224)
digest.update("Hello, ")
digest.update("world!")
incremental_hash = digest.hexdigest
puts "Incremental hash: #{incremental_hash}"

# File hashing
def hash_file(file_path)
  Digest::SHA2.new(224).file(file_path).hexdigest
end

file_hash = hash_file("example.txt")
puts "File hash: #{file_hash}"

# Large file with progress
def hash_large_file(file_path)
  file_size = File.size(file_path)
  bytes_read = 0
  digest = Digest::SHA2.new(224)
  
  File.open(file_path, 'rb') do |file|
    while buffer = file.read(8192) # 8KB chunks
      digest.update(buffer)
      bytes_read += buffer.size
      progress = (bytes_read.to_f / file_size) * 100
      puts "Progress: #{progress.round(2)}%"
    end
  end
  
  digest.hexdigest
end

large_file_hash = hash_large_file("large_file.bin")
puts "Large file hash: #{large_file_hash}"

# Install with: gem install sha224
require 'sha224'

# Simple hashing
text = "Hello, world!"
hash = SHA224.hash(text)
puts "Hash: #{hash}"

# Incremental hashing
hasher = SHA224::Hasher.new
hasher.update("Hello, ")
hasher.update("world!")
incremental_hash = hasher.hexdigest
puts "Incremental hash: #{incremental_hash}"

# File hashing
file_hash = SHA224.file("example.txt")
puts "File hash: #{file_hash}"

# Large file with progress
large_file_hash = SHA224.file_with_progress("large_file.bin") do |bytes_read, total_size|
  progress = (bytes_read.to_f / total_size) * 100
  puts "Progress: #{progress.round(2)}%"
end
puts "Large file hash: #{large_file_hash}"

# API Client
client = SHA224::API::Client.new("YOUR_API_KEY")
api_hash = client.hash_text("Hello, world!")
puts "API hash: #{api_hash}"

# Verify a hash
is_valid = SHA224.verify?(hash, text)
puts "Hash verification: #{is_valid}"

Best Practices

Follow these best practices when implementing SHA-224 in your applications:

Known Test Vectors

Use these test vectors to verify your SHA-224 implementation:

Security Considerations

When implementing SHA-224 in security-sensitive applications, keep these important considerations in mind:

// Example of salted hashing in JavaScript
function saltedSha224(input, salt) {
    return sha224(salt + input);
}

// Generate a random salt
function generateSalt(length = 16) {
    const array = new Uint8Array(length);
    crypto.getRandomValues(array);
    return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
}

// Usage
const salt = generateSalt();
const hash = saltedSha224("sensitive data", salt);

// Store both the hash and salt
storeInDatabase({ hash, salt });

// Vulnerable comparison (DO NOT USE)
function vulnerableCompare(hash1, hash2) {
    return hash1 === hash2; // Time varies based on where the first difference occurs
}

// Constant-time comparison (RECOMMENDED)
function constantTimeCompare(hash1, hash2) {
    if (hash1.length !== hash2.length) {
        return false;
    }
    
    let result = 0;
    for (let i = 0; i < hash1.length; i++) {
        // XOR the characters and OR the result with the running total
        result |= hash1.charCodeAt(i) ^ hash2.charCodeAt(i);
    }
    
    return result === 0;
}

// Example of algorithm agility in hash storage
const hashData = {
    algorithm: "SHA-224",
    hash: sha224("data to hash"),
    salt: generateSalt()
};

// Later, when verifying:
function verifyHash(data, hashData) {
    let computedHash;
    
    switch (hashData.algorithm) {
        case "SHA-224":
            computedHash = sha224(hashData.salt + data);
            break;
        case "SHA-256":
            computedHash = sha256(hashData.salt + data);
            break;
        case "SHA3-224":
            computedHash = sha3_224(hashData.salt + data);
            break;
        default:
            throw new Error("Unsupported hash algorithm");
    }
    
    return constantTimeCompare(computedHash, hashData.hash);
}

Next Steps

Now that you understand the basics of implementing SHA-224, here are some next steps to explore: