如何实现WebSocket与NestJS API间的JWT认证接口调用

方案一：为WebSocket生成专属动态JWT令牌（含必要上下文信息） #

既然静态令牌无法满足API对user_id、client_id等上下文的要求，可以在WebSocket服务初始化时，让后端生成专属动态JWT令牌，令牌中注入WebSocket所需的身份标识（比如固定的role: 'system_websocket'、专属client_id等），同时设置合理的过期时间。

实现步骤：

• 在NestJS后端新增一个仅内部可访问的令牌生成逻辑（可直接在WebSocket网关初始化时触发），无需守卫保护，仅限本地调用。
• 生成令牌时，在payload中加入API所需的必要字段（如user_id设为预先创建的系统用户ID，用于匹配权限规则），同时赋予对应的操作权限（比如permissions: ['device_data_write']）。
• 将生成的动态令牌存入WebSocket服务内存（无需持久化到数据库），每次调用API时携带该令牌。

示例代码（NestJS中生成令牌）：

import { JwtService } from '@nestjs/jwt';
import { WebSocketGateway } from '@nestjs/websockets';

@WebSocketGateway()
export class DeviceGateway {
  private wsAuthToken: string;

  constructor(private readonly jwtService: JwtService) {
    this.generateWsAuthToken();
  }

  private generateWsAuthToken() {
    const payload = {
      user_id: 'system_websocket_001', // 预先创建的系统用户ID
      client_id: 'device_ws_client',
      role: 'system',
      permissions: ['device_data_update'],
    };
    this.wsAuthToken = this.jwtService.sign(payload, { expiresIn: '24h' });
  }

  // WebSocket消息处理逻辑中调用API时携带令牌
  async handleDeviceData(client: Socket, data: any) {
    await axios.post('http://your-nestjs-api/device/update', data, {
      headers: { Authorization: `Bearer ${this.wsAuthToken}` },
    });
  }
}

方案二：扩展守卫逻辑，实现安全的WebSocket身份识别 #

不要直接给WebSocket开后门，而是在现有守卫中加入专属令牌+请求来源校验的双重验证：

• 保留WebSocket的专属静态令牌，但在JWT payload中加入特殊标识（如is_websocket: true），守卫中先校验令牌签名和该标识。
• 额外校验请求的来源IP，仅允许本地服务器或设备所在的固定IP段调用，进一步缩小访问范围。

示例代码（守卫中的扩展逻辑）：

import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';

@Injectable()
export class AuthGuard implements CanActivate {
  constructor(private readonly jwtService: JwtService) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const request = context.switchToHttp().getRequest();
    const token = this.extractTokenFromHeader(request);

    if (!token) return false;

    try {
      const payload = await this.jwtService.verifyAsync(token);
      
      // 校验WebSocket专属请求
      if (payload.is_websocket) {
        // 校验请求来源IP（示例：仅允许本地或特定IP段）
        const clientIp = request.ip;
        const allowedIps = ['127.0.0.1', '192.168.1.0/24'];
        if (!this.isIpAllowed(clientIp, allowedIps)) return false;
        // 校验WebSocket所需权限
        return payload.permissions.includes('device_data_update');
      }

      // 原有用户认证逻辑
      request.user = payload;
      return this.validateUserPermissions(payload);
    } catch {
      return false;
    }
  }

  // IP验证辅助方法
  private isIpAllowed(ip: string, allowedIps: string[]): boolean {
    return allowedIps.some(allowedIp => {
      if (allowedIp.includes('/')) {
        // 可引入ipaddr.js等库实现CIDR格式验证
        const [range, mask] = allowedIp.split('/');
        // 此处省略具体CIDR验证逻辑
        return true;
      } else {
        return ip === allowedIp;
      }
    });
  }

  private extractTokenFromHeader(request: Request): string | undefined {
    const [type, token] = request.headers.authorization?.split(' ') ?? [];
    return type === 'Bearer' ? token : undefined;
  }
}

方案三：使用NestJS内部服务调用，绕过HTTP API #

如果WebSocket服务和API服务同属一个NestJS应用，直接调用内部业务Service是最安全高效的方案，无需经过HTTP请求和守卫校验。

实现步骤：

• 将API的业务逻辑抽离到独立的Service类（比如DeviceService），API控制器仅作为HTTP入口调用Service方法。
• 在WebSocket网关中注入该Service类，直接调用对应的业务方法，复用核心逻辑。

示例代码：

// 抽离的业务Service
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/sequelize';
import { Device } from './device.model';

@Injectable()
export class DeviceService {
  constructor(@InjectModel(Device) private deviceModel: typeof Device) {}

  async updateDeviceData(data: any) {
    // 原API中的数据库更新逻辑
    return this.deviceModel.update(data, { where: { id: data.id } });
  }
}

// API控制器
import { Controller, Post, Body, UseGuards } from '@nestjs/common';
import { AuthGuard } from '../auth/auth.guard';
import { DeviceService } from './device.service';

@Controller('device')
export class DeviceController {
  constructor(private readonly deviceService: DeviceService) {}

  @Post('update')
  @UseGuards(AuthGuard)
  async update(@Body() data: any) {
    return this.deviceService.updateDeviceData(data);
  }
}

// WebSocket网关直接调用Service
import { WebSocketGateway } from '@nestjs/websockets';
import { DeviceService } from './device.service';

@WebSocketGateway()
export class DeviceGateway {
  constructor(private readonly deviceService: DeviceService) {}

  async handleDeviceData(client: Socket, data: any) {
    // 直接调用内部服务，无需HTTP请求和认证
    await this.deviceService.updateDeviceData(data);
  }
}

内容的提问来源于stack exchange，提问作者Léo