JwtStrategy 需要秘密或密钥

Question

我有以下错误，我不知道为什么会发生。你能帮我

错误 [ExceptionHandler] JwtStrategy 需要秘密或密钥 类型错误：JwtStrategy 需要秘密或密钥 在新的 JwtStrategy (C:\Users\wapg2\OneDrive\Productos\node_modules\passport-jwt\lib\strategy.js:45:15)

身份验证控制器：

import { Controller, Get, Post, UseGuards } from '@nestjs/common';
import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';

import { User, Auth } from 'src/common/decorators';
import { Usuario } from 'src/usuarios/entities';
import { AuthService } from './auth.service';
import { JwtAuthGuard, LocalAuthGuard } from './guards';

@ApiTags('Auth routes')
@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}
  @UseGuards(LocalAuthGuard) //Aca usamos las estrategias
  @Post('login')
  //Passport crea automáticamente un objeto user, según el valor que devolvemos del método validate(), y lo asigna al objeto Request como req.user
  login(@User() usuario: Usuario) {
    const data = this.authService.login(usuario);
    return {
      message: 'Login exitoso',
      data,
    };
  }

  //Esta ruta se vuelve privada al usar JwtAuthGuard
  @UseGuards(JwtAuthGuard)
  @ApiBearerAuth()
  @Get('profile')
  profile(@User() usuario: Usuario) {
    return {
      message: 'Petición correcta',
      usuario,
    };
  }

  @Auth() //-> decorador creado por nosotros para reducir @UseGuards(JwtAuthGuard) y @ApiBearerAuth()
  @Get('refresh')
  refreshToken(@User() usuario: Usuario) {
    const data = this.authService.login(usuario);
    return {
      message: 'Refresh exitoso',
      data,
    };
  }
}

身份验证服务

import { Injectable } from '@nestjs/common';
import { compare } from 'bcryptjs';
import { JwtService } from '@nestjs/jwt';

import { Usuario } from 'src/usuarios/entities';
import { UsuariosService } from 'src/usuarios/usuarios.service';
import { response } from 'express';

@Injectable()
export class AuthService {
  constructor(
    //Inyectamos UsuariosService y JwtService para usar las funciones que ofrecen. Estos servicios los podemos usar gracias a que hemos inyectado los módulos UserModule y JwtModule en el AuthModule. Tambien es posible usar el servicio UsuariosService gracias a que hemos exportado dicho servicio en el UsuariosModule (exports: [UsuariosService])
    private readonly usuarioService: UsuariosService,
    private readonly jwtService: JwtService,
  ) {}

  async validateUser(email: string, password: string): Promise<any> {
    const usuario = await this.usuarioService.buscarPorEmail({ email });

    console.log(usuario);

    if (usuario && (await compare(password, usuario.contrasena))) {
      const { contrasena, ...usuarioSinContrasena } = usuario;
      return usuarioSinContrasena;
    }

    return null;
  }

  //login crea el token JWT
  login(usuario: Usuario) {
    const { id } = usuario; //destructuración del objet user. Sacamos el id del retsto de los datos del user (...rest)

    //creamos la info del payload del jwt. el sub va a servir para identificar a cada usuario
    const payload = { sub: id };

    return {
      usuario,
      accesToken: this.jwtService.sign(payload), //Generamos el token
    };
  }
}

身份验证模块：

import { Module } from '@nestjs/common';
import { PassportModule } from '@nestjs/passport';
import { JwtModule } from '@nestjs/jwt';
import { ConfigService } from '@nestjs/config';

import { AuthService } from './auth.service';
import { AuthController } from './auth.controller';
import { JwtStrategy, LocalStrategy } from './strategies';
import { JWT_SECRET } from '../config/constants';
import { UsuariosModule } from 'src/usuarios/usuarios.module';

@Module({
  imports: [
    PassportModule.register({
      defaultStrategy: 'jwt',
    }),
    JwtModule.registerAsync({
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({
        secret: config.get<string>(JWT_SECRET),
        signOptions: { expiresIn: '60m' }, //Tiempo en el que expira el token
      }),
    }),
    UsuariosModule,
  ], //<-- se inportan los servicios y todo lo que se necesita de passport
  providers: [AuthService, LocalStrategy, JwtStrategy],
  controllers: [AuthController],
})
export class AuthModule {}

这是我的 jwtStrtegy

