Node.js与JWT完美结合构建高效安全的用户认证体系从入门到实战全攻略

威震华夏关云长

引言

在现代Web应用开发中，用户认证系统是保障应用安全的核心组件。随着前后端分离架构的普及，传统的基于会话(Session)的认证方式逐渐显露出局限性，特别是在分布式系统和跨域场景下。JSON Web Token(JWT)作为一种轻量级的、基于JSON的开放标准(RFC 7519)，为解决这些问题提供了优雅的方案。

JWT具有自包含、无状态、可扩展等特性，非常适合在Node.js应用中实现用户认证。本文将从基础概念入手，逐步深入到实战应用，全面介绍如何使用Node.js和JWT构建高效、安全的用户认证体系。

JWT基础：理解认证的核心

什么是JWT？

JWT(JSON Web Token)是一种开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于在各方之间安全地传输信息。JWT可以用于认证和信息交换，因为它的数字签名或加密特性确保了信息的可信度。

JWT的结构

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

1. Header(头部)：包含令牌的类型和使用的签名算法
2. Payload(载荷)：包含声明(用户信息和元数据)
3. Signature(签名)：用于验证消息的完整性

一个典型的JWT看起来像这样：xxxxx.yyyyy.zzzzz

下面是一个具体的JWT示例：

2. // Header
3. {
4.   "alg": "HS256",
5.   "typ": "JWT"
6. }
8. // Payload
9. {
10.   "sub": "1234567890",
11.   "name": "John Doe",
12.   "iat": 1516239022
13. }
15. // Signature
16. HMACSHA256(
17.   base64UrlEncode(header) + "." +
18.   base64UrlEncode(payload),
19.   secret)

复制代码

JWT的工作原理

JWT认证流程如下：

1. 用户使用用户名和密码进行登录
2. 服务器验证用户凭证
3. 服务器生成一个JWT，其中包含用户信息和过期时间
4. 服务器将JWT发送给客户端
5. 客户端存储JWT(通常在localStorage或cookie中)
6. 客户端在后续请求中通过Authorization头发送JWT
7. 服务器验证JWT的有效性
8. 如果JWT有效，服务器处理请求并返回响应

Node.js环境准备：搭建开发环境

在开始构建JWT认证系统之前，我们需要准备Node.js开发环境并安装必要的依赖。

初始化项目

首先，创建一个新的项目目录并初始化Node.js项目：

2. mkdir node-jwt-auth
3. cd node-jwt-auth
4. npm init -y

复制代码

安装依赖

安装所需的依赖包：

2. npm install express jsonwebtoken bcrypt cors dotenv helmet morgan
3. npm install --save-dev nodemon

复制代码

这些依赖的作用：

• express: Node.js的Web框架
• jsonwebtoken: 用于生成和验证JWT
• bcrypt: 用于密码哈希和验证
• cors: 处理跨域资源共享
• dotenv: 加载环境变量
• helmet: 增强应用安全性
• morgan: HTTP请求日志记录器
• nodemon: 开发时自动重启服务器

创建基本服务器

创建index.js文件并设置基本的Express服务器：

2. require('dotenv').config();
3. const express = require('express');
4. const cors = require('cors');
5. const helmet = require('helmet');
6. const morgan = require('morgan');
8. const app = express();
10. // 中间件
11. app.use(helmet()); // 安全增强
12. app.use(cors()); // 允许跨域
13. app.use(morgan('combined')); // 日志记录
14. app.use(express.json()); // 解析JSON请求体
15. app.use(express.urlencoded({ extended: true })); // 解析URL编码的请求体
17. // 基本路由
18. app.get('/', (req, res) => {
19.   res.json({ message: 'Welcome to JWT Authentication API' });
20. });
22. // 启动服务器
23. const PORT = process.env.PORT || 3000;
24. app.listen(PORT, () => {
25.   console.log(`Server is running on port ${PORT}`);
26. });

复制代码

配置环境变量

创建.env文件来存储敏感信息：

2. PORT=3000
3. JWT_SECRET=your_super_secret_key
4. JWT_EXPIRES_IN=1h
5. BCRYPT_SALT_ROUNDS=10
6. MONGODB_URI=mongodb://localhost:27017/jwt_auth

复制代码

实现用户注册：创建用户账户

设置数据库模型

为了简单起见，我们将使用内存数组来模拟数据库。在实际应用中，你应该使用像MongoDB、MySQL或PostgreSQL这样的数据库。

创建models/User.js文件：

