登录与鉴权

1. 用户提交账号密码
2. 服务端验证通过，创建 Session 对象（存储用户信息、权限等）
3. 服务端将 Session ID 写入 Response 的 Set-Cookie 头
4. 浏览器存储 Cookie，后续同域请求自动携带
5. 服务端根据 Cookie 中的 Session ID 查找对应 Session
6. 找到则认为已登录，找不到则返回 401

// 登录接口
app.post('/login', (req, res) => {
  const { username, password } = req.body
  const user = verifyCredentials(username, password)
  if (!user) return res.status(401).json({ message: '认证失败' })

  // 创建 Session
  req.session.userId = user.id
  req.session.role = user.role

  res.cookie('sessionId', req.sessionID, {
    httpOnly: true,
    secure: true,
    sameSite: 'Strict',
    maxAge: 30 * 60 * 1000 // 30 分钟
  })

  res.json({ message: '登录成功' })
})

// 鉴权中间件
function authMiddleware(req, res, next) {
  if (!req.session.userId) {
    return res.status(401).json({ message: '未登录' })
  }
  next()
}

Header.Payload.Signature

// Header - 声明类型和签名算法
{
  "alg": "HS256",
  "typ": "JWT"
}

// Payload - 用户数据（Claims）
{
  "sub": "1234567890",    // 用户 ID
  "name": "John",         // 自定义字段
  "role": "admin",        // 权限信息
  "iat": 1716000000,      // 签发时间
  "exp": 1716003600       // 过期时间
}

// Signature - 签名
HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret
)

签发：
1. 用户提交凭证，服务端验证通过
2. 服务端用密钥对 Header + Payload 计算签名
3. 拼接三部分生成 Token，返回给客户端

验证：
1. 客户端请求携带 Token（通常放 Authorization 头）
2. 服务端取出 Header 和 Payload，用同一密钥重新计算签名
3. 对比计算出的签名和 Token 中的签名是否一致
4. 校验 exp 是否过期
5. 一致且未过期则鉴权通过

// 签发
const token = jwt.sign(
  { userId: user.id, role: user.role },
  process.env.JWT_SECRET,
  { expiresIn: '2h' }
)

// 验证中间件
function jwtAuth(req, res, next) {
  const authHeader = req.headers.authorization
  if (!authHeader?.startsWith('Bearer ')) {
    return res.status(401).json({ message: '缺少 Token' })
  }

  const token = authHeader.slice(7)
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET)
    req.user = decoded
    next()
  } catch (err) {
    if (err.name === 'TokenExpiredError') {
      return res.status(401).json({ message: 'Token 已过期' })
    }
    return res.status(401).json({ message: 'Token 无效' })
  }
}

1. 登录成功，服务端返回 Access Token + Refresh Token
2. 客户端用 Access Token 访问业务接口
3. Access Token 过期，客户端用 Refresh Token 请求刷新接口
4. 服务端验证 Refresh Token 有效，签发新的 Access Token
5. Refresh Token 也过期，用户需重新登录

// 刷新接口
app.post('/refresh', (req, res) => {
  const { refreshToken } = req.body

  try {
    const decoded = jwt.verify(refreshToken, process.env.REFRESH_SECRET)

    // 检查 Refresh Token 是否在黑名单
    if (isTokenRevoked(decoded.jti)) {
      return res.status(401).json({ message: '令牌已失效' })
    }

    const newAccessToken = jwt.sign(
      { userId: decoded.userId, role: decoded.role },
      process.env.JWT_SECRET,
      { expiresIn: '15m' }
    )

    res.json({ accessToken: newAccessToken })
  } catch {
    res.status(401).json({ message: '请重新登录' })
  }
})

角色说明：
- Resource Owner：用户
- Client：博客平台（第三方应用）
- Authorization Server：GitHub 授权服务器
- Resource Server：GitHub API 服务器

流程：
1. 用户点击"GitHub 登录"
2. 博客平台将用户重定向到 GitHub 授权页：
   GET https://github.com/login/oauth/authorize?
     response_type=code&
     client_id=xxx&
     redirect_uri=https://blog.com/callback&
     scope=read:user&
     state=随机字符串（防CSRF）

