Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

第二十六 口令(password)

口令概述

计算机、互联网中为了保护系统安全、认证用户身份,经常使用账号/密码(准确来说应该为“口令“)对用户进行访问控制。口令(password)是信息安全领域最古老、最广泛使用的身份认证机制,从1961年 MIT 的 CTSS 时间共享系统首次引入口令机制至今,口令仍然是绝大多数系统用户认证的第一道防线。

口令在计算机互联网中扮演非常重要的作用。据统计,超过80%的数据泄露事件与弱口令或口令管理不当有关。理解口令安全原理、掌握口令保护技术,是每个开发者和安全从业者的必修课。

口令安全威胁

口令面临着多种攻击方式的威胁,了解这些威胁是保护口令安全的第一步。

暴力破解

暴力破解(Brute Force Attack)是最直接的攻击方式,攻击者尝试所有可能的字符组合来猜测口令。对于一个长度为 $n$、字符集大小为 $k$ 的口令,其可能的组合数为 $k^n$。

口令长度仅小写字母 ($k=26$)大小写+数字 ($k=62$)大小写+数字+符号 ($k=95$)
6 位$3.08 \times 10^8$$5.68 \times 10^{10}$$7.35 \times 10^{11}$
8 位$2.09 \times 10^{11}$$2.18 \times 10^{14}$$6.63 \times 10^{15}$
10 位$1.41 \times 10^{14}$$8.39 \times 10^{17}$$5.99 \times 10^{19}$
12 位$9.54 \times 10^{16}$$3.23 \times 10^{21}$$5.41 \times 10^{23}$

现代 GPU 可以每秒尝试数十亿次简单哈希运算,因此短口令在暴力破解面前几乎不堪一击。

字典攻击

字典攻击(Dictionary Attack)比暴力破解更高效。攻击者使用预先收集的常用密码、常见单词、人名、地名等组成的“字典“,逐一尝试。由于大多数人倾向于使用容易记忆的密码,字典攻击的成功率远高于暴力破解。

根据统计,最常用的弱密码包括:

排名密码出现频率
1123456约 1%
2password约 0.8%
312345678约 0.6%
4qwerty约 0.4%
5abc123约 0.3%
6888888约 0.2%
7111111约 0.2%
8123123约 0.15%

这些密码在字典攻击面前毫无抵抗力。

彩虹表攻击

彩虹表攻击(Rainbow Table Attack)是一种利用预计算来加速口令破解的技术。攻击者预先计算大量口令的哈希值,并存储在查找表中(彩虹表)。当获取到系统的哈希值后,只需在表中查找即可反推出原始口令。

彩虹表的核心思想是用空间换时间。设口令空间为 $N$,直接暴力破解需要 $O(N)$ 次哈希运算,而彩虹表预计算后查找只需 $O(N^{2/3})$ 的空间和 $O(N^{2/3})$ 的时间。

防御彩虹表攻击的关键手段是使用盐值(salt),即在每个口令哈希前加入随机数据,使得预计算表失效。

钓鱼攻击

钓鱼攻击(Phishing)不直接攻击口令本身,而是通过伪装成合法网站或服务,诱骗用户主动输入口令。钓鱼攻击的技术手段包括:

  • 邮件钓鱼:发送伪装成银行、社交媒体等官方通知的邮件
  • 网站克隆:搭建与目标网站高度相似的假网站
  • 中间人攻击:在用户与服务器之间截获通信
  • 短信钓鱼(Smishing):通过短信诱导用户访问钓鱼网站

键盘记录与社会工程学

键盘记录(Keylogging)通过在用户设备上安装恶意软件,记录用户的键盘输入来窃取口令。社会工程学(Social Engineering)则通过心理操纵,让用户主动透露口令信息,例如冒充IT支持人员要求用户提供密码。

如何构造强口令

口令如此重要,如何保护好自己的口令呢?首先口令本身应该足够复杂,足够抵御攻击。

密码长度、复杂度与熵

口令的安全强度可以用信息熵(Information Entropy)来量化。信息熵的计算公式为:

$$H = L \times \log_2(k)$$

其中 $L$ 为口令长度,$k$ 为字符集大小。

口令示例长度字符集熵(bit)安全等级
1234566数字(10)19.9极弱
password8小写(26)37.6弱
P@ssw0rd8混合(95)52.6中等
ARG2on&@!9混合(95)59.2较强
ARG2on&@!略10混合+中文80+强

一般来说,熵值达到 60 bit 以上才被认为具有较好的安全性,80 bit 以上则相当安全。

密码短语(Passphrase)

