哈希算法与数据安全实践：MD5、SHA家族完全指南

几年前我接手过一个老项目，第一次拉数据库下来看用户表，password 字段全是 32 位十六进制——纯 MD5，没盐，没迭代。更糟的是，里面好几百个账号的哈希值我直接拿去 cmd5 这类在线网站一查，明文当场就出来了，123456、admin888 一抓一大把。那一刻我才真正理解，"哈希过了"和"安全"完全是两码事。

后来我自作聪明，把存密码这块换成了 SHA-256 加盐，觉得 256 位总够长了吧。结果第二年走安全审计，对方一句话把我噎住：SHA-256 是为"快"设计的，你拿一张二手显卡一秒能算几十亿次，加了盐也只是防彩虹表，挡不住针对单个账号的爆破。那次之后我才老老实实换成 bcrypt。

所以这篇不打算从教科书定义开始背。我想把哈希这东西到底"快在哪、坑在哪、什么场景该用什么"讲清楚——这些都是我自己踩过坑、或者眼睁睁看着同事踩坑换来的经验。

先看一张我自己常用的速查表

下面这张表是我贴在 wiki 上、新人入职必看的一页。记不住原理没关系，至少别选错算法：

算法	主要用途	现在还能用吗	我踩过/见过的坑
MD5	文件指纹、缓存键、去重	安全场景一律禁用	当密码存 = 等于裸奔；2004 年王小云就构造出碰撞了
SHA-1	旧系统兼容（Git 历史）	新项目别碰	2017 年 Google 的 SHAttered 已经做出真实碰撞，别再当"比 MD5 安全"用
SHA-256	文件校验、签名、内容寻址	这些场景放心用	千万别拿它直接存密码——太快了，加盐也救不了爆破
bcrypt	密码存储	推荐	cost 别填默认就完事，按服务器性能调到登录有 ~100ms 延迟才合理
Argon2	密码存储（新项目首选）	最推荐	内存参数配太高会被人用登录接口打满内存，上线前压一下

哈希算法基础

什么是哈希

哈希（Hash）是一种单向函数，将任意长度的输入转换为固定长度的输出：

输入 → 哈希函数 → 输出（哈希值/摘要）

"hello"     → MD5  → "5d41402abc4b2a76b9719d911017c592"
"hello123"  → MD5  → "cc03e747a6afbbcbf8be7668acfebee5"

哈希的特性

1. 确定性（Deterministic）

相同输入始终产生相同输出：

// 多次计算结果相同
hash('hello') === hash('hello'); // true

2. 快速计算

哈希运算速度快，适合大数据处理。

3. 雪崩效应（Avalanche Effect）

输入的微小变化导致输出完全不同：

hash('hello'); // 5d41402abc4b2a76b9719d911017c592
hash('hello '); // 3b8292d5e20e01955a89190cdc9d2c9e (多了一个空格)

4. 单向性（One-way）

无法从哈希值反推原始输入：

// ❌ 不可能实现
function reverseHash(hash) {
  // 无法从哈希值得到原始数据
}

5. 抗碰撞性（Collision Resistance）

难以找到两个不同输入产生相同输出：

// 理论上可能，但实际很难找到
hash('input1') === hash('input2'); // 碰撞

哈希的应用场景

// 1. 密码存储
const passwordHash = hash(password + salt);
database.save({ username, password: passwordHash });

// 2. 文件完整性校验
const fileHash = hash(fileContent);
// 下载后验证哈希值是否匹配

// 3. 数据去重
const seen = new Set();
items.forEach((item) => {
  const itemHash = hash(JSON.stringify(item));
  if (!seen.has(itemHash)) {
    seen.add(itemHash);
    processItem(item);
  }
});

// 4. 缓存键生成
const cacheKey = hash(url + params);
const cached = cache.get(cacheKey);

// 5. 数字签名
const signature = sign(hash(document), privateKey);

常见哈希算法详解

MD5（Message-Digest Algorithm 5）

特点：

输出128位（16字节，32位十六进制）
速度快
⚠️ 已被破解，不推荐用于安全场景

// 浏览器环境使用Web Crypto API
async function md5(message) {
  const encoder = new TextEncoder();
  const data = encoder.encode(message);

  // Web Crypto API不直接支持MD5，使用第三方库
  // 或使用SubtleCrypto的SHA系列
}

// Node.js环境
const crypto = require('crypto');

function md5(text) {
  return crypto.createHash('md5').update(text).digest('hex');
}

console.log(md5('hello')); // "5d41402abc4b2a76b9719d911017c592"

安全性：

✅ 文件校验（非安全场景）
❌ 密码存储
❌ 数字签名
❌ 任何需要安全性的场景

MD5碰撞示例：

2004年王小云教授破解MD5，可以在几秒内找到碰撞：

// 两个不同的输入产生相同的MD5
const input1 = '某个特殊构造的字符串1';
const input2 = '某个特殊构造的字符串2';

