Introdução à autenticação SPNEGO/Kerberos na primavera

Introdução à autenticação SPNEGO / Kerberos na primavera

1. Visão geral

Neste tutorial, vamos entender os fundamentos do protocolo de autenticação Kerberos. Também cobriremos a necessidade deSPNEGO em conexão com Kerberos.

Por fim, veremos como usar a extensãoSpring Security Kerberos para criar aplicativos habilitados para Kerberos com SPNEGO.

Antes de prosseguirmos, vale a pena observar que este tutorial irá apresentar muitos novos termos para os não iniciados nesta área. Portanto, vamos passar algum tempo na frente para cobrir o terreno.

2. Entendendo o Kerberos

Kerberos is a Network Authentication Protocol desenvolvido no Massachusetts Institute of Technology (MIT) no início dos anos oitenta. Como você deve perceber, isso é relativamente antigo e resistiu ao teste do tempo. O Windows Server suporta amplamente o Kerberos como um mecanismo de autenticação e até tornou a opção de autenticação padrão.

Tecnicamente,Kerberos is a ticket-based authentication protocol que permite que os nós em uma rede de computadores se identifiquem uns aos outros.

2.1. Caso de uso simples para Kerberos

Vamos traçar uma situação hipotética para demonstrar isso.

Suponha que um usuário, através de seu cliente de email em sua máquina, precise receber seus emails de um servidor de email em outra máquina na mesma rede. Há uma necessidade óbvia de autenticação aqui. O cliente e o servidor de email devem poder se identificar e confiar um no outro para que eles se comuniquem com segurança.

Como o Kerberos pode nos ajudar aqui? Kerberos introduces a third party called Key Distribution Centre (KDC), que tem uma confiança mútua com cada nó da rede. Vamos ver como isso pode funcionar em nosso caso:

2.2. Principais aspectos do protocolo Kerberos

Embora isso possa parecer esotérico, isso é bastante simples e criativo para garantir a comunicação em uma rede não segura. Alguns dos problemas apresentados aqui são um dado adquirido na era do TLS em todos os lugares!

Embora uma discussão detalhada do protocolo Kerberos não seja possível aqui, vamos examinar alguns aspectos importantes:

Presume-se que a confiança entre nós (cliente e servidor) e o KDC exista aqui na mesma região
A senha nunca é trocada pela rede
A confiança entre o cliente e o servidor está implícita com base no fato de que eles podem descriptografar mensagens com uma chave compartilhada apenas com o KDC
A confiança entre o cliente e o servidor é mútua
O cliente pode armazenar em cache tickets para uso repetido até a expiração, fornecendo uma experiência de logon único
As mensagens do autenticador são baseadas no carimbo de data e hora e, portanto, são boas apenas para uso único
Todas as três partes aqui devem ter um tempo relativamente sincronizado

Embora isso apenas arranhe a superfície desse belo protocolo de autenticação, é suficiente para nos levar adiante com o nosso tutorial.

3. Entendendo o SPNEGO

SPNEGO significaSimple and Protected GSS-API Negotiation Mechanism. Que nome! Vamos primeiro ver o que significa GSS-API. OGeneric Security Service Application Program Interface (GSS-API) nada mais é do que um padrão IETF para cliente e servidor se comunicarem de maneira segura e independente do fornecedor.

SPNEGO is a part of the GSS-API for client and server to negotiate the choice of security mechanism para usar, por exemplo, Kerberos ou NTLM.

4. Por que precisamos do SPNEGO com o Kerberos?

Como vimos na seção anterior, o Kerberos é um protocolo de autenticação de rede puro, operando principalmente na camada de transporte (TCP / UDP). Embora isso seja bom para muitos casos de uso, isso não atende aos requisitos da Web moderna. Se temos um aplicativo que opera em uma abstração mais alta, como HTTP, não é possível usar o Kerberos diretamente.

É aqui que a SPNEGO vem em nossa ajuda. No caso de um aplicativo da web, a comunicação ocorre principalmente entre um navegador da web como o Chrome e um servidor da web como o Tomcat que hospeda o aplicativo da web por HTTP. Se habilitados, eles podemnegotiate Kerberos as a security mechanism through SPNEGO and exchange tickets as SPNEGO tokens over HTTP.

Então, como isso muda nosso cenário mencionado anteriormente? Vamos substituir nosso cliente de e-mail simples por um navegador da web e servidor de e-mail por um aplicativo da web:

Portanto, nada mudou muito em relação ao diagrama anterior, exceto que a comunicação entre cliente e servidor ocorre explicitamente agora via HTTP. Vamos entender isso melhor:

A máquina cliente se autentica no KDC e armazena em cache o TGT
O navegador da Web na máquina cliente está configurado para usar SPNEGO e Kerberos
O aplicativo da web também está configurado para suportar SPNEGO e Kerberos
Aplicativo da Web lança um desafio de "Negociar" para o navegador da Web que tenta acessar um recurso protegido
O tíquete de serviço é empacotado como token SPNEGO e trocado como um cabeçalho HTTP

5. Exigências

