讲 MFA 之前必须先讲清"什么是 factor"。 所谓"多因素", 不是"输入两个东西"—— 输密码 + 输安全问题, 仍然是单因素 (都是"你知道的"), 攻击者一次钓鱼能同时拿到。 真正的多因素要求两类来源不同的凭证, 让攻击者必须同时攻破两个独立通道。

三类因子

2FA / MFA / Step-up 概念辨析

哪些 MFA 能抵抗钓鱼?

Google Authenticator / Authy / 1Password 里那串"30 秒变一次"的 6 位数字, 背后只是两条 RFC—— RFC 4226 (HOTP) 和 RFC 6238 (TOTP)。 公式简单到一页纸说得完, 但理解它你才能解释清楚: 为什么用 SHA-1 仍然是安全的; 为什么必须容忍时钟偏移; 为什么 6 位刚好够。

HOTP 公式 (RFC 4226 · 计数器型)

# HOTP(K, C) = Truncate( HMAC-SHA1(K, C) ) mod 10^Digits
# 输入
K      // 共享密钥 (≥ 16 字节, 通常 20 字节)
C      // 8 字节计数器 (大端编码)
Digits // 输出位数, 通常 6

# 步骤
1) HS = HMAC-SHA1(K, C)            // 输出 20 字节
2) offset = HS[19] & 0x0F          // 取末字节低 4 位 (0..15)
3) bin = (HS[offset]   & 0x7F) << 24
       | (HS[offset+1] & 0xFF) << 16
       | (HS[offset+2] & 0xFF) << 8
       | (HS[offset+3] & 0xFF)     // 动态截断 4 字节
4) return bin mod 10^Digits      // 6 位 → mod 1_000_000

TOTP 公式 (RFC 6238 · 时间型)

# TOTP = HOTP(K, T)
# 把 HOTP 里的"计数器"换成"时间步长"

T  = floor( (Now - T0) / X )
#   Now: 当前 Unix 时间 (秒)
#   T0:  起始时间, 通常 0
#   X:   时间步长, 通常 30 秒

# 然后照搬 HOTP
TOTP = HOTP(K, T)

# 例: 2026-05-26 10:30:00 UTC = 1779179400 秒
#     T = floor(1779179400 / 30) = 59305980
#     把 59305980 作为 8 字节大端塞进 HOTP, 算出 6 位数字

TOTP 工作时序

otpauth URI 与 QR Code

用户绑定时不需要手敲密钥——服务端生成一个特殊 URI, 编成二维码, 用户用 Authenticator App 扫一下就把密钥导入到本地。

# otpauth URI 格式 (Google Authenticator 约定)
otpauth://totp/{Issuer}:{Account}?secret={Base32}&issuer={Issuer}&algorithm=SHA1&digits=6&period=30

# 实际例子
otpauth://totp/Acme:alice@example.com?secret=JBSWY3DPEHPK3PXP&issuer=Acme&algorithm=SHA1&digits=6&period=30

Go 实战 · 手写 HOTP / TOTP

// hotp.go · 30 行实现 RFC 4226
package main

import (
    "crypto/hmac"
    "crypto/sha1"
    "encoding/binary"
    "fmt"
    "time"
)

func HOTP(key []byte, counter uint64, digits int) string {
    // 1) 8 字节大端计数器
    buf := make([]byte, 8)
    binary.BigEndian.PutUint64(buf, counter)

    // 2) HMAC-SHA1
    mac := hmac.New(sha1.New, key)
    mac.Write(buf)
    h := mac.Sum(nil)  // 20 字节

    // 3) 动态截断
    offset := h[19] & 0x0F
    bin := (uint32(h[offset])&0x7F)<<24 |
           uint32(h[offset+1])<<16 |
           uint32(h[offset+2])<<8 |
           uint32(h[offset+3])

    // 4) 取低 N 位
    mod := uint32(1)
    for i := 0; i < digits; i++ { mod *= 10 }
    return fmt.Sprintf("%0*d", digits, bin%mod)
}

func TOTP(key []byte, t time.Time, digits int) string {
    counter := uint64(t.Unix() / 30)
    return HOTP(key, counter, digits)
}

func main() {
    // RFC 6238 附录 B 测试向量: K = "12345678901234567890" (ASCII)
    K := []byte("12345678901234567890")
    t := time.Unix(59, 0)
    fmt.Println("T = 1 :", TOTP(K, t, 8))  // → 94287082
}

Go 实战 · pquerna/otp 生产用法

// 生产请用社区库, 自带 Base32 / QR / 时钟漂移容忍等细节
$ go get github.com/pquerna/otp/totp
$ go get github.com/skip2/go-qrcode

import (
    "github.com/pquerna/otp/totp"
    qrcode "github.com/skip2/go-qrcode"
)

// 1) 用户绑定: 生成密钥 + 返回 QR Code 图片
func bindTOTP(w http.ResponseWriter, r *http.Request) {
    key, _ := totp.Generate(totp.GenerateOpts{
        Issuer:      "OpenPlatform",
        AccountName: "alice@example.com",
        Period:      30,
        Digits:      otp.DigitsSix,
        Algorithm:   otp.AlgorithmSHA1,
    })

    // 关键: 服务端必须把 key.Secret() 存入用户表 (加密存储)
    saveSecret(currentUser, key.Secret())

    // 返回 QR 给用户扫
    png, _ := qrcode.Encode(key.URL(), qrcode.Medium, 256)
    w.Header().Set("Content-Type", "image/png")
    w.Write(png)
}

