66-后端认证与授权

学习目标

• 了解Web3应用中认证与授权的重要性
• 掌握JWT和OAuth等认证机制的实现
• 学习基于角色的访问控制(RBAC)的设计和实现
• 了解Web3特有的认证方式，如基于钱包的认证
• 学习认证与授权的最佳实践和安全措施

核心知识点

1. 认证与授权的基本概念

**认证(Authentication)**：验证用户的身份，确认用户是谁。

**授权(Authorization)**：确定用户可以访问哪些资源和执行哪些操作。

在Web3应用中，认证与授权尤为重要，因为涉及到用户的数字资产和敏感信息。

2. JWT认证

JWT (JSON Web Token) 是一种基于JSON的开放标准，用于在各方之间安全地传输信息。

2.1 JWT的结构

JWT由三部分组成，用点(.)分隔：

• Header：包含令牌类型和哈希算法
• Payload：包含声明，如用户ID、角色等
• Signature：使用密钥对前两部分进行签名

2.2 实现示例

// auth.js
const jwt = require('jsonwebtoken');

// 生成JWT令牌
exports.generateToken = (userId, role) => {
  return jwt.sign(
    { id: userId, role },
    process.env.JWT_SECRET,
    { expiresIn: '24h' }
  );
};

// 验证JWT令牌
exports.verifyToken = (token) => {
  try {
    return jwt.verify(token, process.env.JWT_SECRET);
  } catch (error) {
    return null;
  }
};

// 认证中间件
exports.authenticate = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  
  if (!token) {
    return res.status(401).json({ message: 'Access token required' });
  }
  
  const decoded = exports.verifyToken(token);
  
  if (!decoded) {
    return res.status(401).json({ message: 'Invalid or expired token' });
  }
  
  req.user = decoded;
  next();
};

3. OAuth认证

OAuth是一种开放标准的授权协议，允许用户授权第三方应用访问其资源，而无需共享密码。

3.1 OAuth 2.0流程

1. 客户端请求授权：用户点击登录按钮，重定向到授权服务器
2. 用户认证：用户在授权服务器上登录并授权
3. 授权服务器颁发授权码：授权成功后，重定向回客户端并携带授权码
4. 客户端获取访问令牌：客户端使用授权码向授权服务器请求访问令牌
5. 客户端访问资源：使用访问令牌访问受保护的资源

3.2 实现示例

使用Passport.js实现OAuth认证：

// passport.js
const passport = require('passport');
const GoogleStrategy = require('passport-google-oauth20').Strategy;
const User = require('./models/User');

passport.use(
  new GoogleStrategy(
    {
      clientID: process.env.GOOGLE_CLIENT_ID,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
      callbackURL: '/api/auth/google/callback',
    },
    async (accessToken, refreshToken, profile, done) => {
      try {
        // 查找或创建用户
        let user = await User.findOne({ googleId: profile.id });
        
        if (!user) {
          user = new User({
            googleId: profile.id,
            username: profile.displayName,
            email: profile.emails[0].value,
          });
          await user.save();
        }
        
        done(null, user);
      } catch (error) {
        done(error, null);
      }
    }
  )
);

// 序列化用户
passport.serializeUser((user, done) => {
  done(null, user.id);
});

// 反序列化用户
passport.deserializeUser(async (id, done) => {
  try {
    const user = await User.findById(id);
    done(null, user);
  } catch (error) {
    done(error, null);
  }
});

module.exports = passport;

4. 基于角色的访问控制(RBAC)

RBAC是一种基于角色的授权模型，通过将权限分配给角色，再将角色分配给用户来实现访问控制。

4.1 RBAC的核心概念

• **用户(User)**：系统中的用户
• **角色(Role)**：一组权限的集合
• **权限(Permission)**：对资源的操作权限
• **资源(Resource)**：系统中的资源，如API、数据等

4.2 实现示例

// rbac.js
const Role = require('./models/Role');
const Permission = require('./models/Permission');

