SHA-224 Documentation

// Using the built-in SHA-224 implementation from sha224.js
const message = "Hello, SHA-224!";
const hash = SHA224.hash(message);

console.log(`Message: ${message}`);
console.log(`SHA-224 Hash: ${hash}`);
// Output: SHA-224 Hash: 4bca29762f61c13fbef29b4596316407703a43d5fa84905cd25c45d3

// JavaScript
string SHA224.hash(string|Uint8Array input)

# Python
hashlib.sha224(bytes).hexdigest() -> str
hashlib.sha224(bytes).digest() -> bytes

// Java
MessageDigest.getInstance("SHA-224").digest(byte[] input) -> byte[]

// C#
using System.Security.Cryptography;
SHA224.Create().ComputeHash(byte[] buffer) -> byte[]

// Go
sha256.Sum224([]byte) -> [28]byte

import hashlib
import base64

def sha224_output_formats(message):
    """Demonstrate different output formats for SHA-224"""
    # Convert message to bytes if it's a string
    if isinstance(message, str):
        message = message.encode('utf-8')
    
    # Create SHA-224 hash object
    sha224_hash = hashlib.sha224(message)
    
    # Get the hash in different formats
    binary = sha224_hash.digest()
    hex_string = sha224_hash.hexdigest()
    base64_string = base64.b64encode(binary).decode('ascii')
    base64url_string = base64.urlsafe_b64encode(binary).decode('ascii').rstrip('=')
    
    return {
        'message': message.decode('utf-8') if isinstance(message, bytes) else message,
        'binary': binary,
        'binary_length': len(binary),
        'hex': hex_string,
        'hex_length': len(hex_string),
        'base64': base64_string,
        'base64_length': len(base64_string),
        'base64url': base64url_string,
        'base64url_length': len(base64url_string)
    }

# Example usage
result = sha224_output_formats("Hello, world!")
print(f"Message: {result['message']}")
print(f"Binary (shown as bytes): {result['binary']}")
print(f"Binary length: {result['binary_length']} bytes")
print(f"Hexadecimal: {result['hex']}")
print(f"Hexadecimal length: {result['hex_length']} characters")
print(f"Base64: {result['base64']}")
print(f"Base64 length: {result['base64_length']} characters")
print(f"Base64URL: {result['base64url']}")
print(f"Base64URL length: {result['base64url_length']} characters")