密码短语(Passphrase)是由多个随机单词组成的口令,例如 “correct-horse-battery-staple”。密码短语的核心优势在于:

  • 长度更长:即使每个单词只有4-5个字母,4个单词组成的短语也有16-20个字符
  • 更容易记忆:相比随机字符串,有意义的单词组合更容易记住
  • 熵值更高:假设使用包含7776个单词的词典(类似 diceware),4个单词的熵为 $4 \times \log_2(7776) \approx 51.7$ bit;5个单词则达到约64.6 bit

密码强度评估

前面我们提到密码有强弱之分,那么该如何量化评估一个密码的强度呢?可以参考这篇博客计算密码强度《如何使用Rust编程语言来产生密码或是计算密码强度?密码又该如何安全保存呢?》。

在 Rust 中,我们可以使用 passwords 库来评估密码强度:

/*
[dependencies]
passwords = "3.1.16"
*/

use passwords::{analyzer, scorer};

fn main(){
    let pwds = vec!["123456","password","P@ssw0rd","ARG2on&@!","ARG2on&@!略","Tr0ub4dor&3xYz!@#"];
    for pwd in &pwds{
        let analyzed = analyzer::analyze(pwd);
        println!("Password: {},Length: {} characters,Score: {}", pwd,analyzed.length(),scorer::score(&analyzed));
    }
}

passwords 库的 scorer::score() 函数会综合考虑密码长度、字符多样性、常见模式等因素,返回一个0-100的分数。分数越高,密码强度越大。

口令存储安全

绝不存储明文密码

在系统设计中,有一条铁律:永远不要存储用户的明文密码。历史上无数数据泄露事件证明,存储明文密码是极其危险的行为。即使数据库被攻破,攻击者也不应该能直接获取用户的原始密码。

哈希 + 盐值

正确的口令存储方式是使用密码哈希函数对口令进行单向变换,并附加盐值(salt)来防御彩虹表攻击。

盐值(Salt) 是一个随机生成的字符串,每个用户的盐值都不同。存储时将盐值与口令拼接后再进行哈希:

$$\text{stored} = \text{salt} \parallel \text{hash}(\text{salt} \parallel \text{password})$$

盐值的作用:

  • 使相同口令产生不同的哈希值
  • 使预计算的彩虹表失效
  • 增加攻击者需要独立破解每个口令的成本

Argon2:现代密码哈希算法

Argon2 是密码哈希竞赛(Password Hashing Competition, PHC)的获胜者,被认为是目前最安全的密码哈希算法。Argon2 有三个变体:

  • Argon2d:纯数据依赖型,抗 GPU 攻击最强,但易受侧信道攻击
  • Argon2i:纯独立型,抗侧信道攻击,但对 GPU 攻击的抵抗力稍弱
  • Argon2id:混合型,先进行一遍独立型再进行数据依赖型,兼顾两者优势

Argon2 的核心思想是内存硬(memory-hard):它需要大量内存来完成计算,这使得 GPU、ASIC 等并行计算硬件的优势被大大削弱。

/*
[dependencies]
argon2 = {version = "0.5.3",feature = ["getrandom"]}
rand_core = { version = "0.6", features = ["getrandom"] }
*/

fn main()-> Result<(), argon2::password_hash::errors::Error> {
    use argon2::{
        password_hash::{
            rand_core::OsRng, PasswordHash, PasswordHasher, PasswordVerifier, SaltString,
        },
        Argon2,
    };

    let pwd = "ARG2on&@!略";
    let password = pwd.as_bytes(); // Bad password; don't actually use!
    let salt = SaltString::generate(&mut OsRng);

    // Argon2 with default params (Argon2id v19)
    let argon2 = Argon2::default();

    // Hash password to PHC string ($argon2id$v=19$...)
    let password_hash = argon2.hash_password(password, &salt)?.to_string();

    // Verify password against PHC string.
    //
    // NOTE: hash params from `parsed_hash` are used instead of what is configured in the
    // `Argon2` instance.
    let parsed_hash = PasswordHash::new(&password_hash)?;
    assert!(Argon2::default()
        .verify_password(password, &parsed_hash)
        .is_ok());

    println!("{}", &password_hash);
    Ok(())
}

Argon2 的 PHC 字符串格式为:

$argon2id$v=19$m=19456,t=2,p=1$salt$hash

其中 m 表示内存成本(KB),t 表示时间迭代次数,p 表示并行度。

PBKDF2:基于密钥派生的方案

PBKDF2(Password-Based Key Derivation Function 2)是一种通过多次迭代哈希运算来增加破解成本的算法。PBKDF2 的核心思想是:

$$DK = \text{PBKDF2}(PRF, \text{password}, \text{salt}, c, dkLen)$$

其中 $c$ 为迭代次数,$PRF$ 为伪随机函数(通常使用 HMAC-SHA256 或 HMAC-SHA512)。迭代次数越多,攻击者每次尝试的成本越高。