2. const bcrypt = require('bcrypt');
4. // 模拟数据库
5. let users = [];
7. class User {
8.   constructor(userData) {
9.     this.id = users.length + 1;
10.     this.username = userData.username;
11.     this.email = userData.email;
12.     this.passwordHash = this.hashPassword(userData.password);
13.     this.createdAt = new Date();
14.   }
16.   // 哈希密码
17.   hashPassword(password) {
18.     return bcrypt.hashSync(password, parseInt(process.env.BCRYPT_SALT_ROUNDS));
19.   }
21.   // 验证密码
22.   validatePassword(password) {
23.     return bcrypt.compareSync(password, this.passwordHash);
24.   }
26.   // 转换为安全对象（不包含密码）
27.   toSafeObject() {
28.     const { passwordHash, ...userWithoutPassword } = this;
29.     return userWithoutPassword;
30.   }
32.   // 静态方法：查找用户
33.   static findByEmail(email) {
34.     return users.find(user => user.email === email);
35.   }
37.   // 静态方法：查找用户ByID
38.   static findById(id) {
39.     return users.find(user => user.id === id);
40.   }
42.   // 静态方法：创建用户
43.   static create(userData) {
44.     // 检查用户是否已存在
45.     if (this.findByEmail(userData.email)) {
46.       throw new Error('User already exists');
47.     }
49.     const user = new User(userData);
50.     users.push(user);
51.     return user;
52.   }
53. }
55. module.exports = User;

复制代码

创建注册路由

创建routes/auth.js文件来处理认证相关的路由：

2. const express = require('express');
3. const jwt = require('jsonwebtoken');
4. const User = require('../models/User');
6. const router = express.Router();
8. // 用户注册
9. router.post('/register', async (req, res) => {
10.   try {
11.     const { username, email, password } = req.body;
13.     // 验证输入
14.     if (!username || !email || !password) {
15.       return res.status(400).json({
16.         message: 'Please provide username, email and password'
17.       });
18.     }
20.     // 创建新用户
21.     const user = User.create({ username, email, password });
23.     // 返回用户信息（不包含密码）
24.     res.status(201).json({
25.       message: 'User created successfully',
26.       user: user.toSafeObject()
27.     });
28.   } catch (error) {
29.     res.status(400).json({ message: error.message });
30.   }
31. });
33. module.exports = router;

复制代码

将路由集成到主应用

在index.js中添加认证路由：

2. const authRouter = require('./routes/auth');
4. // 使用认证路由
5. app.use('/api/auth', authRouter);

复制代码

实现用户登录：生成JWT令牌

现在，让我们实现用户登录功能，并在成功登录后生成JWT。

扩展认证路由

在routes/auth.js中添加登录路由：

2. // 用户登录
3. router.post('/login', async (req, res) => {
4.   try {
5.     const { email, password } = req.body;
7.     // 验证输入
8.     if (!email || !password) {
9.       return res.status(400).json({
10.         message: 'Please provide email and password'
11.       });
12.     }
14.     // 查找用户
15.     const user = User.findByEmail(email);
16.     if (!user) {
17.       return res.status(401).json({ message: 'Invalid credentials' });
18.     }
20.     // 验证密码
21.     const isPasswordValid = user.validatePassword(password);
22.     if (!isPasswordValid) {
23.       return res.status(401).json({ message: 'Invalid credentials' });
24.     }
26.     // 生成JWT
27.     const token = jwt.sign(
28.       {
29.         sub: user.id,
30.         username: user.username,
31.         email: user.email
32.       },
33.       process.env.JWT_SECRET,
34.       { expiresIn: process.env.JWT_EXPIRES_IN }
35.     );
37.     // 返回令牌和用户信息
38.     res.json({
39.       message: 'Login successful',
40.       token,
41.       user: user.toSafeObject()
42.     });
43.   } catch (error) {
44.     res.status(500).json({ message: error.message });
45.   }
46. });

复制代码

JWT验证中间件：保护路由

为了保护需要认证的路由，我们需要创建一个中间件来验证JWT。

创建认证中间件

创建middleware/auth.js文件：

2. const jwt = require('jsonwebtoken');
4. module.exports = function(req, res, next) {
5.   // 从请求头获取令牌
6.   const authHeader = req.headers['authorization'];
7.   const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN
9.   if (!token) {
10.     return res.status(401).json({ message: 'Access token required' });
11.   }
13.   // 验证令牌
14.   jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
15.     if (err) {
16.       return res.status(403).json({ message: 'Invalid or expired token' });
17.     }
19.     // 将用户信息添加到请求对象
20.     req.user = user;
21.     next();
22.   });
23. };