// 检查用户是否具有特定权限
exports.hasPermission = async (userId, permission) => {
  try {
    // 获取用户角色
    const user = await User.findById(userId).populate('roles');
    
    if (!user) {
      return false;
    }
    
    // 检查角色是否具有权限
    for (const role of user.roles) {
      const roleWithPermissions = await Role.findById(role._id).populate('permissions');
      
      for (const perm of roleWithPermissions.permissions) {
        if (perm.name === permission) {
          return true;
        }
      }
    }
    
    return false;
  } catch (error) {
    console.error(error);
    return false;
  }
};

// 授权中间件
exports.authorize = (permission) => {
  return async (req, res, next) => {
    const hasPerm = await exports.hasPermission(req.user.id, permission);
    
    if (!hasPerm) {
      return res.status(403).json({ message: 'Access denied' });
    }
    
    next();
  };
};

5. Web3特有的认证方式

5.1 基于钱包的认证

基于钱包的认证是Web3应用的特色，用户可以使用其加密货币钱包进行身份验证。

工作原理：

1. 服务器生成一个随机挑战(challenge)
2. 用户使用钱包签名该挑战
3. 服务器验证签名的有效性
4. 验证通过后，颁发访问令牌

5.2 实现示例

// walletAuth.js
const ethers = require('ethers');
const jwt = require('jsonwebtoken');

// 生成挑战
exports.generateChallenge = (address) => {
  return {
    address,
    nonce: Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15),
    timestamp: Date.now(),
  };
};

// 验证签名
exports.verifySignature = (address, signature, challenge) => {
  try {
    const message = JSON.stringify(challenge);
    const signerAddress = ethers.utils.verifyMessage(message, signature);
    return signerAddress.toLowerCase() === address.toLowerCase();
  } catch (error) {
    return false;
  }
};

// 基于钱包的认证中间件
exports.walletAuthenticate = async (req, res, next) => {
  const { address, signature, challenge } = req.body;
  
  if (!address || !signature || !challenge) {
    return res.status(401).json({ message: 'Authentication required' });
  }
  
  const isValid = exports.verifySignature(address, signature, challenge);
  
  if (!isValid) {
    return res.status(401).json({ message: 'Invalid signature' });
  }
  
  // 生成JWT令牌
  const token = jwt.sign(
    { address, id: address }, // 使用地址作为ID
    process.env.JWT_SECRET,
    { expiresIn: '24h' }
  );
  
  req.user = { address, token };
  next();
};

6. 认证与授权的最佳实践

6.1 安全措施

• 使用HTTPS：加密传输，防止中间人攻击
• 令牌过期：设置合理的令牌过期时间
• 令牌刷新：实现令牌刷新机制，提高用户体验
• 密码哈希：使用bcrypt等算法哈希存储密码
• 输入验证：对所有输入进行严格验证
• 防止暴力攻击：实现登录尝试限制
• 日志记录：记录认证和授权相关的操作

6.2 性能优化

• 缓存：缓存用户会话和权限信息
• 令牌验证：使用高效的令牌验证方法
• 数据库索引：为用户和权限表添加适当的索引

实用案例分析

案例1：基于JWT的认证系统

需求：实现一个基于JWT的用户认证系统，包括注册、登录和权限控制。

实现：

// app.js
const express = require('express');
const auth = require('./auth');
const rbac = require('./rbac');
const userController = require('./controllers/userController');
const transactionController = require('./controllers/transactionController');

const app = express();

// 注册
app.post('/api/auth/register', userController.register);

// 登录
app.post('/api/auth/login', userController.login);

// 受保护的路由
app.get('/api/users', auth.authenticate, rbac.authorize('view:users'), userController.getUsers);
app.get('/api/transactions', auth.authenticate, rbac.authorize('view:transactions'), transactionController.getTransactions);
app.post('/api/transactions', auth.authenticate, rbac.authorize('create:transactions'), transactionController.createTransaction);

app.listen(3001, () => {
  console.log('Server running on port 3001');
});

// controllers/userController.js
const User = require('../models/User');
const auth = require('../auth');
const bcrypt = require('bcrypt');

