java - 不使用Keycloak的Wildfly中仅承载身份验证

Question

我想在Wildfly中实现自己的仅承载身份验证的实现。本质上，我将执行以下步骤：


收到请求后，我将检查它是否具有授权标头。
我获得令牌并针对数据库（在这种情况下，我将使用Redis）进行检查以确保其有效性。
我从数据库中获得了该用户的角色。
我希望能够在我的其余服务上使用@RolesAllowed注释。


我该怎么办？我需要如何修改Wildfly配置文件？我需要实现哪些接口？如何将用户的角色传递给安全上下文，以便Wildfly为我执行@RolesAllowed检查？

如果回答，请认为我是一位经验丰富的Java程序员，但对Wildfly还是陌生的，因此您可以跳过有关编程逻辑的详细信息，而不是有关Wildfly配置的详细信息。另外，在您的答案中，不必担心令牌最初是如何到达Redis的，或客户端如何获得的。

编辑

这是我所做的，但是还没有运气。我已经实现了实现AuthenticationFilter的ContainerRequestFilter。 （我在下面仅包括已实现的主要过滤器功能。请注意，有些帮助器功能未从数据库中获取角色）。即使在函数末尾用用户概要文件（包含角色）设置了请求上下文的安全性上下文时，我也无法在我的JAX-RS rest服务上使用@RolesAllowed注释。关于我该怎么办的任何指示？

注意：我尚未修改任何Wildfly配置文件或web.xml文件。我知道每个请求都将调用过滤器，因为我能够在每个请求中记录来自该过滤器的消息。

/** 
 * (non-Javadoc)
 * @see javax.ws.rs.container.ContainerRequestFilter#filter(javax.ws.rs.container.ContainerRequestContext)
 */
@Override
public void filter(ContainerRequestContext requestContext) {

    //1. Read the JSON web token from the header
    String authorizationHeader = requestContext.getHeaderString(HttpHeaders.AUTHORIZATION);
    if (authorizationHeader == null || !authorizationHeader.startsWith("Bearer ")) {
        requestContext.abortWith(Response.status(Response.Status.UNAUTHORIZED).build());
        return;
    }

    String token = authorizationHeader.substring("Bearer".length()).trim();

    try{
        //Note that if the token is not in the database,
        //an exception will be thrown and we abort.

        UserProfile userProfile = this.getUserProfile(token);

        if (null == userProfile){
            userProfile = this.decodeToken(token);
        }


        if (null == userProfile){
            throw new Exception();
        }


        String role = userProfile.getUserRole();
        if (null == role){
            role = this.getRoleFromMod(userProfile);
            if (null == role){
                role = RoleType.READ_ONLY;
            }
            userProfile.setUserRole(role);
            this.updateUserProfileForToken(token, userProfile);

        }

        userProfile.setUserRole(role);

        //5. Create a security context class that implements the crazy interface 
        //and set it here.
        requestContext.setSecurityContext(new ModSecurityContext(userProfile));

    }
    catch(Exception e){
        requestContext.abortWith(Response.status(Response.Status.UNAUTHORIZED).build());
    }
}

Answer 1

是的，我不确定它在EE环境中如何工作，甚至使资源类成为无状态的Bean。 @RolesAllowed批注旨在用于ejb。在这种情况下，从servlet请求中检索主体（我相信）。我要做的只是实现您自己的授权过滤器，该过滤器查找注释并在安全上下文中对照主体进行检查。

您可以看到how Jersey implements it。除了AnnotatedMethod类之外，没有任何东西是真正针对泽西岛的。为此，您可以使用java.lang.reflect.Method（resourceInfo.getResourceMethod（））进行一些反射。除此之外，您几乎可以照原样复制代码。完成后，只需在应用程序中注册RolesAllowedDynamicFeature。或者只是用@Provider对其进行注释以进行扫描。

您还需要确保认证过滤器用@Priority(Priorities.AUTHENTICATION)注释，以便在授权过滤器之前用@Priority(Priorities.AUTHORIZATION)对其进行调用。



更新

这是我链接到的代码的重构，因此它不使用Jersey特定的类。 AnnotatedMethod仅更改为Method。

@Provider
public class RolesAllowedFeature implements DynamicFeature {

    @Override
    public void configure(ResourceInfo resourceInfo, FeatureContext configuration) {
        Method resourceMethod = resourceInfo.getResourceMethod();

        if (resourceMethod.isAnnotationPresent(DenyAll.class)) {
            configuration.register(new RolesAllowedRequestFilter());
            return;
        }

        RolesAllowed ra = resourceMethod.getAnnotation(RolesAllowed.class);
        if (ra != null) {
            configuration.register(new RolesAllowedRequestFilter(ra.value()));
            return;
        }

        if (resourceMethod.isAnnotationPresent(PermitAll.class)) {
            return;
        }

        ra = resourceInfo.getResourceClass().getAnnotation(RolesAllowed.class);
        if (ra != null) {
             configuration.register(new RolesAllowedRequestFilter(ra.value()));
        }
    }