复制代码

可选角色验证中间件

创建middleware/roles.js文件，用于基于角色的访问控制：

2. module.exports = function(...roles) {
3.   return function(req, res, next) {
4.     if (!req.user) {
5.       return res.status(401).json({ message: 'Access denied' });
6.     }
8.     // 在实际应用中，你可能需要从数据库获取用户的角色
9.     // 这里我们假设用户信息中包含角色
10.     const userRoles = req.user.roles || [];
11.    
12.     const hasRole = roles.some(role => userRoles.includes(role));
13.    
14.     if (!hasRole) {
15.       return res.status(403).json({ message: 'Insufficient permissions' });
16.     }
17.    
18.     next();
19.   };
20. };

复制代码

受保护路由：实现需要认证的API

现在，让我们创建一些需要JWT认证的路由。

创建受保护的路由

创建routes/protected.js文件：

2. const express = require('express');
3. const authMiddleware = require('../middleware/auth');
4. const rolesMiddleware = require('../middleware/roles');
6. const router = express.Router();
8. // 所有认证用户都可以访问的路由
9. router.get('/profile', authMiddleware, (req, res) => {
10.   // 在实际应用中，你可能需要从数据库获取完整的用户信息
11.   res.json({
12.     message: 'Access granted to protected profile',
13.     user: req.user
14.   });
15. });
17. // 只有管理员可以访问的路由
18. router.get('/admin', authMiddleware, rolesMiddleware('admin'), (req, res) => {
19.   res.json({
20.     message: 'Welcome, admin!',
21.     user: req.user
22.   });
23. });
25. module.exports = router;

复制代码

将受保护路由集成到主应用

在index.js中添加受保护路由：

2. const protectedRouter = require('./routes/protected');
4. // 使用受保护路由
5. app.use('/api/protected', protectedRouter);

复制代码

JWT刷新令牌：实现令牌刷新机制

为了提高安全性并改善用户体验，我们可以实现JWT刷新令牌机制。这样，当访问令牌过期时，客户端可以使用刷新令牌获取新的访问令牌，而无需重新登录。

修改用户模型

更新models/User.js以支持刷新令牌：

2. const bcrypt = require('bcrypt');
3. const crypto = require('crypto');
5. // 模拟数据库
6. let users = [];
7. let refreshTokens = []; // 存储刷新令牌
9. class User {
10.   constructor(userData) {
11.     this.id = users.length + 1;
12.     this.username = userData.username;
13.     this.email = userData.email;
14.     this.passwordHash = this.hashPassword(userData.password);
15.     this.createdAt = new Date();
16.   }
18.   // 哈希密码
19.   hashPassword(password) {
20.     return bcrypt.hashSync(password, parseInt(process.env.BCRYPT_SALT_ROUNDS));
21.   }
23.   // 验证密码
24.   validatePassword(password) {
25.     return bcrypt.compareSync(password, this.passwordHash);
26.   }
28.   // 转换为安全对象（不包含密码）
29.   toSafeObject() {
30.     const { passwordHash, ...userWithoutPassword } = this;
31.     return userWithoutPassword;
32.   }
34.   // 静态方法：查找用户
35.   static findByEmail(email) {
36.     return users.find(user => user.email === email);
37.   }
39.   // 静态方法：查找用户ByID
40.   static findById(id) {
41.     return users.find(user => user.id === id);
42.   }
44.   // 静态方法：创建用户
45.   static create(userData) {
46.     // 检查用户是否已存在
47.     if (this.findByEmail(userData.email)) {
48.       throw new Error('User already exists');
49.     }
51.     const user = new User(userData);
52.     users.push(user);
53.     return user;
54.   }
56.   // 静态方法：添加刷新令牌
57.   static addRefreshToken(userId, token) {
58.     refreshTokens.push({
59.       userId,
60.       token,
61.       expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000) // 7天后过期
62.     });
63.   }
65.   // 静态方法：验证刷新令牌
66.   static verifyRefreshToken(userId, token) {
67.     const refreshToken = refreshTokens.find(
68.       rt => rt.userId === userId && rt.token === token
69.     );
70.    
71.     if (!refreshToken) {
72.       return false;
73.     }
74.    
75.     // 检查是否过期
76.     if (refreshToken.expiresAt < new Date()) {
77.       // 删除过期令牌
78.       refreshTokens = refreshTokens.filter(rt => rt.token !== token);
79.       return false;
80.     }
81.    
82.     return true;
83.   }
85.   // 静态方法：删除刷新令牌
86.   static removeRefreshToken(token) {
87.     refreshTokens = refreshTokens.filter(rt => rt.token !== token);
88.   }
89. }
91. module.exports = User;

