Autenticação X.509 no Spring Security

1. Visão geral

Neste artigo, focaremos nos principais casos de uso para autenticação de certificado X.509 -* verificação da identidade de um ponto de comunicação *ao usar o protocolo HTTPS (HTTP sobre SSL).

Simplificando - enquanto uma conexão segura é estabelecida, o cliente verifica o servidor de acordo com seu certificado (emitido por uma autoridade de certificação confiável).

Além disso, X.509 em Spring Security pode ser usado para* verificar a identidade de um cliente através do servidor durante a conexão. Isso se chama _ "autenticação mútua", _ *e veremos como isso é feito aqui também.

Por fim, tocaremos em* quando fizer sentido usar esse tipo de autenticação *.

Para demonstrar a verificação do servidor, criaremos um aplicativo Web simples e instalaremos uma autoridade de certificação personalizada em um navegador.

E, para mutual authentication, criaremos um certificado de cliente e modificaremos nosso servidor para permitir apenas clientes verificados.

2. Keystores

*Requisito Opcional* : Para usar chaves criptograficamente fortes, juntamente com os recursos de criptografia e descriptografia, você precisa dos _Java Cryptography Extension (JCE) Arquivos de Política de Jurisdição de Força Ilimitada'_ instalados em sua _JVM._

Eles podem ser baixados, por exemplo, em Oracle (siga as instruções de instalação incluídas no download). Algumas distribuições Linux também fornecem um pacote instalável por meio de seus gerenciadores de pacotes.

Para implementar a autenticação X.509 em um aplicativo Spring, primeiro criaremos uma keystore no formato Java Key-Store (JKS).

Essa keystore deve conter um certificado válido de authority ou uma cadeia de certificados authorities e um certificado próprio para o nosso servidor. O último deve ser assinado por um dos authorities incluídos e deve ser nomeado após o hostname no qual o servidor está sendo executado; usaremos o aplicativo Java keytool aqui.

*Para simplificar* o processo de criação de _keys_ e _certificates_ usando _keytool_, o código https://github.com/eugenp/tutorials[ no _Github_], fornece um _Makefile_ for GNU _make_ comentado, contendo todas as etapas necessárias para concluir esta seção. Você também pode personalizá-lo facilmente através de algumas variáveis de ambiente.

*Dica:* Como uma _exposição completa_, você pode executar _make_ sem argumentos. Isso criará um _keystore_, um _truststore_ e dois certificados para importação no seu navegador (um para _localhost_ e outro para um usuário chamado _ “cid” _).

Para criar uma nova keystore com uma autoridade de certificação, podemos executar make da seguinte maneira:

$> make create-keystore PASSWORD=changeit

Agora, adicionaremos um certificado para nosso host de desenvolvimento a esta keystore criada e assiná-lo por nossa certificate Authority:

$> make add-host HOSTNAME=localhost

Para permitir a client authentication, também precisamos de uma keystore chamada _ “truststore” . Este _truststore deve conter certificados válidos de nossa certificate Authority e todos os clientes permitidos. Para referência sobre o uso do keytool, consulte o Makefile nas seguintes seções :

$> make create-truststore PASSWORD=changeit
$> make add-client CLIENTNAME=cid

3. Exemplo de aplicação

Nosso projeto de servidor seguro SSL consistirá em uma classe de aplicativo anotada link:/spring-boot-application-configuration [_ @ SpringBootApplication_] (que é um tipo de link:/bootstraping-a-web-application-with-spring-and -java-based-configuration [@Configuration]) _, um arquivo de configuração _application.properties e um front-end muito simples no estilo MVC.

Tudo o que o aplicativo precisa fazer é apresentar uma página HTML com uma mensagem _ "Olá \ {Usuário}!" _. Dessa forma, podemos inspecionar o certificado do servidor em um navegador para garantir que a conexão seja verificada e protegida.

Primeiro, criamos um novo projeto Maven com três pacotes Spring Boot Starter incluídos:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
    <version>1.4.0.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>1.4.0.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
    <version>1.4.0.RELEASE</version>
</dependency>

*Para referência:* você encontrará os pacotes configuráveis no _Maven Central_ (https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.boot%22%20AND%20a%3A % 22spring-boot-starter-security% 22 [security], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.boot%22%20AND%20a%3A % 22spring-boot-starter-web% 22 [web], https://search.maven.org/classic/#search%7Cgav%7C1%7Cg%3A%22org.springframework.boot%22%20AND%20a%3A % 22spring-boot-starter-timeleaf% 22 [timeleaf]).

Como próximo passo, criamos a classe principal do aplicativo e o controlador do usuário:

@SpringBootApplication
public class X509AuthenticationServer {
    public static void main(String[] args) {
        SpringApplication.run(X509AuthenticationServer.class, args);
    }
}

@Controller
public class UserController {
    @RequestMapping(value = "/user")
    public String user(Model model, Principal principal) {

        UserDetails currentUser
          = (UserDetails) ((Authentication) principal).getPrincipal();
        model.addAttribute("username", currentUser.getUsername());
        return "user";
    }
}

Agora, informamos ao aplicativo onde eles podem encontrar nossa keystore e como ele pode ser acessado. Definimos SSL com o status “ativado” e alteramos a porta de escuta padrão para indicar uma conexão segura.

Além disso, configuramos alguns user-details para acessar nosso servidor via Basic Authentication:

server.ssl.key-store=../keystore/keystore.jks
server.ssl.key-store-password=${PASSWORD}
server.ssl.key-alias=localhost
server.ssl.key-password=${PASSWORD}
server.ssl.enabled=true
server.port=8443
security.user.name=Admin
security.user.password=admin

Este será o modelo HTML, localizado na pasta resources/templates:

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>X.509 Authentication Demo</title>
</head>
<body>
    <h2>Hello <span th:text="${username}"/>!</h2>
</body>
</html>

Antes de concluir esta seção e examinar o site, ainda precisamos instalar nossa autoridade de certificação gerada como trusted certificate em um navegador de nossa escolha.

Uma instalação exemplar de nossa certificate Authority para Mozilla Firefox seria semelhante a seguir:

Digite about: preferências na barra de endereço
Abra Avançado → Certificados → Exibir Certificados → Autoridades
Clique em Import
Localize a pasta Baeldung tutorials e sua subpasta spring-security-x509/keystore
Selecione o arquivo ca.crt e clique em OK
Escolha "Confie nesta CA para identificar sites" _ e clique em _OK

TOC

Autenticação X.509 no Spring Security