import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class SHA224Hasher {
    
    /**
     * Calculates SHA-224 hash of a string input
     * 
     * @param input The string to hash
     * @return Hexadecimal representation of the hash
     * @throws HashingException If any error occurs during hashing
     */
    public static String hashString(String input) throws HashingException {
        if (input == null) {
            throw new IllegalArgumentException("Input string cannot be null");
        }
        
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-224");
            byte[] hashBytes = digest.digest(input.getBytes(StandardCharsets.UTF_8));
            return bytesToHex(hashBytes);
        } catch (NoSuchAlgorithmException e) {
            throw new HashingException("SHA-224 algorithm not available", e);
        }
    }
    
    /**
     * Calculates SHA-224 hash of an input stream
     * Suitable for large files or data streams
     * 
     * @param inputStream The data stream to hash
     * @return Hexadecimal representation of the hash
     * @throws HashingException If any error occurs during hashing
     */
    public static String hashStream(InputStream inputStream) throws HashingException {
        if (inputStream == null) {
            throw new IllegalArgumentException("Input stream cannot be null");
        }
        
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-224");
            byte[] buffer = new byte[8192]; // 8KB buffer
            int bytesRead;
            
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                digest.update(buffer, 0, bytesRead);
            }
            
            byte[] hashBytes = digest.digest();
            return bytesToHex(hashBytes);
        } catch (NoSuchAlgorithmException e) {
            throw new HashingException("SHA-224 algorithm not available", e);
        } catch (IOException e) {
            throw new HashingException("Error reading from input stream", e);
        }
    }
    
    /**
     * Converts a byte array to a hexadecimal string
     */
    private static String bytesToHex(byte[] bytes) {
        StringBuilder hexString = new StringBuilder(2 * bytes.length);
        for (byte b : bytes) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        return hexString.toString();
    }
    
    /**
     * Custom exception for hashing operations
     */
    public static class HashingException extends Exception {
        public HashingException(String message) {
            super(message);
        }
        
        public HashingException(String message, Throwable cause) {
            super(message, cause);
        }
    }
    
    // Example usage with error handling
    public static void main(String[] args) {
        try {
            String hash = SHA224Hasher.hashString("Hello, world!");
            System.out.println("SHA-224 Hash: " + hash);
        } catch (IllegalArgumentException e) {
            System.err.println("Invalid input: " + e.getMessage());
        } catch (HashingException e) {
            System.err.println("Hashing error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

// Main thread code (app.js)
// Create a dedicated Web Worker for SHA-224 computations
const hashWorker = new Worker('hash-worker.js');

// Setup message handling
hashWorker.onmessage = function(e) {
  const { id, hash, error, duration } = e.data;
  
  if (error) {
    console.error(`Error computing hash for job ${id}: ${error}`);
    return;
  }
  
  console.log(`Received hash for job ${id}: ${hash}`);
  console.log(`Computation took ${duration}ms`);
  
  // Update UI or process the hash result
  document.getElementById(`result-${id}`).textContent = hash;
};

// Function to request a hash calculation
function calculateHash(text, id) {
  // Send the text to the worker
  hashWorker.postMessage({ 
    id: id, 
    text: text,
    timestamp: Date.now()
  });
  
  console.log(`Sent hash job ${id} to worker`);
}

// Event listeners for UI elements
document.getElementById('hash-button').addEventListener('click', function() {
  const textInput = document.getElementById('hash-input').value;
  const jobId = Math.random().toString(36).substring(2, 9);
  calculateHash(textInput, jobId);
});

// Import or include the SHA-224 implementation
importScripts('sha224.js');

// Handle incoming messages
self.onmessage = function(e) {
  const { id, text, timestamp } = e.data;
  
  try {
    console.log(`Worker received job ${id}`);
    
    // Calculate the hash
    const startTime = performance.now();
    const hash = SHA224.hash(text);
    const endTime = performance.now();
    
    // Return the result
    self.postMessage({
      id: id,
      hash: hash,
      duration: endTime - startTime,
      received: timestamp
    });
  } catch (err) {
    // Return any errors
    self.postMessage({
      id: id,
      error: err.message,
      received: timestamp
    });
  }
};

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadSafeSHA224Example {

    /**
     * Thread-safe hash calculation using thread confinement
     * (each thread gets its own MessageDigest instance)
     */
    public static String calculateHash(String input) throws NoSuchAlgorithmException {
        // Create a new MessageDigest instance for this thread
        MessageDigest digest = MessageDigest.getInstance("SHA-224");
        byte[] hashBytes = digest.digest(input.getBytes(StandardCharsets.UTF_8));
        
        // Convert to hex
        StringBuilder sb = new StringBuilder();
        for (byte b : hashBytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
    
    /**
     * Anti-pattern: Incorrect sharing of MessageDigest instance across threads
     * This will produce incorrect or corrupted hashes
     */
    public static class UnsafeHasher implements Runnable {
        private static MessageDigest sharedDigest; // UNSAFE for concurrent use
        private final String input;
        
        static {
            try {
                sharedDigest = MessageDigest.getInstance("SHA-224");
            } catch (NoSuchAlgorithmException e) {
                throw new RuntimeException(e);
            }
        }
        
        public UnsafeHasher(String input) {
            this.input = input;
        }
        
        @Override
        public void run() {
            // DANGER: Multiple threads updating the shared digest state
            sharedDigest.update(input.getBytes(StandardCharsets.UTF_8));
            byte[] hashBytes = sharedDigest.digest();
            
            StringBuilder sb = new StringBuilder();
            for (byte b : hashBytes) {
                sb.append(String.format("%02x", b));
            }
            
            System.out.println(Thread.currentThread().getName() + 
                " - Input: " + input + 
                " - Hash: " + sb.toString());
        }
    }
    
    /**
     * Correct pattern: Thread-safe hashing with thread confinement
     */
    public static class SafeHasher implements Runnable {
        private final String input;
        
        public SafeHasher(String input) {
            this.input = input;
        }
        
        @Override
        public void run() {
            try {
                // Each thread gets its own MessageDigest instance
                String hash = calculateHash(input);
                
                System.out.println(Thread.currentThread().getName() + 
                    " - Input: " + input + 
                    " - Hash: " + hash);
            } catch (NoSuchAlgorithmException e) {
                System.err.println("Error calculating hash: " + e.getMessage());
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        String[] inputs = {
            "Thread safety is important",
            "SHA-224 is not thread safe by default",
            "Use separate instances for each thread",
            "Never share mutable objects across threads"
        };
        
        ExecutorService executor = Executors.newFixedThreadPool(4);
        
        System.out.println("Running with safe hashers (thread confinement):");
        for (String input : inputs) {
            executor.submit(new SafeHasher(input));
        }
        
        executor.shutdown();
        executor.awaitTermination(5, TimeUnit.SECONDS);
        
        System.out.println("\nWARNING: Now demonstrating INCORRECT usage (will produce errors):");
        ExecutorService badExecutor = Executors.newFixedThreadPool(4);
        for (String input : inputs) {
            badExecutor.submit(new UnsafeHasher(input));
        }
        
        badExecutor.shutdown();
        badExecutor.awaitTermination(5, TimeUnit.SECONDS);
    }
}