复制代码

更新认证路由

在routes/auth.js中添加令牌刷新和注销功能：

2. const crypto = require('crypto');
4. // 生成随机刷新令牌
5. function generateRefreshToken() {
6.   return crypto.randomBytes(40).toString('hex');
7. }
9. // 用户登录（更新版）
10. router.post('/login', async (req, res) => {
11.   try {
12.     const { email, password } = req.body;
14.     // 验证输入
15.     if (!email || !password) {
16.       return res.status(400).json({
17.         message: 'Please provide email and password'
18.       });
19.     }
21.     // 查找用户
22.     const user = User.findByEmail(email);
23.     if (!user) {
24.       return res.status(401).json({ message: 'Invalid credentials' });
25.     }
27.     // 验证密码
28.     const isPasswordValid = user.validatePassword(password);
29.     if (!isPasswordValid) {
30.       return res.status(401).json({ message: 'Invalid credentials' });
31.     }
33.     // 生成访问令牌
34.     const accessToken = jwt.sign(
35.       {
36.         sub: user.id,
37.         username: user.username,
38.         email: user.email
39.       },
40.       process.env.JWT_SECRET,
41.       { expiresIn: process.env.JWT_EXPIRES_IN }
42.     );
44.     // 生成刷新令牌
45.     const refreshToken = generateRefreshToken();
46.     User.addRefreshToken(user.id, refreshToken);
48.     // 返回令牌和用户信息
49.     res.json({
50.       message: 'Login successful',
51.       accessToken,
52.       refreshToken,
53.       user: user.toSafeObject()
54.     });
55.   } catch (error) {
56.     res.status(500).json({ message: error.message });
57.   }
58. });
60. // 刷新令牌
61. router.post('/refresh-token', (req, res) => {
62.   try {
63.     const { refreshToken } = req.body;
64.    
65.     if (!refreshToken) {
66.       return res.status(401).json({ message: 'Refresh token required' });
67.     }
68.    
69.     // 验证刷新令牌
70.     const decoded = jwt.verify(refreshToken, process.env.JWT_REFRESH_SECRET);
71.    
72.     // 检查刷新令牌是否在数据库中
73.     const isValid = User.verifyRefreshToken(decoded.sub, refreshToken);
74.     if (!isValid) {
75.       return res.status(403).json({ message: 'Invalid refresh token' });
76.     }
77.    
78.     // 获取用户信息
79.     const user = User.findById(decoded.sub);
80.     if (!user) {
81.       return res.status(404).json({ message: 'User not found' });
82.     }
83.    
84.     // 生成新的访问令牌
85.     const newAccessToken = jwt.sign(
86.       {
87.         sub: user.id,
88.         username: user.username,
89.         email: user.email
90.       },
91.       process.env.JWT_SECRET,
92.       { expiresIn: process.env.JWT_EXPIRES_IN }
93.     );
94.    
95.     res.json({
96.       accessToken: newAccessToken
97.     });
98.   } catch (error) {
99.     res.status(403).json({ message: 'Invalid or expired refresh token' });
100.   }
101. });
103. // 注销
104. router.post('/logout', authMiddleware, (req, res) => {
105.   try {
106.     const { refreshToken } = req.body;
107.    
108.     if (refreshToken) {
109.       // 删除刷新令牌
110.       User.removeRefreshToken(refreshToken);
111.     }
112.    
113.     res.json({ message: 'Logout successful' });
114.   } catch (error) {
115.     res.status(500).json({ message: error.message });
116.   }
117. });

复制代码

更新环境变量

在.env文件中添加刷新令牌相关的配置：

2. PORT=3000
3. JWT_SECRET=your_super_secret_key
4. JWT_EXPIRES_IN=1h
5. JWT_REFRESH_SECRET=your_super_refresh_secret_key
6. BCRYPT_SALT_ROUNDS=10
7. MONGODB_URI=mongodb://localhost:27017/jwt_auth

复制代码

安全最佳实践：提高JWT安全性

使用JWT时，遵循安全最佳实践至关重要，以防止常见的安全漏洞。

1. 使用强密钥

确保你的JWT密钥足够强大且随机。不要使用简单或常见的字符串。