#![allow(unused)]
fn main() {
use hex;
use rand;
use ring::digest;
use pbkdf2;

fn pbkdf2() {

    const CREDENTIAL_LEN: usize = digest::SHA512_OUTPUT_LEN;
    let n_iter = NonZeroU32::new(100_000).unwrap();
    let rng = rand::SystemRandom::new();

    let mut salt = [0u8; CREDENTIAL_LEN];
    rng.fill(&mut salt);

    let password = "Guess Me If You Can!";
    let mut pbkdf2_hash = [0u8; CREDENTIAL_LEN];
    pbkdf2::derive(
        pbkdf2::PBKDF2_HMAC_SHA512,
        n_iter,
        &salt,
        password.as_bytes(),
        &mut pbkdf2_hash,
    );
    println!("Salt: {}", HEXUPPER.encode(&salt));
    println!("PBKDF2 hash: {}", HEXUPPER.encode(&pbkdf2_hash));

    let should_succeed = pbkdf2::verify(
        pbkdf2::PBKDF2_HMAC_SHA512,
        n_iter,
        &salt,
        password.as_bytes(),
        &pbkdf2_hash,
    );
    let wrong_password = "Definitely not the correct password";
    let should_fail = pbkdf2::verify(
        pbkdf2::PBKDF2_HMAC_SHA512,
        n_iter,
        &salt,
        wrong_password.as_bytes(),
        &pbkdf2_hash,
    );

    assert!(should_succeed.is_ok());
    assert!(!should_fail.is_ok());
}
}

PBKDF2 的迭代次数建议至少 100,000 次(2026年标准),且应随硬件性能提升而定期增加。

bcrypt 与 scrypt

bcrypt 是一种专门为密码哈希设计的算法,内置盐值并使用 Blowfish 密码的变体进行多次加密。bcrypt 的特点是:

  • 内置盐值,无需单独管理
  • 自适应成本因子(cost factor),可随硬件升级调整
  • 故意设计为计算缓慢,增加暴力破解成本

scrypt 在 bcrypt 的基础上增加了内存硬特性,需要大量内存才能完成计算,有效抵御 GPU/ASIC 攻击。scrypt 的参数包括:

  • $N$(CPU/内存成本因子)
  • $r$(块大小)
  • $p$(并行因子)

密码哈希算法对比

特性Argon2bcryptscryptPBKDF2
抗暴力破解优秀良好优秀一般
抗GPU/ASIC优秀(内存硬)一般优秀(内存硬)差
抗侧信道攻击良好(Argon2i)一般一般良好
可调参数内存/时间/并行度成本因子CPU/内存/并行度迭代次数
标准化PHC winner广泛使用RFC 7914RFC 2898
推荐程度首选推荐推荐可用
Rust 库argon2rust-bcryptscryptpbkdf2

推荐策略:新项目首选 Argon2id;已有项目使用 bcrypt 也是可接受的;PBKDF2 虽然广泛支持,但在抗 GPU 攻击方面不如前三者。

如何管理你的口令

生活中各种形形色色的密码(口令)数不胜数,如何管理这些密码也是一件十分重要的事情。

密码管理器

使用诸如 LastPass、1Password、Bitwarden、KeePassXC 等专业的密码管理器能够同时兼顾密码的安全和便捷。密码管理器的核心功能包括:

  • 自动生成强密码:为每个账号生成唯一的随机强密码
  • 安全存储:使用强加密算法(如 AES-256)存储所有密码
  • 自动填充:在浏览器和移动应用中自动填写密码
  • 跨设备同步:在手机、电脑、平板之间安全同步密码库
  • 安全审计:检测重复密码、弱密码、已泄露密码
  • 双因素与 Passkey:内置 TOTP、支持硬件密钥与 Passkey(部分功能需付费)
  • 共享与紧急访问:家庭/团队共享,以及“人不在了,家人如何取回库“

密码管理器的工作原理

无论哪家产品,核心流程都是同一套:一个加密库(vault)+ 一个把主密码变成密钥的 KDF + 一条同步链路。

主密码 ──► KDF(Argon2id / PBKDF2-SHA256 / scrypt)──► 主密钥
                                                       │
                              AEAD 解密(AES-256-GCM / ChaCha20-Poly1305 /
                              或 AES-256-CBC + HMAC-SHA256)
                                                       ▼
                                                 加密库(vault)
                                                       │
                              同步:服务器只保存密文(零知识)

几个很容易混淆的概念,必须先分清:

概念含义边界
零知识(ZKE)服务端只存密文,厂商声称自己也无法解密这是架构 + 承诺,在恶意服务器或被投毒的客户端面前可能失守
端到端加密(E2EE)密钥只在终端,密码学上杜绝服务端解密仍受客户端漏洞、KDF 参数、恢复流程影响
认证协议证明“我知道主密码“而不发送主密码1Password 用 SRP;多数厂商是发送派生出的认证哈希
KDF 参数决定拖库后被离线爆破的成本老账号常因历史参数过低成为整个库的短板

