Le printemps des jetons de Sécurité basé sur l'API auth & utilisateur/mot de passe d'authentification

Je suis en train de créer une application web qui fournissent une API REST en utilisant le Printemps, et je suis en train de configurer la sécurité.

Je suis en train de mettre en œuvre ce type de modèle: https://developers.google.com/accounts/docs/MobileApps (Google ont totalement changé la page, donc n'a plus de sens - voir la page j'ai été réfère ici: http://web.archive.org/web/20130822184827/https://developers.google.com/accounts/docs/MobileApps)

Voici ce que j'ai besoin de accompish:

• Web app est simple connexion/inscrivez-formes que le travail avec la normale de printemps utilisateur/mot de passe d'authentification (qui ont fait ce genre de chose avant avec dao/authenticationmanager/userdetailsservice etc)
• Api REST points de terminaison qui sont apatrides séances et chaque demande authentifiés en fonction de l'ona jeton fourni avec la demande

(par exemple, les connexions de l'utilisateur/des panneaux à l'aide de formes normales, la webapp permet de sécuriser les cookie avec un jeton qui peut ensuite être utilisé dans la suite de demandes d'API)

J'ai eu une authentification normale de configuration comme ci-dessous:

@Override protected void configure(HttpSecurity http) throws Exception {
    http
        .csrf()
            .disable()
        .authorizeRequests()
            .antMatchers("/resources/**").permitAll()
            .antMatchers("/mobile/app/sign-up").permitAll()
            .antMatchers("/v1/**").permitAll()
            .anyRequest().authenticated()
            .and()
        .formLogin()
            .loginPage("/")
            .loginProcessingUrl("/loginprocess")
            .failureUrl("/?loginFailure=true")
            .permitAll();
}

Je pensais d'ajouter un pré-auth filtre, qui vérifie la présence de la marque dans la demande et puis définit le contexte de sécurité (serait-ce à dire que la normal à la suite d'authentification sera sauté?), cependant, au-delà de la normale d'utilisateur/mot de passe je n'ai pas fait trop avec la base de jetons de sécurité, mais en fonction d'autres exemples, je suis venu avec les éléments suivants:

Sécurité Config:

@Override protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf()
                .disable()
            .addFilter(restAuthenticationFilter())
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
                .exceptionHandling().authenticationEntryPoint(new Http403ForbiddenEntryPoint()).and()
                .antMatcher("/v1/**")
            .authorizeRequests()
                .antMatchers("/resources/**").permitAll()
                .antMatchers("/mobile/app/sign-up").permitAll()
                .antMatchers("/v1/**").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/")
                .loginProcessingUrl("/loginprocess")
                .failureUrl("/?loginFailure=true")
                .permitAll();
    }

Mon custom reste de filtre:

public class RestAuthenticationFilter extends AbstractAuthenticationProcessingFilter {
public RestAuthenticationFilter(String defaultFilterProcessesUrl) {
super(defaultFilterProcessesUrl);
}
private final String HEADER_SECURITY_TOKEN = "X-Token"; 
private String token = "";
@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
this.token = request.getHeader(HEADER_SECURITY_TOKEN);
//If we have already applied this filter - not sure how that would happen? - then just continue chain
if (request.getAttribute(FILTER_APPLIED) != null) {
chain.doFilter(request, response);
return;
}
//Now mark request as completing this filter
request.setAttribute(FILTER_APPLIED, Boolean.TRUE);
//Attempt to authenticate
Authentication authResult;
authResult = attemptAuthentication(request, response);
if (authResult == null) {
unsuccessfulAuthentication(request, response, new LockedException("Forbidden"));
} else {
successfulAuthentication(request, response, chain, authResult);
}
}
/**
* Attempt to authenticate request - basically just pass over to another method to authenticate request headers 
*/
@Override public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException, IOException, ServletException {
AbstractAuthenticationToken userAuthenticationToken = authUserByToken();
if(userAuthenticationToken == null) throw new AuthenticationServiceException(MessageFormat.format("Error | {0}", "Bad Token"));
return userAuthenticationToken;
}
/**
* authenticate the user based on token, mobile app secret & user agent
* @return
*/
private AbstractAuthenticationToken authUserByToken() {
AbstractAuthenticationToken authToken = null;
try {
//TODO - just return null - always fail auth just to test spring setup ok
return null;
} catch (Exception e) {
logger.error("Authenticate user by token error: ", e);
}
return authToken;
}

Ci-dessus se traduit par une erreur sur l'app démarrage en disant: authenticationManager must be specified
Quelqu'un peut-il me dire la meilleure façon de le faire - est un pre_auth filtre la meilleure façon de le faire?

---

MODIFIER

J'ai écrit ce que j'ai trouvé et comment je l'ai fait avec Ressort de sécurité (y compris le code) l'application d'une norme jeton de mise en œuvre (pas d'authentification OAuth)

Aperçu du problème et de l'approche ou de la solution

La mise en œuvre de la solution avec Ressort de sécurité

Espère que cela aide certains autres..