2. // 生成强随机密钥的示例
3. const crypto = require('crypto');
4. const jwtSecret = crypto.randomBytes(64).toString('hex');

复制代码

2. 设置合理的过期时间

访问令牌应该有较短的过期时间（如15分钟到1小时），而刷新令牌可以有较长的过期时间（如几天到几周）。

2. // 短期访问令牌
3. const accessToken = jwt.sign(payload, secret, { expiresIn: '15m' });
5. // 长期刷新令牌
6. const refreshToken = jwt.sign(payload, refreshSecret, { expiresIn: '7d' });

复制代码

3. 使用HTTPS

始终通过HTTPS传输JWT，以防止中间人攻击。

2. // 在生产环境中，确保使用HTTPS
3. if (process.env.NODE_ENV === 'production') {
4.   app.use(express.redirect('https'));
5. }

复制代码

4. 存储令牌的安全方式

• 访问令牌：可以存储在内存中或短期存储在浏览器的会话存储中
• 刷新令牌：应该存储在HttpOnly cookie中，以防止XSS攻击

2. // 设置HttpOnly cookie的示例
3. res.cookie('refreshToken', refreshToken, {
4.   httpOnly: true,
5.   secure: process.env.NODE_ENV === 'production',
6.   sameSite: 'strict',
7.   maxAge: 7 * 24 * 60 * 60 * 1000 // 7天
8. });

复制代码

5. 实现令牌撤销机制

提供一种机制来撤销特定的令牌，例如在用户更改密码或注销时。

2. // 令牌黑名单示例
3. const tokenBlacklist = new Set();
5. // 在注销时添加令牌到黑名单
6. router.post('/logout', (req, res) => {
7.   const token = req.headers.authorization?.split(' ')[1];
8.   if (token) {
9.     tokenBlacklist.add(token);
10.   }
11.   res.json({ message: 'Logged out successfully' });
12. });
14. // 在中间件中检查黑名单
15. const authMiddleware = (req, res, next) => {
16.   const token = req.headers.authorization?.split(' ')[1];
17.   
18.   if (!token) {
19.     return res.status(401).json({ message: 'No token provided' });
20.   }
21.   
22.   if (tokenBlacklist.has(token)) {
23.     return res.status(401).json({ message: 'Token revoked' });
24.   }
25.   
26.   jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
27.     if (err) {
28.       return res.status(403).json({ message: 'Failed to authenticate token' });
29.     }
30.    
31.     req.user = decoded;
32.     next();
33.   });
34. };

复制代码

6. 避免在JWT中存储敏感信息

JWT的Payload只是Base64编码的，不是加密的。不要在JWT中存储敏感信息，如密码、信用卡号等。

2. // 好的做法 - 只存储非敏感信息
3. const token = jwt.sign(
4.   {
5.     sub: user.id,
6.     username: user.username,
7.     role: user.role
8.   },
9.   secret
10. );
12. // 不好的做法 - 存储敏感信息
13. const token = jwt.sign(
14.   {
15.     sub: user.id,
16.     username: user.username,
17.     password: user.password, // 不要这样做！
18.     creditCard: user.creditCard // 不要这样做！
19.   },
20.   secret
21. );

复制代码

7. 使用适当的签名算法

使用强签名算法，如HS256或RS256，避免使用无签名算法(如none)。

2. // 使用HS256算法
3. const token = jwt.sign(payload, secret, { algorithm: 'HS256' });
5. // 或者使用RS256算法（非对称加密）
6. const token = jwt.sign(payload, privateKey, { algorithm: 'RS256' });

复制代码

完整示例：一个完整的认证系统示例

让我们整合所有部分，创建一个完整的认证系统示例。

完整的index.js文件

2. require('dotenv').config();
3. const express = require('express');
4. const cors = require('cors');
5. const helmet = require('helmet');
6. const morgan = require('morgan');
7. const crypto = require('crypto');
9. const authRouter = require('./routes/auth');
10. const protectedRouter = require('./routes/protected');
12. const app = express();
14. // 中间件
15. app.use(helmet()); // 安全增强
16. app.use(cors()); // 允许跨域
17. app.use(morgan('combined')); // 日志记录
18. app.use(express.json()); // 解析JSON请求体
19. app.use(express.urlencoded({ extended: true })); // 解析URL编码的请求体
21. // 基本路由
22. app.get('/', (req, res) => {
23.   res.json({ message: 'Welcome to JWT Authentication API' });
24. });
26. // 使用路由
27. app.use('/api/auth', authRouter);
28. app.use('/api/protected', protectedRouter);
30. // 错误处理中间件
31. app.use((err, req, res, next) => {
32.   console.error(err.stack);
33.   res.status(500).json({ message: 'Something went wrong!' });
34. });
36. // 启动服务器
37. const PORT = process.env.PORT || 3000;
38. app.listen(PORT, () => {
39.   console.log(`Server is running on port ${PORT}`);
40. });

