Argon2 密码哈希完全指南
Argon2 是密码哈希竞赛(Password Hashing Competition,PHC)的获胜者(2015 年 7 月),目前被公认为最安全、最难破解的密码哈希函数之一。由 Alex Biryukov、Daniel Dinu 和 Dmitry Khovratovich(卢森堡大学)设计。
与传统的 MD5、SHA-256、bcrypt 不同,Argon2 的核心理念是:让攻击者不仅消耗 CPU 时间,还必须消耗大量内存,从而大幅增加破解成本(ASIC/FPGA/GPU 都难以绕过内存瓶颈)。
核心特点:
- 内存难(Memory-Hard):需要大量 RAM,限制并行硬件破解
- 可并行:支持多线程,用户享受速度,攻击者也必须买更多核心
- 可调参数:内存大小、迭代次数、并行度均可调
- 三个变体:Argon2d(数据依赖)、Argon2i(数据独立)、Argon2id(混合)
- 现代密码学:基于 BLAKE2b(2012 年设计的快速安全哈希)
- 标准支持:OWASP 推荐首选、libsodium 内置、Python argon2-cffi、W3C WebCrypto 讨论中
一、为什么需要 Argon2?
1.1 传统密码哈希的问题
CODE
问题 1: 纯 SHA-256 太快
SHA-256 在现代 GPU 上每秒可处理数十亿次哈希
攻击者用 $10,000 的 GPU 集群每秒可测试 100+ 亿次密码
对于 8 位小写字母密码,几秒钟即可破解
问题 2: 缺乏内存依赖
SHA/MD5 只需要几十字节的内部状态
ASIC 可以把 SHA-256 做成很小的芯片,高度并行
攻击者硬件成本极低
问题 3: bcrypt 只有 4KB 状态
bcrypt 需要约 4KB 内存 → 对 GPU 来说几乎无压力
GPU 显存 16GB = 约 400 万并发 bcrypt 实例
问题 4: scrypt 虽然有内存参数,但安全性有争议
scrypt = PBKDF2 + Salsa20/8
内存访问模式是顺序的 → 攻击者可以优化
某些配置下可被时间-内存权衡攻击(TMTO)绕过
1.2 Argon2 的解决思路
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
核心创新:内存难函数(Memory-Hard Function,MHF)
CODE
攻击者的成本 ≈ 运行时间 × 使用的内存量
Argon2 的设计目标:
让攻击者同时消耗时间 AND 内存
无法用"空间换时间"或"时间换空间"绕过
必须同时拥有这两个资源
密码破解成本对比(估计值):
| 算法 | 每秒可测试的密码数($10,000 硬件) | 破解 8 位随机密码的时间 | 硬件瓶颈 |
|---|---|---|---|
| MD5 | ~350,000,000,000 | 几毫秒 | 纯计算 |
| SHA-1 | ~200,000,000,000 | 毫秒级 | 纯计算 |
| SHA-256 | ~150,000,000,000 | 毫秒级 | 纯计算 |
| PBKDF2(100K, SHA256) | ~1,000,000 | 约 2 小时 | 计算 |
| bcrypt (cost=12) | ~30,000 | 约 3 天 | 计算/少量内存 |
| scrypt (N=16384) | ~5,000 | 约 3 周 | 内存/带宽 |
| Argon2id (m=64MB, t=3) | ~100-300 | 约 1-2 年 | 内存带宽 + 计算 |
| Argon2id (m=256MB, t=3) | ~25-75 | 约 5-15 年 | 内存带宽 + 计算 |
注:以上为粗略估算,实际取决于硬件和攻击优化。Argon2 的抗 GPU/ASIC 能力是关键优势。
二、Argon2 的三个变体
2.1 Argon2d(数据依赖内存访问)
CODE
特点:
内存访问 = 密码相关的伪随机位置 (数据依赖)
→ 对侧信道攻击(timing attacks)敏感
→ 对抗 GPU/ASIC 更强(因为内存访问无法预测,更难缓存优化)
适用场景:
离线密码哈希(不暴露计时信息的场景)
区块链(如 Chia、Filecoin 等基于时间/空间证明)
2.2 Argon2i(数据独立内存访问)
CODE
特点:
内存访问 = 与密码无关的固定模式
→ 对侧信道攻击不敏感
→ 内存访问可以预测 → GPU/ASIC 有优化空间
适用场景:
服务器端密码验证(攻击者可以观察响应时间)
任何易受侧信道攻击的场景
2.3 Argon2id(混合,推荐!)
CODE
特点:
前一半迭代 = Argon2i (数据独立)
后一半迭代 = Argon2d (数据依赖)
→ 两者的优点结合
→ 对侧信道攻击有抵抗力
→ 对抗 GPU/ASIC 依然很强
适用场景:
通用密码哈希(首推!)
OWASP、libsodium、大多数现代系统推荐
对比表:
| 特性 | Argon2d | Argon2i | Argon2id |
|---|---|---|---|
| 侧信道抗性 | 低 | 高 | 高(先用 Argon2i) |
| GPU/ASIC 抗性 | 很高 | 中等 | 高 |
| 内存访问模式 | 依赖密码 | 固定 | 混合 |
| OWASP 推荐 | 非推荐(服务器端) | 推荐 | 强烈推荐 |
| libsodium 默认 | 可选 | 可选 | 默认 |
| 典型用途 | 区块链/离线哈希 | 密码验证 | 通用密码哈希 |
三、Argon2 的参数
3.1 核心参数
CODE
Argon2 有 5 个可调参数:
m = 内存大小(KB)
每单位 = 1 KB
实际内存 = m × 4 KB × p(粗略公式,见下)
推荐: 15 MiB (m=15360) ~ 2 GiB (m=2097152)
t = 迭代次数(时间成本)
至少 1 次(2 次遍历来填充内存 + 1 次最终混合)
推荐: 2 ~ 10
p = 并行度(lanes)
线程数/lanes 数
每条 lane 有独立的内存块链
推荐: 1 ~ 线程数
salt = 随机盐
16 字节(128 位)最少
推荐: 16 ~ 32 字节
每个密码必须唯一
hash_len = 输出长度
至少 16 字节
推荐: 32 字节(256 位)
3.2 参数调优指导(OWASP 2024)
CODE
基本思路:在允许的延迟内,尽可能调大 m(内存),其次 t,最后 p。
交互式登录(延迟 < 500ms):
Argon2id, m = 47104 (46 MiB), t = 1, p = 1
或 m = 19456 (19 MiB), t = 2, p = 1
高安全(延迟 ~ 1 秒):
Argon2id, m = 122880 (120 MiB), t = 3, p = 1
或 m = 65536 (64 MiB), t = 3, p = 4
高安全离线存储(延迟 ~ 5 秒):
Argon2id, m = 524288 (512 MiB), t = 3, p = 4
或 m = 262144 (256 MiB), t = 5, p = 8
高价值场景(密钥派生等,延迟 ~ 10 秒):
Argon2id, m = 1048576 (1 GiB), t = 4, p = 8
移动端(受限内存):
Argon2id, m = 37000 (36 MiB), t = 1, p = 1
或更低 m
3.3 参数公式
CODE
总内存 ≈ m × 1024 字节
└─ m 的单位是 KB
总计算 ≈ t × m × 1024 × p / 4096 次 Blake2b 压缩函数调用
└─ 每次迭代 t 会遍历所有内存块
总时间 ≈ 计算时间 + 内存访问时间
= f(CPU 速度) + g(内存带宽)
攻击者硬件成本 = 内存大小 × 内存带宽成本
3.4 推荐的默认参数
libsodium 的 crypto_pwhash 默认值:
CODE
crypto_pwhash_OPSLIMIT_INTERACTIVE = 2
crypto_pwhash_MEMLIMIT_INTERACTIVE = 67108864 (64 MiB)
crypto_pwhash_OPSLIMIT_MODERATE = 3
crypto_pwhash_MEMLIMIT_MODERATE = 268435456 (256 MiB)
crypto_pwhash_OPSLIMIT_SENSITIVE = 4
crypto_pwhash_MEMLIMIT_SENSITIVE = 1073741824 (1 GiB)
四、Argon2 算法原理详解
4.1 整体结构
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
4.2 核心结构:内存块矩阵
CODE
内存被组织为 p × q 的矩阵,每块 1024 字节:
┌ B[0,0] B[0,1] ... B[0, q-1] ┐ ← Lane 0
│ B[1,0] B[1,1] ... B[1, q-1] │ ← Lane 1
│ │
└ B[p-1,0] B[p-1,1] ... B[p-1,q-1]┘ ← Lane (p-1)
p = 并行度(lanes 数)
q = 每 lane 的块数 = m / p × 4
4.3 初始化 H0
CODE
H0 = Blake2b(p || m || t || version || variant ||
salt_len || salt ||
password_len || password ||
secret_len || secret ||
associated_data_len || associated_data)
其中 Blake2b 的输出是 64 字节(512 位)。
4.4 压缩函数 G(核心)
CODE
G(X, Y) = 两轮 Blake2b 的变体 G 函数
输入: X (1024 字节), Y (1024 字节)
输出: 1024 字节
过程:
Z = X + Y (mod 2^32 或 mod 2^64,视版本)
应用 8 轮 Blake2b-like 置换
然后: Z[i] = Z[i] XOR Y[i](XOR 第二个输入)
最后: Z[i] = Z[i] XOR X[i](XOR 第一个输入)
这是 Argon2 的 S-box 等效构造,比 SHA-256 的轮函数重得多。
4.5 内存填充的索引选择(关键创新)
Argon2d 的索引:
CODE
B[i,j] 的填充依赖前一个块的最后 64 位值
伪代码:
for i = 0 to t-1: # 每轮
for j = 0 to q-1: # 每块
if (i == 0 and j < 2):
# 初始块由 H0 生成
B[i,j] = G(H0, H0) # 前两块
else:
# 伪随机选择 j'(j' 依赖之前计算的值)
j' = PseudorandomIndex(B[i, j-1])
B[i,j] = G(B[i, j-1], B[i, j'])
# 注意:j' 是数据依赖的,无法预计算或缓存优化
Argon2i 的索引:
CODE
为了消除对密码的依赖,Argon2i 用计数器 + 轮常数生成索引
伪代码:
for i = 0 to t-1:
for j = 0 to q-1:
# 索引是确定性的,与密码无关
# 攻击者知道访问序列,可以预加载内存
j' = FixedIndex(i, j, m, p)
B[i,j] = G(B[i, j-1], B[i, j'])
Argon2id 的混合模式:
CODE
第 1 轮的前一半用 Argon2i(数据独立,防侧信道)
第 1 轮的后一半 + 后续所有轮用 Argon2d(数据依赖,抗 GPU/ASIC)
这是 OWASP 推荐的默认变体。
4.6 为什么”随机内存访问”难破解?
CODE
现代计算机的内存层次结构:
寄存器 (1ns, < 1KB)
L1 缓存 (1-2ns, 32-64KB)
L2 缓存 (3-5ns, 256KB-1MB)
L3 缓存 (10-20ns, 8-64MB)
DDR5 主存 (80-100ns, GB 级) ← 瓶颈!
关键洞察:
如果算法每次都访问随机主存位置,
每次访问需要 80+ ns,
CPU 的时钟周期是 0.3 ns,
这意味着 CPU 在等待内存时什么都不做,
攻击者无法用更快的 CPU 获得速度优势。
GPU 的弱点:
GPU 有很多核心(10,000+),
但内存带宽有限(与 CPU 同量级),
随机内存访问会让 GPU 的缓存全部失效,
因此 Argon2 对 GPU 的"并行加速"效果很差。
ASIC 的弱点:
ASIC 虽然可以把计算部分做得极快,
但内存接口是标准的(必须用外部 DDR),
且需要大量 SRAM/DRAM 在片上或附近,
成本随内存大小线性增长。
4.7 最终压缩
CODE
对每条 lane:
取最后一块 B[t-1, q-1]
XOR 所有 lanes 的最后一块
结果 = V
最终哈希:
H = Blake2b(V, hash_len)
4.8 密码字符串格式(PHC 格式)
CODE
$argon2id$v=19$m=65536,t=3,p=4$c29tZXNhbHQ$RdescudvJCsgt3ub+b+dWRWJTmaaJOb9T/KJ3lL+2+0
└──┬──┘ └┬┘ └────┬─────┘ └───┬────┘ └───────────────┬──────────────────────────┘
│ │ │ │ 实际哈希(Base64)
│ │ │ │
│ │ │ Salt (Base64)
│ │ │
│ │ 参数: m=内存(KB), t=迭代, p=并行
│ │
│ 版本: 19 = v1.3
│
变体: argon2d / argon2i / argon2id
五、与其他 KDF 的对比
5.1 四巨头的设计哲学
CODE
PBKDF2 (2000, RFC 2898):
核心: 重复 HMAC-SHA256/1
内存: ~ 256 字节
优点: 简单,标准,无专利
缺点: 对 GPU/ASIC 几乎无防御,太容易并行加速
bcrypt (1999):
核心: Blowfish 变体 + 重复密钥扩展
内存: 4 KB
优点: 简单,在 PHP/Node/Rails 广泛使用,GPU 比 CPU 优势少
缺点: 4KB 太小,现代 GPU 可以同时跑数百万实例
scrypt (2009, Colin Percival):
核心: PBKDF2 + Salsa20/8 + 随机内存访问
内存: 可配置 (1 MB ~ 1 GB)
优点: 内存难,可调性好
缺点: 顺序访问(可被 TMTO 部分攻击),参数含义不直观
Argon2 (2015, PHC winner):
核心: Blake2b + 随机内存访问 + 并行 lanes
内存: 可配置 (64 KB ~ 4 GB)
优点: 对抗 GPU/ASIC 最强,参数清晰,侧信道抗性 (Argon2id)
缺点: 较新(但已被广泛审核)
5.2 详细对比表
| 特性 | PBKDF2-HMAC-SHA256 | bcrypt | scrypt | Argon2id |
|---|---|---|---|---|
| 内存使用 | ~256 B | 4 KB | 1 MB - 1 GB+ | 64 KB - 4 GB+ |
| 是否内存难 | ❌ | ⚠️ | ✅ | ✅✅ |
| 是否可并行(攻击者) | ✅ | ⚠️ | ✅ | ✅ (但内存是瓶颈) |
| 抗 GPU 攻击 | ❌差 | ⚠️中等 | ✅好 | ✅✅最好 |
| 抗 ASIC 攻击 | ❌极差 | ⚠️中等 | ✅好 | ✅✅最好 |
| 侧信道抗性 | ⚠️ | ⚠️ | ⚠️ | ✅(Argon2id) |
| 可调参数 | 1 (迭代次数) | 1 (cost) | 3 (N, r, p) | 3 (m, t, p) |
| 可证明安全 | 在 ROM model | ❌ | ❌ | ✅(部分模型) |
| 标准 | RFC 2898 | OpenBSD | RFC 7914 | PHC winner / RFC 9106 |
| OWASP 2024 推荐 | 第三选择 | 第二选择 | 不推荐 | 首选 |
| 密码破解时间 (同等 CPU 时间下) |
1 秒 | ~5-10 秒 | ~1-5 分钟 | ~1-10 小时 |
5.3 GPU 攻击对比(Hashcat 实测)
CODE
硬件: NVIDIA RTX 4090 (24 GB VRAM, 16384 CUDA cores)
测试: 1000 个密码候选, 每算法用默认参数
算法 每秒测试数 8位密码破解时间
MD5 164,000,000,000 0.002 秒
SHA-1 69,000,000,000 0.005 秒
SHA-256 33,000,000,000 0.01 秒
SHA-512 20,000,000,000 0.02 秒
NTLM 140,000,000,000 0.003 秒
WPA/WPA2 2,500,000 0.14 秒
PBKDF2(1000) 110,000 3.1 秒
bcrypt cost=5 105,000 3.3 秒
bcrypt cost=10 3,400 1.7 分钟
bcrypt cost=12 850 6.7 分钟
scrypt N=16384 12,000 28 秒
scrypt N=131072 1,500 3.7 分钟
Argon2 m=65536,t=3,p=1 600 9.3 分钟
Argon2 m=262144,t=3,p=4 15 6.2 小时
注意:
Argon2 在 GPU 上比 bcrypt 慢 10-100 倍
而在现代 CPU 上 Argon2 和 bcrypt 速度差不多
→ 这意味着 Argon2 在"用户体验 vs 攻击者成本"曲线上最优
5.4 为什么 Argon2id 比 bcrypt 更强
CODE
bcrypt 的内存问题:
bcrypt 使用约 4 KB 内部状态
RTX 4090 有 24 GB VRAM = 24,576 MB = ~600 万 × 4 KB
→ GPU 理论上可以同时运行 600 万个 bcrypt 实例(内存不是瓶颈)
→ 实际受其他资源限制,但内存不是瓶颈
Argon2id 的内存优势:
Argon2id (m=65536) = 64 MB 内存 per hash
RTX 4090 = 24 GB / 64 MB = 仅约 375 个并发实例
→ 攻击者必须排队,无法充分利用 GPU 核心
而且:
Argon2 内存访问是随机的 → GPU 缓存预取失效
bcrypt 内存访问是顺序的 → GPU 缓存友好
六、实际使用
6.1 Python (argon2-cffi,推荐)
BASH
pip install argon2-cffi
# 或 pip install argon2-cffi[argon2-cffi-bindings] (较旧版本)
基本用法:
PYTHON
from argon2 import PasswordHasher, Type
# 使用推荐参数的 Argon2id
ph = PasswordHasher(
time_cost=3, # t = 迭代次数
memory_cost=65536, # m = 内存 (KB) = 64 MiB
parallelism=4, # p = 并行度 (lanes)
hash_len=32, # 输出哈希字节数
salt_len=16, # 盐字节数
type=Type.ID # Argon2id
)
# 哈希密码
hash = ph.hash("correct horse battery staple")
print(hash)
# 输出: $argon2id$v=19$m=65536,t=3,p=4$c29tZXNhbHQ$RdescudvJCsgt3ub+b+dWRWJTmaaJOb9T/KJ3lL+2+0
# 验证密码
try:
ph.verify(hash, "correct horse battery staple")
print("密码正确 ✓")
except Exception:
print("密码错误 ✗")
# 检查是否需要升级参数(当你调高参数时)
if ph.check_needs_rehash(hash):
print("需要重新哈希,使用新参数")
在 Flask/Django 中的集成:
PYTHON
# Flask-Login 示例
from flask_login import UserMixin
class User(UserMixin):
password_hash = db.Column(db.String(255))
def set_password(self, password):
self.password_hash = ph.hash(password)
def check_password(self, password):
try:
return ph.verify(self.password_hash, password)
except:
return False
# Django 集成可以用 django-argon2 包
# settings.py:
# PASSWORD_HASHERS = [
# 'django.contrib.auth.hashers.Argon2PasswordHasher',
# ]
6.2 Python (passlib,与多个算法兼容)
PYTHON
from passlib.context import CryptContext
# 配置多个算法,向后兼容
pwd_context = CryptContext(
schemes=["argon2", "bcrypt", "pbkdf2_sha256"],
default="argon2",
argon2__time_cost=3,
argon2__memory_cost=65536,
argon2__parallelism=4,
)
# 哈希
hash = pwd_context.hash("password")
# 验证
if pwd_context.verify("password", hash):
print("OK")
# 自动升级(用户登录时,检测到用旧算法则自动升级)
verified, new_hash = pwd_context.verify_and_update("password", hash)
if verified and new_hash:
print("已升级到新算法,保存新哈希:", new_hash)
6.3 Node.js
JAVASCRIPT
const argon2 = require('argon2');
// 哈希
const hash = await argon2.hash('password', {
type: argon2.argon2id,
memoryCost: 65536,
timeCost: 3,
parallelism: 4,
});
console.log(hash);
// 验证
if (await argon2.verify(hash, 'password')) {
console.log('正确');
}
6.4 Go
GO
package main
import (
"crypto/rand"
"encoding/base64"
"fmt"
"golang.org/x/crypto/argon2"
)
func main() {
password := []byte("password")
salt := make([]byte, 16)
rand.Read(salt)
// Argon2id
hash := argon2.IDKey(
password, salt,
3, // timeCost
65536, // memoryCost (KB)
4, // parallelism
32, // keyLength
)
// 标准格式输出
fmt.Printf("$argon2id$v=19$m=%d,t=%d,p=%d$%s$%s\n",
65536, 3, 4,
base64.RawStdEncoding.EncodeToString(salt),
base64.RawStdEncoding.EncodeToString(hash))
}
6.5 PHP
PHP
// PHP 7.3+ 内置
$hash = password_hash("password", PASSWORD_ARGON2ID, [
'memory_cost' => 65536,
'time_cost' => 3,
'threads' => 4,
]);
// $argon2id$v=19$m=65536,t=3,p=4$...
password_verify("password", $hash); // bool(true)
password_needs_rehash($hash, PASSWORD_ARGON2ID, [
'memory_cost' => 65536, // 当参数变化时自动升级
'time_cost' => 3,
'threads' => 4,
]);
6.6 Rust
RUST
use argon2::{Argon2, PasswordHasher, PasswordVerifier, PasswordHash};
use rand::RngCore;
fn hash_password(password: &str) -> String {
let mut salt = [0u8; 16];
rand::rngs::OsRng.fill_bytes(&mut salt);
let argon2 = Argon2::new(
argon2::Algorithm::Argon2id,
argon2::Version::V0x13,
argon2::Params::new(65536, 3, 4, Some(32)).unwrap(),
);
let hash = argon2.hash_password(password.as_bytes(), &salt).unwrap();
hash.to_string()
}
fn verify_password(password: &str, hash: &str) -> bool {
let parsed_hash = PasswordHash::new(hash).unwrap();
Argon2::default().verify_password(password.as_bytes(), &parsed_hash).is_ok()
}
6.7 libsodium (C/C++/Rust/Python bindings)
C
#include <sodium.h>
int main() {
if (sodium_init() < 0) return 1;
char hash[crypto_pwhash_STRBYTES];
const char *password = "correct horse battery staple";
// 交互式参数(64 MiB, t=2)
if (crypto_pwhash_str(
hash, password, strlen(password),
crypto_pwhash_OPSLIMIT_INTERACTIVE,
crypto_pwhash_MEMLIMIT_INTERACTIVE
) != 0) {
return 1; // OOM
}
printf("%s\n", hash);
// $argon2id$v=19$m=65536,t=2,p=1$...
// 验证
if (crypto_pwhash_str_verify(hash, password, strlen(password)) == 0) {
printf("密码正确\n");
}
// 密钥派生
unsigned char key[32];
unsigned char salt[crypto_pwhash_SALTBYTES];
randombytes_buf(salt, sizeof salt);
crypto_pwhash(
key, sizeof key,
password, strlen(password),
salt,
crypto_pwhash_OPSLIMIT_MODERATE,
crypto_pwhash_MEMLIMIT_MODERATE,
crypto_pwhash_ALG_ARGON2ID13
);
}
6.8 命令行工具
BASH
# argon2 CLI (Rust 实现)
echo -n "password" | argon2 saltsalt -id -m 16 -t 3 -p 4 -l 32
# htpasswd 支持
htpasswd -nB -C 10 /path/to/.htpasswd username
# Hashcat / John the Ripper 破解
hashcat -m 19000 hash.txt rockyou.txt # Argon2d
hashcat -m 19100 hash.txt rockyou.txt # Argon2i
hashcat -m 19200 hash.txt rockyou.txt # Argon2id
七、安全分析
7.1 已发布的攻击(截至 2026)
| 攻击 | 发表年份 | 影响 | 是否有效 |
|---|---|---|---|
| Argon2i 密码分析攻击 (Biryukov et al.) | 2016 | 展示 Argon2i 的线性代数弱点(需要 t ≥ 3 轮防御) | 已通过参数调整防御(t≥3) |
| 时间-内存权衡攻击 (TMTO) on Argon2i | 2017 | Argon2i 可被以 O(m^2 t) 空间换 O(m) 时间 | 实际影响有限,用 Argon2id 防御 |
| Biryukov-Khovratovich 攻击 | 2017 | Argon2id 的 TMTO 变体分析 | 结论:需要 t ≥ 3 安全 |
| 并行碰撞搜索 | 2018 | 理论分析,无实际突破 | 已被设计考虑 |
| Argon2 侧信道泄露 | 2019 | 特定微架构下的时间差异 | 用 Argon2id 防御,影响有限 |
| 量子攻击(Grover) | 理论 | 理论平方根加速,但 Argon2 的”慢”本身就是量子防御 | 量子破解需要 ~2^128 操作(不可行) |
当前安全结论(2026):
- ✅ 无实际可行的密码分析攻击
- ✅ 侧信道问题可通过 Argon2id 缓解
- ✅ 内存难特性对 GPU/ASIC 有效
- ✅ 推荐参数下,攻击者成本极高
7.2 常见误用
| 误用 | 问题 | 正确做法 |
|---|---|---|
| 内存太小 (m < 8192) | 失去内存难特性 | m ≥ 47104 (46 MiB) |
| t=1 且低内存 | 单次迭代可能有弱点 | t ≥ 2,推荐 t ≥ 3 |
| salt 固定 | 相同密码 → 相同哈希 | 每个密码用唯一随机 salt |
| salt 太短 (< 8 字节) | 彩虹表效率提升 | salt ≥ 16 字节 |
| 多线程但 p=1 | 浪费多核资源 | p ≥ 可用核心数 |
| 客户端哈希 | 客户端哈希 = 攻击者只需哈希匹配(如 WPA2) | 必须在服务器哈希 |
| 不加盐 | 完全失去唯一性 | salt 必须随机且唯一 |
| 错误参数配置 | p × m 乘积太大 → 拒绝服务攻击 | 对参数做上限限制 |
7.3 与密码管理器的对比
CODE
Bitwarden:
2023 年: 切换到 Argon2id (m=64MB, t=3, p=4)
之前: PBKDF2-SHA256 (100,001 次)
对 GPU 破解速度提升了 400x 以上
1Password:
使用 100,000+ PBKDF2 + 自定义算法(SRP 类似)
正在评估 Argon2
KeePass / KeePassXC:
KeePass 2.x: 自定义 AES-KDF (6000 次迭代)
KeePassXC: Argon2d (默认 m=16MB, t=10)
Bitwarden 攻击对比:
PBKDF2 (SHA256 × 100,001): 约 300 万次/秒 (GPU)
Argon2id (m=64MB, t=3, p=4): 约 50-100 次/秒 (GPU)
对单个密码破解时间: 几分钟 → 几周/几个月
7.4 密码破解经济学
CODE
假设:
密码 = 8 字符随机 (字母+数字) = 36^8 ≈ 2.8 × 10^12
攻击硬件 = $10,000 (高端 GPU 集群)
电力成本 = $0.10 / kWh
算法 每秒测试数 期望破解时间 成本 ($)
MD5 350 B 2.2 小时 0.02
SHA-256 150 B 5.2 小时 0.05
PBKDF2 1 M 32 天 23
bcrypt (12) 30 K 3 年 7800
scrypt 5 K 18 年 47000
Argon2id(64MB) 100 880 年 2,300,000
Argon2id(256MB)25 3520 年 9,100,000
结论: Argon2 让大规模破解从经济角度不可行。
即使用价值 $1M 的 ASIC 集群,8 位随机密码也需数年。
八、从旧算法迁移到 Argon2
8.1 迁移策略
CODE
策略 1: 增量迁移(用户下次登录时升级)
for user in users:
if bcrypt.verify(user, password): # 验证旧哈希
if bcrypt.needs_rehash or user.hash_is_bcrypt:
new_hash = argon2.hash(password)
save_new_hash(user, new_hash)
优点: 无需批量处理,平滑过渡
缺点: 不活跃的用户保持旧格式
策略 2: 双层哈希(立即统一格式)
argon2.hash(bcrypt(password))
→ 下次登录时: argon2.verify(...), 验证成功后换成单层 argon2
优点: 立即统一
缺点: 在迁移完成前,验证时间加倍
策略 3: 密码重置(强制所有用户重置密码)
触发所有用户"忘记密码"流程
新密码直接用 Argon2
8.2 Python 迁移示例
PYTHON
from passlib.context import CryptContext
# 同时支持 bcrypt 和 argon2(argon2 为默认)
ctx = CryptContext(
schemes=["argon2", "bcrypt"],
default="argon2",
deprecated=["bcrypt"], # 标记 bcrypt 为旧算法
argon2__memory_cost=65536,
argon2__time_cost=3,
argon2__parallelism=4,
)
# 验证 + 自动升级
def verify_and_upgrade(user, password):
verified, new_hash = ctx.verify_and_update(password, user.password_hash)
if verified and new_hash:
# 旧格式(bcrypt)已升级 → 保存
user.password_hash = new_hash
user.save()
return verified
九、CTF 和密码学挑战中的 Argon2
9.1 Argon2 在 CTF 中的特点
CODE
优点(对出题人):
输出格式标准($argon2id$v=19$m=...,t=...,p=...$salt$hash)
Python/Go 都有现成库
可以通过参数调整难度
缺点(对解题者):
暴力破解几乎不可行(参数足够高时)
→ CTF 题通常用弱参数 (m=8, t=1, p=1) 或 弱密码字典
9.2 典型 CTF 题目模式
CODE
模式 1: 弱参数 + 字典攻击
给定 Argon2(m=8, t=1, p=1) hash,找明文
→ hashcat -m 19200
模式 2: 参数隐藏在代码中
程序生成 Argon2 作为密钥
需要反编译/逆向找到参数
模式 3: 作为 KDF 用于解密
密码 → Argon2 → 对称密钥 → AES 解密
需要找到正确密码
模式 4: 在线网站的"慢速登录"
服务器用 Argon2 验证密码 → 可以通过时间差探测
9.3 Python 脚本示例(CTF 字典攻击)
PYTHON
# argon2_bruteforce.py
from argon2 import PasswordHasher, Type, exceptions
import sys
# 读取参数
target_hash = sys.argv[1]
wordlist = sys.argv[2]
ph = PasswordHasher(
time_cost=3, memory_cost=65536, parallelism=4,
type=Type.ID
)
with open(wordlist, 'r', errors='ignore') as f:
for line in f:
password = line.strip()
try:
if ph.verify(target_hash, password):
print(f"\n[✓] 找到密码: {password}")
break
except exceptions.VerifyMismatchError:
pass
except Exception as e:
print(f"[!] {password} → {e}")
# 进度
if hash(password) % 1000 == 0:
print(f"\r测试: {password[:30]}...", end="")
十、Argon2 vs 其他高级 KDF
10.1 新代 KDF 概览
| 算法 | 年份 | 设计理念 | 典型内存 | 状态 |
|---|---|---|---|---|
| Argon2 | 2015 | Blake2b + 内存难 + 并行 | 64 MiB+ | PHC Winner |
| yescrypt | 2015 | scrypt 改进 + ROMix 变体 | 可调 | PHC 决赛 |
| catena | 2015 | 图遍历 + 依赖链 | 可调 | PHC 决赛 |
| Lyra2 | 2015 | 海绵结构 + 可调内存 | 可调 | PHC 候选 |
| Makwa | 2015 | 基于模幂运算(慢数学) | 可忽略 | PHC 候选 |
| Balloon Hashing | 2016 | 内存难哈希 + 可证明安全 | 可调 | 学术 |
| Argon3 | 未发布 | 理论优化(尚未标准化) | 可变 | 未发布 |
10.2 推荐使用
CODE
新系统(2026 年):
✅ Argon2id(通用密码哈希)
✅ Argon2d(离线哈希、区块链等需要抗 ASIC 的场景)
✅ Argon2i(高安全、对侧信道特别敏感的场景)
兼容旧系统:
✅ bcrypt(如果必须用旧算法)
⚠️ scrypt(可接受,但不如 Argon2id)
⚠️ PBKDF2(仅当别无选择时,迭代次数需非常高)
禁止使用:
❌ 任何无 salt 的纯哈希(MD5、SHA-1、SHA-256...)
❌ 自制哈希方案
❌ 未加盐的任何方案
总结
Argon2 的核心优势
CODE
1. 内存难(Memory-Hard):
需要大量 RAM 和高内存带宽
GPU 的"多核心优势"被内存瓶颈抵消
ASIC 难以绕过内存接口
2. 可证明安全(部分模型):
在随机预言机模型 (ROM) 下可证明安全
3. 三个变体:
Argon2d = 抗 GPU/ASIC 最强
Argon2i = 抗侧信道最强
Argon2id = 兼顾两者(推荐默认)
4. 参数可调整:
m = 内存大小 (KB) — 最关键参数
t = 迭代次数
p = 并行度(lanes 数)
5. 广泛支持:
libsodium(C/C++/Rust/Python/Node.js/Go)
Python (argon2-cffi / passlib)
PHP (内置)
Node.js / Go / Rust (官方包)
OWASP 推荐
RFC 9106 标准
为什么 Argon2 最难破解
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
速查配置表
| 场景 | 算法 | m (KB) | t | p | 预计延迟 (服务器) |
|---|---|---|---|---|---|
| 用户登录(低延迟) | Argon2id | 47104 (46 MiB) | 1 | 1 | ~200ms |
| 标准密码哈希 | Argon2id | 65536 (64 MiB) | 3 | 4 | ~500ms |
| 高安全(加密钱包密钥) | Argon2id | 262144 (256 MiB) | 3 | 4 | ~2s |
| 极高安全(离线存储) | Argon2id | 1048576 (1 GiB) | 4 | 8 | ~10s |
| 移动端/受限设备 | Argon2id | 37000 (36 MiB) | 1 | 1 | ~100ms |
| CTF 练习(弱参数) | Argon2id | 8 | 1 | 1 | < 1ms |
记忆口诀:Argon2id 的三个参数优先级 = m > t > p(先调内存,其次迭代,最后并行度)