威胁模型:密码管理器怕什么

威胁说明靠什么防住
服务器被拖库攻击者拿到整份密文库高熵主密码 + 足够强的 KDF 参数
恶意/被入侵的服务端服务端下发恶意配置或降级加密算法客户端校验、E2EE、第三方审计
供应链攻击客户端、npm 包、CI、浏览器扩展、安装包被投毒官方签名、可复现构建、及时更新
本地恶意软件内存 dump、键盘记录、剪贴板劫持系统安全、避免明文复制粘贴
钓鱼与同形字域名在假站上被自动填充只在精确匹配的域名填充
恢复/共享流程被滥用紧急访问、组织邀请、找回流程最小权限、谨慎授权

记住一句话:密码管理器把“记住很多密码“的风险,收敛成“守住一把钥匙“的风险。 这把钥匙(主密码)和它的派生方式(KDF),决定了整套体系的上限。

LastPass

一句话概括:功能齐全、价格便宜的云同步老牌选手,但安全历史包袱最重。

  • 历史与定位:2008 年上线,长期由 LogMeIn/GoTo 运营,从浏览器扩展起家,主打全平台自动填充、共享与家庭版。
  • 安全设计:零知识;主密码经 PBKDF2-SHA256 派生出加密密钥,库以 AES-256 加密后上传;服务端保存密文,以及部分元数据(例如站点 URL、条目名称)。
  • 主要事件:
    • 2011 年发现异常登录、2015 年被入侵(邮箱、提醒等元数据)、2017 年浏览器扩展漏洞。
    • 2022 年:8 月开发者环境被入侵;11–12 月攻击者进一步拿到云存储中的加密库备份和未加密元数据。能不能解密完全取决于主密码强度与 KDF 参数——而历史账号的 PBKDF2 迭代次数曾低至 5,000 次,弱主密码被离线爆破的风险极高。此后 LastPass 上调了默认迭代次数并收紧了默认策略。
    • 2023–2025 年:泄露的库持续被用于撞库与加密货币盗取(泰国 CERT 到 2025 年底仍在跟踪相关案件),是“一次泄露、长期危害“的典型样本。
    • 2026 年 6 月:第三方竞争情报平台 Klue 被攻破,OAuth token 被窃,导致 LastPass 的 Salesforce CRM 数据(姓名、电话、邮箱、地址、工单、销售记录)被复制;官方称生产系统与用户的加密库未受影响。
  • 优点:便宜,功能全(共享、紧急访问、暗网监控、Passkey、家庭版最多 6 人),上手快。
  • 缺点:历史事件多;元数据(“你有哪些网站的账号”)历史上曾泄露;品牌信任修复缓慢。
  • 定价(2026-10,年付,USD,以官网为准):Free(限 1 种设备类型)、Premium 约 $3/月、Families 约 $4/月(6 人)、Plus(含 VPN)、Business 约 $9/用户/月。
  • 建议:已经在用的人至少做三件事——主密码换成 5–6 词的高熵 passphrase、确认 KDF 迭代次数已上调、开启 MFA;新用户有更稳妥的选择。

1Password

一句话概括:闭源商业产品里体验和工程能力最强的一家,“双密钥“设计在 2026 年的学术评测中表现最好。

  • 安全设计:Secret Key + 主密码(2SKD)。Secret Key 是 128 位随机值,在设备上生成、随邀请流程传递,用户不需要记忆;主密码与 Secret Key 一起经 PBKDF2-HMAC-SHA256 派生出登录密钥与加密密钥。登录使用 SRP(Secure Remote Password),主密码本身从不上传。库里所有字段(包括 URL、标题、备注)都端到端加密。
  • 特色功能:Watchtower(弱口令/重复/泄露检测)、Travel Mode(跨境时隐藏指定库)、Passkey、SSH Agent(用库里的 SSH 密钥做 Git 提交签名)、CLI/SDK/Service Account,以及面向特权访问的 1Password Privileged Access(2026)。1Password 8 起,跨平台核心(shared core)用 Rust 重写,UI 使用 Electron/React。
  • 安全记录:多次第三方审计,并公开安全设计白皮书;2023 年 Okta 支持系统被入侵,攻击者拿到部分用户的元数据,但因缺少 Secret Key,官方称未触及用户库。2026 年 2 月 ETH Zurich 的“恶意服务器“研究认为它对其中两类攻击“潜在受影响“,但同时指出 Secret Key + SRP 让离线爆破基本不可行。
  • 优点:体验和跨平台一致性最好;开发者工具(SSH、CLI、CI 集成)最完善;家庭/团队共享成熟。
  • 缺点:闭源、价格最高一档;Rust 核心 + Electron 的组合在低配机器上略重;没有免费版,只有 14 天试用。
  • 定价(2026-10,年付,USD):Individual 标价 $3.99/月(常年有首年 25% 折扣,约 $2.99/月);Families $5.99/月(5 人,促销 $4.49);Teams Starter Pack $24.95/月(10 人);Business $8.99/用户/月。

