SHA-224 in JavaScript: Complete Guide

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

/**
 * SHA-224 Hasher class for Node.js
 */
class SHA224Hasher {
  /**
   * Hash a string
   * @param {string} data - String to hash
   * @param {string} encoding - Input encoding (default: 'utf8')
   * @returns {string} Hex digest
   */
  static hashString(data, encoding = 'utf8') {
    return crypto
      .createHash('sha224')
      .update(data, encoding)
      .digest('hex');
  }

  /**
   * Hash a buffer
   * @param {Buffer} buffer - Buffer to hash
   * @returns {string} Hex digest
   */
  static hashBuffer(buffer) {
    return crypto
      .createHash('sha224')
      .update(buffer)
      .digest('hex');
  }

  /**
   * Hash a file synchronously
   * @param {string} filepath - Path to file
   * @returns {string} Hex digest
   */
  static hashFileSync(filepath) {
    const fileBuffer = fs.readFileSync(filepath);
    return this.hashBuffer(fileBuffer);
  }

  /**
   * Hash a file asynchronously
   * @param {string} filepath - Path to file
   * @returns {Promise} Promise resolving to hex digest
   */
  static async hashFile(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);
    });
  }

  /**
   * Hash a file using streams (most efficient)
   * @param {string} filepath - Path to file
   * @returns {Promise} Promise resolving to hex digest
   */
  static async hashFileStream(filepath) {
    const hash = crypto.createHash('sha224');
    const stream = fs.createReadStream(filepath);
    const pipelineAsync = promisify(pipeline);

    await pipelineAsync(stream, hash);
    return hash.digest('hex');
  }

  /**
   * Hash multiple chunks incrementally
   * @param {Array} chunks - Array of data chunks
   * @returns {string} Hex digest
   */
  static hashChunks(chunks) {
    const hash = crypto.createHash('sha224');

    for (const chunk of chunks) {
      hash.update(chunk);
    }

    return hash.digest('hex');
  }

  /**
   * Create HMAC-SHA224
   * @param {string} key - Secret key
   * @param {string} data - Data to authenticate
   * @returns {string} HMAC hex digest
   */
  static createHMAC(key, data) {
    return crypto
      .createHmac('sha224', key)
      .update(data)
      .digest('hex');
  }
}

// Usage examples
async function examples() {
  // Hash string
  const stringHash = SHA224Hasher.hashString('Hello World');
  console.log('String hash:', stringHash);

  // Hash buffer
  const bufferHash = SHA224Hasher.hashBuffer(Buffer.from('Binary data'));
  console.log('Buffer hash:', bufferHash);

  // Hash file (async)
  try {
    const fileHash = await SHA224Hasher.hashFile('./example.txt');
    console.log('File hash:', fileHash);
  } catch (error) {
    console.error('Error hashing file:', error);
  }

  // HMAC
  const hmac = SHA224Hasher.createHMAC('secret-key', 'message');
  console.log('HMAC:', hmac);

  // Incremental hashing
  const chunks = ['Part 1', 'Part 2', 'Part 3'];
  const chunkedHash = SHA224Hasher.hashChunks(chunks);
  console.log('Chunked hash:', chunkedHash);
}

// examples();

module.exports = SHA224Hasher;

const crypto = require('crypto');
const fs = require('fs');
const { Transform, Readable } = require('stream');
const { pipeline } = require('stream/promises');

/**
 * Custom transform stream for hashing with progress
 */
class HashTransform extends Transform {
  constructor(algorithm = 'sha224', onProgress) {
    super();
    this.hash = crypto.createHash(algorithm);
    this.bytesProcessed = 0;
    this.onProgress = onProgress;
    this.startTime = Date.now();
  }

  _transform(chunk, encoding, callback) {
    this.hash.update(chunk);
    this.bytesProcessed += chunk.length;

    if (this.onProgress) {
      const elapsed = (Date.now() - this.startTime) / 1000;
      const throughput = this.bytesProcessed / elapsed / 1048576; // MB/s

      this.onProgress({
        bytesProcessed: this.bytesProcessed,
        elapsedTime: elapsed,
        throughputMBps: throughput
      });
    }

    // Pass through the data unchanged
    callback(null, chunk);
  }

  _flush(callback) {
    this.push(this.hash.digest('hex'));
    callback();
  }

  getHash() {
    return this.hash.digest('hex');
  }
}

/**
 * Advanced streaming SHA-224 hasher
 */
class StreamingHasher {
  /**
   * Hash file with progress reporting
   * @param {string} filepath - Path to file
   * @param {Function} onProgress - Progress callback
   * @returns {Promise