SHA-224 Troubleshooting Guide

import hashlib

# Check for line ending issues
text_windows = "Hello\r\nWorld"  # Windows style
text_unix = "Hello\nWorld"       # Unix style

hash_windows = hashlib.sha224(text_windows.encode()).hexdigest()
hash_unix = hashlib.sha224(text_unix.encode()).hexdigest()

print(f"Windows (CRLF): {hash_windows}")
print(f"Unix (LF):      {hash_unix}")
print(f"Match: {hash_windows == hash_unix}")  # False!

# Solution: Normalize line endings
def normalize_text(text):
    return text.replace('\r\n', '\n').replace('\r', '\n')

text1_normalized = normalize_text("Hello\r\nWorld")
text2_normalized = normalize_text("Hello\nWorld")

hash1 = hashlib.sha224(text1_normalized.encode()).hexdigest()
hash2 = hashlib.sha224(text2_normalized.encode()).hexdigest()
print(f"After normalization: {hash1 == hash2}")  # True!

// Problematic: invisible trailing spaces
const text1 = "Hello World  ";  // Has trailing spaces
const text2 = "Hello World";    // No trailing spaces

// These will produce different hashes!
console.log(SHA224(text1) === SHA224(text2)); // false

// Solution: Always trim input
function safeHash(input) {
  // Remove leading/trailing whitespace
  const cleaned = input.trim();

  // Optionally normalize internal whitespace
  const normalized = cleaned.replace(/\s+/g, ' ');

  return SHA224(normalized);
}

// Now they match
console.log(safeHash(text1) === safeHash(text2)); // true

import hashlib
import codecs

def remove_bom(text):
    """Remove BOM from string if present"""
    if text.startswith(codecs.BOM_UTF8.decode('utf-8')):
        return text[1:]
    return text

# Reading file with potential BOM
def safe_file_hash(filepath):
    with open(filepath, 'r', encoding='utf-8-sig') as f:
        # 'utf-8-sig' automatically removes BOM
        content = f.read()
    return hashlib.sha224(content.encode('utf-8')).hexdigest()

# Manual BOM handling
text_with_bom = '\ufeffHello World'  # BOM character
text_without = 'Hello World'

print(f"With BOM: {hashlib.sha224(text_with_bom.encode()).hexdigest()}")
print(f"Without:  {hashlib.sha224(text_without.encode()).hexdigest()}")

# Clean version
cleaned = remove_bom(text_with_bom)
print(f"Cleaned:  {hashlib.sha224(cleaned.encode()).hexdigest()}")

import hashlib

text = "Café"  # Contains non-ASCII character

# Different encodings produce different hashes
encodings = ['utf-8', 'latin-1', 'ascii', 'utf-16']

for encoding in encodings:
    try:
        encoded = text.encode(encoding)
        hash_value = hashlib.sha224(encoded).hexdigest()
        print(f"{encoding:8} : {hash_value}")
    except UnicodeEncodeError:
        print(f"{encoding:8} : Cannot encode!")

# Best practice: Always use UTF-8
def consistent_hash(text):
    """Always use UTF-8 encoding for consistency"""
    if isinstance(text, bytes):
        # If already bytes, decode and re-encode to ensure UTF-8
        text = text.decode('utf-8', errors='replace')
    return hashlib.sha224(text.encode('utf-8')).hexdigest()

// Common mistake: Hashing Base64 string instead of decoded data
const data = "Hello World";
const base64 = btoa(data);

// Wrong: Hashing the Base64 string
const wrongHash = SHA224(base64);

// Correct: Decode Base64 first, then hash
function hashBase64Data(base64String) {
  // Decode Base64 to binary
  const binaryString = atob(base64String);

  // Convert to byte array
  const bytes = new Uint8Array(binaryString.length);
  for (let i = 0; i < binaryString.length; i++) {
    bytes[i] = binaryString.charCodeAt(i);
  }

  // Hash the actual bytes
  return SHA224(bytes);
}

// For Node.js
function hashBase64NodeJS(base64String) {
  const crypto = require('crypto');
  const buffer = Buffer.from(base64String, 'base64');
  return crypto.createHash('sha224').update(buffer).digest('hex');
}

import hashlib

# Common confusion: hex string vs actual bytes
hex_string = "48656c6c6f"  # "Hello" in hex

# Wrong: Hashing the hex string itself
wrong = hashlib.sha224(hex_string.encode()).hexdigest()
print(f"Hashing hex string: {wrong}")

# Correct: Convert hex to bytes first
correct = hashlib.sha224(bytes.fromhex(hex_string)).hexdigest()
print(f"Hashing actual bytes: {correct}")

# Should match hashing "Hello" directly
direct = hashlib.sha224(b"Hello").hexdigest()
print(f"Direct hash of 'Hello': {direct}")
print(f"Matches: {correct == direct}")  # True

import hashlib
import time

def hash_file_inefficient(filepath):
    """DON'T DO THIS - Loads entire file into memory"""
    with open(filepath, 'rb') as f:
        data = f.read()  # Problem: loads entire file!
    return hashlib.sha224(data).hexdigest()

def hash_file_efficient(filepath, chunk_size=8192):
    """Efficient streaming hash for large files"""
    sha224 = hashlib.sha224()

    with open(filepath, 'rb') as f:
        while chunk := f.read(chunk_size):
            sha224.update(chunk)

    return sha224.hexdigest()