Bitwarden

一句话概括:开源 + 免费够用 + 可自托管,个人与中小团队的性价比之王。

  • 安全设计:零知识;主密码经 PBKDF2-HMAC-SHA256(默认迭代次数已提升到 60 万次)或可选的 Argon2id 派生;加密使用 AES-256-CBC + HMAC-SHA256 或 AES-256-GCM。
  • 开源与自托管:客户端与服务端代码公开,可自建(官方提供容器镜像);社区还有 Rust 写的兼容服务端 Vaultwarden(原名 bitwarden_rs),资源占用很小,适合家用 NAS 或小团队。
  • 特色功能:无限密码与无限设备同步(免费)、Send(一次性分享密文)、组织/集合、紧急访问、TOTP(2026 年起归入 Premium)、Passkey、CLI;企业版提供目录同步/SCIM。
  • 2026 年的两点变化:
    • 1 月起 Premium 从 $9.99/年涨到 $19.80/年,同时免费版不再包含内置 TOTP、附件和紧急访问。
    • 4 月 CLI 的 npm 包被投毒:@bitwarden/cli@2026.4.0 在 4 月 22 日约 1.5 小时的窗口内被替换,恶意代码通过 preinstall 钩子窃取开发者/CI/云凭据,下载量约 334 次;官方称用户库与生产系统未被访问,随后发布回滚版本并建议受影响者轮换凭据。这件事提醒我们:密码管理器的风险不只在“库“,也在发布链和 CI。
  • 2026 年 ETH Zurich 研究:在“恶意服务器“模型下,Bitwarden 被测出 12 类攻击面,是三家被测产品中最多的——便宜不等于安全,产品需要在恢复、共享、旧加密兼容路径上持续收紧。
  • 优点:免费版最强;开源可审计;自托管自由度高;整体价格最低。
  • 缺点:UI/体验不如 1Password 精致;高级功能逐步收费;自托管意味着备份、升级、安全全由自己负责。
  • 定价(2026-10,年付,USD):Free / Premium $19.80/年 / Families $47.88/年(6 人)/ Teams $4/用户/月 / Enterprise $6/用户/月(每个席位附带一份免费 Families)。

KeePassXC

一句话概括:完全离线、开源、文件即库——把“信任“从厂商手里拿回到自己手里。

  • 安全设计:本地 KDBX 4 数据库文件;加密算法可选 AES-256-CBC 或 ChaCha20,完整性由 HMAC-SHA256 保护;KDF 可选 Argon2d(默认)/ Argon2id / AES-KDF。开库密钥可以是“主密码 + 密钥文件 + YubiKey challenge-response“的任意组合,也就是说,没有密钥文件或硬件钥匙,光知道主密码也打不开。
  • 同步:没有云,需要自己同步(Syncthing、Nextcloud、坚果云、U 盘、私有 Git……);多设备并发修改可能冲突,建议开启备份并定期做数据库比较/合并。
  • 特色功能:Auto-Type(模拟键盘输入,绕过剪贴板监控)、浏览器集成(native messaging)、TOTP、SSH Agent、附件、多库、组/标签、历史记录、Passkey(2.7.12 起记录备份资格/备份状态标志)。
  • 认证与审计:GPLv3 开源;2.7.9 通过法国 ANSSI 的 CSPN 安全签证(2025-11);持续第三方审计。2026 年 9 月发布 2.8.0-beta1(迁移 Qt6、Wayland 下支持 Auto-Type、Windows ARM64 原生构建等)。
  • 优点:无云、无订阅、无厂商拖库风险;可放在加密 U 盘里随身携带;审计与认证记录好。
  • 缺点:同步、备份、多端体验全靠自己;本地恶意软件风险更高(库就在本机);手机上需要 KeePassDX(Android)/ KeePassium(iOS)等第三方客户端。
  • 定价:免费(GPLv3),可自愿捐赠。

横向对比

维度LastPass1PasswordBitwardenKeePassXC
形态云同步(闭源)云同步(闭源)云同步(开源,可自托管)本地文件(开源)
密钥派生PBKDF2-SHA256主密码 + Secret Key,PBKDF2PBKDF2 60 万次 / Argon2idArgon2d/id、AES-KDF
认证方式派生哈希SRP派生哈希无(纯本地)
全字段加密是是(含 URL、标题)是是(本地文件加密)
硬件密钥支持支持支持YubiKey challenge-response
免费版限 1 种设备类型无(14 天试用)无限密码与设备完全免费
个人年费(约)$36$48(促销 $36)$19.80$0
家庭共享6 人5 人6 人自己同步
自托管否否是(Vaultwarden)本质就是自持
主要风险历史泄露、元数据闭源、价格功能分层、供应链备份、同步、本地恶意软件
适合人群预算敏感的家庭追求体验的付费用户开发者/自托管/预算党技术控/离线场景

