SHA-224 vs SHA-256

import hashlib

# SHA-224 implementation
def sha224_hash(input_data):
    """
    Compute SHA-224 hash of input data.
    
    Args:
        input_data: String or bytes to hash
        
    Returns:
        Hex string of SHA-224 digest
    """
    # Convert string to bytes if necessary
    if isinstance(input_data, str):
        input_data = input_data.encode('utf-8')
    
    # Create SHA-224 hash object
    hash_obj = hashlib.sha224(input_data)
    
    # Return hex digest
    return hash_obj.hexdigest()

# SHA-256 implementation
def sha256_hash(input_data):
    """
    Compute SHA-256 hash of input data.
    
    Args:
        input_data: String or bytes to hash
        
    Returns:
        Hex string of SHA-256 digest
    """
    # Convert string to bytes if necessary
    if isinstance(input_data, str):
        input_data = input_data.encode('utf-8')
    
    # Create SHA-256 hash object
    hash_obj = hashlib.sha256(input_data)
    
    # Return hex digest
    return hash_obj.hexdigest()

# Example usage
message = "Hello, World!"
print(f"SHA-224: {sha224_hash(message)}")
# Output: SHA-224: 8552d8b7a7dc5476cb9e25dee69a8091290764b7f2a64fe6e78e9568

print(f"SHA-256: {sha256_hash(message)}")
# Output: SHA-256: dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f

# Streaming example for large files
def hash_file(filename, algorithm='sha224'):
    """
    Hash a file using the specified algorithm.
    
    Args:
        filename: Path to the file
        algorithm: 'sha224' or 'sha256'
        
    Returns:
        Hex digest of the file
    """
    if algorithm == 'sha224':
        hash_obj = hashlib.sha224()
    elif algorithm == 'sha256':
        hash_obj = hashlib.sha256()
    else:
        raise ValueError(f"Unsupported algorithm: {algorithm}")
    
    # Process file in chunks to handle large files efficiently
    with open(filename, 'rb') as f:
        for chunk in iter(lambda: f.read(4096), b''):
            hash_obj.update(chunk)
    
    return hash_obj.hexdigest()

# Usage
# print(f"File SHA-224: {hash_file('example.txt', 'sha224')}")
# print(f"File SHA-256: {hash_file('example.txt', 'sha256')}")

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

public class SHAComparison {
    
    /**
     * Computes SHA-224 hash of input data.
     * 
     * @param input The string to hash
     * @return Hex string of SHA-224 digest
     * @throws NoSuchAlgorithmException If SHA-224 is not available
     */
    public static String sha224Hash(String input) throws NoSuchAlgorithmException {
        // Get SHA-224 MessageDigest instance
        MessageDigest md = MessageDigest.getInstance("SHA-224");
        
        // Update with input bytes
        md.update(input.getBytes(StandardCharsets.UTF_8));
        
        // Get digest
        byte[] digest = md.digest();
        
        // Convert to hex string
        return bytesToHex(digest);
    }
    
    /**
     * Computes SHA-256 hash of input data.
     * 
     * @param input The string to hash
     * @return Hex string of SHA-256 digest
     * @throws NoSuchAlgorithmException If SHA-256 is not available
     */
    public static String sha256Hash(String input) throws NoSuchAlgorithmException {
        // Get SHA-256 MessageDigest instance
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        
        // Update with input bytes
        md.update(input.getBytes(StandardCharsets.UTF_8));
        
        // Get digest
        byte[] digest = md.digest();
        
        // Convert to hex string
        return bytesToHex(digest);
    }
    
    /**
     * Converts a byte array to a hex string.
     */
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
    
    /**
     * Example usage of SHA-224 and SHA-256.
     */
    public static void main(String[] args) {
        try {
            String message = "Hello, World!";
            
            String sha224 = sha224Hash(message);
            System.out.println("SHA-224: " + sha224);
            // Output: SHA-224: 8552d8b7a7dc5476cb9e25dee69a8091290764b7f2a64fe6e78e9568
            
            String sha256 = sha256Hash(message);
            System.out.println("SHA-256: " + sha256);
            // Output: SHA-256: dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f
            
            // Performance comparison
            performanceComparison(message);
            
        } catch (NoSuchAlgorithmException e) {
            System.err.println("Algorithm not available: " + e.getMessage());
        }
    }
    
