Autenticación RESTful vía Spring

Problema:
Tenemos una API RESTful basada en Spring MVC que contiene información confidencial. La API debe estar protegida, sin embargo, no es deseable enviar las credenciales del usuario (combinación de usuario / paso) con cada solicitud. Según las pautas REST (y los requisitos comerciales internos), el servidor debe permanecer sin estado. La API será consumida por otro servidor en un enfoque de estilo mashup.

Requisitos:

• El cliente realiza una solicitud a .../authenticate(URL desprotegida) con credenciales; El servidor devuelve un token seguro que contiene suficiente información para que el servidor valide futuras solicitudes y permanezca sin estado. Esto probablemente consistiría en la misma información que el token Remember-Me de Spring Security .

• El cliente realiza solicitudes posteriores a varias URL (protegidas), agregando el token obtenido previamente como un parámetro de consulta (o, de manera menos deseable, un encabezado de solicitud HTTP).

• No se puede esperar que el cliente almacene cookies.

• Como ya usamos Spring, la solución debería hacer uso de Spring Security.

Hemos estado golpeando nuestras cabezas contra la pared tratando de hacer que esto funcione, así que espero que alguien ya haya resuelto este problema.

Dado el escenario anterior, ¿cómo podría resolver esta necesidad particular?

Logramos que esto funcione exactamente como se describe en el OP, y esperamos que alguien más pueda hacer uso de la solución. Esto es lo que hicimos:

Configure el contexto de seguridad de esta manera:

<security:http realm="Protected API" use-expressions="true" auto-config="false" create-session="stateless" entry-point-ref="CustomAuthenticationEntryPoint">
    <security:custom-filter ref="authenticationTokenProcessingFilter" position="FORM_LOGIN_FILTER" />
    <security:intercept-url pattern="/authenticate" access="permitAll"/>
    <security:intercept-url pattern="/**" access="isAuthenticated()" />
</security:http>

<bean id="CustomAuthenticationEntryPoint"
    class="com.demo.api.support.spring.CustomAuthenticationEntryPoint" />

<bean id="authenticationTokenProcessingFilter"
    class="com.demo.api.support.spring.AuthenticationTokenProcessingFilter" >
    <constructor-arg ref="authenticationManager" />
</bean>

Como puede ver, hemos creado una costumbre AuthenticationEntryPoint, que básicamente solo devuelve un 401 Unauthorizedsi nuestra solicitud no fue autenticada en la cadena de filtros AuthenticationTokenProcessingFilter.

CustomAuthenticationEntryPoint :

public class CustomAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response,
            AuthenticationException authException) throws IOException, ServletException {
        response.sendError( HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized: Authentication token was either missing or invalid." );
    }
}

AuthenticationTokenProcessingFilter :

public class AuthenticationTokenProcessingFilter extends GenericFilterBean {

    @Autowired UserService userService;
    @Autowired TokenUtils tokenUtils;
    AuthenticationManager authManager;

    public AuthenticationTokenProcessingFilter(AuthenticationManager authManager) {
        this.authManager = authManager;
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        @SuppressWarnings("unchecked")
        Map<String, String[]> parms = request.getParameterMap();

        if(parms.containsKey("token")) {
            String token = parms.get("token")[0]; // grab the first "token" parameter

            // validate the token
            if (tokenUtils.validate(token)) {
                // determine the user based on the (already validated) token
                UserDetails userDetails = tokenUtils.getUserFromToken(token);
                // build an Authentication object with the user's info
                UsernamePasswordAuthenticationToken authentication = 
                        new UsernamePasswordAuthenticationToken(userDetails.getUsername(), userDetails.getPassword());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails((HttpServletRequest) request));
                // set the authentication into the SecurityContext
                SecurityContextHolder.getContext().setAuthentication(authManager.authenticate(authentication));         
            }
        }
        // continue thru the filter chain
        chain.doFilter(request, response);
    }
}

Obviamente, TokenUtilscontiene un código privado (y muy específico para cada caso) y no se puede compartir fácilmente. Aquí está su interfaz:

public interface TokenUtils {
    String getToken(UserDetails userDetails);
    String getToken(UserDetails userDetails, Long expiration);
    boolean validate(String token);
    UserDetails getUserFromToken(String token);
}

Eso debería llevarte a un buen comienzo. Feliz codificación :)

Puede considerar la autenticación de acceso implícito . Esencialmente, el protocolo es el siguiente:

1. La solicitud se realiza desde el cliente.
2. El servidor responde con una cadena única nonce
3. El cliente proporciona un nombre de usuario y contraseña (y algunos otros valores) md5 hash con el nonce; este hash se conoce como HA1
4. El servidor puede verificar la identidad del cliente y entregar los materiales solicitados.
5. La comunicación con el nonce puede continuar hasta que el servidor suministre un nuevo nonce (se utiliza un contador para eliminar los ataques de repetición)

Toda esta comunicación se realiza a través de encabezados, que, como señala jmort253, generalmente es más seguro que comunicar material sensible en los parámetros de la url.

La autenticación de acceso implícito es compatible con Spring Security . Tenga en cuenta que, aunque los documentos dicen que debe tener acceso a la contraseña de texto sin formato de su cliente, puede autenticarse correctamente si tiene el hash HA1 para su cliente.

Con respecto a los tokens que transportan información, JSON Web Tokens ( http://jwt.io ) es una tecnología brillante. El concepto principal es incorporar elementos de información (reclamos) en el token y luego firmar todo el token para que el extremo de validación pueda verificar que los reclamos son realmente confiables.

Uso esta implementación de Java: https://bitbucket.org/b_c/jose4j/wiki/Home

También hay un módulo Spring (spring-security-jwt), pero no he investigado qué admite.

¿Por qué no empiezas a usar OAuth con JSON WebTokens?

http://projects.spring.io/spring-security-oauth/

OAuth2 es un protocolo / marco de autorización estandarizado. Según la especificación oficial de OAuth2 :

Puedes encontrar más información aquí