md5(input1) === md5(input2); // true（碰撞）

SHA-1（Secure Hash Algorithm 1）

特点：

输出160位（20字节，40位十六进制）
比MD5更安全，但也已被破解
Git使用SHA-1（正在迁移到SHA-256）

// 浏览器环境
async function sha1(message) {
  const encoder = new TextEncoder();
  const data = encoder.encode(message);
  const hashBuffer = await crypto.subtle.digest('SHA-1', data);

  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
}

// Node.js
function sha1(text) {
  return crypto.createHash('sha1').update(text).digest('hex');
}

console.log(sha1('hello')); // "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d"

安全性：

✅ 旧系统兼容（如Git）
⚠️ 正在淘汰
❌ 新项目不推荐使用

SHA-256（SHA-2家族）

特点：

输出256位（32字节，64位十六进制）
目前广泛使用，安全性高
比特币使用SHA-256

// 浏览器环境
async function sha256(message) {
  const encoder = new TextEncoder();
  const data = encoder.encode(message);
  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('');
}

// 使用
const hash = await sha256('hello');
console.log(hash); // "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"

SHA-2家族：

SHA-224（224位）
SHA-256（256位）⭐ 最常用
SHA-384（384位）
SHA-512（512位）

// Node.js支持所有SHA-2变体
crypto.createHash('sha224');
crypto.createHash('sha256');
crypto.createHash('sha384');
crypto.createHash('sha512');

SHA-3（Keccak）

特点：

最新的SHA标准（2015年）
与SHA-2结构完全不同
更强的抗碰撞性

// Node.js（v10.0.0+）
function sha3_256(text) {
  return crypto.createHash('sha3-256').update(text).digest('hex');
}

SHA-3变体：

SHA3-224
SHA3-256
SHA3-384
SHA3-512

算法对比

算法	输出长度	安全性	速度	推荐使用
MD5	128位	❌ 已破解	快	仅用于非安全场景
SHA-1	160位	⚠️ 弱	中等	淘汰中
SHA-256	256位	✅ 安全	中等	⭐ 推荐
SHA-512	512位	✅ 非常安全	慢	高安全需求
SHA3-256	256位	✅ 最安全	慢	未来趋势

密码哈希最佳实践

❌ 错误做法：直接哈希

// ❌ 严重错误：直接存储密码的哈希
const passwordHash = sha256(password);
database.save({ username, password: passwordHash });

问题：

彩虹表攻击：预先计算常见密码的哈希值
相同密码相同哈希：容易识别

✅ 正确做法1：加盐（Salt）

// ✅ 使用随机盐值
const salt = generateRandomSalt(); // 随机字符串
const passwordHash = sha256(password + salt);

database.save({
  username,
  password: passwordHash,
  salt: salt, // 盐值也要存储
});

// 验证密码
function verifyPassword(inputPassword, storedHash, storedSalt) {
  const inputHash = sha256(inputPassword + storedSalt);
  return inputHash === storedHash;
}

生成盐值：

function generateSalt(length = 16) {
  const array = new Uint8Array(length);
  crypto.getRandomValues(array);
  return Array.from(array, (b) => b.toString(16).padStart(2, '0')).join('');
}

// Node.js
function generateSalt(length = 16) {
  return crypto.randomBytes(length).toString('hex');
}

✅ 正确做法2：使用bcrypt

// bcrypt专为密码哈希设计
const bcrypt = require('bcrypt');

// 注册：哈希密码
async function hashPassword(password) {
  const saltRounds = 10; // 计算成本因子
  const hash = await bcrypt.hash(password, saltRounds);
  return hash; // 包含盐值的哈希
}

// 登录：验证密码
async function verifyPassword(password, hash) {
  const match = await bcrypt.compare(password, hash);
  return match; // true/false
}

// 使用
const user = {
  username: 'alice',
  password: await hashPassword('mySecret123'),
};
// password: "$2b$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy"

const isValid = await verifyPassword('mySecret123', user.password); // true

bcrypt优势：

自动生成和存储盐值
可调整计算成本（抗暴力破解）
专为密码设计

✅ 正确做法3：使用Argon2

// Argon2：密码哈希竞赛冠军（2015）
const argon2 = require('argon2');

// 哈希密码
async function hashPassword(password) {
  const hash = await argon2.hash(password);
  return hash;
}

// 验证密码
async function verifyPassword(password, hash) {
  return await argon2.verify(hash, password);
}

Argon2优势：

最新、最安全的密码哈希算法
抗GPU/ASIC攻击
可配置内存使用和计算时间

密码哈希对比

方案	安全性	速度	推荐
MD5直接哈希	❌ 极不安全	快	绝不使用
SHA-256 + Salt	⚠️ 基本安全	快	不推荐
bcrypt	✅ 安全	慢（可调）	⭐ 推荐
Argon2	✅ 最安全	慢（可调）	⭐ 最推荐