def hash_file_with_progress(filepath, chunk_size=8192):
    """Hash with progress reporting"""
    import os

    sha224 = hashlib.sha224()
    file_size = os.path.getsize(filepath)
    processed = 0

    with open(filepath, 'rb') as f:
        while chunk := f.read(chunk_size):
            sha224.update(chunk)
            processed += len(chunk)

            # Report progress
            percent = (processed / file_size) * 100
            print(f"\rProgress: {percent:.1f}%", end='')

    print()  # New line after progress
    return sha224.hexdigest()

# Benchmark different chunk sizes
def find_optimal_chunk_size(filepath):
    sizes = [1024, 4096, 8192, 16384, 32768, 65536]

    for size in sizes:
        start = time.time()
        hash_file_efficient(filepath, size)
        elapsed = time.time() - start
        print(f"Chunk size {size:6}: {elapsed:.3f} seconds")

import hashlib
import concurrent.futures
from pathlib import Path

def hash_single_file(filepath):
    """Hash a single file"""
    sha224 = hashlib.sha224()
    with open(filepath, 'rb') as f:
        while chunk := f.read(8192):
            sha224.update(chunk)
    return filepath, sha224.hexdigest()

def hash_files_sequential(file_list):
    """Slow: Process files one by one"""
    results = {}
    for filepath in file_list:
        _, hash_value = hash_single_file(filepath)
        results[filepath] = hash_value
    return results

def hash_files_parallel(file_list, max_workers=4):
    """Fast: Process files in parallel"""
    results = {}

    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
        # Submit all tasks
        future_to_file = {
            executor.submit(hash_single_file, filepath): filepath
            for filepath in file_list
        }

        # Collect results as they complete
        for future in concurrent.futures.as_completed(future_to_file):
            filepath, hash_value = future.result()
            results[filepath] = hash_value

    return results

# Usage example
files = list(Path('/some/directory').glob('*.txt'))
results = hash_files_parallel(files)

const crypto = require('crypto');
const fs = require('fs');
const { pipeline } = require('stream');

// Inefficient: Loading entire file
function hashFileInefficient(filepath) {
  const data = fs.readFileSync(filepath);
  return crypto.createHash('sha224').update(data).digest('hex');
}

// Efficient: Streaming
function hashFileStream(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);
  });
}

// With progress reporting
function hashFileWithProgress(filepath, onProgress) {
  return new Promise((resolve, reject) => {
    const hash = crypto.createHash('sha224');
    const stats = fs.statSync(filepath);
    const stream = fs.createReadStream(filepath);
    let processed = 0;

    stream.on('data', chunk => {
      hash.update(chunk);
      processed += chunk.length;

      if (onProgress) {
        const percent = (processed / stats.size) * 100;
        onProgress(percent);
      }
    });

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

// Usage
hashFileWithProgress('large-file.bin', percent => {
  process.stdout.write(`\rProgress: ${percent.toFixed(1)}%`);
}).then(hash => {
  console.log(`\nHash: ${hash}`);
});

const crypto = require('crypto');

// Common mistake: Wrong method chaining
try {
  // Wrong: digest() returns string, can't update after
  const hash = crypto.createHash('sha224')
    .digest('hex')
    .update('more data');  // Error!
} catch(e) {
  console.log("Error:", e.message);
}

// Correct: update() before digest()
const hash1 = crypto.createHash('sha224')
  .update('first part')
  .update('second part')
  .digest('hex');

// Reusable hash function with error handling
function createSHA224Hash(data) {
  try {
    if (typeof data === 'string') {
      return crypto.createHash('sha224').update(data, 'utf8').digest('hex');
    } else if (Buffer.isBuffer(data)) {
      return crypto.createHash('sha224').update(data).digest('hex');
    } else if (data instanceof Uint8Array) {
      return crypto.createHash('sha224').update(Buffer.from(data)).digest('hex');
    } else {
      throw new Error('Invalid input type');
    }
  } catch (error) {
    console.error('Hash creation failed:', error);
    return null;
  }
}

import hashlib

# Standard library (always available)
def stdlib_sha224(data):
    if isinstance(data, str):
        data = data.encode('utf-8')
    return hashlib.sha224(data).hexdigest()

# Using PyCryptodome (third-party)
try:
    from Crypto.Hash import SHA224

    def pycryptodome_sha224(data):
        if isinstance(data, str):
            data = data.encode('utf-8')
        h = SHA224.new()
        h.update(data)
        return h.hexdigest()
except ImportError:
    print("PyCryptodome not installed")

# Using cryptography library
try:
    from cryptography.hazmat.primitives import hashes
    from cryptography.hazmat.backends import default_backend

    def cryptography_sha224(data):
        if isinstance(data, str):
            data = data.encode('utf-8')
        digest = hashes.Hash(hashes.SHA224(), backend=default_backend())
        digest.update(data)
        return digest.finalize().hex()
except ImportError:
    print("cryptography library not installed")

# Verify all produce same result
test_data = "Hello World"
results = []

results.append(stdlib_sha224(test_data))
print(f"Standard library: {results[0]}")

try:
    results.append(pycryptodome_sha224(test_data))
    print(f"PyCryptodome:     {results[1]}")
except NameError:
    pass

try:
    results.append(cryptography_sha224(test_data))
    print(f"Cryptography:     {results[2]}")
except NameError:
    pass

# Check all match
if len(set(results)) == 1:
    print("✓ All libraries produce identical results")
else:
    print("✗ Library mismatch detected!")

import hashlib
import struct
import sys

# Check system endianness
print(f"System endianness: {sys.byteorder}")

# Integer to bytes - endianness matters!
number = 0x12345678

# Different endianness produces different hashes
big_endian = struct.pack('>I', number)  # Big-endian
little_endian = struct.pack('