SHA-224 Developer Resources Hub

// JavaScript SHA-224 Example (Node.js)
const crypto = require('crypto');

// Basic hashing
function sha224Hash(data) {
    return crypto.createHash('sha224').update(data).digest('hex');
}

// Stream hashing for files
const fs = require('fs');

function sha224File(filepath) {
    return new Promise((resolve, reject) => {
        const hash = crypto.createHash('sha224');
        const stream = fs.createReadStream(filepath);

        stream.on('data', chunk => hash.update(chunk));
        stream.on('end', () => resolve(hash.digest('hex')));
        stream.on('error', reject);
    });
}

// HMAC-SHA224
function hmacSha224(key, message) {
    return crypto.createHmac('sha224', key).update(message).digest('hex');
}

// Browser WebCrypto API
async function sha224Browser(message) {
    const encoder = new TextEncoder();
    const data = encoder.encode(message);
    const hashBuffer = await crypto.subtle.digest('SHA-224', data);
    const hashArray = Array.from(new Uint8Array(hashBuffer));
    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
}

// Usage
console.log(sha224Hash('Hello, SHA-224!'));
sha224File('example.txt').then(console.log);
console.log(hmacSha224('secret-key', 'message'));

// Java SHA-224 Example
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.file.Files;
import java.nio.file.Paths;

public class SHA224Example {

    // Basic hashing
    public static String sha224Hash(String input) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-224");
        byte[] hashBytes = md.digest(input.getBytes());
        return bytesToHex(hashBytes);
    }

    // File hashing
    public static String sha224File(String filepath) throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA-224");
        byte[] fileBytes = Files.readAllBytes(Paths.get(filepath));
        byte[] hashBytes = md.digest(fileBytes);
        return bytesToHex(hashBytes);
    }

    // HMAC-SHA224
    public static String hmacSha224(String key, String message) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA224");
        SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), "HmacSHA224");
        mac.init(secretKey);
        byte[] hashBytes = mac.doFinal(message.getBytes());
        return bytesToHex(hashBytes);
    }

    // Helper method
    private static String bytesToHex(byte[] bytes) {
        StringBuilder result = new StringBuilder();
        for (byte b : bytes) {
            result.append(String.format("%02x", b));
        }
        return result.toString();
    }

    public static void main(String[] args) throws Exception {
        System.out.println(sha224Hash("Hello, SHA-224!"));
        System.out.println(sha224File("example.txt"));
        System.out.println(hmacSha224("secret-key", "message"));
    }
}

// Go SHA-224 Example
package main

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

// Basic hashing
func sha224Hash(data string) string {
    h := sha256.New224()
    h.Write([]byte(data))
    return hex.EncodeToString(h.Sum(nil))
}

// File hashing
func sha224File(filepath string) (string, error) {
    file, err := os.Open(filepath)
    if err != nil {
        return "", err
    }
    defer file.Close()

    h := sha256.New224()
    if _, err := io.Copy(h, file); err != nil {
        return "", err
    }

    return hex.EncodeToString(h.Sum(nil)), nil
}

// HMAC-SHA224
func hmacSha224(key, message string) string {
    h := hmac.New(sha256.New224, []byte(key))
    h.Write([]byte(message))
    return hex.EncodeToString(h.Sum(nil))
}

func main() {
    fmt.Println(sha224Hash("Hello, SHA-224!"))

    hash, _ := sha224File("example.txt")
    fmt.Println(hash)

    fmt.Println(hmacSha224("secret-key", "message"))
}

// Rust SHA-224 Example
use sha2::{Sha224, Digest};
use hmac::{Hmac, Mac};
use std::fs::File;
use std::io::Read;

// Basic hashing
fn sha224_hash(data: &str) -> String {
    let mut hasher = Sha224::new();
    hasher.update(data.as_bytes());
    format!("{:x}", hasher.finalize())
}

// File hashing
fn sha224_file(filepath: &str) -> std::io::Result {
    let mut file = File::open(filepath)?;
    let mut hasher = Sha224::new();
    let mut buffer = [0u8; 4096];

    loop {
        let bytes_read = file.read(&mut buffer)?;
        if bytes_read == 0 {
            break;
        }
        hasher.update(&buffer[..bytes_read]);
    }

    Ok(format!("{:x}", hasher.finalize()))
}