PBKDF2（基于密码的密钥派生函数）

// 浏览器环境
async function pbkdf2(password, salt, iterations = 100000) {
  const encoder = new TextEncoder();
  const keyMaterial = await crypto.subtle.importKey(
    'raw',
    encoder.encode(password),
    { name: 'PBKDF2' },
    false,
    ['deriveBits']
  );

  const derivedBits = await crypto.subtle.deriveBits(
    {
      name: 'PBKDF2',
      salt: encoder.encode(salt),
      iterations: iterations,
      hash: 'SHA-256',
    },
    keyMaterial,
    256
  );

  const hashArray = Array.from(new Uint8Array(derivedBits));
  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
}

// Node.js
function pbkdf2(password, salt, iterations = 100000) {
  return crypto.pbkdf2Sync(password, salt, iterations, 32, 'sha256').toString('hex');
}

文件完整性校验

计算文件哈希

// 浏览器环境：计算文件MD5/SHA256
async function calculateFileHash(file, algorithm = 'SHA-256') {
  const arrayBuffer = await file.arrayBuffer();
  const hashBuffer = await crypto.subtle.digest(algorithm, arrayBuffer);

  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
}

// 使用
document.querySelector('#fileInput').addEventListener('change', async (e) => {
  const file = e.target.files[0];
  const hash = await calculateFileHash(file);
  console.log(`SHA-256: ${hash}`);
});

分块计算大文件哈希

async function calculateLargeFileHash(file, algorithm = 'SHA-256') {
  const chunkSize = 1024 * 1024; // 1MB
  const chunks = Math.ceil(file.size / chunkSize);

  // Web Crypto不支持流式哈希，使用第三方库
  // 这里展示概念性代码
  let offset = 0;

  for (let i = 0; i < chunks; i++) {
    const chunk = file.slice(offset, offset + chunkSize);
    const arrayBuffer = await chunk.arrayBuffer();
    // 更新哈希...
    offset += chunkSize;
  }

  return hash;
}

完整性校验实战

class FileIntegrityChecker {
  constructor() {
    this.knownHashes = new Map();
  }

  // 注册文件的已知哈希值
  register(filename, hash) {
    this.knownHashes.set(filename, hash.toLowerCase());
  }

  // 校验文件
  async verify(file) {
    const expectedHash = this.knownHashes.get(file.name);

    if (!expectedHash) {
      return { valid: false, error: '未找到已知哈希值' };
    }

    const actualHash = await calculateFileHash(file);

    if (actualHash.toLowerCase() === expectedHash) {
      return { valid: true, hash: actualHash };
    } else {
      return {
        valid: false,
        error: '哈希值不匹配',
        expected: expectedHash,
        actual: actualHash,
      };
    }
  }
}

// 使用
const checker = new FileIntegrityChecker();

// 注册软件的官方哈希值
checker.register('软件.exe', 'abc123...');

// 用户下载后校验
const result = await checker.verify(downloadedFile);
if (result.valid) {
  console.log('✅ 文件完整，未被篡改');
} else {
  console.error('❌ 文件可能被篡改！');
}

实战应用

案例1：防止表单重复提交

class FormSubmitGuard {
  constructor() {
    this.submitted = new Set();
  }

  async canSubmit(formData) {
    // 计算表单数据的哈希
    const dataString = JSON.stringify(formData);
    const hash = await this.hash(dataString);

    if (this.submitted.has(hash)) {
      return false; // 重复提交
    }

    this.submitted.add(hash);
    return true;
  }

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

// 使用
const guard = new FormSubmitGuard();

async function handleSubmit(formData) {
  if (!(await guard.canSubmit(formData))) {
    alert('请勿重复提交！');
    return;
  }

  // 提交表单...
}

案例2：数据去重

class DataDeduplicator {
  constructor() {
    this.seen = new Set();
  }

  async isUnique(data) {
    const hash = await this.hash(data);

    if (this.seen.has(hash)) {
      return false; // 重复
    }

    this.seen.add(hash);
    return true;
  }

  async hash(data) {
    const str = typeof data === 'string' ? data : JSON.stringify(data);
    const encoder = new TextEncoder();
    const dataBuffer = encoder.encode(str);
    const hashBuffer = await crypto.subtle.digest('SHA-256', dataBuffer);
    const hashArray = Array.from(new Uint8Array(hashBuffer));
    return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
  }
}

// 使用：处理API返回的数据
const dedup = new DataDeduplicator();

for (const item of apiData) {
  if (await dedup.isUnique(item)) {
    processItem(item);
  }
}

案例3：ETag生成

// HTTP ETag：用于缓存验证
async function generateETag(content) {
  const hash = await sha256(content);
  return `"${hash.substring(0, 16)}"`;
}

// Express.js示例
app.get('/api/data', async (req, res) => {
  const data = await fetchData();
  const content = JSON.stringify(data);
  const etag = await generateETag(content);

  // 检查客户端ETag
  if (req.headers['if-none-match'] === etag) {
    res.status(304).end(); // Not Modified
    return;
  }

  res.set('ETag', etag);
  res.json(data);
});

案例4：内容寻址存储

// Git风格的内容寻址
class ContentAddressableStorage {
  constructor() {
    this.storage = new Map();
  }