Antes de prosseguirmos com o desenvolvimento de um aplicativo Web que ofereça suporte ao modo de autenticação Kerberos, precisamos reunir algumas configurações básicas. Vamos executar essas tarefas rapidamente.

5.1. Configurando o KDC

A configuração de um ambiente Kerberos para uso em produção está além do escopo deste tutorial. Infelizmente, isso não é uma tarefa trivial e frágil também. Existem várias opções disponíveis para obter uma implementação do Kerberos, tanto em código aberto quanto em versões comerciais:

O MIT disponibilizaimplementation of Kerberos v5 para vários sistemas operacionais
Apache Kerby é uma extensão do diretório Apache, que fornece uma ligação Java Kerberos
O Windows Server da Microsoft oferece suporte ao Kerberos v5 com suporte nativo do Active Directory
Heimdel tem umimplementation of Kerberos v5

A configuração real do KDC e da infraestrutura relacionada depende do provedor e deve ser seguida na respectiva documentação. No entanto,Apache Kerby can be run inside a Docker container, o que o torna neutro em relação à plataforma.

5.2. Configurando usuários no KDC

Precisamos configurar dois usuários - ou, como eles chamam, diretores - no KDC. Podemos usar a ferramenta de linha de comando "kadmin" para esse fim. Suponhamos que tenhamos criado um reino chamado “example.com” no banco de dados KDC e conectado ao “kadmin” com um usuário com privilégios de administrador.

Criaremos nosso primeiro usuário, que desejamos autenticar de um navegador da web, com:

$ kadmin: addprinc -randkey kchandrakant -pw password
Principal "[email protected]" created.

Também precisaremos registrar nosso aplicativo da web com o KDC:

$ kadmin: addprinc -randkey HTTP/[email protected] -pw password
Principal "HTTP/[email protected]" created.

Observe a convenção para nomear o principal aqui, pois isso deve corresponder ao domínio no qual o aplicativo está acessível no navegador da web. Obrowser automatically tries to create a Service Principal Name (SPN) with this convention da web quando apresentado com um desafio "Negociar".

Também precisamos exportar isso como um arquivo keytab para disponibilizá-lo para o aplicativo Web:

$ kadmin: ktadd -k example.keytab HTTP/[email protected]

Isso deve nos dar um arquivo chamado “example.keytab”.

5.3. Configuração do Navegador

Precisamos ativar o navegador da Web que usamos para acessar um recurso protegido no aplicativo Web para o esquema de autenticação "Negociar". Felizmente, a maioria dos navegadores modernos, como o Chrome, suporta "Negociar" como um esquema de autenticação por padrão.

Além disso, podemos configurar o navegador para fornecer "Autenticação Integrada". Nesse modo, quando apresentado ao desafio "Negociar", o navegador tenta usar as credenciais em cache na máquina host, que já foi registrada em um principal do KDC. No entanto, não vamos usar este modo aqui para manter as coisas explícitas.

5.4. Configuração de Domínio

É compreensível que não tenhamos domínios reais para testar nosso aplicativo da web. Mas, infelizmente, não podemos usar localhost ou 127.0.0.1 ou qualquer outro endereço IP com autenticação Kerberos. Há, no entanto, uma solução fácil para isso, que envolve a configuração de entradas no arquivo "hosts", como:

demo.kerberos.bealdung.com 127.0.0.1

6. Primavera para o nosso resgate!

Finalmente, como já esclarecemos o básico, é hora de testar a teoria. Mas, não será complicado criar um aplicativo da web com suporte a SPNEGO e Kerberos? Não se usarmos o Spring. Spring has a Kerberos Extension as part of Spring Security that supports SPNEGO with Kerberos perfeitamente.

Quase tudo o que precisamos fazer é apenas configurações no Spring Security para ativar o SPNEGO com o Kerberos. Usaremos configurações de estilo Java aqui, mas uma configuração XML pode ser definida com a mesma facilidade. Podemos estender a classeWebSecurityConfigurerAdapter para configurar tudo o que precisamos.

6.1. Dependências do Maven

A primeira coisa que precisamos configurar são as dependências:


    org.springframework.security.kerberos
    spring-security-kerberos-web
    ${kerberos.extension.version}


    org.springframework.security.kerberos
    spring-security-kerberos-client
    ${kerberos.extension.version}

Essas dependências estão disponíveis para download emMaven Central.

6.2. Configurações SPNEGO

Em primeiro lugar, o SPNEGO é integrado ao Spring Security como umFilter emHTTPSecurity:

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.authorizeRequests()
      .anyRequest()
      .authenticated()
    .and()
      .addFilterBefore(
        spnegoAuthenticationProcessingFilter(authenticationManagerBean()),
        BasicAuthenticationFilter.class);
}

Mostra apenas a parte necessária para configurar o SPNEGOFiltere não é uma configuraçãoHTTPSecurity completa, que deve ser configurada de acordo com os requisitos de segurança do aplicativo.

Em seguida, precisamos fornecer o SPNEGOFilter comoBean:

