SHA-224 Implementation Solutions

# Secure password storage using PBKDF2 with SHA-224
import os
import hashlib
import binascii

def hash_password(password):
    # Generate a random 16-byte salt
    salt = os.urandom(16)
    
    # Key stretching with PBKDF2-HMAC-SHA224
    # Using 100,000 iterations (adjust based on your security requirements)
    iterations = 100000
    password_hash = hashlib.pbkdf2_hmac(
        'sha224',
        password.encode('utf-8'),
        salt,
        iterations,
        dklen=32  # 32-byte derived key
    )
    
    # Format: algorithm$iterations$salt$hash
    return f"pbkdf2-sha224${iterations}${binascii.hexlify(salt).decode()}${binascii.hexlify(password_hash).decode()}"

def verify_password(stored_hash, provided_password):
    # Extract the components
    algorithm, iterations, salt, hash_value = stored_hash.split('$', 3)
    
    if algorithm != "pbkdf2-sha224":
        raise ValueError("Unsupported algorithm")
    
    # Convert parameters to correct types
    iterations = int(iterations)
    salt = binascii.unhexlify(salt)
    
    # Calculate hash of provided password
    derived_key = hashlib.pbkdf2_hmac(
        'sha224',
        provided_password.encode('utf-8'),
        salt,
        iterations,
        dklen=32
    )
    
    # Constant-time comparison to prevent timing attacks
    # (using hmac.compare_digest would be even better)
    calculated_hash = binascii.hexlify(derived_key).decode()
    
    return calculated_hash == hash_value

# Example usage
password = "mySecurePassword123"
hashed = hash_password(password)
print(f"Stored hash: {hashed}")

# Verification
is_valid = verify_password(hashed, password)
print(f"Password verified: {is_valid}")

// File hashing and verification for secure file transfer
// Requires Node.js with crypto module

const fs = require('fs');
const crypto = require('crypto');
const path = require('path');

/**
 * Calculate SHA-224 hash of a file
 * @param {string} filePath - Path to the file
 * @returns {Promise} - SHA-224 hash as a hex string
 */
function calculateFileHash(filePath) {
  return new Promise((resolve, reject) => {
    const hash = crypto.createHash('sha224');
    const stream = fs.createReadStream(filePath);
    
    stream.on('error', err => reject(err));
    
    stream.on('data', chunk => {
      hash.update(chunk);
    });
    
    stream.on('end', () => {
      resolve(hash.digest('hex'));
    });
  });
}

/**
 * Create a manifest file with SHA-224 hashes for a directory
 * @param {string} directoryPath - Path to directory containing files
 * @param {string} manifestPath - Path to write the manifest file
 */
async function createHashManifest(directoryPath, manifestPath) {
  try {
    const files = fs.readdirSync(directoryPath)
      .filter(file => fs.statSync(path.join(directoryPath, file)).isFile());
    
    const manifest = {};
    
    for (const file of files) {
      const filePath = path.join(directoryPath, file);
      const hash = await calculateFileHash(filePath);
      manifest[file] = hash;
    }
    
    fs.writeFileSync(
      manifestPath, 
      JSON.stringify(manifest, null, 2), 
      'utf8'
    );
    
    console.log(`Manifest created at ${manifestPath}`);
    return manifest;
  } catch (error) {
    console.error('Error creating manifest:', error);
    throw error;
  }
}

/**
 * Verify files against a hash manifest
 * @param {string} directoryPath - Path to directory containing files
 * @param {string} manifestPath - Path to the manifest file
 * @returns {Promise