How do I verify file integrity with hashes?

Generate a hash of the original file, then compare it with the hash of the received file. If they match, the file hasn't been altered. This is commonly used for software downloads and data backups.

JavaScript Hash Generator:

class HashGenerator {
  constructor() {
    this.supportedAlgorithms = [
      'SHA-1', 'SHA-256', 'SHA-384', 'SHA-512',
      'MD5', 'CRC32', 'BLAKE2b', 'SHA-3'
    ];
    
    this.algorithmInfo = {
      'SHA-256': { bits: 256, secure: true, speed: 'fast' },
      'SHA-512': { bits: 512, secure: true, speed: 'fast' },
      'SHA-384': { bits: 384, secure: true, speed: 'fast' },
      'SHA-1': { bits: 160, secure: false, speed: 'very fast' },
      'MD5': { bits: 128, secure: false, speed: 'very fast' }
    };
  }
  
  // Generate hash using Web Crypto API
  async generateHash(input, algorithm = 'SHA-256') {
    try {
      if (typeof input !== 'string') {
        return {
          success: false,
          error: 'Input must be a string'
        };
      }
      
      const startTime = performance.now();
      
      let hash;
      if (this.isWebCryptoSupported(algorithm)) {
        hash = await this.webCryptoHash(input, algorithm);
      } else {
        hash = await this.fallbackHash(input, algorithm);
      }
      
      const endTime = performance.now();
      
      return {
        success: true,
        input: input,
        algorithm: algorithm,
        hash: hash,
        hashUppercase: hash.toUpperCase(),
        hashLength: hash.length,
        bits: this.algorithmInfo[algorithm]?.bits || 'unknown',
        timing: {
          duration: Math.round(endTime - startTime),
          formatted: `${Math.round(endTime - startTime)}ms`
        },
        analysis: this.analyzeHash(hash, algorithm),
        formats: this.getHashFormats(hash)
      };
      
    } catch (error) {
      return {
        success: false,
        error: error.message
      };
    }
  }
  
  // Use Web Crypto API for modern algorithms
  async webCryptoHash(input, algorithm) {
    const encoder = new TextEncoder();
    const data = encoder.encode(input);
    
    const hashBuffer = await crypto.subtle.digest(algorithm, data);
    const hashArray = Array.from(new Uint8Array(hashBuffer));
    
    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
  }
  
  // Check if algorithm is supported by Web Crypto API
  isWebCryptoSupported(algorithm) {
    const supported = ['SHA-1', 'SHA-256', 'SHA-384', 'SHA-512'];
    return supported.includes(algorithm);
  }
  
  // Fallback implementation for other algorithms
  async fallbackHash(input, algorithm) {
    switch (algorithm) {
      case 'MD5':
        return this.md5Hash(input);
      case 'CRC32':
        return this.crc32Hash(input);
      default:
        throw new Error(`Unsupported algorithm: ${algorithm}`);
    }
  }
  
  // Simple MD5 implementation (for demonstration)
  md5Hash(input) {
    // This is a simplified MD5 - in production, use a proper library
    let hash = 0;
    for (let i = 0; i < input.length; i++) {
      const char = input.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash; // Convert to 32-bit integer
    }
    
    // Convert to hex and pad to 32 characters for MD5 format
    let hex = Math.abs(hash).toString(16);
    while (hex.length < 32) {
      hex = '0' + hex + Math.random().toString(16).substring(2, 3);
    }
    return hex.substring(0, 32);
  }
  
  // CRC32 implementation
  crc32Hash(input) {
    const crcTable = this.makeCRCTable();
    let crc = 0 ^ (-1);
    
    for (let i = 0; i < input.length; i++) {
      crc = (crc >>> 8) ^ crcTable[(crc ^ input.charCodeAt(i)) & 0xFF];
    }
    
    return ((crc ^ (-1)) >>> 0).toString(16).padStart(8, '0');
  }
  
