如何在 webflux 中实现自定义身份验证管理器时对未经授权的请求响应自定义 json 正文

Posted 2023-02-27

【中文标题】如何在 webflux 中实现自定义身份验证管理器时对未经授权的请求响应自定义 json 正文

【英文标题】：How to response custom json body on unauthorized requests while implementing custom authentication manager in webflux

【发布时间】：2020-11-27 03:52:15

【问题描述】：

我正在尝试实现自定义 JWT 令牌身份验证，同时我也在处理全局异常以自定义每种异常类型的响应正文。一切正常，除了我想在收到未经授权的请求时返回自定义 json 响应，而不仅仅是 401 状态码。

下面是我对 JwtServerAuthenticationConverter 和 JwtAuthenticationManager 的实现。

@Component
public class JwtServerAuthenticationConverter implements ServerAuthenticationConverter 

    private static final String AUTH_HEADER_VALUE_PREFIX = "Bearer ";

    @Override
    public Mono<Authentication> convert(ServerWebExchange exchange) 

        return Mono.justOrEmpty(exchange)
                .flatMap(serverWebExchange -> Mono.justOrEmpty(
                        serverWebExchange
                                .getRequest()
                                .getHeaders()
                                .getFirst(HttpHeaders.AUTHORIZATION)
                        )
                )
                .filter(header -> !header.trim().isEmpty() && header.trim().startsWith(AUTH_HEADER_VALUE_PREFIX))
                .map(header -> header.substring(AUTH_HEADER_VALUE_PREFIX.length()))
                .map(token -> new UsernamePasswordAuthenticationToken(token, token))
                ;
    

@Component
public class JwtAuthenticationManager implements ReactiveAuthenticationManager 

    private final JWTConfig jwtConfig;
    private final ObjectMapper objectMapper;

    public JwtAuthenticationManager(JWTConfig jwtConfig, ObjectMapper objectMapper) 
        this.jwtConfig = jwtConfig;
        this.objectMapper = objectMapper;
    

    @Override
    public Mono<Authentication> authenticate(Authentication authentication) 

        return Mono.just(authentication)
                .map(auth -> JWTHelper.loadAllClaimsFromToken(auth.getCredentials().toString(), jwtConfig.getSecret()))
                .onErrorResume(throwable -> Mono.error(new JwtException("Unauthorized")))
                .map(claims -> objectMapper.convertValue(claims, JWTUserDetails.class))
                .map(jwtUserDetails ->
                        new UsernamePasswordAuthenticationToken(
                                jwtUserDetails,
                                authentication.getCredentials(),
                                jwtUserDetails.getGrantedAuthorities()
                        )
                )
                ;
    

下面是我的全局异常处理，除了 webflux 从 JwtServerAuthenticationConverter 转换方法返回 401 的情况外，它工作得非常好。

@Configuration
@Order(-2)
public class ExceptionHandler implements WebExceptionHandler 

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) 

        exchange.getResponse().getHeaders().set("Content-Type", MediaType.APPLICATION_JSON_VALUE);

        return buildErrorResponse(ex)
                .flatMap(
                        r -> r.writeTo(exchange, new HandlerStrategiesResponseContext(HandlerStrategies.withDefaults()))
                );
    

    private Mono<ServerResponse> buildErrorResponse(Throwable ex) 

        if (ex instanceof RequestEntityValidationException) 

            return ServerResponse.badRequest().contentType(MediaType.APPLICATION_JSON).body(
                    Mono.just(new ErrorResponse(ex.getMessage())),
                    ErrorResponse.class
            );

         else if (ex instanceof ResponseStatusException) 
            ResponseStatusException exception = (ResponseStatusException) ex;

            if (exception.getStatus().value() == 404) 
                return ServerResponse.status(HttpStatus.NOT_FOUND).contentType(MediaType.APPLICATION_JSON).body(
                        Mono.just(new ErrorResponse("Resource not found - 404")),
                        ErrorResponse.class
                );
             else if (exception.getStatus().value() == 400) 
                return ServerResponse.status(HttpStatus.BAD_REQUEST).contentType(MediaType.APPLICATION_JSON).body(
                        Mono.just(new ErrorResponse("Unable to parse request body - 400")),
                        ErrorResponse.class
                );
            

         else if (ex instanceof JwtException) 

            return ServerResponse.status(HttpStatus.UNAUTHORIZED).contentType(MediaType.APPLICATION_JSON).body(
                    Mono.just(new ErrorResponse(ex.getMessage())),
                    ErrorResponse.class
            );
        

        ex.printStackTrace();
        return ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR).contentType(MediaType.APPLICATION_JSON).body(
                Mono.just(new ErrorResponse("Internal server error - 500")),
                ErrorResponse.class
        );

    


@RequiredArgsConstructor
class HandlerStrategiesResponseContext implements ServerResponse.Context 

    private final HandlerStrategies handlerStrategies;

    @Override
    public List<HttpMessageWriter<?>> messageWriters() 
        return this.handlerStrategies.messageWriters();
    

    @Override
    public List<ViewResolver> viewResolvers() 
        return this.handlerStrategies.viewResolvers();
    

@Configuration
@EnableWebFluxSecurity
public class SecurityConfig 

    @Bean
    public SecurityWebFilterChain securityWebFilterChain(
            ServerHttpSecurity http,
            ReactiveAuthenticationManager jwtAuthenticationManager,
            ServerAuthenticationConverter jwtAuthenticationConverter
    ) 

        AuthenticationWebFilter authenticationWebFilter = new AuthenticationWebFilter(jwtAuthenticationManager);
        authenticationWebFilter.setServerAuthenticationConverter(jwtAuthenticationConverter);

        return http
                .authorizeExchange()
                .pathMatchers("/auth/login", "/auth/logout").permitAll()
                .anyExchange().authenticated()
                .and()
                .addFilterAt(authenticationWebFilter, SecurityWebFiltersOrder.AUTHENTICATION)
                .httpBasic()
                .disable()
                .csrf()
                .disable()
                .formLogin()
                .disable()
                .logout()
                .disable()
                .build();
    

    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() 
        return new BCryptPasswordEncoder();
    

所以当我在标头中使用无效的 JWT 令牌点击它时。这由我的 ExceptionHandler 类处理，我得到了下面的输出，这很棒。

但是当我用空的 jwt 令牌点击它时，我得到了这个。

现在我想返回在 JWT 令牌无效的情况下返回的相同正文。但问题是当提供空令牌时，它甚至不属于 ExceptionHandler 类的句柄方法。这就是为什么它不像我在同一个班级中对 JwtException 所做的那样在我的控制范围内。请问我该怎么做？

【问题讨论】：

在您的转换方法中，如果不存在令牌标头，您可以返回 mono.error

这样做有问题。我检查了每个请求都调用了 convert 方法，不管它的安全路径与否

那么您的路径设置有问题，但由于您没有发布整张图片，我们无法为您提供帮助。

你还需要什么？？

你要我把路由器类放在这里吗？？

【参考方案1】：

我自己解决。 webflux 提供 ServerAuthenticationFailureHandler 来处理自定义响应，但不幸的是 ServerAuthenticationFailureHandler 不起作用，这是一个已知问题，所以我创建了一个失败路由并在其中写入我的自定义响应并设置登录页面。

.formLogin()
.loginPage("/auth/failed")
.and()

.andRoute(path("/auth/failed").and(accept(MediaType.APPLICATION_JSON)), (serverRequest) ->
        ServerResponse
                .status(HttpStatus.UNAUTHORIZED)
                .body(
                        Mono.just(new ErrorResponse("Unauthorized")),
                        ErrorResponse.class
                )
);