JAX-RS: come proteggere gli endpoint REST?

Question

Sto usando JBoss AS e JAX-RS per creare endpoint REST.

consente di dire la mia classe si presenta come

@Path("/users") 
public class UserResource { 


    @GET 
    public Response getAccount() { 
    return "hello"; 
    } 
} 

Ora getAccount non è autenticato al momento

Cercasi
- vorrei aggiungere l'autenticazione in modo che quando il codice colpisce getAccount l'utente è autenticato
- Vorrei che l'autenticazione fosse guidata da annotazioni invece di configurazioni XML, se possibile
- Vorrei fare il confronto del database per vedere se l'utente è valido

Problema
- non ho mai fatto che così non ho idea di come implementarlo
- Googled in giro un sacco e ha trovato esempi Jersey

UPDATE
- vorrei inviare le credenziali di autenticazione con ogni richiesta e non la creazione di qualsiasi sessione

Si prega di guidarmi con un semplice esempio di lavoro e proverei ad estendere da lì

Answer 1

Ho risolto questo con il seguente codice.

nota meccanismo Token verrà aggiornata una volta me che

ho risolto questo modificando l'intercettore ho, il seguente è codice

nota

@Inherited 
@InterceptorBinding 
@Target({ ElementType.TYPE, ElementType.METHOD }) 
@Retention(RetentionPolicy.RUNTIME) 
public @interface SecurityChecked { 

} 

Classe di risorse

public class SecureResource { 

    @GET 
    @SecurityChecked 
    public Response getUser() { 
     return Response.ok("authenticated successfully!").build(); 
    } 
} 

classe Interceptor

@Interceptor 
@Provider 
@ServerInterceptor 
@SecurityChecked 
public class SecurityCheckInterceptor implements PreProcessInterceptor, AcceptedByMethod { 
    private static final Logger LOGGER = LoggerFactory.getLogger(SecurityCheckInterceptor.class); 

    @Nullable 
    @Override 
    public ServerResponse preProcess(final HttpRequest request, final ResourceMethod method) throws Failure, WebApplicationException { 
     final List<String> authToken = request.getHttpHeaders().getRequestHeader("X-AUTH"); 

     if (authToken == null || !isValidToken(authToken.get(0))) { 
      final ServerResponse serverResponse = new ServerResponse(); 
      serverResponse.setStatus(Response.Status.UNAUTHORIZED.getStatusCode()); 
      return serverResponse; 
     } 

     return null; 
    } 

    private static boolean isValidToken(@Nonnull final String authToken) { 
     LOGGER.info("validating token: " + authToken); 
     return true; 
    } 

    @SuppressWarnings("rawtypes") 
    @Override 
    public boolean accept(final Class declaring, final Method method) { 
     // return declaring.isAnnotationPresent(SecurityChecked.class); // if annotation on class 
     return method.isAnnotationPresent(SecurityChecked.class); 
    } 
} 

e poi ho eseguito i miei test di integrazione implementando la classe di risorsa in JBoss e il rilascio in seguito comandi da riga di comando

curl --header 'X-AUTH: 1a629d035831feadOOO4uFReLyEW8aTmrCS' http://localhost:8080/market-1.0-SNAPSHOT/rest/login 
curl --header 'InvalidHeader: InvalidHeaderValue' http://localhost:8080/market-1.0-SNAPSHOT/rest/login 

Answer 2

È necessaria una configurazione di Stateless Spring Security di fronte agli endpoint JAX RS. Ho risolto il problema esatto che stai cercando di risolvere ma non ho il mio codice da condividere ..

Ecco un progetto che ha fatto esattamente la cosa che stai chiedendo, Qualche uomo saggio ha fatto tutto per voi;)

https://github.com/philipsorst/angular-rest-springsecurity

Qual è la magia?

1. Hai un URL non protetti che fa l'autenticazione, e di impostare le ruoli utente come pure ..
2. poi si torna qualche tipo di Token, metterlo alcuni dove nella cache che sarà previsto su ogni chiamata successiva
3. In seguito a una nuova richiesta su altre risorse protette, verificherà se il token è presente nell'archivio cache/sessione (è necessario un meccanismo per tenere traccia dei token validi)
4. Se token è inviato nuovamente e valido, effettuare il Log-in programmatico in Spring Security che garantisce l'utilizzo di tutte le funzionalità di sicurezza fornite da Spring, (annotazioni, tag JSTL ecc.)!
5. Una volta passata la convalida del token si otterranno i dati dell'utente registrati nei controller (ovvero le risorse JAX RS) per gestire ulteriormente la sicurezza.
6. Se il token non era valido o non presente, sarebbe intrappolato dal guasto punto finale che restituirebbe risposta appropriata (401)

Fare riferimento al seguente collegamento per capire come è configurato Stateless Spring Security., https://github.com/philipsorst/angular-rest-springsecurity/blob/master/src/main/resources/context.xml

vedere come un utente viene convalidato per la prima volta e un token viene generato .. https://github.com/philipsorst/angular-rest-springsecurity/blob/master/src/main/java/net/dontdrinkandroot/example/angularrestspringsecurity/rest/resources/UserResource.java

Qui è la classe in cui si svolge login programmatica su ogni richiesta di token dopo controllo .. https://github.com/philipsorst/angular-rest-springsecurity/blob/master/src/main/java/net/dontdrinkandroot/example/angularrestspringsecurity/rest/AuthenticationTokenProcessingFilter.java