    @Priority(Priorities.AUTHORIZATION) // authorization filter - should go after any authentication filters
    private static class RolesAllowedRequestFilter implements ContainerRequestFilter {

        private final boolean denyAll;
        private final String[] rolesAllowed;

        RolesAllowedRequestFilter() {
            this.denyAll = true;
            this.rolesAllowed = null;
        }

        RolesAllowedRequestFilter(final String[] rolesAllowed) {
            this.denyAll = false;
            this.rolesAllowed = (rolesAllowed != null) ? rolesAllowed : new String[]{};
        }

        @Override
        public void filter(final ContainerRequestContext requestContext) throws IOException {
            if (!denyAll) {
                if (rolesAllowed.length > 0 && !isAuthenticated(requestContext)) {
                    throw new ForbiddenException("Not Authorized");
                }

                for (final String role : rolesAllowed) {
                    if (requestContext.getSecurityContext().isUserInRole(role)) {
                        return;
                    }
                }
            }

            throw new ForbiddenException("Not Authorized");
        }

        private static boolean isAuthenticated(final ContainerRequestContext requestContext) {
            return requestContext.getSecurityContext().getUserPrincipal() != null;
        }
    }
}

首先，让我解释一下 DynamicFeature的工作原理。为此，让我们首先将讨论的上下文更改为当前 AuthenticationFilter的实现。

现在，它是为每个请求处理的过滤器。但是，假设我们引入了自定义 @Authenticated批注

@Target({METHOD, TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Authenticated{}

我们可以使用此注释来注释不同的方法和类。为了使它仅由过滤器过滤带注释的方法和类，我们可以引入一个 DynamicFeature来检查注释，然后仅在找到注释时注册过滤器。例如

@Provider
public class AuthenticationDynamicFeature implements DynamicFeature {

    @Override
    public void configure(ResourceInfo resourceInfo, FeatureContext configuration) {
        if (resourceInfo.getResourceMethod().isAnnotationPresent(Authenticated.class)) {
            configuration.register(new AuthenticationFilter());
            return;
        }

        if (resourceInfo.getResourceClass().isAnnotationPresent(Authenticated.class)) {
            configuration.register(new AuthenticationFilter());
        }
    } 
}

一旦注册了此 AuthenticationDynamicFeature类，它将进行注册，以便仅过滤带有 @Authenticated注释的方法和类。

另外，这甚至可以在过滤器内完成。我们可以从 ResourceInfo中获得对 AuthenticationFilter的引用。例如，检查注解（如果不存在），然后继续。

@Provider
@Priority(Priorities.AUTHENTICATION)
public class AuthenticationFilter implements ContainerRequestFilter {

    @Context
    private ResourceInfo resourceInfo;

    @Override
    public void filter(ContainerRequestContext context) throws IOException {

        boolean hasAnnotation = false;
        if (resourceInfo.getResourceMethod().isAnnotationPresent(Authenticated.class)
                || resourceInfo.getResourceClass().isAnnotationPresent(Authenticated.class)) {
            hasAnnotation = true;
        }
        if (!hasAnnotation) return;

        // process authentication is annotation is present

这样，我们可以完全忘记 DynamicFeature。最好只使用 DynamicFeature，我只是举一个例子进行演示。

话虽这么说，如果我们使用 RolesAllowedDynamicFeature查看第一段代码，则可以更好地了解正在发生的情况。它仅为使用 @RolesAllowed和 @DenyAll注释的方法和类注册过滤器。您甚至可以对其进行重构，以将所有注释逻辑（而不是功能）包含在过滤器中。您只有过滤器。就像我在上面的 AuthenticationFilter示例中所做的一样。同样，这只是出于示例目的。

现在就 DynamicFeature的注册而言，它的工作方式与注册任何其他资源类或提供程序类（例如，您的身份验证过滤器）相同。因此，无论您如何注册，只需以相同的方式注册 RolesAllowedDynamicFeature。有扫描，其中扫描 @Path和 @Provider批注。如果这是当前使用的功能，则只需使用 @Provider注释要素类即可注册它。例如，只有一个空的 Application子类将导致扫描发生

@ApplicationPath("/api")
public class RestApplication extends Application {}

然后，在 Application子类中进行了显式注册。例如

@ApplicationPath("/api")
public class RestApplication extends Application {

    @Override
    public Set<Class<?>> getClasses() {
        Set<Class<?>> classes = new HashSet<>();
        classes.add(AuthenticationFilter.class);
        classes.add(RolesAllowedFeature.class);
        classes.add(SomeResource.class);
        return classes;
    }
}

请注意，执行此操作时，将禁用所有继续进行的扫描。

因此，请确保在上述所有内容之后，其他几件事仍然无法解决。


确保当前的 AuthenticationFilter用 @Priority(Priorities.AUTHENTICATION)注释。这是为了确保在授权过滤器之前调用身份验证过滤器。这需要发生，因为身份验证筛选器是设置安全上下文的元素，而授权筛选器会对其进行检查。
确保正确创建安全上下文。授权过滤器将从 SecurityContext.isUserInRole(role)批注中调用 @RolesAllowed传递角色。因此，您需要确保正确实施 isUserInRole。