  async store(content) {
    const hash = await this.hash(content);
    this.storage.set(hash, content);
    return hash; // 返回内容的地址
  }

  retrieve(hash) {
    return this.storage.get(hash);
  }

  async hash(content) {
    const encoder = new TextEncoder();
    const data = encoder.encode(content);
    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('');
  }
}

// 使用
const cas = new ContentAddressableStorage();

const hash1 = await cas.store('Hello World');
const hash2 = await cas.store('Hello World'); // 相同内容，相同哈希

console.log(hash1 === hash2); // true（自动去重）
console.log(cas.retrieve(hash1)); // "Hello World"

安全性考虑

1. 选择合适的算法

// ❌ 错误：使用已破解的算法
const hash = md5(sensitiveData);

// ✅ 正确：使用安全的算法
const hash = await sha256(sensitiveData);

2. 密码哈希使用专用算法

// ❌ 错误：用通用哈希存储密码
const passwordHash = sha256(password);

// ✅ 正确：使用bcrypt/Argon2
const passwordHash = await bcrypt.hash(password, 10);

3. 使用足够长的盐值

// ❌ 错误：盐值太短
const salt = Math.random().toString();

// ✅ 正确：至少16字节的随机盐
const salt = crypto.randomBytes(16).toString('hex');

4. 防止时序攻击

// ❌ 错误：直接比较字符串
function verifyHash(input, expected) {
  return input === expected; // 时序攻击漏洞
}

// ✅ 正确：常量时间比较
function verifyHash(input, expected) {
  if (input.length !== expected.length) {
    return false;
  }

  let result = 0;
  for (let i = 0; i < input.length; i++) {
    result |= input.charCodeAt(i) ^ expected.charCodeAt(i);
  }

  return result === 0;
}

// 或使用crypto.timingSafeEqual（Node.js）
const crypto = require('crypto');
const inputBuffer = Buffer.from(input, 'hex');
const expectedBuffer = Buffer.from(expected, 'hex');
const isValid = crypto.timingSafeEqual(inputBuffer, expectedBuffer);

5. 定期更新哈希算法

// 版本化哈希，便于未来升级
function hashWithVersion(data, version = 2) {
  switch (version) {
    case 1:
      return { version: 1, hash: md5(data) }; // 旧版本
    case 2:
      return { version: 2, hash: sha256(data) }; // 当前版本
    default:
      throw new Error('Unsupported version');
  }
}

// 存储
const result = hashWithVersion(data);
database.save({ data: result.hash, hashVersion: result.version });

// 验证时根据版本使用相应算法

写在最后

如果这篇你只想记住一句话，那就是：存密码永远别用 MD5/SHA 这类通用哈希，用 bcrypt 或 Argon2，且别自己造哈希方案。

我见过太多"我加了盐应该没事吧"的侥幸心理。盐解决的是彩虹表，解决不了"这个算法太快"这个根本问题——攻击者拿到你的库，盯着某个 VIP 账号单点爆破，SHA-256 加盐照样一天跑完。bcrypt/Argon2 的整个设计目的就是"故意慢、故意吃内存"，让爆破在经济上不划算。这是密码哈希和普通哈希最本质的区别，别混为一谈。

至于自己拼算法——sha256(sha256(password + salt)) 这种"加固"，绝大多数时候不是更安全，而是引入了你没意识到的弱点。密码学这块，老老实实用经过审计的成熟库，这不是保守，是常识。

文件校验、去重、内容寻址这些非密码场景，SHA-256 足够了，MD5 在不涉及安全时也还能凑合用（图个快）。分清场景，比记住算法名字重要得多。

顺便说一句，我们站上的哈希工具是纯浏览器本地计算的，你输入的内容不会上传到任何服务器。想验证文件指纹、对一下别人给的 SHA-256、或者随手测测雪崩效应，都可以直接拿它试，不用担心把敏感串丢到别人后端。

就这些。哈希不难，难的是分清"看着安全"和"真的安全"。下次再看到用户表里一片裸 MD5，希望那个去补锅的人不是你。

场景	推荐算法	注意事项
密码存储	bcrypt/Argon2	加盐、调整成本因子
文件校验	SHA-256	非安全场景可用MD5
数字签名	SHA-256/SHA-512	配合非对称加密
数据去重	SHA-256	考虑性能
ETag生成	SHA-256前缀	权衡长度和唯一性

哈希算法与数据安全实践：MD5、SHA家族完全指南

先看一张我自己常用的速查表

下面这张表是我贴在 wiki 上、新人入职必看的一页。记不住原理没关系，至少别选错算法：

算法	主要用途	现在还能用吗	我踩过/见过的坑
MD5	文件指纹、缓存键、去重	安全场景一律禁用	当密码存 = 等于裸奔；2004 年王小云就构造出碰撞了
SHA-1	旧系统兼容（Git 历史）	新项目别碰	2017 年 Google 的 SHAttered 已经做出真实碰撞，别再当"比 MD5 安全"用
SHA-256	文件校验、签名、内容寻址	这些场景放心用	千万别拿它直接存密码——太快了，加盐也救不了爆破
bcrypt	密码存储	推荐	cost 别填默认就完事，按服务器性能调到登录有 ~100ms 延迟才合理
Argon2	密码存储（新项目首选）	最推荐	内存参数配太高会被人用登录接口打满内存，上线前压一下

哈希算法基础

什么是哈希

哈希（Hash）是一种单向函数，将任意长度的输入转换为固定长度的输出：

输入 → 哈希函数 → 输出（哈希值/摘要）

"hello"     → MD5  → "5d41402abc4b2a76b9719d911017c592"
"hello123"  → MD5  → "cc03e747a6afbbcbf8be7668acfebee5"

哈希的特性

1. 确定性（Deterministic）

相同输入始终产生相同输出：

// 多次计算结果相同
hash('hello') === hash('hello'); // true

2. 快速计算

哈希运算速度快，适合大数据处理。

3. 雪崩效应（Avalanche Effect）

输入的微小变化导致输出完全不同：

hash('hello'); // 5d41402abc4b2a76b9719d911017c592
hash('hello '); // 3b8292d5e20e01955a89190cdc9d2c9e (多了一个空格)

4. 单向性（One-way）

无法从哈希值反推原始输入：

// ❌ 不可能实现
function reverseHash(hash) {
  // 无法从哈希值得到原始数据
}

5. 抗碰撞性（Collision Resistance）

难以找到两个不同输入产生相同输出：

// 理论上可能，但实际很难找到
hash('input1') === hash('input2'); // 碰撞

哈希的应用场景

// 1. 密码存储
const passwordHash = hash(password + salt);
database.save({ username, password: passwordHash });

// 2. 文件完整性校验
const fileHash = hash(fileContent);
// 下载后验证哈希值是否匹配

// 3. 数据去重
const seen = new Set();
items.forEach((item) => {
  const itemHash = hash(JSON.stringify(item));
  if (!seen.has(itemHash)) {
    seen.add(itemHash);
    processItem(item);
  }
});

// 4. 缓存键生成
const cacheKey = hash(url + params);
const cached = cache.get(cacheKey);

// 5. 数字签名
const signature = sign(hash(document), privateKey);

常见哈希算法详解

MD5（Message-Digest Algorithm 5）

特点：

输出128位（16字节，32位十六进制）
速度快
⚠️ 已被破解，不推荐用于安全场景

// 浏览器环境使用Web Crypto API
async function md5(message) {
  const encoder = new TextEncoder();
  const data = encoder.encode(message);

  // Web Crypto API不直接支持MD5，使用第三方库
  // 或使用SubtleCrypto的SHA系列
}

// Node.js环境
const crypto = require('crypto');

function md5(text) {
  return crypto.createHash('md5').update(text).digest('hex');
}

console.log(md5('hello')); // "5d41402abc4b2a76b9719d911017c592"

安全性：

✅ 文件校验（非安全场景）
❌ 密码存储
❌ 数字签名
❌ 任何需要安全性的场景

MD5碰撞示例：

2004年王小云教授破解MD5，可以在几秒内找到碰撞：

// 两个不同的输入产生相同的MD5
const input1 = '某个特殊构造的字符串1';
const input2 = '某个特殊构造的字符串2';

md5(input1) === md5(input2); // true（碰撞）

SHA-1（Secure Hash Algorithm 1）

特点：

输出160位（20字节，40位十六进制）
比MD5更安全，但也已被破解
Git使用SHA-1（正在迁移到SHA-256）

// 浏览器环境
async function sha1(message) {
  const encoder = new TextEncoder();
  const data = encoder.encode(message);
  const hashBuffer = await crypto.subtle.digest('SHA-1', data);

  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
}

// Node.js
function sha1(text) {
  return crypto.createHash('sha1').update(text).digest('hex');
}

console.log(sha1('hello')); // "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d"

安全性：

✅ 旧系统兼容（如Git）
⚠️ 正在淘汰
❌ 新项目不推荐使用

SHA-256（SHA-2家族）

特点：

输出256位（32字节，64位十六进制）
目前广泛使用，安全性高
比特币使用SHA-256

// 浏览器环境
async function sha256(message) {
  const encoder = new TextEncoder();
  const data = encoder.encode(message);
  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('');
}

// 使用
const hash = await sha256('hello');
console.log(hash); // "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"

SHA-2家族：

SHA-224（224位）
SHA-256（256位）⭐ 最常用
SHA-384（384位）
SHA-512（512位）

// Node.js支持所有SHA-2变体
crypto.createHash('sha224');
crypto.createHash('sha256');
crypto.createHash('sha384');
crypto.createHash('sha512');

SHA-3（Keccak）

特点：

最新的SHA标准（2015年）
与SHA-2结构完全不同
更强的抗碰撞性

// Node.js（v10.0.0+）
function sha3_256(text) {
  return crypto.createHash('sha3-256').update(text).digest('hex');
}

SHA-3变体：

SHA3-224
SHA3-256
SHA3-384
SHA3-512

算法对比

算法	输出长度	安全性	速度	推荐使用
MD5	128位	❌ 已破解	快	仅用于非安全场景
SHA-1	160位	⚠️ 弱	中等	淘汰中
SHA-256	256位	✅ 安全	中等	⭐ 推荐
SHA-512	512位	✅ 非常安全	慢	高安全需求
SHA3-256	256位	✅ 最安全	慢	未来趋势

密码哈希最佳实践

❌ 错误做法：直接哈希

// ❌ 严重错误：直接存储密码的哈希
const passwordHash = sha256(password);
database.save({ username, password: passwordHash });

问题：

彩虹表攻击：预先计算常见密码的哈希值
相同密码相同哈希：容易识别

✅ 正确做法1：加盐（Salt）

// ✅ 使用随机盐值
const salt = generateRandomSalt(); // 随机字符串
const passwordHash = sha256(password + salt);

database.save({
  username,
  password: passwordHash,
  salt: salt, // 盐值也要存储
});

// 验证密码
function verifyPassword(inputPassword, storedHash, storedSalt) {
  const inputHash = sha256(inputPassword + storedSalt);
  return inputHash === storedHash;
}

生成盐值：

function generateSalt(length = 16) {
  const array = new Uint8Array(length);
  crypto.getRandomValues(array);
  return Array.from(array, (b) => b.toString(16).padStart(2, '0')).join('');
}

// Node.js
function generateSalt(length = 16) {
  return crypto.randomBytes(length).toString('hex');
}

✅ 正确做法2：使用bcrypt

// bcrypt专为密码哈希设计
const bcrypt = require('bcrypt');

// 注册：哈希密码
async function hashPassword(password) {
  const saltRounds = 10; // 计算成本因子
  const hash = await bcrypt.hash(password, saltRounds);
  return hash; // 包含盐值的哈希
}

// 登录：验证密码
async function verifyPassword(password, hash) {
  const match = await bcrypt.compare(password, hash);
  return match; // true/false
}

// 使用
const user = {
  username: 'alice',
  password: await hashPassword('mySecret123'),
};
// password: "$2b$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy"

const isValid = await verifyPassword('mySecret123', user.password); // true

bcrypt优势：

自动生成和存储盐值
可调整计算成本（抗暴力破解）
专为密码设计

✅ 正确做法3：使用Argon2

// Argon2：密码哈希竞赛冠军（2015）
const argon2 = require('argon2');

// 哈希密码
async function hashPassword(password) {
  const hash = await argon2.hash(password);
  return hash;
}

// 验证密码
async function verifyPassword(password, hash) {
  return await argon2.verify(hash, password);
}

Argon2优势：

最新、最安全的密码哈希算法
抗GPU/ASIC攻击
可配置内存使用和计算时间

密码哈希对比

方案	安全性	速度	推荐
MD5直接哈希	❌ 极不安全	快	绝不使用
SHA-256 + Salt	⚠️ 基本安全	快	不推荐
bcrypt	✅ 安全	慢（可调）	⭐ 推荐
Argon2	✅ 最安全	慢（可调）	⭐ 最推荐

PBKDF2（基于密码的密钥派生函数）

// 浏览器环境
async function pbkdf2(password, salt, iterations = 100000) {
  const encoder = new TextEncoder();
  const keyMaterial = await crypto.subtle.importKey(
    'raw',
    encoder.encode(password),
    { name: 'PBKDF2' },
    false,
    ['deriveBits']
  );

  const derivedBits = await crypto.subtle.deriveBits(
    {
      name: 'PBKDF2',
      salt: encoder.encode(salt),
      iterations: iterations,
      hash: 'SHA-256',
    },
    keyMaterial,
    256
  );

  const hashArray = Array.from(new Uint8Array(derivedBits));
  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
}

// Node.js
function pbkdf2(password, salt, iterations = 100000) {
  return crypto.pbkdf2Sync(password, salt, iterations, 32, 'sha256').toString('hex');
}

文件完整性校验

计算文件哈希

// 浏览器环境：计算文件MD5/SHA256
async function calculateFileHash(file, algorithm = 'SHA-256') {
  const arrayBuffer = await file.arrayBuffer();
  const hashBuffer = await crypto.subtle.digest(algorithm, arrayBuffer);

  const hashArray = Array.from(new Uint8Array(hashBuffer));
  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
}

// 使用
document.querySelector('#fileInput').addEventListener('change', async (e) => {
  const file = e.target.files[0];
  const hash = await calculateFileHash(file);
  console.log(`SHA-256: ${hash}`);
});

分块计算大文件哈希

async function calculateLargeFileHash(file, algorithm = 'SHA-256') {
  const chunkSize = 1024 * 1024; // 1MB
  const chunks = Math.ceil(file.size / chunkSize);

  // Web Crypto不支持流式哈希，使用第三方库
  // 这里展示概念性代码
  let offset = 0;

  for (let i = 0; i < chunks; i++) {
    const chunk = file.slice(offset, offset + chunkSize);
    const arrayBuffer = await chunk.arrayBuffer();
    // 更新哈希...
    offset += chunkSize;
  }

  return hash;
}

完整性校验实战

class FileIntegrityChecker {
  constructor() {
    this.knownHashes = new Map();
  }

