Authentification de sécurité de printemps basée sur le paramètre de requête

L'application que je suis en train de travailler sur a déjà de Printemps de Sécurité pour gérer authentification basée sur des formulaires. Maintenant, la condition est de login d'un utilisateur par programmation via un service externe si un jeton se trouve dans l'un des paramètres de la requête.

En d'autres termes, si un paramètre de la requête, dire "jeton", existe, il doit faire appel à un service externe avec jeton pour vérifier si il est un jeton valide. Si elle est alors l'utilisateur sera connecté.

Je ne peux pas comprendre comment et où "déclencheur" ou de "raccrocher" le Printemps de Sécurité pour vérifier ce paramètre et faire la vérification puis authentifier l'utilisateur lorsque approprié, car il n'y a pas de formulaire de connexion. J'ai pensé qu'il devrait y avoir quelque chose dans le Printemps de Sécurité, qui peut être étendu ou personnalisés pour le faire?

J'ai regardé à travers le Printemps de Sécurité de la documentation et je me demande si AbstractPreAuthenticatedProcessingfilter est la bonne chose pour commencer?

source d'informationauteur Bing Qiao

  1. 21

    J'en ai un similaire d'installation dans mon application. Voici les éléments de base pour autant que je peux dire:

    Vous avez besoin pour créer un AuthenticationProvider comme suit:

    public class TokenAuthenticationProvider implements AuthenticationProvider {

    @Autowired private SomeService userSvc;

    @Override
    public Authentication authenticate(Authentication auth) throws AuthenticationException {
        if (auth.isAuthenticated())
            return auth;

        String token = auth.getCredentials().toString();
        User user = userSvc.validateApiAuthenticationToken(token);
        if (user != null) {
            auth = new PreAuthenticatedAuthenticationToken(user, token);
            auth.setAuthenticated(true);
            logger.debug("Token authentication. Token: " + token + "; user: " + user.getDisplayName());
        } else
            throw new BadCredentialsException("Invalid token " + token);
        return auth;
    }
}

    Vous devez également créer un Filter pour activer le paramètre personnalisé dans un jeton d'authentification:

    public class AuthenticationTokenFilter implements Filter {
@Override
public void init(FilterConfig fc) throws ServletException {
}
@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain fc) throws IOException, ServletException {
SecurityContext context = SecurityContextHolder.getContext();
if (context.getAuthentication() != null && context.getAuthentication().isAuthenticated()) {
//do nothing
} else {
Map<String,String[]> params = req.getParameterMap();
if (!params.isEmpty() && params.containsKey("auth_token")) {
String token = params.get("auth_token")[0];
if (token != null) {
Authentication auth = new TokenAuthentication(token);
SecurityContextHolder.getContext().setAuthentication(auth);
}
}
}
fc.doFilter(req, res);
}
@Override
public void destroy() {
}
class TokenAuthentication implements Authentication {
private String token;
private TokenAuthentication(String token) {
this.token = token;
}
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return new ArrayList<GrantedAuthority>(0);
}
@Override
public Object getCredentials() {
return token;
}
@Override
public Object getDetails() {
return null;
}
@Override
public Object getPrincipal() {
return null;
}
@Override
public boolean isAuthenticated() {
return false;
}
@Override
public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {
}
@Override
public String getName() {
//your custom logic here
}
}
}

    Vous avez besoin pour créer des haricots pour ces:

    <beans:bean id="authTokenFilter" class="com.example.security.AuthenticationTokenFilter" scope="singleton" />
<beans:bean id="tokenAuthProvider" class="com.example.security.TokenAuthenticationProvider" />

    Enfin, vous devez câbler ces haricots dans la sécurité de votre config (ajuster en conséquence):

    <sec:http >
<!-- other configs here -->
<sec:custom-filter ref="authTokenFilter" after="BASIC_AUTH_FILTER" /> <!-- or other appropriate filter -->
</sec:http>
<sec:authentication-manager>
<!-- other configs here -->
<sec:authentication-provider ref="tokenAuthProvider" />
</sec:authentication-manager>

    Il y a peut être une autre façon, mais cela fonctionne bien (à l'aide de Printemps de Sécurité 3.1 pour le moment).

  2. 3

    Si vous utilisez Spring MVC contrôleur ou d'un service, où targe paramètre de la requête est passé, puis vous pouvez utiliser @exiger une autorisation préalable de Printemps de sécurité de l'annotation.

    Dire, vous avez quelques Printemps service qui permet de vérifier passé jeton et effectuer l'authentification si elle est adoptée jeton est valide: 

    @Service("authenticator")
class Authenticator {        
...
public boolean checkTokenAndAuthenticate(Object token) {
...
//check token and if it is invalid return "false"
...
//if token is valid then perform programmatically authentication and return "true"  
}
...             
}

    Puis, avec le Printemps de sécurité @exiger une autorisation préalable de l'annotation que vous pouvez faire cela, il manière suivante:

    ...
@PreAuthorize("@authenticator.checkTokenAndAuthenticate(#token)")
public Object methodToBeChecked(Object token) { ... }
...

    Aussi, vous devez activer la sécurité Printemps annotations et ajouter le printemps-la sécurité-les aspects de POM (ou pot à classpath).

  3. 1

    Il y a un blog avec une solution détaillée pour la mise en œuvre Personnalisée à base de jetons Sessionless l'authentification avec le Printemps de Sécurité, Espérons que cette aide.

    http://javattitude.com/2014/06/07/spring-security-custom-token-based-rest-authentication/