Méthode personnalisée d'Annotation à l'aide de Jersey AbstractHttpContextInjectable ne fonctionne pas

Je veux restreindre certaines méthodes si elles sont accessibles de façon non sécuritaire. Je suis de la création d'une annotation @Secure qui vérifie si la demande a été transmis sur des canaux sécurisés. Cependant, je ne peux pas créer une méthode injectable qui s'empare de la HttpContext de la demande.

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Secure {

}

public class SecureProvider<T> implements InjectableProvider<Secure, AbstractResourceMethod> {
    @Override
    public ComponentScope getScope() {
        return ComponentScope.PerRequest;
    }

    @Override
    public Injectable<?> getInjectable(ComponentContext componentContext,
                                       Secure annotation,
                                       AbstractResourceMethod method) {
        return new SecureInjectable();
    }
}

public class SecureInjectable<T> extends AbstractHttpContextInjectable<T> {
    @Override
    public T getValue(HttpContext context) {    
        //validation here

        return null;
    }
}

Je suis en utilisant le Dropwizard cadre, l'initialisation des Fournisseurs devrait être aussi simple que:

environment.addProvider(new SessionRestrictedToProvider<>(new SessionAuthenticator(), "MySession"));
environment.addProvider(new SecureProvider<>());
environment.setSessionHandler(new SessionHandler());

Utilisation:

@Resource
@Path("/account")
public class AccountResource {
    @GET
    @Path("/test_secure")
    @Secure
    public Response isSecure() {
        return Response.ok().build();
    }
}

À ce point, je suis en supposant qu'une HttpContext Injectable ne fonctionne pas sur une méthode, mais je suis à une perte quant à ce que d'autres options que je pourrais utiliser pour mettre en œuvre cette annotation.

À partir de votre exemple, je n'ai pas vraiment l'objectif que vous essayez d'atteindre. Ne vous souhaitez restreindre l'accès à certaines méthodes (url) si elles sont en cours d'accès non sécurisé manière, ou que vous aimeriez avoir injectable valeur booléenne (fournie comme argument à la méthode) représentant le type de demande sécurisé ou non sécurisé?
Je veux restreindre certaines méthodes si elles sont accessibles de façon non sécuritaire. Désolé, j'aurais dû faire plus clair!

OriginalL'auteur IAE | 2013-11-05

Si vous ne souhaitez pas utiliser l'AOP, je pense que vous pouvez le faire par la mise en œuvre de ResourceMethodDispatchProvider et ResourceMethodDispatchAdapter.

public class CustomDispatchProvider implements ResourceMethodDispatchProvider {

ResourceMethodDispatchProvider provider;

CustomDispatchProvider(ResourceMethodDispatchProvider provider)
{
    this.provider = provider;
}

@Override
public RequestDispatcher create(AbstractResourceMethod abstractResourceMethod) {
    System.out.println("creating new dispatcher for " + abstractResourceMethod);

    RequestDispatcher defaultDispatcher = provider.create(abstractResourceMethod);
    if (abstractResourceMethod.getMethod().isAnnotationPresent(Secure.class))
        return new DispatcherDecorator(defaultDispatcher);
    else
        return defaultDispatcher;
}

@Provider
public static class CustomDispatchAdapter implements ResourceMethodDispatchAdapter
{

    @Override
    public ResourceMethodDispatchProvider adapt(ResourceMethodDispatchProvider provider) {
        return new CustomDispatchProvider(provider);
    }

}

public static class DispatcherDecorator implements RequestDispatcher
{
    private RequestDispatcher dispatcher;

    DispatcherDecorator(RequestDispatcher dispatcher)
    {
        this.dispatcher = dispatcher;
    }

    public void dispatch(Object resource, HttpContext context) {
        if (context.getRequest().isSecure())
        {
            System.out.println("secure request detected");
            this.dispatcher.dispatch(resource, context);
        }
        else
        {
            System.out.println("request is NOT secure");
            throw new RuntimeException("cannot access this resource over an insecure connection");
        }

    }

}
}

Dans Dropwizard, ajoutez le fournisseur comme ceci:
de l'environnement.addProvider(CustomDispatchAdapter.class);

OriginalL'auteur John R

MODIFIER cela fonctionne avec JAX-RS 2.0. Bien que Jersey est maintenant sur la version 2.4.1, Dropwizard est malheureusement toujours à l'aide de 1.17.1 :(.

Vous pouvez utiliser un ContainerRequestFilter avec votre annotation.

Tout d'abord, l'annotation:

//need a name binding annotation
@NameBinding
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface Secure { }

Ensuite, le filtre:

//filter will only be run for methods that have @Secure annotation
@Secure
public class SecureFilter implements ContainerRequestFilter
{
    @Override
    public void filter(ContainerRequestContext requestContext) throws IOException
    {
        //check if HTTPS
        if (!requestContext.getSecurityContext().isSecure())
        {
            //if not, abort the request
            requestContext.abortWith(Response.status(Response.Status.BAD_REQUEST)
                                             .entity("HTTPS is required.")
                                             .build());
        }
    }
}

