Question

这里的文档有点薄，所以我遇到了一个问题。我尝试使用Guards来保护Controller或其Actions的安全，所以我将要求身份验证的请求（由JWT扮演）。在我的auth.guard.ts中，我要求输入“ request.user”，但它为空，因此无法检查用户角色。我不知道如何定义“ request.user”。这是我的身份验证模块，它是导入的。

auth.controller.ts

import { Controller, Get, UseGuards } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';
import { AuthService } from './auth.service';
import { RolesGuard } from './auth.guard';

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @Get('token')
  async createToken(): Promise<any> {
    return await this.authService.signIn();
  }

  @Get('data')
  @UseGuards(RolesGuard)
  findAll() {
    return { message: 'authed!' };
  }
}

roles.guard.ts

此处user.request为空，因为我从未定义它。该文档没有显示方式或位置。

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core';

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private readonly reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const roles = this.reflector.get<string[]>('roles', context.getHandler());
    if (!roles) {
      return true;
    }
    const request = context.switchToHttp().getRequest();
    const user = request.user; // it's undefined
    const hasRole = () =>
      user.roles.some(role => !!roles.find(item => item === role));
    return user && user.roles && hasRole();
  }
}

auth.module.ts

import { Module } from '@nestjs/common';
import { AuthService } from './auth.service';
import { HttpStrategy } from './http.strategy';
import { UserModule } from './../user/user.module';
import { AuthController } from './auth.controller';
import { JwtStrategy } from './jwt.strategy';
import { PassportModule } from '@nestjs/passport';
import { JwtModule } from '@nestjs/jwt';

@Module({
  imports: [
    PassportModule.register({ defaultStrategy: 'jwt' }),
    JwtModule.register({
      secretOrPrivateKey: 'secretKey',
      signOptions: {
        expiresIn: 3600,
      },
    }),
    UserModule,
  ],
  providers: [AuthService, HttpStrategy],
  controllers: [AuthController],
})
export class AuthModule {}

auth.service.ts

import { Injectable } from '@nestjs/common';
import { UserService } from '../user/user.service';
import { JwtService } from '@nestjs/jwt';

@Injectable()
export class AuthService {
  constructor(
    private readonly userService: UserService,
    private readonly jwtService: JwtService,
  ) {}

  async signIn(): Promise<object> {
    // In the real-world app you shouldn't expose this method publicly
    // instead, return a token once you verify user credentials
    const user: any = { email: 'user@email.com' };
    const token: string = this.jwtService.sign(user);
    return { token };
  }

  async validateUser(payload: any): Promise<any> {
    // Validate if token passed along with HTTP request
    // is associated with any registered account in the database
    return await this.userService.findOneByEmail(payload.email);
  }
}

jwt.strategy.ts

import { ExtractJwt, Strategy } from 'passport-jwt';
import { AuthService } from './auth.service';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable, UnauthorizedException } from '@nestjs/common';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(private readonly authService: AuthService) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      secretOrKey: 'secretKey',
    });
  }

  async validate(payload: any) {
    const user = await this.authService.validateUser(payload);
    if (!user) {
      throw new UnauthorizedException();
    }
    return user;
  }
}

文档：https://docs.nestjs.com/guards

感谢您的帮助。

Answer 1

除了您的RolesGuard，您还需要使用AuthGuard。

标准

您可以使用将用户对象附加到请求的标准AuthGuard实现。当用户未经身份验证时，它将引发401错误。

@UseGuards(AuthGuard('jwt'))

扩展名

如果由于需要不同的行为而需要编写自己的防护，请扩展原始的AuthGuard并覆盖您需要更改的方法（在示例中为handleRequest）：

@Injectable()
export class MyAuthGuard extends AuthGuard('jwt') {

  handleRequest(err, user, info: Error) {
    // don't throw 401 error when unauthenticated
    return user;
  }

}

为什么这样做？

如果您查看AuthGuard中的source code，您会发现它将用户附加到请求上，作为通行证方法的回调。如果您不想使用/扩展AuthGuard，则必须实现/复制相关部分。

const user = await passportFn(
  type || this.options.defaultStrategy,
  options,
  // This is the callback passed to passport. handleRequest returns the user.
  (err, info, user) => this.handleRequest(err, info, user)
);
// Then the user object is attached to the request
// under the default property 'user' which you can change by configuration.
request[options.property || defaultOptions.property] = user;

Answer 2

在使选定的答案起作用（谢谢）之后，我也发现了这个选项，您可以将其添加到本质上执行相同操作的构造函数中。

http://www.passportjs.org/docs/authorize/

验证回调中的关联

上述方法的一个缺点是它需要两个策略和支持路线相同的实例。

为避免这种情况，请将策略的passReqToCallback选项设置为true。启用此选项后，req将作为第一个参数传递给验证回调。

    @Injectable()
    export class LocalStrategy extends PassportStrategy(Strategy, 'local') {
    
        constructor(private authService: AuthService) {
            super({
                passReqToCallback: true
            })
        }

        // rest of the strategy (validate)
    }

Answer 3

如果您使用req.authInfo可以使用吗？

只要不提供对password.authenticate方法的自定义回调，用户数据就应像这样附加到请求对象上。

req.authInfo应该是您在validate方法中返回的对象

Answer 4

您可以将多个守护程序连接在一起（@UseGuards（AuthGuard（'jwt'），RolesGuard））以在它们之间传递上下文。然后，您将在'RolesGuard'中访问'req.user'对象。

使用Guards（Roles，JWT）获取用户数据

4 个答案:

标准

扩展名

为什么这样做？