// HMAC-SHA224
fn hmac_sha224(key: &str, message: &str) -> String {
    type HmacSha224 = Hmac;

    let mut mac = HmacSha224::new_from_slice(key.as_bytes())
        .expect("HMAC can take key of any size");
    mac.update(message.as_bytes());

    format!("{:x}", mac.finalize().into_bytes())
}

fn main() {
    println!("{}", sha224_hash("Hello, SHA-224!"));

    match sha224_file("example.txt") {
        Ok(hash) => println!("{}", hash),
        Err(e) => eprintln!("Error: {}", e),
    }

    println!("{}", hmac_sha224("secret-key", "message"));
}

// C# SHA-224 Example
using System;
using System.Security.Cryptography;
using System.Text;
using System.IO;

public class SHA224Example
{
    // Basic hashing
    public static string Sha224Hash(string input)
    {
        using (SHA224 sha224 = SHA224.Create())
        {
            byte[] bytes = Encoding.UTF8.GetBytes(input);
            byte[] hash = sha224.ComputeHash(bytes);
            return BitConverter.ToString(hash).Replace("-", "").ToLower();
        }
    }

    // File hashing
    public static string Sha224File(string filepath)
    {
        using (SHA224 sha224 = SHA224.Create())
        using (FileStream stream = File.OpenRead(filepath))
        {
            byte[] hash = sha224.ComputeHash(stream);
            return BitConverter.ToString(hash).Replace("-", "").ToLower();
        }
    }

    // HMAC-SHA224
    public static string HmacSha224(string key, string message)
    {
        byte[] keyBytes = Encoding.UTF8.GetBytes(key);
        byte[] messageBytes = Encoding.UTF8.GetBytes(message);

        using (HMACSHA224 hmac = new HMACSHA224(keyBytes))
        {
            byte[] hash = hmac.ComputeHash(messageBytes);
            return BitConverter.ToString(hash).Replace("-", "").ToLower();
        }
    }

    static void Main()
    {
        Console.WriteLine(Sha224Hash("Hello, SHA-224!"));
        Console.WriteLine(Sha224File("example.txt"));
        Console.WriteLine(HmacSha224("secret-key", "message"));
    }
}

// PHP SHA-224 Example

// Basic hashing
function sha224_hash($data) {
    return hash('sha224', $data);
}

// File hashing
function sha224_file($filepath) {
    return hash_file('sha224', $filepath);
}

// HMAC-SHA224
function hmac_sha224($key, $message) {
    return hash_hmac('sha224', $message, $key);
}

// Streaming hash for large files
function sha224_file_stream($filepath) {
    $ctx = hash_init('sha224');
    $handle = fopen($filepath, 'rb');

    while (!feof($handle)) {
        $buffer = fread($handle, 4096);
        hash_update($ctx, $buffer);
    }

    fclose($handle);
    return hash_final($ctx);
}

// Password hashing with salt
function sha224_password($password, $salt = null) {
    if ($salt === null) {
        $salt = bin2hex(random_bytes(16));
    }
    $hash = hash('sha224', $salt . $password);
    return $salt . ':' . $hash;
}

// Usage examples
echo sha224_hash("Hello, SHA-224!") . "\n";
echo sha224_file("example.txt") . "\n";
echo hmac_sha224("secret-key", "message") . "\n";
echo sha224_password("mypassword") . "\n";

# Ruby SHA-224 Example
require 'digest'
require 'openssl'

# Basic hashing
def sha224_hash(data)
  Digest::SHA224.hexdigest(data)
end

# File hashing
def sha224_file(filepath)
  Digest::SHA224.file(filepath).hexdigest
end

# HMAC-SHA224
def hmac_sha224(key, message)
  OpenSSL::HMAC.hexdigest('SHA224', key, message)
end

# Streaming hash for large files
def sha224_file_stream(filepath)
  digest = Digest::SHA224.new
  File.open(filepath, 'rb') do |file|
    buffer = ""
    while file.read(4096, buffer)
      digest.update(buffer)
    end
  end
  digest.hexdigest
end

# Class-based approach
class SHA224Hasher
  def initialize
    @digest = Digest::SHA224.new
  end

  def update(data)
    @digest.update(data)
    self
  end

  def finalize
    @digest.hexdigest
  end
end

# Usage examples
puts sha224_hash("Hello, SHA-224!")
puts sha224_file("example.txt")
puts hmac_sha224("secret-key", "message")

# Using the class
hasher = SHA224Hasher.new
hasher.update("Hello, ").update("SHA-224!")
puts hasher.finalize