    /**
     * Simple performance comparison between SHA-224 and SHA-256.
     */
    private static void performanceComparison(String input) throws NoSuchAlgorithmException {
        final int iterations = 1_000_000;
        
        // SHA-224 timing
        long start224 = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            sha224Hash(input + i);
        }
        long time224 = System.nanoTime() - start224;
        
        // SHA-256 timing
        long start256 = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            sha256Hash(input + i);
        }
        long time256 = System.nanoTime() - start256;
        
        System.out.println("\nPerformance comparison for " + iterations + " iterations:");
        System.out.println("SHA-224: " + (time224 / 1_000_000) + " ms");
        System.out.println("SHA-256: " + (time256 / 1_000_000) + " ms");
        System.out.println("Difference: " + 
            String.format("%.2f%%", (time256 - time224) * 100.0 / time256));
    }
}

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

public class SHAComparison
{
    /// 

    /// Computes SHA-224 hash of input data.
    /// 
    /// The string to hash
    /// Hex string of SHA-224 digest
    public static string Sha224Hash(string input)
    {
        // Note: .NET doesn't have a built-in SHA224 implementation
        // We can use SHA256 and truncate the result
        using (SHA256 sha256 = SHA256.Create())
        {
            // Compute the hash
            byte[] fullHash = sha256.ComputeHash(Encoding.UTF8.GetBytes(input));
            
            // Truncate to 224 bits (28 bytes)
            byte[] sha224Hash = new byte[28];
            Array.Copy(fullHash, sha224Hash, 28);
            
            // Convert to hex string
            return BitConverter.ToString(sha224Hash).Replace("-", "").ToLower();
        }
        
        // Alternative using a SHA224 implementation from a library
        // (e.g., Bouncy Castle or a custom implementation)
        /*
        using (var sha224 = new SHA224Managed())
        {
            byte[] hash = sha224.ComputeHash(Encoding.UTF8.GetBytes(input));
            return BitConverter.ToString(hash).Replace("-", "").ToLower();
        }
        */
    }
    
    /// 

    /// Computes SHA-256 hash of input data.
    /// 
    /// The string to hash
    /// Hex string of SHA-256 digest
    public static string Sha256Hash(string input)
    {
        using (SHA256 sha256 = SHA256.Create())
        {
            // Compute the hash
            byte[] hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(input));
            
            // Convert to hex string
            return BitConverter.ToString(hashBytes).Replace("-", "").ToLower();
        }
    }
    
    /// 

    /// Main method demonstrating SHA-224 and SHA-256.
    /// 
    public static void Main()
    {
        string message = "Hello, World!";
        
        string sha224 = Sha224Hash(message);
        Console.WriteLine($"SHA-224: {sha224}");
        // Output: SHA-224: 8552d8b7a7dc5476cb9e25dee69a8091290764b7f2a64fe6e78e9568
        
        string sha256 = Sha256Hash(message);
        Console.WriteLine($"SHA-256: {sha256}");
        // Output: SHA-256: dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f
        
        // Performance comparison
        PerformanceComparison(message);
    }
    
    /// 

    /// Simple performance comparison between SHA-224 and SHA-256.
    /// 
    private static void PerformanceComparison(string input)
    {
        const int iterations = 100_000;
        
        // SHA-224 timing
        var watch224 = System.Diagnostics.Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            Sha224Hash(input + i);
        }
        watch224.Stop();
        
        // SHA-256 timing
        var watch256 = System.Diagnostics.Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            Sha256Hash(input + i);
        }
        watch256.Stop();
        
        Console.WriteLine($"\nPerformance comparison for {iterations} iterations:");
        Console.WriteLine($"SHA-224: {watch224.ElapsedMilliseconds} ms");
        Console.WriteLine($"SHA-256: {watch256.ElapsedMilliseconds} ms");
        Console.WriteLine($"Difference: {((double)watch256.ElapsedMilliseconds - watch224.ElapsedMilliseconds) * 100.0 / watch256.ElapsedMilliseconds:F2}%");
    }
}