现代Web安全实践：基于Token与Refresh Token的单点登录(SSO)实现

const jwt = require('jsonwebtoken');
const crypto = require('crypto');


// 生成密钥对（实际项目应该预生成并妥善保存）
const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048,
});


// 生成Token
function generateTokens(user) {
  const accessToken = jwt.sign(
    { userId: user.id, role: user.role },
    privateKey,
    { algorithm: 'RS256', expiresIn: '1h' }
  );


  const refreshToken = jwt.sign(
    { userId: user.id, tokenVersion: user.tokenVersion },
    privateKey,
    { algorithm: 'RS256', expiresIn: '7d' }
  );


  return { accessToken, refreshToken };
}


// 验证中间件
function authenticate(req, res, next) {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];


  if (!token) return res.sendStatus(401);


  jwt.verify(token, publicKey, (err, user) => {
    if (err) return res.sendStatus(403);
    req.user = user;
    next();
  });
}

app.post('/refresh-token', (req, res) => {
  const refreshToken = req.cookies.refreshToken;


  if (!refreshToken) return res.sendStatus(401);


  jwt.verify(refreshToken, publicKey, async (err, payload) => {
    if (err) return res.sendStatus(403);


    // 检查数据库中的token版本（防止被盗用）
    const user = await User.findById(payload.userId);
    if (user.tokenVersion !== payload.tokenVersion) {
      return res.sendStatus(403);
    }


    // 颁发新Token
    const newTokens = generateTokens(user);


    // 设置HttpOnly Cookie
    res.cookie('refreshToken', newTokens.refreshToken, {
      httpOnly: true,
      secure: true,
      sameSite: 'strict',
      maxAge: 7 * 24 * 60 * 60 * 1000
    });


    res.json({ accessToken: newTokens.accessToken });
  });
});

const api = axios.create({
  baseURL: process.env.API_URL,
});


// 请求拦截器
api.interceptors.request.use(config => {
  const token = localStorage.getItem('accessToken');
  if (token) {
    config.headers.Authorization = `Bearer ${token}`;
  }
  return config;
});


// 响应拦截器
api.interceptors.response.use(
  response => response,
  async error => {
    const originalRequest = error.config;


    // 401错误且不是刷新请求
    if (error.response.status === 401 && !originalRequest._retry) {
      originalRequest._retry = true;


      try {
        const { data } = await axios.post('/refresh-token', {}, {
          withCredentials: true // 携带cookie
        });


        localStorage.setItem('accessToken', data.accessToken);
        originalRequest.headers.Authorization = `Bearer ${data.accessToken}`;
        return api(originalRequest);
      } catch (refreshError) {
        // 刷新失败跳转登录
        window.location = '/login';
        return Promise.reject(refreshError);
      }
    }


    return Promise.reject(error);
  }
);

// 用户模型增加字段
const userSchema = new mongoose.Schema({
  tokenVersion: {
    type: Number,
    default: 0
  },
  // 其他字段...
});


// 密码修改时增加版本号
userSchema.methods.invalidateTokens = function() {
  this.tokenVersion += 1;
  return this.save();
};

app.post('/login', async (req, res) => {
  const { email, password } = req.body;


  const user = await User.findOne({ email });
  if (!user || !await bcrypt.compare(password, user.password)) {
    return res.status(401).send('认证失败');
  }


  // 检查是否开启MFA
  if (user.mfaEnabled) {
    const tempToken = jwt.sign(
      { userId: user.id, mfa: true },
      privateKey,
      { expiresIn: '5m' }
    );
    return res.json({ mfaRequired: true, tempToken });
  }


  // 常规登录流程
  const tokens = generateTokens(user);
  sendTokens(res, tokens);
});


app.post('/verify-mfa', authenticateTempToken, (req, res) => {
  const { code } = req.body;


  if (verifyMfaCode(req.user.userId, code)) {
    const user = await User.findById(req.user.userId);
    const tokens = generateTokens(user);
    sendTokens(res, tokens);
  } else {
    res.status(401).send('MFA验证失败');
  }
});

// 记录Token使用情况
function logTokenUsage(token, action) {
  const payload = jwt.decode(token);
  AuditLog.create({
    userId: payload.userId,
    action,
    ip: req.ip,
    userAgent: req.headers['user-agent']
  });
}