3. 用户在 GitHub 页面确认授权
4. GitHub 将用户重定向回博客平台：
   GET https://blog.com/callback?code=授权码&state=随机字符串

5. 博客平台后端用授权码换 Access Token（服务端间通信，不经过浏览器）：
   POST https://github.com/login/oauth/access_token
   Body: { client_id, client_secret, code, redirect_uri }

6. GitHub 返回 Access Token
7. 博客平台用 Access Token 调用 GitHub API 获取用户信息
8. 博客平台根据用户信息完成注册/登录，建立自己的会话

// 后端用授权码换 Token
app.get('/callback', async (req, res) => {
  const { code, state } = req.query

  // 验证 state 防 CSRF
  if (state !== req.session.oauthState) {
    return res.status(403).json({ message: 'state 校验失败' })
  }

  // 用授权码换 Access Token
  const tokenResponse = await fetch('https://github.com/login/oauth/access_token', {
    method: 'POST',
    headers: { 'Accept': 'application/json' },
    body: JSON.stringify({
      client_id: process.env.GITHUB_CLIENT_ID,
      client_secret: process.env.GITHUB_CLIENT_SECRET,
      code,
      redirect_uri: 'https://blog.com/callback'
    })
  })

  const { access_token } = await tokenResponse.json()

  // 用 Token 获取用户信息
  const userResponse = await fetch('https://api.github.com/user', {
    headers: { Authorization: `Bearer ${access_token}` }
  })

  const githubUser = await userResponse.json()

  // 根据 GitHub 用户信息创建或查找本站用户，建立会话
  const localUser = await findOrCreateUser(githubUser)
  req.session.userId = localUser.id

  res.redirect('/dashboard')
})

1. 用户访问 A 系统，A 发现未登录
2. A 将用户重定向到 SSO 认证中心
3. 用户在认证中心登录，认证中心创建全局 Session，写入认证中心域的 Cookie
4. 认证中心将用户重定向回 A，URL 中带上 Ticket
5. A 的后端拿 Ticket 去认证中心验证，验证通过后建立 A 的局部 Session
6. 用户访问 B 系统，B 发现未登录，重定向到认证中心
7. 认证中心发现已有全局 Session（Cookie 还在），直接签发 Ticket 重定向回 B
8. B 验证 Ticket，建立局部 Session
9. 用户无感完成 B 的登录

// 前端 Axios 拦截器实现无感刷新
let isRefreshing = false
let pendingRequests = []

axios.interceptors.response.use(null, async (error) => {
  const originalRequest = error.config

  if (error.response?.status === 401 && !originalRequest._retry) {
    if (isRefreshing) {
      // 正在刷新，把请求存入队列
      return new Promise((resolve) => {
        pendingRequests.push((newToken) => {
          originalRequest.headers.Authorization = `Bearer ${newToken}`
          resolve(axios(originalRequest))
        })
      })
    }

    originalRequest._retry = true
    isRefreshing = true

    try {
      const { data } = await axios.post('/refresh')
      const newToken = data.accessToken
      setAccessToken(newToken)

      // 重发队列中的请求
      pendingRequests.forEach(callback => callback(newToken))
      pendingRequests = []

      originalRequest.headers.Authorization = `Bearer ${newToken}`
      return axios(originalRequest)
    } catch {
      // 刷新失败，清除凭证跳转登录
      clearTokens()
      window.location.href = '/login'
      return Promise.reject(error)
    } finally {
      isRefreshing = false
    }
  }

  return Promise.reject(error)
})

// 服务端设置 Cookie 安全属性
res.cookie('token', value, {
  httpOnly: true,     // JS 无法读取，防 XSS
  secure: true,       // 仅 HTTPS 传输
  sameSite: 'Strict', // 禁止跨站携带，防 CSRF
  maxAge: 900000,     // 15 分钟
  path: '/',
  domain: '.example.com'
})