Hash Generator

SHA-1 (Legacy)

SHA-1 produces a 160-bit (20-byte) hash, typically rendered as a 40-character hex string. It was widely used in TLS/SSL certificates, Git, and digital signatures.

Use only for legacy system compatibility (e.g., verifying old Git commits, legacy certificates).

SHA-256 (Recommended)

SHA-256 produces a 256-bit (32-byte) hash, rendered as a 64-character hex string. It is the most widely used hash algorithm today — standard for TLS 1.2+, Bitcoin, JWT signatures, and certificate transparency.

Use for password hashing (with salt), digital signatures, integrity verification, blockchain, and TLS.

SHA-384 / SHA-512

SHA-384 (384-bit / 48-byte / 96 hex chars) and SHA-512 (512-bit / 64-byte / 128 hex chars) are the larger SHA-2 variants. SHA-512 is faster on 64-bit CPUs; SHA-384 is truncated SHA-512 with different initial values.

SHA-384 common in TLS 1.3 cipher suites; SHA-512 used in some blockchain and PKI systems.

File Checksums vs Text Hashing

This tool supports both text input and file uploads. For files, the entire binary content is streamed through the hash algorithm — identical to sha256sum or shasum CLI tools.

# CLI equivalents (all produce identical results)
sha256sum file.txt
shasum -a 256 file.txt
openssl dgst -sha256 file.txt

# This tool: drag & drop any file → instant checksum

Browser: Web Crypto API

Native crypto.subtle.digest() — no dependencies, works in all modern browsers.

async function sha256(text) {
  const encoder = new TextEncoder();
  const data = encoder.encode(text);
  const hashBuffer = await crypto.subtle.digest('SHA-256', data);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
}

// Usage
const hash = await sha256('Hello, World!');
console.log(hash); // a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e

// For files (FileReader + crypto.subtle)
async function hashFile(file, algorithm = 'SHA-256') {
  const arrayBuffer = await file.arrayBuffer();
  const hashBuffer = await crypto.subtle.digest(algorithm, arrayBuffer);
  return Array.from(new Uint8Array(hashBuffer))
    .map(b => b.toString(16).padStart(2, '0')).join('');
}

Node.js: crypto module

Built-in crypto.createHash() — synchronous and streaming APIs available.

const crypto = require('crypto');

// String hashing
function sha256(text) {
  return crypto.createHash('sha256').update(text, 'utf8').digest('hex');
}

console.log(sha256('Hello, World!'));
// a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e

// File checksum (streaming - memory efficient)
const fs = require('fs');
function hashFile(filepath, algorithm = 'sha256') {
  return new Promise((resolve, reject) => {
    const hash = crypto.createHash(algorithm);
    const stream = fs.createReadStream(filepath);
    stream.on('error', reject);
    stream.on('data', chunk => hash.update(chunk));
    stream.on('end', () => resolve(hash.digest('hex')));
  });
}

// Usage
hashFile('./large-file.iso', 'sha512').then(console.log);

Browser: File Checksum via FileReader

Using FileReader for older browser compatibility (fallback when file.arrayBuffer() unavailable).

function hashFileLegacy(file, algorithm = 'SHA-256') {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = async (e) => {
      try {
        const hashBuffer = await crypto.subtle.digest(algorithm, e.target.result);
        const hashArray = Array.from(new Uint8Array(hashBuffer));
        resolve(hashArray.map(b => b.toString(16).padStart(2, '0')).join(''));
      } catch (err) { reject(err); }
    };
    reader.onerror = () => reject(reader.error);
    reader.readAsArrayBuffer(file);
  });
}

// Usage
const fileInput = document.getElementById('file-input');
fileInput.addEventListener('change', async (e) => {
  const file = e.target.files[0];
  if (file) {
    const hash = await hashFileLegacy(file, 'SHA-256');
    console.log('SHA-256:', hash);
  }
});

Algorithm Selection Guide

Quick reference for choosing the right hash algorithm.

// Use SHA-256 for:
- Password hashing (with bcrypt/scrypt/Argon2 wrapper)
- JWT signatures (HS256, RS256)
- File integrity checks
- TLS certificates
- General purpose cryptographic hashing

// Use SHA-384 for:
- TLS 1.3 cipher suites (AES-GCM-SHA384)
- When regulatory compliance requires >256-bit
- Certificate transparency logs

// Use SHA-512 for:
- Long-term archival (20+ years)
- Some blockchain protocols
- When SHA-512/256 (truncated) needed

// Avoid SHA-1 for:
- Any new security application
- Digital signatures
- Certificate generation
- Password storage

// MD5: NOT available in Web Crypto API
// Use only for non-cryptographic checksums (e.g., file dedup)