express验证token的中间件

以下是一个示例的 Express 验证 token 的中间件：

const jwt = require('jsonwebtoken');

function auth(req, res, next) {
  const token = req.header('auth-token');
  if (!token) return res.status(401).send('Access Denied');

  try {
    const verified = jwt.verify(token, process.env.JWT_SECRET);
    req.user = verified;
    next();
  } catch (err) {
    res.status(400).send('Invalid Token');
  }
}

module.exports = auth;

该中间件首先从请求头中获取 `auth-token`，如果不存在则返回 401 状态码和 `Access Denied` 消息。如果存在，则使用 `jsonwebtoken` 包中的 `verify` 方法验证 token 是否有效，并将解码后的用户信息存储在请求对象中的 `user` 属性中，然后将控制权传递给下一个中间件或路由处理程序。如果 token 无效，则返回 400 状态码和 `Invalid Token` 消息。最后，将中间件导出，以便在应用程序中使用。

相关问题

nestjs 登录验证token

在 NestJS 中，我们可以通过中间件来实现 Token 鉴权。具体实现步骤如下：

1. 创建一个 `AuthMiddleware` 中间件，用于验证 Token 是否有效：

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';
import { AuthService } from './auth.service';

@Injectable()
export class AuthMiddleware implements NestMiddleware {
  constructor(private readonly authService: AuthService) {}

  async use(req: Request, res: Response, next: NextFunction) {
    const authHeader = req.headers.authorization;
    if (authHeader) {
      const token = authHeader.split(' ')[1];
      const decoded = await this.authService.verifyToken(token);
      if (decoded) {
        req.user = decoded;
        return next();
      }
    }
    return res.status(401).send({ message: 'Token验证失败' });
  }
}

上述代码中，我们定义了一个 `AuthMiddleware` 中间件，通过 `AuthService` 中的 `verifyToken` 方法来验证 Token 是否有效。如果 Token 有效，我们将解码后的信息存储在 `req.user` 中，方便后续的请求处理。

2. 在 `AppModule` 中注册 `AuthMiddleware` 中间件：

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { AuthModule } from './auth/auth.module';
import { AuthMiddleware } from './auth/auth.middleware';
import { UserController } from './user/user.controller';

@Module({
  imports: [AuthModule],
  controllers: [UserController],
})
export class AppModule implements NestModule {
  constructor(private readonly authMiddleware: AuthMiddleware) {}

  configure(consumer: MiddlewareConsumer) {
    consumer.apply(this.authMiddleware).forRoutes('*');
  }
}

上述代码中，在 `configure` 方法中注册了 `AuthMiddleware` 中间件，并将其应用于所有路由。

3. 在 `UserController` 中添加获取当前用户信息的方法：

import { Controller, Get, Req } from '@nestjs/common';

@Controller('user')
export class UserController {
  @Get('me')
  async me(@Req() req) {
    return req.user;
  }
}

上述代码中，我们定义了一个 `me` 方法用于获取当前用户信息。由于我们在 `AuthMiddleware` 中间件中将解码后的信息存储在了 `req.user` 中，因此在 `UserController` 中可以直接获取该信息。

通过上述步骤，我们就实现了 Token 鉴权。当客户端发送请求时，需要在请求头中带上 Token，服务端会根据 Token 来验证用户身份，并返回相应的结果。

express 验证 authorization的代码

下面是一个示例代码，使用 Express 和 jsonwebtoken 库实现验证 Authorization 头部的 JWT token。

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

// 中间件函数用于验证 Authorization 头部的 JWT token
function verifyToken(req, res, next) {
  // 获取 Authorization 头部的值
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];

  // 如果 Authorization 头部不存在或格式不正确则返回 401 错误
  if (!token) {
    return res.status(401).json({ error: 'Unauthorized' });
  }

  try {
    // 验证 JWT token 是否有效
    const decoded = jwt.verify(token, 'secret_key');
    req.user = decoded;
    next();
  } catch (err) {
    // 验证失败则返回 403 错误
    res.status(403).json({ error: 'Forbidden' });
  }
}

// 使用中间件函数验证路由
app.get('/protected', verifyToken, (req, res) => {
  res.json({ message: 'Hello World' });
});

// 监听端口
app.listen(3000, () => {
  console.log('Server started on port 3000');
});

在上面的代码中，`verifyToken` 中间件函数用于验证 Authorization 头部的 JWT token。在 `verifyToken` 函数中，首先获取 Authorization 头部的值，然后验证 Authorization 头部是否存在或格式是否正确。如果验证通过，则将解密的 payload 数据存储在 `req.user` 中并调用 `next()` 函数以继续路由处理。如果验证失败，则返回 403 错误。

接着，在 `/protected` 路由中使用 `verifyToken` 中间件函数来验证请求是否有有效的 JWT token。如果验证通过，则返回一个简单的 JSON 响应。否则，会返回 401 或 403 错误。