除此之外,Dashlane、NordPass、Proton Pass、Enpass、Keeper、以及浏览器内置的密码管理器和 KeePass 原版也都各有拥趸。它们多半是上表某个象限的变体;选型时只需回答三个问题:库放在谁手里、主密码怎么守、出事怎么恢复。

怎么选

  • 只想要“装上就别管了“,且愿意付费 → 1Password。
  • 想免费、开源、还能自己托管 → Bitwarden(家用 NAS 可上 Vaultwarden)。
  • 不接受“库放在别人的服务器上“ → KeePassXC,但要接受自己备份与同步。
  • 已经在用 LastPass → 先加固(passphrase、迭代次数、MFA),再从容迁移,不必恐慌式换库。
  • 企业/团队 → 重点看 SSO/SCIM、审计日志、自托管与合规要求;1Password Business 与 Bitwarden Teams/Enterprise 都能覆盖。

迁移与应急的实操要点

  1. 导出即明文:CSV/JSON 导出是明文,务必在断网、可信的机器上操作,迁移完立即删除(最好安全擦除)。
  2. TOTP 不一定跟着走:有的产品出于安全考虑不在导出中包含 TOTP 种子,迁移后要逐项确认验证码还能生成。
  3. Passkey 迁移受限:Passkey 绑定域名与账户,建议保留旧库一段时间,确认新库可用后再删除。
  4. 留一条后路:云方案开启紧急访问或保存恢复码;本地方案把 KDBX 与密钥文件分开存放,并做异地离线备份。
  5. 主密码不写进任何联网设备:纸质封存 + 家人知情的位置约定,胜过存在备忘录里。

使用密码管理器的十条实践

  1. 主密码用 5–6 个随机单词的 passphrase(≥ 80 bit 熵),不要用 P@ssw0rd 式改造。
  2. 主密码只留在脑子里和纸质备份里,不进浏览器、不进云笔记。
  3. 开启 MFA,优先硬件密钥/TOTP,短信只作兜底。
  4. 每个站点唯一密码,长度 ≥ 16,交给生成器。
  5. 自动填充只在精确匹配的域名生效,防同形字钓鱼。
  6. 不要把“第二因素“和“密码“放在同一个库里(除非你接受这个权衡)。
  7. 定期跑一次安全审计:弱口令、重复口令、已泄露口令。
  8. 保持客户端与浏览器扩展更新;警惕 npm/CI/安装包供应链投毒。
  9. 每季度做一次加密备份,并验证备份真的能打开。
  10. 团队用组织/集合 + 最小权限;人员离职立即撤销权限。

Rust 生态里的密码管理器

  • Vaultwarden:Rust 实现的 Bitwarden 兼容服务端,可在 NAS、树莓派上运行,是自托管的首选方案。
  • keepass crate:纯 Rust 的 KDB / KDBX3 / KDBX4 解析库(写入 KDBX 4.1 仍在实验阶段),可以拿它写一个“库体检“小工具:遍历条目、找出重复密码、检查口令是否过期、导出审计报告。
  • 1Password:1Password 8 的跨平台核心用 Rust 重写,是 Rust 在终端安全软件里落地的典型案例。

单点登录(SSO)

单点登录(Single Sign-On, SSO)允许用户使用一组凭证登录多个相关系统。常见的 SSO 协议包括:

  • OAuth 2.0:授权框架,广泛用于第三方登录(如微信、GitHub 登录)
  • SAML:企业级 SSO 标准,常用于企业内部系统
  • OpenID Connect:基于 OAuth 2.0 的身份认证层

SSO 的优势是减少用户需要记忆的密码数量,但风险在于一旦 SSO 凭证泄露,所有关联系统都将受到影响。

OTP(一次性口令)

OTP(One Time Password,一次性口令)是一种每次使用后即失效的动态密码机制,可以有效防止口令重放攻击。

HOTP:基于计数器的 OTP

HOTP(HMAC-Based One-Time Password)基于一个递增的计数器和共享密钥来生成一次性口令。其计算公式为:

$$HOTP(K, C) = \text{Truncate}(\text{HMAC-SHA1}(K, C))$$

其中 $K$ 为共享密钥,$C$ 为计数器值。Truncate 函数将 HMAC 的输出截取为指定位数(通常6位)的数字。

HOTP 的问题是客户端和服务端的计数器必须保持同步,如果客户端生成了 OTP 但未使用(计数器递增),服务端的计数器就会落后,需要通过“滑动窗口“机制来容错。