复制代码

完整的models/User.js文件

2. const bcrypt = require('bcrypt');
3. const crypto = require('crypto');
5. // 模拟数据库
6. let users = [];
7. let refreshTokens = []; // 存储刷新令牌
9. class User {
10.   constructor(userData) {
11.     this.id = users.length + 1;
12.     this.username = userData.username;
13.     this.email = userData.email;
14.     this.passwordHash = this.hashPassword(userData.password);
15.     this.role = userData.role || 'user'; // 默认角色为user
16.     this.createdAt = new Date();
17.   }
19.   // 哈希密码
20.   hashPassword(password) {
21.     return bcrypt.hashSync(password, parseInt(process.env.BCRYPT_SALT_ROUNDS));
22.   }
24.   // 验证密码
25.   validatePassword(password) {
26.     return bcrypt.compareSync(password, this.passwordHash);
27.   }
29.   // 转换为安全对象（不包含密码）
30.   toSafeObject() {
31.     const { passwordHash, ...userWithoutPassword } = this;
32.     return userWithoutPassword;
33.   }
35.   // 静态方法：查找用户
36.   static findByEmail(email) {
37.     return users.find(user => user.email === email);
38.   }
40.   // 静态方法：查找用户ByID
41.   static findById(id) {
42.     return users.find(user => user.id === id);
43.   }
45.   // 静态方法：创建用户
46.   static create(userData) {
47.     // 检查用户是否已存在
48.     if (this.findByEmail(userData.email)) {
49.       throw new Error('User already exists');
50.     }
52.     const user = new User(userData);
53.     users.push(user);
54.     return user;
55.   }
57.   // 静态方法：添加刷新令牌
58.   static addRefreshToken(userId, token) {
59.     // 移除该用户的所有现有刷新令牌
60.     refreshTokens = refreshTokens.filter(rt => rt.userId !== userId);
61.    
62.     // 添加新刷新令牌
63.     refreshTokens.push({
64.       userId,
65.       token,
66.       expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000) // 7天后过期
67.     });
68.   }
70.   // 静态方法：验证刷新令牌
71.   static verifyRefreshToken(userId, token) {
72.     const refreshToken = refreshTokens.find(
73.       rt => rt.userId === userId && rt.token === token
74.     );
75.    
76.     if (!refreshToken) {
77.       return false;
78.     }
79.    
80.     // 检查是否过期
81.     if (refreshToken.expiresAt < new Date()) {
82.       // 删除过期令牌
83.       refreshTokens = refreshTokens.filter(rt => rt.token !== token);
84.       return false;
85.     }
86.    
87.     return true;
88.   }
90.   // 静态方法：删除刷新令牌
91.   static removeRefreshToken(token) {
92.     refreshTokens = refreshTokens.filter(rt => rt.token !== token);
93.   }
94. }
96. // 创建一个管理员用户（用于测试）
97. if (users.length === 0) {
98.   User.create({
99.     username: 'admin',
100.     email: 'admin@example.com',
101.     password: 'admin123',
102.     role: 'admin'
103.   });
104. }
106. module.exports = User;

复制代码

完整的routes/auth.js文件