  // 注册文件的已知哈希值
  register(filename, hash) {
    this.knownHashes.set(filename, hash.toLowerCase());
  }

  // 校验文件
  async verify(file) {
    const expectedHash = this.knownHashes.get(file.name);

    if (!expectedHash) {
      return { valid: false, error: '未找到已知哈希值' };
    }

    const actualHash = await calculateFileHash(file);

    if (actualHash.toLowerCase() === expectedHash) {
      return { valid: true, hash: actualHash };
    } else {
      return {
        valid: false,
        error: '哈希值不匹配',
        expected: expectedHash,
        actual: actualHash,
      };
    }
  }
}

// 使用
const checker = new FileIntegrityChecker();

// 注册软件的官方哈希值
checker.register('软件.exe', 'abc123...');

// 用户下载后校验
const result = await checker.verify(downloadedFile);
if (result.valid) {
  console.log('✅ 文件完整，未被篡改');
} else {
  console.error('❌ 文件可能被篡改！');
}

实战应用

案例1：防止表单重复提交

class FormSubmitGuard {
  constructor() {
    this.submitted = new Set();
  }

  async canSubmit(formData) {
    // 计算表单数据的哈希
    const dataString = JSON.stringify(formData);
    const hash = await this.hash(dataString);

    if (this.submitted.has(hash)) {
      return false; // 重复提交
    }

    this.submitted.add(hash);
    return true;
  }

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

// 使用
const guard = new FormSubmitGuard();

async function handleSubmit(formData) {
  if (!(await guard.canSubmit(formData))) {
    alert('请勿重复提交！');
    return;
  }

  // 提交表单...
}

案例2：数据去重

class DataDeduplicator {
  constructor() {
    this.seen = new Set();
  }