TOTP:基于时间的 OTP

TOTP(Time-Based One-Time Password)是 HOTP 的改进版本,使用时间戳代替计数器:

$$TOTP(K, T) = HOTP(K, T)$$

其中 $T = \lfloor \frac{\text{current_time} - T_0}{X} \rfloor$,$T_0$ 为起始时间(通常为 Unix 纪元),$X$ 为时间步长(通常为30秒)。

TOTP 的优势在于不需要计数器同步,只需保证客户端和服务端的时钟大致同步即可。这就是 Google Authenticator、Microsoft Authenticator 等认证器应用的工作原理。

Rust 实现 TOTP

以下是一个使用 Rust 实现 TOTP 的示例:

#![allow(unused)]
fn main() {
use hmac::{Hmac, Mac};
use sha1::Sha1;

type HmacSha1 = Hmac<Sha1>;

/// 生成 TOTP 一次性口令
///
/// # 参数
/// - `secret`: 共享密钥(原始字节;Base32 字符串需要先解码)
/// - `time_step`: 时间步长(秒),通常为30
/// - `digits`: 输出位数,通常为6
///
/// # 返回
/// 指定位数的数字字符串
fn generate_totp(secret: &[u8], time_step: u64, digits: usize) -> String {
    let time = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_secs();

    // 计算时间计数器
    let counter = time / time_step;

    // 将计数器转换为8字节大端序
    let counter_bytes: [u8; 8] = counter.to_be_bytes();

    // 计算 HMAC-SHA1
    let mut mac = HmacSha1::new_from_slice(secret).expect("HMAC can take key of any size");
    mac.update(&counter_bytes);
    let result = mac.finalize().into_bytes();

    // 动态截断
    let offset = (result[19] & 0x0f) as usize;
    let binary: u32 = ((result[offset] & 0x7f) as u32) << 24
        | (result[offset + 1] as u32) << 16
        | (result[offset + 2] as u32) << 8
        | (result[offset + 3] as u32);

    // 取指定位数
    let otp = binary % 10u32.pow(digits as u32);
    format!("{:0width$}", otp, width = digits)
}

#[test]
fn test_totp() {
    // 示例密钥(实际应用中应使用安全的随机密钥)
    let secret = b"12345678901234567890"; // 20字节密钥

    let code = generate_totp(secret, 30, 6);
    println!("Current TOTP code: {}", code);
    assert_eq!(code.len(), 6);
}
}

在实际生产环境中,推荐使用成熟的 crate 如 totp-rs:

[dependencies]
totp-rs = "^5.0"
/*
[dependencies]
totp-rs="^5.0"
*/
use totp_rs::{Algorithm, TOTP, Secret};

fn main() {
    // Secret::Encoded 接收的是 Base32 字符串,不是任意数字串。
    // 下面是 RFC 6238 测试密钥 "12345678901234567890" 的 Base32 编码。
    let totp = TOTP::new(
        Algorithm::SHA256,           // 哈希算法
        6,                         // 位数
        1,                         // skew(允许的时间偏差步数)
        30,                        // 时间步长(秒)
        Secret::Encoded("GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ".to_string())
            .to_bytes()
            .unwrap(),
    ).unwrap();

    // 生成当前 TOTP 码
    let code = totp.generate_current().unwrap();
    println!("TOTP code: {}", code);

    // 验证 TOTP 码
    let valid = totp.check_current(&code).unwrap();
    println!("Valid: {}", valid);
}

Secret::Encoded 的参数必须是 Base32 字符串(字符集为 A-Z 和 2-7)。如果把 12345678901234567890 这样的十进制数字串直接传进去,to_bytes() 会返回 ParseBase32 错误,unwrap() 就会 panic。如果手里是原始字节,也可以改用 Secret::Raw(b"12345678901234567890".to_vec()),就不需要先做 Base32 编码。

多因素认证(MFA)简介

多因素认证(Multi-Factor Authentication, MFA)通过组合多种认证因素来提高安全性。认证因素分为三类:

  1. 知识因素(Something you know):口令、PIN码、安全问题答案
  2. 持有因素(Something you have):手机、安全令牌、智能卡
  3. 固有因素(Something you are):指纹、面部识别、虹膜扫描

MFA 的安全增益可以用概率来理解。假设口令被破解的概率为 $p_1$,OTP 被截获的概率为 $p_2$,则 MFA 被攻破的概率约为 $p_1 \times p_2$,远低于单一因素。

常见的 MFA 方案:

  • 口令 + 短信验证码
  • 口令 + TOTP(Google Authenticator)
  • 口令 + 硬件安全密钥(YubiKey、FIDO2)
  • 口令 + 生物识别(指纹、面部)

趣味阅读:历史上的暗语和化名

