Argon2 密码哈希完全指南

← 返回指南列表

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(先调内存,其次迭代,最后并行度)