2. const express = require('express');
3. const jwt = require('jsonwebtoken');
4. const User = require('../models/User');
6. const router = express.Router();
8. // 生成随机刷新令牌
9. function generateRefreshToken() {
10.   return crypto.randomBytes(40).toString('hex');
11. }
13. // 用户注册
14. router.post('/register', async (req, res) => {
15.   try {
16.     const { username, email, password, role } = req.body;
18.     // 验证输入
19.     if (!username || !email || !password) {
20.       return res.status(400).json({
21.         message: 'Please provide username, email and password'
22.       });
23.     }
25.     // 创建新用户
26.     const user = User.create({ username, email, password, role });
28.     // 返回用户信息（不包含密码）
29.     res.status(201).json({
30.       message: 'User created successfully',
31.       user: user.toSafeObject()
32.     });
33.   } catch (error) {
34.     res.status(400).json({ message: error.message });
35.   }
36. });
38. // 用户登录
39. router.post('/login', async (req, res) => {
40.   try {
41.     const { email, password } = req.body;
43.     // 验证输入
44.     if (!email || !password) {
45.       return res.status(400).json({
46.         message: 'Please provide email and password'
47.       });
48.     }
50.     // 查找用户
51.     const user = User.findByEmail(email);
52.     if (!user) {
53.       return res.status(401).json({ message: 'Invalid credentials' });
54.     }
56.     // 验证密码
57.     const isPasswordValid = user.validatePassword(password);
58.     if (!isPasswordValid) {
59.       return res.status(401).json({ message: 'Invalid credentials' });
60.     }
62.     // 生成访问令牌
63.     const accessToken = jwt.sign(
64.       {
65.         sub: user.id,
66.         username: user.username,
67.         email: user.email,
68.         role: user.role
69.       },
70.       process.env.JWT_SECRET,
71.       { expiresIn: process.env.JWT_EXPIRES_IN }
72.     );
74.     // 生成刷新令牌
75.     const refreshToken = generateRefreshToken();
76.     User.addRefreshToken(user.id, refreshToken);
78.     // 返回令牌和用户信息
79.     res.json({
80.       message: 'Login successful',
81.       accessToken,
82.       refreshToken,
83.       user: user.toSafeObject()
84.     });
85.   } catch (error) {
86.     res.status(500).json({ message: error.message });
87.   }
88. });
90. // 刷新令牌
91. router.post('/refresh-token', (req, res) => {
92.   try {
93.     const { refreshToken } = req.body;
94.    
95.     if (!refreshToken) {
96.       return res.status(401).json({ message: 'Refresh token required' });
97.     }
98.    
99.     // 验证刷新令牌
100.     const decoded = jwt.verify(refreshToken, process.env.JWT_REFRESH_SECRET);
101.    
102.     // 检查刷新令牌是否在数据库中
103.     const isValid = User.verifyRefreshToken(decoded.sub, refreshToken);
104.     if (!isValid) {
105.       return res.status(403).json({ message: 'Invalid refresh token' });
106.     }
107.    
108.     // 获取用户信息
109.     const user = User.findById(decoded.sub);
110.     if (!user) {
111.       return res.status(404).json({ message: 'User not found' });
112.     }
113.    
114.     // 生成新的访问令牌
115.     const newAccessToken = jwt.sign(
116.       {
117.         sub: user.id,
118.         username: user.username,
119.         email: user.email,
120.         role: user.role
121.       },
122.       process.env.JWT_SECRET,
123.       { expiresIn: process.env.JWT_EXPIRES_IN }
124.     );
125.    
126.     res.json({
127.       accessToken: newAccessToken
128.     });
129.   } catch (error) {
130.     res.status(403).json({ message: 'Invalid or expired refresh token' });
131.   }
132. });
134. // 注销
135. router.post('/logout', (req, res) => {
136.   try {
137.     const { refreshToken } = req.body;
138.    
139.     if (refreshToken) {
140.       // 删除刷新令牌
141.       User.removeRefreshToken(refreshToken);
142.     }
143.    
144.     res.json({ message: 'Logout successful' });
145.   } catch (error) {
146.     res.status(500).json({ message: error.message });
147.   }
148. });
150. module.exports = router;

复制代码

完整的routes/protected.js文件

2. const express = require('express');
3. const authMiddleware = require('../middleware/auth');
4. const rolesMiddleware = require('../middleware/roles');
6. const router = express.Router();
8. // 所有认证用户都可以访问的路由
9. router.get('/profile', authMiddleware, (req, res) => {
10.   // 在实际应用中，你可能需要从数据库获取完整的用户信息
11.   res.json({
12.     message: 'Access granted to protected profile',
13.     user: req.user
14.   });
15. });
17. // 只有管理员可以访问的路由
18. router.get('/admin', authMiddleware, rolesMiddleware('admin'), (req, res) => {
19.   res.json({
20.     message: 'Welcome, admin!',
21.     user: req.user
22.   });
23. });
25. // 普通用户和管理员都可以访问的路由
26. router.get('/user-or-admin', authMiddleware, rolesMiddleware('user', 'admin'), (req, res) => {
27.   res.json({
28.     message: 'Welcome, user or admin!',
29.     user: req.user
30.   });
31. });
33. module.exports = router;

复制代码

完整的middleware/auth.js文件