口令和暗语不仅是计算机时代的产物,在人类历史上,暗语和化名一直扮演着重要角色。

暗语

鸡肋
河山统一
天王盖地虎,宝塔镇河妖天王
宫廷玉液酒,一百八一杯
识时务者为俊杰
风浪越大鱼越贵
龙门飞甲,便知真假

在中国近现代史上,暗语更是被广泛使用:

  • 邱小姐:中国第一颗原子弹的代号
  • 黄河:中国第一次核试验的代号
  • 长江:中国氢弹试验的代号

这些暗语在特定的历史时期和特定的群体中发挥了保密通信的作用。

化名

李得胜
伍豪
军统六哥——郑耀先
军统店小二——许忠义

在革命战争年代,化名是保护身份安全的重要手段。毛泽东曾使用“李得胜“作为化名,周恩来使用“伍豪“(这也是“豪密“命名的由来)。在谍战领域,化名更是特工的基本操作。

拓展思考

常用的账号密码基本都是大小写英文字母、数字、特殊字符的组合,有没有可能使用简体/繁体中文或者其他字符呢?就好比图形验证码通常都使用数字、大小写英文字母,后来演变成12306选择同类图片、手动补齐图片拼图,依次点击指定的文字符号等方式?

这个问题实际上涉及字符编码和系统兼容性的深层问题。现代系统(如 UTF-8 编码的数据库和应用)理论上完全支持中文密码,但在实践中仍面临以下挑战:

  • 输入法依赖:中文输入需要输入法,在某些设备或场景下可能不便
  • 键盘布局:在非中文键盘上输入中文密码极为困难
  • 兼容性:部分老旧系统可能不支持非 ASCII 字符的密码
  • 长度计算:中文字符在 UTF-8 中占3个字节,可能影响密码长度限制的判断

不过,在 Rust 中处理 Unicode 密码是完全可行的,正如本章代码示例中的 ARG2on&@!略 就包含了中文字符。

参考链接

总结

主题关键要点推荐实践
口令威胁暴力破解、字典攻击、彩虹表、钓鱼多层防御,不依赖单一措施
口令构造长度、复杂度、熵12位以上,混合字符集,或使用密码短语
口令存储哈希+盐值,绝不存明文Argon2id > bcrypt > scrypt > PBKDF2
口令管理密码管理器、SSO1Password(体验)/Bitwarden(开源免费)/KeePassXC(离线),主密码用 passphrase,启用 MFA
动态口令HOTP/TOTP30秒步长,6位数字,结合MFA使用
多因素认证知识+持有+固有至少启用双因素认证

练习题

  1. 安全分析:假设一个攻击者使用 GPU 集群每秒可以尝试 $10^{10}$ 次 SHA-256 哈希运算。对于一个8位纯数字密码(如生日),平均需要多长时间才能破解?如果是12位混合字符密码呢?

  2. 编程实践:使用 Rust 实现一个密码强度检测器,要求:

    • 计算密码的信息熵
    • 检测是否包含常见弱密码模式(如123456、password等)
    • 检测是否包含用户名或常见单词
    • 给出密码强度评分和改进建议
  3. 算法对比:为什么 Argon2 被认为是比 PBKDF2 更安全的密码哈希算法?请从内存硬度、抗 GPU/ASIC 攻击等角度分析。

  4. TOTP 实现:基于本章的 TOTP 示例代码,实现一个完整的命令行 TOTP 认证器:

    • 支持添加/删除密钥
    • 支持显示当前所有 TOTP 码
    • 支持密钥的 Base32 编码/解码
    • 数据持久化存储(加密保存)
  5. 思考题:在密码管理器中,主密码的安全性至关重要。如果主密码被遗忘,用户将无法恢复所有存储的密码。请分析密码管理器的设计如何在安全性和可用性之间取得平衡?是否有更好的替代方案?

  6. 实战挑战:使用 Rust 实现一个简单的用户认证系统,要求:

    • 用户注册:使用 Argon2id 哈希密码并存储
    • 用户登录:验证密码并返回 JWT token
    • 密码修改:验证旧密码后更新为新密码
    • TOTP 二次验证:登录时要求输入 TOTP 码
    • 使用 SQLite 存储用户数据
  7. 方案评估:假设你要为一个 20 人的小团队选密码管理器,团队里有 Windows、macOS、Linux 三种系统,预算有限,且有一位成员坚持“所有数据不能离开公司内网“。请结合本章内容回答:

    • 你会给出哪两套候选方案?各自的密钥派生与认证流程有什么不同?
    • “零知识(ZKE)“与“端到端加密(E2EE)“的差别是什么?在什么威胁模型下前者可能失效?
    • 如果要求“内网自托管“,Bitwarden 官方服务端与 Vaultwarden 各有什么取舍?你还需要额外承担哪些运维责任?