面试被问懵了？后端说你不懂 Auth？8 种 API 鉴权方案原理+代码一次讲透

Authorization: Basic dXNlcjpwYXNzd29yZA==

// 把上面那串解码，就是：user:password
// 所以必须用 HTTPS，不然在网络上裸奔

第一步：你登录，发送用户名+密码（只需要这一次）
          │
          ▼
第二步：服务器验证通过，在数据库创建一条 Session 记录
        Session 记录长这样：
        { sessionId: "abc123", userId: 42, 过期时间: 24小时后 }
          │
          ▼
第三步：服务器把 sessionId 写进 Cookie，发给你的浏览器
        Set-Cookie: sessionId=abc123; HttpOnly; Secure
          │
          ▼
第四步：之后每次请求，浏览器自动带上这个 Cookie
        Cookie: sessionId=abc123
          │
          ▼
第五步：服务器拿着 abc123 去查数据库，找到对应用户
        → 知道你是谁，放行 ✓

// Node.js + Express 设置 Session 的代码
app.use(session({
  secret: process.env.SESSION_SECRET,    // 加密用的密钥，别写死在代码里
  store: new RedisStore({ client: redis }), // Session 存 Redis，不然重启就丢了
  cookie: {
    httpOnly: true,    // JS 读不到，防止 XSS 盗取
    secure: true,      // 只在 HTTPS 下发送
    sameSite: 'strict', // 防止 CSRF 攻击
    maxAge: 24 * 60 * 60 * 1000  // 24 小时后过期
  }
}));

你的请求 → 负载均衡 → 服务器A（有你的 Session）✓ 认识你
你的请求 → 负载均衡 → 服务器B（没有你的 Session）✗ 不认识你！

GET /v1/charges HTTP/1.1
Host: api.stripe.com
Authorization: Bearer sk_live_abc123def456

❌ 危险：GET /api/data?api_key=abc123
           ↑ 这个 URL 会出现在服务器日志里，别人一翻日志就能看到

✓ 正确：放在 HTTP Header 里

import crypto from'crypto';

// 生成 API Key
function generateApiKey(): string {
return`sk_${crypto.randomBytes(32).toString('hex')}`;
}

// ⚠️ 重要：存数据库时不能存明文，要存哈希值
// 就像密码一样，万一数据库泄露，别人也拿不到真实的 Key
const rawKey = generateApiKey();  // 这个只展示给用户一次
const hashedKey = crypto
  .createHmac('sha256', process.env.HASH_SECRET!)
  .update(rawKey)
  .digest('hex');  // 存这个到数据库

await db.apiKeys.create({ hash: hashedKey, userId, scopes: ['read'] });

Authorization: Bearer 这里放什么都行

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
.
eyJzdWIiOiJ1c2VyXzEyMyIsInJvbGUiOiJhZG1pbiIsImV4cCI6MTcwMDAwMDAwMH0
.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

第一段（Header）：告诉你用什么算法签名的
{
"alg": "HS256",
"typ": "JWT"
}

第二段（Payload）：用户信息，随便放什么
{
"sub": "user_123",         // 用户 ID
"role": "admin",           // 角色
"email": "zhang@example.com",
"exp": 1700003600          // 过期时间（Unix 时间戳）
}

第三段（Signature）：签名，用来防止有人篡改前两段
HMACSHA256(第一段 + "." + 第二段, 服务器的密钥)

登录
  │
  ▼  服务器验证通过，用密钥签名生成 JWT，返回给你
  │
  ▼  你的浏览器/App 保存这个 JWT
  │
  ▼  之后每次请求，带上 JWT：
     Authorization: Bearer eyJhbGci...
  │
  ▼  服务器收到后：
     1. 用同一个密钥验证签名（确认没被篡改）
     2. 检查 exp 字段有没有过期
     3. 从 Payload 里直接读取用户信息
     → 全程不需要查数据库！

import jwt from'jsonwebtoken';

// 登录成功后，生成 JWT
const token = jwt.sign(
  {
    sub: user.id,
    role: user.role,
    email: user.email
    // ❌ 不要放：password、phone、idCard 等敏感信息
  },
  process.env.JWT_SECRET!,  // 这个密钥要好好保存，泄露就完了
  { expiresIn: '15m' }      // 15 分钟过期，为什么这么短？下面解释
);

// 每次请求时，验证 JWT 的中间件
const authMiddleware = (req: Request, res: Response, next: NextFunction) => {
try {
    // 从请求头里取出 token
    const token = req.headers.authorization?.split(' ')[1];
    if (!token) {
      return res.status(401).json({ error: '没有提供 token' });
    }

    // 验证签名 + 检查过期时间（jwt.verify 自动做这两件事）
    const decoded = jwt.verify(token, process.env.JWT_SECRET!) as { sub: string; role: string };
    req.user = decoded;  // 把用户信息挂到请求上，后续代码直接用
    next();
  } catch (err) {
    res.status(401).json({ error: 'token 无效或已过期' });
  }
};

登录成功，同时颁发两个 token：
  ├── access_token（15分钟过期）← 用来访问 API，过期了就换
  └── refresh_token（7天过期，存数据库）← 用来换新的 access_token

正常请求：用 access_token
access_token 过期：用 refresh_token 换一个新的 access_token
退出登录：从数据库删除 refresh_token（立刻失效，下次刷新就换不出来了）
封号用户：删掉他的 refresh_token，access_token 最多再撑 15 分钟

