SHA-224 Benchmarks and Comparisons

// JavaScript example using Web Crypto API
async function generateSignature(message, privateKey) {
  const encoder = new TextEncoder();
  const data = encoder.encode(message);
  
  // SHA-224 is appropriate for a 2048-bit RSA key
  const signature = await window.crypto.subtle.sign(
    {
      name: "RSASSA-PKCS1-v1_5",
      hash: {name: "SHA-224"},
    },
    privateKey,
    data
  );
  
  return signature;
}

// C example optimized for embedded systems
#include "sha224.h"

void verify_firmware_integrity(const uint8_t *firmware, size_t length, const uint8_t expected_hash[28]) {
  SHA224_CTX ctx;
  uint8_t hash[28];
  
  SHA224_Init(&ctx);
  SHA224_Update(&ctx, firmware, length);
  SHA224_Final(hash, &ctx);
  
  // Compare computed hash with expected hash
  if (memcmp(hash, expected_hash, 28) == 0) {
    // Firmware integrity verified
    execute_firmware(firmware);
  } else {
    // Integrity check failed
    report_error();
  }
}

# Python example for content-addressable storage
import hashlib
import os

class ContentStore:
    def __init__(self, base_path):
        self.base_path = base_path
        os.makedirs(base_path, exist_ok=True)
    
    def store(self, data):
        """Store data and return its SHA-224 content address"""
        # Calculate SHA-224 hash
        hash_obj = hashlib.sha224(data)
        content_id = hash_obj.hexdigest()
        
        # Organize files in a directory structure based on hash prefix
        prefix = content_id[:4]
        dir_path = os.path.join(self.base_path, prefix)
        os.makedirs(dir_path, exist_ok=True)
        
        # Store data if it doesn't already exist
        file_path = os.path.join(dir_path, content_id)
        if not os.path.exists(file_path):
            with open(file_path, 'wb') as f:
                f.write(data)
        
        return content_id
    
    def retrieve(self, content_id):
        """Retrieve data by its SHA-224 content address"""
        prefix = content_id[:4]
        file_path = os.path.join(self.base_path, prefix, content_id)
        
        if os.path.exists(file_path):
            with open(file_path, 'rb') as f:
                return f.read()
        return None

// Node.js example for a distributed data verification system
const crypto = require('crypto');
const net = require('net');

// Using SHA-224 instead of SHA-256 reduces network traffic by 12.5%
// when transmitting hash values
function createDataVerifier() {
  const server = net.createServer((socket) => {
    socket.on('data', (data) => {
      // Parse the incoming verification request
      const request = JSON.parse(data.toString());
      
      // Calculate SHA-224 hash of the payload
      const hash = crypto.createHash('sha224')
        .update(request.payload)
        .digest('hex');
      
      // Compare with claimed hash
      const verified = hash === request.claimedHash;
      
      // Send verification result
      socket.write(JSON.stringify({
        verified,
        actualHash: hash
      }));
    });
  });
  
  return server;
}