Autenticação RESTful via Spring

Problema:
Temos uma API RESTful baseada no Spring MVC que contém informações confidenciais. A API deve ser protegida, no entanto, o envio das credenciais do usuário (combinação usuário / senha) com cada solicitação não é desejável. De acordo com as diretrizes REST (e requisitos internos de negócios), o servidor deve permanecer sem estado. A API será consumida por outro servidor em uma abordagem no estilo de mashup.

Requisitos:

• O cliente faz uma solicitação para .../authenticate(URL não protegido) com credenciais; O servidor retorna um token seguro que contém informações suficientes para o servidor validar solicitações futuras e permanecer sem estado. Provavelmente, isso consistiria nas mesmas informações que o Remember-Me Token da Spring Security .

• O cliente faz solicitações subsequentes para várias URLs (protegidas), acrescentando o token obtido anteriormente como um parâmetro de consulta (ou, menos desejável, um cabeçalho de solicitação HTTP).

• Não se espera que o cliente armazene cookies.

• Como já usamos o Spring, a solução deve usar o Spring Security.

Temos batido nossas cabeças contra a parede tentando fazer isso funcionar, por isso espero que alguém por aí já tenha resolvido esse problema.

Dado o cenário acima, como você pode resolver essa necessidade específica?

Conseguimos fazer isso funcionar exatamente como descrito no OP, e esperamos que alguém possa fazer uso da solução. Aqui está o que fizemos:

Configure o contexto de segurança da seguinte maneira:

<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 você pode ver, criamos um personalizado AuthenticationEntryPoint, que basicamente apenas retorna a 401 Unauthorizedse a solicitação não foi autenticada na cadeia de filtros por nossa 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, TokenUtilscontém algum código privado (e muito específico para cada caso) e não pode ser facilmente compartilhado. Aqui está sua interface:

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

Isso deve levá-lo a um bom começo. Feliz codificação. :)

Você pode considerar a autenticação de acesso Digest . Essencialmente, o protocolo é o seguinte:

1. A solicitação é feita do cliente
2. O servidor responde com uma string nonce exclusiva
3. O cliente fornece um nome de usuário e senha (e alguns outros valores) MD5 hash com o nonce; esse hash é conhecido como HA1
4. O servidor pode verificar a identidade do cliente e fornecer os materiais solicitados
5. A comunicação com o nonce pode continuar até que o servidor forneça um novo nonce (um contador é usado para eliminar ataques de reprodução)

Toda essa comunicação é feita por meio de cabeçalhos, que, como jmort253 aponta, geralmente são mais seguros do que a comunicação de material sensível nos parâmetros da URL.

A autenticação Digest Access é suportada pelo Spring Security . Observe que, embora os documentos digam que você deve ter acesso à senha de texto sem formatação do seu cliente, você poderá se autenticar com êxito se tiver o hash HA1 para o seu cliente.

Em relação aos tokens que transportam informações, o JSON Web Tokens ( http://jwt.io ) é uma tecnologia brilhante. O conceito principal é incorporar elementos de informação (declarações) no token e, em seguida, assinar todo o token para que o fim da validação possa verificar se as declarações são realmente confiáveis.

Eu uso esta implementação Java: https://bitbucket.org/b_c/jose4j/wiki/Home

Há também um módulo Spring (spring-security-jwt), mas não examinei o que ele suporta.

Por que você não começa a usar OAuth com JSON WebTokens

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

OAuth2 é um protocolo / estrutura de autorização padronizada. Conforme especificação oficial do OAuth2 :

Você pode encontrar mais informações aqui