你（资源所有者）             ← 你的 GitHub 数据的主人
掘金网站（客户端）           ← 想要访问你数据的第三方应用
GitHub 授权服务器（Auth Server）← 负责问你"同意吗"的中间人
GitHub API（资源服务器）    ← 真正存着你数据的地方

第一步：你在掘金点击"用 GitHub 登录"
          │
          ▼
第二步：掘金把你的浏览器跳转到 GitHub 授权页
        URL 里带着：掘金的 client_id、跳回哪里、要什么权限
        GET https://github.com/login/oauth/authorize
          ?client_id=掘金的应用ID
          &redirect_uri=https://juejin.cn/callback
          &scope=read:user,user:email    ← 申请读取用户信息的权限
          &state=随机字符串              ← 防止 CSRF 攻击用的
          │
          ▼
第三步：你在 GitHub 上点"同意授权"
          │
          ▼
第四步：GitHub 把你的浏览器跳回掘金，带着一个短命的"授权码"
        https://juejin.cn/callback?code=abc123&state=随机字符串
          │
          ▼
第五步：掘金后端服务器拿着这个 code，悄悄去找 GitHub 换 token
        （这一步在服务端发生，你的浏览器看不见）
        POST https://github.com/login/oauth/access_token
        { client_id, client_secret, code }
          │
          ▼
第六步：GitHub 返回 access_token
          │
          ▼
第七步：掘金用 access_token 调用 GitHub API，读取你的公开信息

// 第五步：用 code 换 token（在你的后端实现）
const tokenRes = await fetch('https://github.com/login/oauth/access_token', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  },
  body: JSON.stringify({
    client_id: process.env.GITHUB_CLIENT_ID,
    client_secret: process.env.GITHUB_CLIENT_SECRET,  // 这个绝不能泄露
    code: req.query.code,
  })
});

const { access_token } = await tokenRes.json();

// 第七步：用 access_token 获取用户信息
const userRes = await fetch('https://api.github.com/user', {
  headers: { Authorization: `Bearer ${access_token}` }
});
const githubUser = await userRes.json();
// { login: "zhangsan", email: "...", avatar_url: "..." }

scope=openid email profile

{
  "iss": "https://accounts.google.com",   // 谁签发的（Google）
"sub": "1234567890",                    // 用户在 Google 的唯一 ID
"email": "zhang@gmail.com",
"name": "张三",
"picture": "https://头像URL",
"aud": "你的应用ID",                    // 这个 token 是给谁的
"exp": 1700003600                       // 过期时间
}

所有系统都问大哥：这个人可以信任吗？

┌─────────────────────────────────────────────┐
│          身份认证中心（大哥/IdP）             │
│    （Okta、Azure AD、或公司自建的系统）        │
└──────────┬──────────────────────────────────┘
           │ 管理所有用户的登录状态
           │
    ┌──────┼──────────┐
    ▼      ▼          ▼
   OA    飞书     内部 GitLab
  （小弟们，都听大哥的）

你第一次访问飞书
  → 飞书："你没登录，去大哥那里确认一下"
  → 大哥："你有登录记录吗？"
  → 没有 → 你输入工号密码 → 大哥验证通过 → 建立 SSO Session
  → 大哥给飞书一个证明 → 飞书放你进去 ✓

你之后访问 OA
  → OA："你没登录，去大哥那里"
  → 大哥："你有登录记录！" → 直接给 OA 一个证明
  → OA 放你进去 ✓ （你全程不用再输密码）

// 用 passport.js 接入公司的 Okta SSO（基于 OIDC 协议）
passport.use('sso', new OIDCStrategy({
  issuer: 'https://your-company.okta.com',
  clientID: process.env.CLIENT_ID,
  clientSecret: process.env.CLIENT_SECRET,
  callbackURL: '/auth/callback',
  scope: 'openid email profile',
}, (tokenSet, userInfo, done) => {
  // userInfo 里就是用户信息，直接用
  // 通常还要查本地数据库，看这个用户在你系统里有没有账号
  return done(null, userInfo);
}));

所有外部流量
      │
      ▼
┌─────────────┐
│  API 网关   │ ← 统一在这里验证用户身份
│ 验证 token │   然后把用户信息注入到请求头里
└──────┬──────┘
       │ X-User-Id: 42
       │ X-User-Role: admin
       ▼
  ┌────┼────┬───────┐
  ▼    ▼    ▼       ▼
服务A 服务B 服务C  服务D
（各自只处理业务，不用重复验证身份）

┌──────────────────────────────────────────┐
│         面向用户的 Web App                │
│  登录：OIDC（对接公司 SSO 或三方登录）    │
│  维持登录状态：JWT + HttpOnly Cookie      │
│  服务间调用：Bearer JWT 透传              │
└──────────────────────────────────────────┘

┌──────────────────────────────────────────┐
│         对外开放的 API（给开发者用）       │
│  认证：API Key                           │
│  权限控制：OAuth 2.0 Scope               │
│  限流：按 API Key 单独限制               │
└──────────────────────────────────────────┘

┌──────────────────────────────────────────┐
│         公司内部服务互相调用              │
│  认证：OAuth 2.0 Client Credentials      │
│  没有用户参与，纯机器对机器              │
└──────────────────────────────────────────┘