  async isUnique(data) {
    const hash = await this.hash(data);

    if (this.seen.has(hash)) {
      return false; // 重复
    }

    this.seen.add(hash);
    return true;
  }

  async hash(data) {
    const str = typeof data === 'string' ? data : JSON.stringify(data);
    const encoder = new TextEncoder();
    const dataBuffer = encoder.encode(str);
    const hashBuffer = await crypto.subtle.digest('SHA-256', dataBuffer);
    const hashArray = Array.from(new Uint8Array(hashBuffer));
    return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
  }
}

// 使用：处理API返回的数据
const dedup = new DataDeduplicator();

for (const item of apiData) {
  if (await dedup.isUnique(item)) {
    processItem(item);
  }
}

案例3：ETag生成

// HTTP ETag：用于缓存验证
async function generateETag(content) {
  const hash = await sha256(content);
  return `"${hash.substring(0, 16)}"`;
}

// Express.js示例
app.get('/api/data', async (req, res) => {
  const data = await fetchData();
  const content = JSON.stringify(data);
  const etag = await generateETag(content);

  // 检查客户端ETag
  if (req.headers['if-none-match'] === etag) {
    res.status(304).end(); // Not Modified
    return;
  }

  res.set('ETag', etag);
  res.json(data);
});

案例4：内容寻址存储

// Git风格的内容寻址
class ContentAddressableStorage {
  constructor() {
    this.storage = new Map();
  }

