认证与授权

认证与授权的基本概念

认证（Authentication）是验证用户身份的过程，确保用户确实是其所声称的那个人。授权（Authorization）则是确定已验证用户对系统资源的访问权限。两者常被混淆，但本质不同：认证解决"你是谁"的问题，授权解决"你能做什么"的问题。

在Web应用中，典型的认证流程包括用户提交凭证（如用户名密码），系统验证凭证的有效性。授权则发生在认证之后，系统根据用户角色或权限决定是否允许特定操作。例如，普通用户可能只能查看数据，而管理员可以编辑数据。

Node.js中的认证实现

Node.js生态提供了多种认证方案。最基础的是基于会话（Session）的认证：

const express = require('express');
const session = require('express-session');

const app = express();
app.use(session({
  secret: 'your_secret_key',
  resave: false,
  saveUninitialized: true
}));

app.post('/login', (req, res) => {
  // 验证用户凭证
  if (isValidUser(req.body.username, req.body.password)) {
    req.session.user = { username: req.body.username };
    res.send('登录成功');
  } else {
    res.status(401).send('认证失败');
  }
});

现代应用更常用基于令牌（Token）的认证，如JWT（JSON Web Token）：

const jwt = require('jsonwebtoken');
const express = require('express');
const app = express();

app.post('/login', (req, res) => {
  // 验证用户凭证
  if (isValidUser(req.body.username, req.body.password)) {
    const token = jwt.sign(
      { username: req.body.username },
      'your_secret_key',
      { expiresIn: '1h' }
    );
    res.json({ token });
  } else {
    res.status(401).send('认证失败');
  }
});

授权策略与实现

RBAC（基于角色的访问控制）是最常见的授权模型。在Node.js中可以这样实现：

function checkPermission(requiredRole) {
  return (req, res, next) => {
    const userRole = getUserRole(req.user); // 从请求中获取用户角色
    if (userRole === requiredRole) {
      next();
    } else {
      res.status(403).send('无权访问');
    }
  };
}

app.get('/admin', checkPermission('admin'), (req, res) => {
  res.send('管理员面板');
});

更细粒度的授权可以使用ABAC（基于属性的访问控制）：

function canEditPost(req, res, next) {
  const post = getPostById(req.params.id);
  if (req.user.id === post.authorId || req.user.role === 'admin') {
    next();
  } else {
    res.status(403).send('无权编辑此文章');
  }
}

app.put('/posts/:id', canEditPost, (req, res) => {
  // 更新文章逻辑
});

OAuth与第三方认证

OAuth是处理第三方认证的标准协议。Node.js中可以使用Passport.js简化实现：

const passport = require('passport');
const GoogleStrategy = require('passport-google-oauth20').Strategy;

passport.use(new GoogleStrategy({
    clientID: GOOGLE_CLIENT_ID,
    clientSecret: GOOGLE_CLIENT_SECRET,
    callbackURL: "/auth/google/callback"
  },
  (accessToken, refreshToken, profile, done) => {
    // 查找或创建用户
    User.findOrCreate({ googleId: profile.id }, (err, user) => {
      return done(err, user);
    });
  }
));

app.get('/auth/google',
  passport.authenticate('google', { scope: ['profile'] }));

app.get('/auth/google/callback', 
  passport.authenticate('google', { failureRedirect: '/login' }),
  (req, res) => {
    res.redirect('/');
  });

安全最佳实践

认证与授权实现需要考虑多种安全因素：

1. 密码存储应使用bcrypt等算法哈希：

const bcrypt = require('bcrypt');
const saltRounds = 10;

async function hashPassword(password) {
  return await bcrypt.hash(password, saltRounds);
}

async function checkPassword(password, hash) {
  return await bcrypt.compare(password, hash);
}

2. JWT应设置合理的过期时间并启用HTTPS：

const token = jwt.sign(
  { userId: user.id },
  process.env.JWT_SECRET,
  { expiresIn: '15m' } // 短期有效的访问令牌
);

3. 防范CSRF攻击：

const csrf = require('csurf');
const csrfProtection = csrf({ cookie: true });

app.get('/form', csrfProtection, (req, res) => {
  res.render('send', { csrfToken: req.csrfToken() });
});

app.post('/process', csrfProtection, (req, res) => {
  // 处理表单数据
});

性能与扩展性考虑

大规模系统中的认证授权需要考虑性能：

1. 使用Redis存储会话数据：

const redis = require('redis');
const RedisStore = require('connect-redis')(session);

const redisClient = redis.createClient();
app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: 'your_secret',
  resave: false,
  saveUninitialized: false
}));

2. 实现JWT的黑名单机制：

const revokedTokens = new Set();

app.post('/logout', (req, res) => {
  const token = req.headers.authorization.split(' ')[1];
  revokedTokens.add(token);
  res.send('登出成功');
});

function checkRevoked(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1];
  if (revokedTokens.has(token)) {
    return res.status(401).send('令牌已失效');
  }
  next();
}

3. 微服务架构中的集中式授权服务：

// 授权服务
app.post('/check-permission', (req, res) => {
  const { userId, resource, action } = req.body;
  const allowed = checkUserPermission(userId, resource, action);
  res.json({ allowed });
});

// 业务服务中的中间件
async function checkRemotePermission(resource, action) {
  return (req, res, next) => {
    const response = await axios.post('http://auth-service/check-permission', {
      userId: req.user.id,
      resource,
      action
    });
    if (response.data.allowed) {
      next();
    } else {
      res.status(403).send('无权访问');
    }
  };
}

常见问题与调试

开发过程中可能遇到的典型问题：

1. 跨域认证问题解决方案：

app.use(cors({
  origin: ['https://yourdomain.com', 'https://yourotherdomain.com'],
  credentials: true
}));

2. 调试JWT问题：

function verifyToken(token) {
  try {
    return jwt.verify(token, process.env.JWT_SECRET);
  } catch (err) {
    console.error('JWT验证失败:', err.message);
    return null;
  }
}

3. 会话持久化问题排查：

app.use(session({
  // ...
  cookie: {
    secure: process.env.NODE_ENV === 'production',
    sameSite: 'lax',
    maxAge: 24 * 60 * 60 * 1000 // 1天
  }
}));

新兴技术与趋势

认证授权领域的新发展：

1. WebAuthn实现无密码认证：

const { generateRegistrationOptions } = require('@simplewebauthn/server');

app.get('/webauthn-register', (req, res) => {
  const options = generateRegistrationOptions({
    rpName: 'Your Site',
    rpID: 'yoursite.com',
    userID: req.user.id,
    userName: req.user.username
  });
  req.session.challenge = options.challenge;
  res.json(options);
});

2. 零信任架构中的持续认证：

function continuousAuth(req, res, next) {
  if (req.session.lastAuthTime < Date.now() - 30 * 60 * 1000) {
    return res.status(401).json({ requireReauth: true });
  }
  next();
}

app.use('/sensitive-route', continuousAuth);

3. 区块链身份认证探索：

const { verifySignature } = require('./blockchain-auth');

app.post('/blockchain-login', (req, res) => {
  const { walletAddress, signature } = req.body;
  const isValid = verifySignature(walletAddress, signature);
  if (isValid) {
    // 创建或登录用户
  }
});