@Bean
public SpnegoAuthenticationProcessingFilter spnegoAuthenticationProcessingFilter(
  AuthenticationManager authenticationManager) {
    SpnegoAuthenticationProcessingFilter filter = new SpnegoAuthenticationProcessingFilter();
    filter.setAuthenticationManager(authenticationManager);
    return filter;
}

6.3. Configurações Kerberos

Além disso, podemos configurar o Kerberos adicionandoAuthenticationProvider aAuthenticationManagerBuilder no Spring Security:

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
      .authenticationProvider(kerberosAuthenticationProvider())
      .authenticationProvider(kerberosServiceAuthenticationProvider());
}

A primeira coisa que devemos fornecer éKerberosAuthenticationProvider comoBean. Esta é uma implementação deAuthenticationProvider, e é aqui que definimosSunJaasKerberosClient como umKerberosClient:

@Bean
public KerberosAuthenticationProvider kerberosAuthenticationProvider() {
    KerberosAuthenticationProvider provider = new KerberosAuthenticationProvider();
    SunJaasKerberosClient client = new SunJaasKerberosClient();
    provider.setKerberosClient(client);
    provider.setUserDetailsService(userDetailsService());
    return provider;
}

Em seguida, também temos que fornecerKerberosServiceAuthenticationProvider comoBean. Esta é a classe que valida os tíquetes de serviço Kerberos ou tokens SPNEGO:

@Bean
public KerberosServiceAuthenticationProvider kerberosServiceAuthenticationProvider() {
    KerberosServiceAuthenticationProvider provider = new KerberosServiceAuthenticationProvider();
    provider.setTicketValidator(sunJaasKerberosTicketValidator());
    provider.setUserDetailsService(userDetailsService());
    return provider;
}

Por último, precisamos fornecerSunJaasKerberosTicketValidator comoBean. Esta é uma implementação deKerberosTicketValidatore usa o Módulo de Login SUN JAAS:

@Bean
public SunJaasKerberosTicketValidator sunJaasKerberosTicketValidator() {
    SunJaasKerberosTicketValidator ticketValidator = new SunJaasKerberosTicketValidator();
    ticketValidator.setServicePrincipal("HTTP/[email protected]");
    ticketValidator.setKeyTabLocation(new FileSystemResource("example.keytab"));
    return ticketValidator;
}

6.4. Detalhes do usuario

Vimos referências aUserDetailsService em nossoAuthenticationProvider antes, então por que precisamos disso? Bem, como conhecemos o Kerberos, é puramente um mecanismo de autenticação baseado em tíquete.

Portanto, embora seja capaz de identificar o usuário, não fornece outros detalhes relacionados ao usuário, como suas autorizações. Precisamos de umUserDetailsService válido fornecido para nossoAuthenticationProvider para preencher essa lacuna.

6.5. Executando o aplicativo

Isso é basicamente o que precisamos para configurar um aplicativo Web com o Spring Security ativado para SPNEGO com Kerberos. Quando inicializamos o aplicativo Web e acessamos qualquer página, o navegador da Web deve solicitar o nome de usuário e a senha, preparar um token SPNEGO com o Ticket de Serviço e enviá-lo ao aplicativo.

O aplicativo deve poder processá-lo usando as credenciais no arquivo keytab e responder com autenticação bem-sucedida.

No entanto, como vimos anteriormente, a configuração de um ambiente Kerberos funcional é complicada e bastante quebradiça. Se as coisas não funcionarem como esperado, vale a pena verificar todas as etapas novamente. Um erro simples, como incompatibilidade no nome de domínio, pode levar à falha com mensagens de erro que não são particularmente úteis.

7. Uso prático de SPNEGO e Kerberos

Agora que vimos como funciona a autenticação Kerberos e como podemos usar SPNEGO com Kerberos em aplicativos da web, podemos questionar a necessidade dela. Embora faça todo o sentido usá-lo como um mecanismo SSO em uma rede corporativa, por que devemos usá-lo em aplicativos da web?

Bem, por um lado, mesmo depois de tantos anos, o Kerberos ainda é usado muito ativamente em aplicativos corporativos, especialmente aplicativos baseados no Windows. Se uma organização tiver vários aplicativos da web internos e externos, faz sentido paraextend the same SSO infrastructure to cover them all. Isso facilita muito para os administradores e usuários de uma organização ter uma experiência perfeita por meio de aplicativos diferentes.

8. Conclusão

Para resumir, neste tutorial, entendemos o básico do protocolo de autenticação Kerberos. Também discutimos o SPNEGO como parte da GSS-API e como podemos usá-lo para facilitar a autenticação baseada em Kerberos em um aplicativo da Web por HTTP. Além disso, tentamos construir um pequeno aplicativo da web aproveitando o suporte integrado do Spring Security para SPNEGO com Kerberos.

Este tutorial fornece apenas uma rápida amostra de um mecanismo de autenticação poderoso e testado pelo tempo. Existe muita informação disponível para aprendermos e possivelmente apreciarmos ainda mais!

Como sempre, o código pode ser encontradoover on GitHub.

TOC

Introdução à autenticação SPNEGO/Kerberos na primavera