  async store(content) {
    const hash = await this.hash(content);
    this.storage.set(hash, content);
    return hash; // 返回内容的地址
  }

  retrieve(hash) {
    return this.storage.get(hash);
  }

  async hash(content) {
    const encoder = new TextEncoder();
    const data = encoder.encode(content);
    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('');
  }
}

// 使用
const cas = new ContentAddressableStorage();

const hash1 = await cas.store('Hello World');
const hash2 = await cas.store('Hello World'); // 相同内容，相同哈希

console.log(hash1 === hash2); // true（自动去重）
console.log(cas.retrieve(hash1)); // "Hello World"

安全性考虑

1. 选择合适的算法

// ❌ 错误：使用已破解的算法
const hash = md5(sensitiveData);

// ✅ 正确：使用安全的算法
const hash = await sha256(sensitiveData);

2. 密码哈希使用专用算法

// ❌ 错误：用通用哈希存储密码
const passwordHash = sha256(password);

// ✅ 正确：使用bcrypt/Argon2
const passwordHash = await bcrypt.hash(password, 10);

3. 使用足够长的盐值

// ❌ 错误：盐值太短
const salt = Math.random().toString();

// ✅ 正确：至少16字节的随机盐
const salt = crypto.randomBytes(16).toString('hex');

4. 防止时序攻击

// ❌ 错误：直接比较字符串
function verifyHash(input, expected) {
  return input === expected; // 时序攻击漏洞
}

// ✅ 正确：常量时间比较
function verifyHash(input, expected) {
  if (input.length !== expected.length) {
    return false;
  }

  let result = 0;
  for (let i = 0; i < input.length; i++) {
    result |= input.charCodeAt(i) ^ expected.charCodeAt(i);
  }

  return result === 0;
}

// 或使用crypto.timingSafeEqual（Node.js）
const crypto = require('crypto');
const inputBuffer = Buffer.from(input, 'hex');
const expectedBuffer = Buffer.from(expected, 'hex');
const isValid = crypto.timingSafeEqual(inputBuffer, expectedBuffer);

5. 定期更新哈希算法

// 版本化哈希，便于未来升级
function hashWithVersion(data, version = 2) {
  switch (version) {
    case 1:
      return { version: 1, hash: md5(data) }; // 旧版本
    case 2:
      return { version: 2, hash: sha256(data) }; // 当前版本
    default:
      throw new Error('Unsupported version');
  }
}

// 存储
const result = hashWithVersion(data);
database.save({ data: result.hash, hashVersion: result.version });

// 验证时根据版本使用相应算法

写在最后

如果这篇你只想记住一句话，那就是：存密码永远别用 MD5/SHA 这类通用哈希，用 bcrypt 或 Argon2，且别自己造哈希方案。

文件校验、去重、内容寻址这些非密码场景，SHA-256 足够了，MD5 在不涉及安全时也还能凑合用（图个快）。分清场景，比记住算法名字重要得多。

就这些。哈希不难，难的是分清"看着安全"和"真的安全"。下次再看到用户表里一片裸 MD5，希望那个去补锅的人不是你。

哈希算法与数据安全实践：MD5、SHA家族完全指南

哈希算法与数据安全实践：MD5、SHA家族完全指南

先看一张我自己常用的速查表

目录

哈希算法基础

什么是哈希

哈希的特性

哈希的应用场景

常见哈希算法详解

MD5（Message-Digest Algorithm 5）

SHA-1（Secure Hash Algorithm 1）

SHA-256（SHA-2家族）

SHA-3（Keccak）

算法对比

密码哈希最佳实践

❌ 错误做法：直接哈希

✅ 正确做法1：加盐（Salt）

✅ 正确做法2：使用bcrypt

✅ 正确做法3：使用Argon2

密码哈希对比

PBKDF2（基于密码的密钥派生函数）

文件完整性校验

计算文件哈希

分块计算大文件哈希

完整性校验实战

实战应用

案例1：防止表单重复提交

案例2：数据去重

案例3：ETag生成

案例4：内容寻址存储

安全性考虑

1. 选择合适的算法

2. 密码哈希使用专用算法

3. 使用足够长的盐值

4. 防止时序攻击

5. 定期更新哈希算法

写在最后

推荐实践

相关工具

相关阅读

浏览器API完全指南：FileReader、Canvas、Web Workers深度解析

前端性能优化实战：从加载到渲染的完整指南

时间戳与时区处理完全指南：从Unix时间到全球化应用

哈希算法与数据安全实践：MD5、SHA家族完全指南

哈希算法与数据安全实践：MD5、SHA家族完全指南

先看一张我自己常用的速查表

目录

哈希算法基础

什么是哈希

哈希的特性

哈希的应用场景

常见哈希算法详解

MD5（Message-Digest Algorithm 5）

SHA-1（Secure Hash Algorithm 1）

SHA-256（SHA-2家族）

SHA-3（Keccak）

算法对比

密码哈希最佳实践

❌ 错误做法：直接哈希

✅ 正确做法1：加盐（Salt）

✅ 正确做法2：使用bcrypt

✅ 正确做法3：使用Argon2

密码哈希对比

PBKDF2（基于密码的密钥派生函数）

文件完整性校验

计算文件哈希

分块计算大文件哈希

完整性校验实战

实战应用

案例1：防止表单重复提交

案例2：数据去重

案例3：ETag生成

案例4：内容寻址存储

安全性考虑

1. 选择合适的算法

2. 密码哈希使用专用算法

3. 使用足够长的盐值

4. 防止时序攻击

5. 定期更新哈希算法

写在最后