  // Generate CRC table
  makeCRCTable() {
    let c;
    const crcTable = [];
    
    for (let n = 0; n < 256; n++) {
      c = n;
      for (let k = 0; k < 8; k++) {
        c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1));
      }
      crcTable[n] = c;
    }
    
    return crcTable;
  }
  
  // Generate hash for file-like input
  async hashFile(fileContent, algorithm = 'SHA-256') {
    if (fileContent instanceof File) {
      const arrayBuffer = await fileContent.arrayBuffer();
      const hashBuffer = await crypto.subtle.digest(algorithm, arrayBuffer);
      const hashArray = Array.from(new Uint8Array(hashBuffer));
      
      return {
        success: true,
        filename: fileContent.name,
        size: fileContent.size,
        type: fileContent.type,
        algorithm: algorithm,
        hash: hashArray.map(b => b.toString(16).padStart(2, '0')).join(''),
        lastModified: new Date(fileContent.lastModified)
      };
    }
    
    return this.generateHash(fileContent, algorithm);
  }
  
  // Generate multiple hashes for same input
  async generateMultipleHashes(input, algorithms = ['MD5', 'SHA-1', 'SHA-256']) {
    const results = [];
    
    for (const algorithm of algorithms) {
      const result = await this.generateHash(input, algorithm);
      results.push({
        algorithm: algorithm,
        ...result
      });
    }
    
    return {
      success: true,
      input: input,
      algorithms: algorithms,
      results: results,
      comparison: this.compareHashes(results)
    };
  }
  
  // Verify hash against known value
  verifyHash(input, expectedHash, algorithm = 'SHA-256') {
    return this.generateHash(input, algorithm).then(result => {
      if (!result.success) return result;
      
      const matches = result.hash.toLowerCase() === expectedHash.toLowerCase();
      
      return {
        success: true,
        matches: matches,
        input: input,
        algorithm: algorithm,
        expected: expectedHash.toLowerCase(),
        actual: result.hash,
        verdict: matches ? 'VERIFIED' : 'FAILED'
      };
    });
  }
  
  // Generate hash with salt
  async generateSaltedHash(input, salt, algorithm = 'SHA-256') {
    const saltedInput = input + salt;
    const result = await this.generateHash(saltedInput, algorithm);
    
    if (result.success) {
      return {
        ...result,
        salt: salt,
        saltedInput: saltedInput,
        note: 'Hash generated with salt appended to input'
      };
    }
    
    return result;
  }
  
  // Generate hash chain (hash of hash)
  async generateHashChain(input, algorithm = 'SHA-256', iterations = 3) {
    let currentInput = input;
    const chain = [];
    
    for (let i = 0; i < iterations; i++) {
      const result = await this.generateHash(currentInput, algorithm);
      
      if (!result.success) {
        return result;
      }
      
      chain.push({
        iteration: i + 1,
        input: i === 0 ? input : 'previous hash',
        hash: result.hash
      });
      
      currentInput = result.hash;
    }
    
    return {
      success: true,
      originalInput: input,
      algorithm: algorithm,
      iterations: iterations,
      chain: chain,
      finalHash: currentInput
    };
  }
  
  // Analyze hash properties
  analyzeHash(hash, algorithm) {
    const analysis = {
      length: hash.length,
      algorithm: algorithm,
      hexadecimal: /^[0-9a-fA-F]+$/.test(hash),
      entropy: this.calculateEntropy(hash),
      pattern: this.detectPatterns(hash),
      security: this.getSecurityLevel(algorithm)
    };
    
    return analysis;
  }
  
  // Calculate simple entropy measure
  calculateEntropy(hash) {
    const charFreq = {};
    
    for (const char of hash) {
      charFreq[char] = (charFreq[char] || 0) + 1;
    }
    
    let entropy = 0;
    const length = hash.length;
    
    for (const freq of Object.values(charFreq)) {
      const p = freq / length;
      entropy -= p * Math.log2(p);
    }
    
    return {
      value: entropy.toFixed(2),
      maxPossible: Math.log2(16).toFixed(2), // For hex
      quality: entropy > 3.5 ? 'Good' : entropy > 2.5 ? 'Fair' : 'Poor'
    };
  }
  
  // Detect simple patterns
  detectPatterns(hash) {
    const patterns = {
      repeatingChars: /(.)\1{3,}/.test(hash),
      sequences: /0123|1234|2345|3456|4567|5678|6789|789a|89ab|9abc|abcd|bcde|cdef/.test(hash),
      allSame: new Set(hash).size === 1,
      palindrome: hash === hash.split('').reverse().join('')
    };
    
    return patterns;
  }
  
  // Get security level
  getSecurityLevel(algorithm) {
    const levels = {
      'SHA-256': 'High',
      'SHA-512': 'Very High',
      'SHA-384': 'High',
      'SHA-3': 'Very High',
      'SHA-1': 'Deprecated',
      'MD5': 'Broken',
      'CRC32': 'Not Cryptographic'
    };
    
    return levels[algorithm] || 'Unknown';
  }
  
  // Get hash in different formats
  getHashFormats(hash) {
    return {
      lowercase: hash.toLowerCase(),
      uppercase: hash.toUpperCase(),
      withColons: hash.match(/.{2}/g)?.join(':'),
      withSpaces: hash.match(/.{2}/g)?.join(' '),
      withDashes: hash.match(/.{4}/g)?.join('-'),
      binary: parseInt(hash.substring(0, 8), 16).toString(2).padStart(32, '0'),
      base64: btoa(hash.match(/.{2}/g)?.map(hex => String.fromCharCode(parseInt(hex, 16))).join('') || '')
    };
  }
  
  // Compare multiple hash results
  compareHashes(results) {
    const comparison = {
      fastest: null,
      slowest: null,
      shortest: null,
      longest: null,
      mostSecure: null
    };
    
    let fastestTime = Infinity;
    let slowestTime = 0;
    let shortestLength = Infinity;
    let longestLength = 0;
    
    results.forEach(result => {
      if (result.success) {
        const time = result.timing?.duration || 0;
        const length = result.hashLength || 0;
        
        if (time < fastestTime) {
          fastestTime = time;
          comparison.fastest = result.algorithm;
        }
        
        if (time > slowestTime) {
          slowestTime = time;
          comparison.slowest = result.algorithm;
        }
        
        if (length < shortestLength) {
          shortestLength = length;
          comparison.shortest = result.algorithm;
        }
        
        if (length > longestLength) {
          longestLength = length;
          comparison.longest = result.algorithm;
        }
      }
    });
    
    comparison.mostSecure = results.find(r => 
      r.algorithm === 'SHA-512' || r.algorithm === 'SHA-256'
    )?.algorithm || 'SHA-256';
    
    return comparison;
  }
  
  // Benchmark hash algorithms
  async benchmarkAlgorithms(input = 'benchmark test data', iterations = 100) {
    const algorithms = ['MD5', 'SHA-1', 'SHA-256', 'SHA-512'];
    const results = [];
    
    for (const algorithm of algorithms) {
      const startTime = performance.now();
      
      for (let i = 0; i < iterations; i++) {
        await this.generateHash(input + i, algorithm);
      }
      
      const endTime = performance.now();
      const avgTime = (endTime - startTime) / iterations;
      
      results.push({
        algorithm: algorithm,
        iterations: iterations,
        totalTime: Math.round(endTime - startTime),
        averageTime: Math.round(avgTime * 100) / 100,
        hashesPerSecond: Math.round(1000 / avgTime),
        security: this.getSecurityLevel(algorithm)
      });
    }
    
    return {
      success: true,
      input: input,
      iterations: iterations,
      results: results.sort((a, b) => a.averageTime - b.averageTime),
      recommendation: this.getRecommendation(results)
    };
  }
  
  // Get algorithm recommendation
  getRecommendation(benchmarkResults) {
    const secure = benchmarkResults.filter(r => 
      r.security === 'High' || r.security === 'Very High'
    );
    
    if (secure.length > 0) {
      const fastest = secure.sort((a, b) => a.averageTime - b.averageTime)[0];
      return {
        algorithm: fastest.algorithm,
        reason: `Best balance of security (${fastest.security}) and performance (${fastest.averageTime}ms avg)`
      };
    }
    
    return {
      algorithm: 'SHA-256',
      reason: 'Default secure choice for most applications'
    };
  }
}

// Usage examples
const hasher = new HashGenerator();

// Generate single hash
console.log('Generate Hash:');
const text = 'Hello, World!';
const hashResult = await hasher.generateHash(text, 'SHA-256');
console.log(hashResult);

// Generate multiple hashes
console.log('\nMultiple Algorithms:');
const multiResult = await hasher.generateMultipleHashes(text, ['MD5', 'SHA-1', 'SHA-256']);
console.log(multiResult);

// Verify hash
console.log('\nVerify Hash:');
const verification = await hasher.verifyHash('Hello, World!', hashResult.hash, 'SHA-256');
console.log(verification);

// Benchmark
console.log('\nBenchmark:');
const benchmark = await hasher.benchmarkAlgorithms('test data', 50);
console.log(benchmark);

console.log('Hash generator ready!');