Et enfin, l'enregistrement du filtre. Cela dépend de comment vous définissez votre Maillot app. Voici deux façons que vous pourriez avoir, mais il existe de nombreuses autres possibilités, donc je ne vais pas tous les couvrir.

Si vous avez un ResourceConfig avec grizzly, tu voudrais ceci:

final ResourceConfig rc = new ResourceConfig()
            .packages("my.package.for.resources")
            .register(SecureFilter.class);

Si vous utilisez l'application personnalisée modèle:

public class MyApplication extends ResourceConfig {
    public MyApplication() {
        packages("my.package.for.resources");
        register(SecureFilter.class);
    }
}

Utilisation:

@Resource
@Path("/account")
public class AccountResource {

    //filter will run for this method
    @GET
    @Path("/test_secure")
    @Secure
    public Response isSecure() {
        return Response.ok().build();
    }

    //filter will NOT run for this method
    @GET
    @Path("/test_insecure")
    public Response allowInsecure() {
        return Response.ok().build();
    }
}

Corrigez-moi si je me trompe, mais c'est la solution pour JAX-RS 2.0. Malheureusement, Dropwizard (dernière version 0.6.2) utilise encore la version 1.17.
Oh non! Malheureusement, vous avez raison. Je n'ai pas vérifier le Dropwizard docs et suppose qu'ils ont utilisé JAX-RS 2.0. Eh bien, je vais laisser cette réponse, si quelqu'un vient à travers à la recherche d'un 2.0 solution. Aussi, Dropwizard devrait vraiment mise à niveau, la nouvelle spécification est beaucoup plus facile à utiliser.
Hmm, pourquoi est - SecureFilter lui-même annoté avec @Secure?
C'est parce que l'annotation @Secure est marqué comme NameBinding (jax-rs-spec.java.net/nonav/2.0/apidocs/javax/ws/rs/...) qui se lie à la ressource méthodes de filtres/séparateurs.
Il ne fait pas de sens. Que @Sécurisé ne peut pas être appliqué à la classe parce que son type de cible est la seule MÉTHODE. Merci de modifier à {ElementType.MÉTHODE,type d'élément.TYPE} ou quelque chose de semblable...

OriginalL'auteur Alden

Permettant annoté méthodes pour être accessibles uniquement via un canal sécurisé qui peut être fait à l'aide de l'AOP. Veuillez trouver la solution à l'aide de Guice et c'est l'AOP capacités (bien entendu, d'autres AOP solutions pourraient être utilisés).

Vous aurez besoin de Guice bibliothèque (com.google.injecter:guice:3.0).

Tout d'abord créer des annotations

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Secure {}

ensuite configurer guice bundle

public class SecurableMethodsService extends Service<Configuration> {

  @Override
  public void initialize(Bootstrap<Configuration> bootstrap) {
    bootstrap.addBundle(GuiceBundle.newBuilder().addModule(new SecurableMethodsDemonstrationModule()).build());
  }

  @Override
  public void run(Configuration configuration, Environment environment) throws Exception {
  }

}

module lie méthode intercepteur

public class SecurableMethodsDemonstrationModule extends AbstractModule {

  @Override
  protected void configure() {
    bind(SecuredMethodsContainingResource.class);
    bindInterceptor(Matchers.any(), Matchers.annotatedWith(Secure.class), new OnlySecureAllowedInterceptor(getProvider(SecurityContext.class)));
  }

}

qui vérifie si la connexion est sécurisée (remarque: dans cet exemple, la ressource est signalé comme pas trouvé si la connexion n'est pas sécurisée, vous pourriez avoir besoin d'ajuster ce pour votre cas d'utilisation)

public class OnlySecureAllowedInterceptor implements MethodInterceptor {

  private final Provider<SecurityContext> securityContextProvider;

  public OnlySecureAllowedInterceptor(Provider<SecurityContext> securityContextProvider) {
    this.securityContextProvider = securityContextProvider;
  }

  public Object invoke(MethodInvocation invocation) throws Throwable {
    if (!securityContextProvider.get().isSecure()) {
      throw new NotFoundException();
    }
    return invocation.proceed();
  }

}

et enfin les ressources sécurisées méthode ressemble à

@Path("")
public class SecuredMethodsContainingResource {

  @GET
  @Path("for-all")
  public String forAll() {
    return "for-all";
  }

  @GET
  @Path("secure")
  @Secure
  public String secure() {
    return "secure";
  }

}

J'ai ajouté de la dépendance sur dropwizard-guice à la place (com.hubspot.dropwizard:dropwizard-guice:0.7.0.2) - GuiceBundle n'a pas été inclus dans Guice bibliothèque

OriginalL'auteur Jonas

Vous devez vous connecter pour publier un commentaire.