exports.register = async (req, res) => {
  try {
    const { username, email, password, role } = req.body;
    
    // 检查用户是否已存在
    const existingUser = await User.findOne({ email });
    if (existingUser) {
      return res.status(400).json({ message: 'User already exists' });
    }
    
    // 哈希密码
    const hashedPassword = await bcrypt.hash(password, 10);
    
    // 创建新用户
    const user = new User({
      username,
      email,
      password: hashedPassword,
      roles: [role || 'user'] // 默认角色
    });
    
    await user.save();
    
    // 生成JWT令牌
    const token = auth.generateToken(user._id, user.roles);
    
    res.status(201).json({ user, token });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

exports.login = async (req, res) => {
  try {
    const { email, password } = req.body;
    
    // 查找用户
    const user = await User.findOne({ email });
    if (!user) {
      return res.status(401).json({ message: 'Invalid credentials' });
    }
    
    // 验证密码
    const isPasswordValid = await bcrypt.compare(password, user.password);
    if (!isPasswordValid) {
      return res.status(401).json({ message: 'Invalid credentials' });
    }
    
    // 生成JWT令牌
    const token = auth.generateToken(user._id, user.roles);
    
    res.status(200).json({ user, token });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

exports.getUsers = async (req, res) => {
  try {
    const users = await User.find().select('-password');
    res.status(200).json(users);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

案例2：基于钱包的认证系统

需求：实现一个基于以太坊钱包的认证系统，允许用户使用MetaMask等钱包登录。

实现：

// app.js
const express = require('express');
const walletAuth = require('./walletAuth');
const userController = require('./controllers/walletUserController');

const app = express();

// 生成挑战
app.post('/api/auth/wallet/challenge', userController.generateChallenge);

// 验证签名并登录
app.post('/api/auth/wallet/login', walletAuth.walletAuthenticate, userController.walletLogin);

// 受保护的路由
app.get('/api/profile', walletAuth.authenticate, userController.getProfile);

app.listen(3001, () => {
  console.log('Server running on port 3001');
});

// controllers/walletUserController.js
const User = require('../models/WalletUser');
const walletAuth = require('../walletAuth');

exports.generateChallenge = (req, res) => {
  const { address } = req.body;
  
  if (!address) {
    return res.status(400).json({ message: 'Address required' });
  }
  
  const challenge = walletAuth.generateChallenge(address);
  res.status(200).json(challenge);
};

exports.walletLogin = async (req, res) => {
  try {
    const { address } = req.user;
    
    // 查找或创建用户
    let user = await User.findOne({ address });
    
    if (!user) {
      user = new User({ address });
      await user.save();
    }
    
    res.status(200).json({ user, token: req.user.token });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

exports.getProfile = async (req, res) => {
  try {
    const user = await User.findOne({ address: req.user.address });
    res.status(200).json(user);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

常见问题解决方案

问题1：JWT令牌安全

解决方案：

• 使用强密钥并定期轮换
• 设置合理的过期时间
• 实现令牌撤销机制
• 存储令牌指纹，防止重放攻击

问题2：基于钱包的认证安全性

解决方案：

• 验证签名的有效性
• 使用随机挑战，防止重放攻击
• 限制签名的有效期
• 实现会话管理

问题3：权限管理复杂性

解决方案：

• 使用RBAC模型，简化权限管理
• 实现权限继承，减少重复配置
• 提供管理界面，方便权限配置
• 定期审查权限设置

问题4：认证性能优化

解决方案：

• 缓存用户会话信息
• 使用Redis存储会话数据
• 实现令牌批量验证
• 优化数据库查询

总结

本教程介绍了Web3应用后端认证与授权的核心概念和实践方法，包括JWT、OAuth、基于角色的访问控制以及Web3特有的基于钱包的认证方式。通过本教程的学习，开发者将能够设计和实现安全、高效的认证与授权系统，保护Web3应用的用户数据和数字资产。

在实际开发中，认证与授权系统的设计应根据具体应用的需求和场景进行调整，同时要注重安全性和性能优化，确保系统能够满足Web3应用的特殊需求。