2. const jwt = require('jsonwebtoken');
4. module.exports = function(req, res, next) {
5.   // 从请求头获取令牌
6.   const authHeader = req.headers['authorization'];
7.   const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN
9.   if (!token) {
10.     return res.status(401).json({ message: 'Access token required' });
11.   }
13.   // 验证令牌
14.   jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
15.     if (err) {
16.       return res.status(403).json({ message: 'Invalid or expired token' });
17.     }
19.     // 将用户信息添加到请求对象
20.     req.user = user;
21.     next();
22.   });
23. };

复制代码

完整的middleware/roles.js文件

2. module.exports = function(...roles) {
3.   return function(req, res, next) {
4.     if (!req.user) {
5.       return res.status(401).json({ message: 'Access denied' });
6.     }
8.     // 在实际应用中，你可能需要从数据库获取用户的角色
9.     // 这里我们假设用户信息中包含角色
10.     const userRole = req.user.role;
11.    
12.     const hasRole = roles.includes(userRole);
13.    
14.     if (!hasRole) {
15.       return res.status(403).json({ message: 'Insufficient permissions' });
16.     }
17.    
18.     next();
19.   };
20. };

复制代码

完整的.env文件

2. PORT=3000
3. JWT_SECRET=your_super_secret_key_that_should_be_very_long_and_random
4. JWT_EXPIRES_IN=1h
5. JWT_REFRESH_SECRET=your_super_refresh_secret_key_that_should_also_be_long_and_random
6. BCRYPT_SALT_ROUNDS=10
7. MONGODB_URI=mongodb://localhost:27017/jwt_auth

复制代码

如何使用这个认证系统

2. curl -X POST http://localhost:3000/api/auth/register \
3.   -H "Content-Type: application/json" \
4.   -d '{"username":"john", "email":"john@example.com", "password":"password123"}'

复制代码

2. curl -X POST http://localhost:3000/api/auth/login \
3.   -H "Content-Type: application/json" \
4.   -d '{"email":"john@example.com", "password":"password123"}'

复制代码

2. # 将YOUR_ACCESS_TOKEN替换为登录后获得的令牌
3. curl -X GET http://localhost:3000/api/protected/profile \
4.   -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

复制代码

2. curl -X POST http://localhost:3000/api/auth/refresh-token \
3.   -H "Content-Type: application/json" \
4.   -d '{"refreshToken":"YOUR_REFRESH_TOKEN"}'

复制代码

2. curl -X POST http://localhost:3000/api/auth/logout \
3.   -H "Content-Type: application/json" \
4.   -d '{"refreshToken":"YOUR_REFRESH_TOKEN"}'

复制代码

总结：构建安全高效的认证系统

通过本文，我们详细介绍了如何使用Node.js和JWT构建一个完整、安全的用户认证系统。我们从JWT的基础知识开始，逐步实现了用户注册、登录、令牌验证、令牌刷新和注销等功能，并讨论了安全最佳实践。

关键要点回顾

1. JWT的优势：JWT是无状态的、自包含的，适合分布式系统和跨域场景。
2. 安全性：使用强密钥、设置合理的过期时间、使用HTTPS、安全存储令牌等措施至关重要。
3. 令牌刷新：实现刷新令牌机制可以提高用户体验和安全性。
4. 角色访问控制：基于角色的访问控制可以灵活地管理用户权限。
5. 最佳实践：避免在JWT中存储敏感信息，使用适当的签名算法，实现令牌撤销机制等。

进一步改进方向

虽然我们已经构建了一个功能完整的认证系统，但仍有改进的空间：

1. 数据库集成：将用户数据存储在MongoDB、MySQL或PostgreSQL等数据库中，而不是内存数组。
2. 密码策略：实现密码强度检查、密码历史记录和密码过期策略。
3. 账户锁定：在多次登录失败后锁定账户，防止暴力破解。
4. 多因素认证：添加短信或电子邮件验证码、TOTP等多因素认证。
5. 审计日志：记录用户登录、注销和重要操作，以便审计和安全分析。
6. OAuth集成：支持通过Google、Facebook等第三方服务登录。

结语

JWT和Node.js的结合为构建现代Web应用的认证系统提供了强大而灵活的解决方案。通过遵循本文介绍的最佳实践和实现方法，你可以构建一个既安全又高效的认证系统，为你的应用提供可靠的安全保障。

随着技术的不断发展，认证和安全领域也在不断演进。保持对最新安全趋势和最佳实践的关注，持续改进你的认证系统，是确保应用长期安全的关键。