import { ConfigService } from '@nestjs/config';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy, ExtractJwt } from "passport-jwt";
import { JWT_SECRET } from "src/config/constants";
import { UserService } from "src/user/user.service";
import { Injectable } from '@nestjs/common';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy){
  constructor(
    private readonly userService: UserService,
    private readonly config: ConfigService,
  ) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: config.get<string>(JWT_SECRET),
    });
  }

  async validate(payload: any) {
    const { sub: id } = payload;
    return await this.userService.getOne(id);
  }
}

Answer 1

您尚未发布 LocalStrategy 定义所在的文件，但我猜测问题是您可能已从 passport-jwt 导入了 Strategy 依赖项code> 而不是该文件中的 passport-local。

Answer 2

你不应该像这样导入

import { ExtractJwt, Strategy } from 'passport-jwt';

相反你应该这样做

import { Strategy } from 'passport-local';

Answer 3

使用nestjs，您可以创建自己的策略文件作为jwt.stategy.ts

import { ExtractJwt, Strategy } from 'passport-jwt';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import {Request} from 'express';


@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy, "jwt") {
  constructor(configService: ConfigService) {
    super({
      // get JWT from Header 
      // jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      
      // get JWT from cookie
      jwtFromRequest: ExtractJwt.fromExtractors([
        (request: Request) => (
          request.cookies.jwt
        )
      ]),
      ignoreExpiration: false,
      secretOrKey: configService.get<string>("JWT_SECRET"), // REQUIRED
    });
  }

  async validate(payload: any) {
    return payload;
  }
}

，并使用guard作为@UseGuards(AuthGuard("jwt"))

  @UseGuards(AuthGuard("jwt"))
  @ApiBearerAuth()
  @Get('profile')
  profile(@User() usuario: Usuario) {
    return {
      message: 'Petición correcta',
      usuario,
    };
  }

名称 "jwt" 是对定义时策略名称的引用：

PassportStrategy(Strategy, "jwt")

Answer 4

我找到这个例子：

import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';

type JwtPayload = {
  sub: string;
  username: string;
};

@Injectable()
export class AccessTokenStrategy extends PassportStrategy(Strategy, 'jwt') {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      secretOrKey:
        '7sFHZrGLIMIwTotAEyNS/j4yUEW7OtYmGebnAKWQOBJ/kB+ur4XnGt1oxnRC9HUOUK+hBfcOmqw+BmlgXFB4zRzte6LRqvXlLrNiXO+REDKycfYBFywXtFQ65ZE0B5Z9EwFXaP29QysUSc2HxDeWIMzfl5nMYDj0TYHEYPJPs2Zb4hKNPIpHdA2e+8r6imFsD5C5vh0P3psnLTX8liWgkC+8ENf1YxiORqAMt9kQ9Ola7WSkaTKe6dqLKGHDMeICTw2YcCZ7+I9yT4Umgncqz78pAsBHDJPE/oFMtxw9/moCMoMH2D6dJ34R09OQ/gv8lwIjKZfBVGNsqxHW8vuppw==',
    });
  }

  validate(payload: JwtPayload) {
    return payload;
  }
}

在我的例子中，我使用这个命令 node -e "console.log(require('crypto').randomBytes(256).toString('base64'));" 来生成随机秘密，可以使用 openssl 生成代码。

按照本教程操作：

https://www.elvisduru.com/blog/ Nestjs-jwt-身份验证-刷新-令牌

Answer 5

选项 secretOrKey 为 < passport-jwt 包的强>必需：

secretOrKey 是包含秘密的字符串或缓冲区（对称）
或 PEM 编码的公钥（非对称），用于验证令牌的
签名。除非提供了 secretOrKeyProvider，否则为必需。

使用任意值作为secretOrKey的示例配置：

var opts = {}
opts.jwtFromRequest = ExtractJwt.fromAuthHeaderAsBearerToken();
opts.secretOrKey = 'secret'; // arbitrary value used for verify JWT token
opts.issuer = 'accounts.examplesoft.com';
opts.audience = 'yoursite.net';

Answer 6

如果仍然遇到问题，请尝试以下操作：

确保 ConfigModule 已正确导入并配置为加载环境变量。

在您的 AuthModule 中，您应该：

ConfigModule.forRoot({
  isGlobal: true,
}),

这确保可以在整个应用程序中访问环境变量。