// 2) 登录二次验证: 用户输入 6 位码, 服务端校验
func verifyTOTP(w http.ResponseWriter, r *http.Request) {
    code := r.FormValue("code")
    secret := getSecret(currentUser)

    if !totp.Validate(code, secret) {
        http.Error(w, "invalid code", 401); return
    }
    w.Write([]byte("verified"))
}

"收个验证码"是最被用户接受的二次验证方式, 但从 2016 年起 NIST 就建议弃用 SMS OTP(800-63B v3, §5.1.3.3)。 原因不是"算法弱", 而是手机网络这个传输通道本身就充满漏洞—— SIM Swap、SS7 信令攻击、运营商内鬼、实时钓鱼代理, 任何一条都能让验证码落到攻击者手里, 而用户和服务方都察觉不到。

SIM Swap 攻击

SMS / Email OTP 的攻击面汇总

那应该用什么?

Passkey 不是"新的密码", 而是用 Day 02 的公私钥彻底取代密码—— 浏览器里按一下指纹 / Face ID, 设备用预先生成的私钥给服务端的挑战签个名。 整套体系的协议规范叫 WebAuthn (W3C Level 3), 它与硬件密钥的底层协议 CTAP2 (FIDO Alliance) 组合, 就是FIDO2。 Passkey 是 WebAuthn 凭证可以同步到云端的版本——Apple Keychain / Google 密码管理器替你同步。

WebAuthn 抗钓鱼的三个机制

1. Origin Binding。 浏览器把当前页面的真实 origin(协议+域+端口)塞进给认证器的 challenge。钓鱼站 examp1e.com 跟真站 example.com origin 不同, 私钥根本算不出有效签名。
2. 设备本地解锁。 私钥永远不离开设备, 调用时用 Touch ID / Face ID / PIN 解锁。攻击者就算偷到 token 也用不上。
3. Challenge 一次性 + 服务端随机生成。 每次登录 challenge 都不同, 重放无效。

注册流程 (Attestation)

登录流程 (Assertion)

登录时服务端发一个新 challenge, 设备用注册时存的私钥对 challenge + Origin + 计数器签名, 服务端用注册时存的公钥验证签名。整个过程没有"输入密码"这一步。

// Go 实战 · 用 go-webauthn/webauthn 库
$ go get github.com/go-webauthn/webauthn/webauthn

import "github.com/go-webauthn/webauthn/webauthn"

// 1) 初始化 RP (Relying Party)
var wa, _ = webauthn.New(&webauthn.Config{
    RPDisplayName: "Open Platform",
    RPID:          "example.com",            // 必须与浏览器实际域匹配
    RPOrigins:     []string{"https://example.com"},
})

// 2) 注册第一步: 服务端生成 challenge, 返回给前端
func beginRegister(w http.ResponseWriter, r *http.Request) {
    user := currentUser(r)
    options, session, _ := wa.BeginRegistration(user)
    saveSession(user.ID, session)  // 服务端临时存 session (含 challenge)
    json.NewEncoder(w).Encode(options)
}

// 3) 注册第二步: 前端把设备返回的 attestation 发回, 服务端校验
func finishRegister(w http.ResponseWriter, r *http.Request) {
    user := currentUser(r)
    session := loadSession(user.ID)
    credential, err := wa.FinishRegistration(user, session, r)
    if err != nil {
        http.Error(w, err.Error(), 400); return
    }
    saveCredential(user.ID, credential)  // 存 pub + credentialID
    w.Write([]byte("registered"))
}

// 4) 登录两步类似 — BeginLogin / FinishLogin
func beginLogin(w http.ResponseWriter, r *http.Request) {
    user := lookupUser(r.FormValue("email"))
    options, session, _ := wa.BeginLogin(user)
    saveSession(user.ID, session)
    json.NewEncoder(w).Encode(options)
}

func finishLogin(w http.ResponseWriter, r *http.Request) {
    user := lookupUser(r.URL.Query().Get("email"))
    session := loadSession(user.ID)
    _, err := wa.FinishLogin(user, session, r)
    if err != nil {
        http.Error(w, err.Error(), 401); return
    }
    // 验证成功 — 颁发 Session Cookie (Day 01 / Day 04 流程)
    issueSession(w, r, user)
}

浏览器端 JS

// register.js · 让浏览器调起 Touch ID / Face ID
const opts = await fetch('/webauthn/begin-register').then(r => r.json())

// challenge / userId 从 base64url 解码为 ArrayBuffer
opts.publicKey.challenge = b64ToBuf(opts.publicKey.challenge)
opts.publicKey.user.id   = b64ToBuf(opts.publicKey.user.id)

const cred = await navigator.credentials.create({ publicKey: opts.publicKey })

await fetch('/webauthn/finish-register', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    id:    cred.id,
    rawId: bufToB64(cred.rawId),
    type:  cred.type,
    response: {
      attestationObject: bufToB64(cred.response.attestationObject),
      clientDataJSON:    bufToB64(cred.response.clientDataJSON),
    },
  }),
})

Passkey vs 传统硬件密钥

1. 用一句话讲清三类因子各自的代表机制。"密码 + 安全问题"为什么不算 2FA?
2. 写出 TOTP 的完整公式(包括 HOTP 部分), 解释为什么需要"动态截断"。
3. 讲清 SIM Swap 攻击的完整链——攻击者第一步、第二步...到拿到验证码的关键节点。
4. WebAuthn 抗钓鱼的三个机制是什么? 为什么 evilginx2 类工具无法绕过它?
5. 动手用 Go 写 8 位数字的 TOTP 函数, 用 RFC 6238 附录 B 的测试向量(K="12345678901234567890"; T=59) 验证输出是 94287082。