Einführung in die SPNEGO / Kerberos-Authentifizierung im Frühjahr

1. Übersicht

In diesem Lernprogramm werden die Grundlagen des Kerberos-Authentifizierungsprotokolls erläutert. Wir werden auch den Bedarf an SPNEGO im Zusammenhang mit Kerberos decken.

Schließlich werden wir sehen, wie Sie die Spring Security Kerberos-Erweiterung verwenden, um Anwendungen zu erstellen, die für Kerberos mit SPNEGO aktiviert sind.

Bevor wir fortfahren, sollten Sie beachten, dass dieses Tutorial viele neue Begriffe für diejenigen einführt, die in diesem Bereich noch nicht eingeweiht sind. Daher werden wir einige Zeit im Voraus verbringen, um das Gelände abzudecken.

2. Kerberos verstehen

Kerberos ist ein Netzwerkauthentifizierungsprotokoll, das Anfang der achtziger Jahre am Massachusetts Institute of Technology (MIT) entwickelt wurde. Wie Sie vielleicht feststellen, ist dies relativ alt und hat den Test der Zeit bestanden. Windows Server unterstützt Kerberos weitgehend als Authentifizierungsmechanismus und hat es sogar zur Standardauthentifizierungsoption gemacht.

Technisch gesehen ist Kerberos ein Ticket-basiertes Authentifizierungsprotokoll , mit dem sich Knoten in einem Computernetzwerk untereinander identifizieren können.

2.1. Einfacher Anwendungsfall für Kerberos

Lassen Sie uns eine hypothetische Situation aufstellen, um dies zu demonstrieren.

Angenommen, ein Benutzer muss über seinen E-Mail-Client auf seinem Computer seine E-Mails von einem Mailserver auf einem anderen Computer im selben Netzwerk abrufen. Hier besteht ein offensichtlicher Authentifizierungsbedarf. Der Mail-Client und der Mail-Server müssen sich identifizieren und vertrauen können, damit sie sicher kommunizieren können.

Wie kann uns Kerberos hier helfen? Kerberos führt einen Drittanbieter namens Key Distribution Center (KDC) ein , der mit jedem Knoten im Netzwerk ein gegenseitiges Vertrauen hat. Mal sehen, wie das in unserem Fall funktionieren kann:

2.2. Hauptaspekte des Kerberos-Protokolls

Dies mag zwar esoterisch klingen, ist jedoch recht einfach und kreativ bei der Sicherung der Kommunikation über ein ungesichertes Netzwerk. Einige der hier vorgestellten Probleme sind im Zeitalter von TLS überall selbstverständlich!

Eine ausführliche Erörterung des Kerberos-Protokolls ist hier nicht möglich. Lassen Sie uns jedoch einige wichtige Aspekte durchgehen:

  • Es wird angenommen, dass hier Vertrauen über Knoten (Client und Server) und KDC über denselben Bereich besteht
  • Das Passwort wird niemals über das Netzwerk ausgetauscht
  • Das Vertrauen zwischen Client und Server basiert auf der Tatsache, dass sie Nachrichten mit einem Schlüssel entschlüsseln können, der nur für das KDC freigegeben ist
  • Das Vertrauen zwischen Client und Server ist gegenseitig
  • Der Client kann Tickets für die wiederholte Verwendung bis zum Ablauf zwischenspeichern und so eine einmalige Anmeldung ermöglichen
  • Authenticator-Nachrichten basieren auf dem Zeitstempel und sind daher nur zur einmaligen Verwendung geeignet
  • Alle drei Parteien müssen hier eine relativ synchronisierte Zeit haben

Während dies nur die Oberfläche dieses schönen Authentifizierungsprotokolls zerkratzt, reicht es aus, um mit unserem Tutorial loszulegen.

3. SPNEGO verstehen

SPNEGO steht für Simple and Protected GSS-API Negotiation Mechanism. Ein ziemlicher Name! Lassen Sie uns zuerst sehen, wofür GSS-API steht. Die GSS-API (Generic Security Service Application Program Interface) ist nichts anderes als ein IETF-Standard für die sichere und herstellerunabhängige Kommunikation von Client und Server.

SPNEGO ist Teil der GSS-API für Client und Server, um die Wahl des Sicherheitsmechanismus auszuhandeln, der beispielsweise Kerberos oder NTLM verwendet.

4. Warum brauchen wir SPNEGO mit Kerberos?

Wie wir im vorherigen Abschnitt gesehen haben, ist Kerberos ein reines Netzwerkauthentifizierungsprotokoll, das hauptsächlich in der Transportschicht (TCP / UDP) ausgeführt wird. Dies ist zwar für viele Anwendungsfälle gut, entspricht jedoch nicht den Anforderungen für das moderne Web. Wenn wir eine Anwendung haben, die mit einer höheren Abstraktion arbeitet, wie z. B. HTTP, ist es nicht möglich, Kerberos direkt zu verwenden.

Hier hilft uns SPNEGO. Bei einer Webanwendung erfolgt die Kommunikation hauptsächlich zwischen einem Webbrowser wie Chrome und einem Webserver wie Tomcat, auf dem die Webanwendung über HTTP gehostet wird. Wenn aktiviert, können sie Kerberos als Sicherheitsmechanismus über SPNEGO aushandeln und Tickets als SPNEGO-Token über HTTP austauschen .

Wie ändert dies unser zuvor erwähntes Szenario? Ersetzen wir unseren einfachen Mail-Client durch einen Webbrowser und einen Mail-Server durch eine Webanwendung:

Daran hat sich im Vergleich zu unserem vorherigen Diagramm nicht viel geändert, außer dass die Kommunikation zwischen Client und Server jetzt explizit über HTTP erfolgt. Lassen Sie uns das besser verstehen:

  • Der Client-Computer authentifiziert sich beim KDC und speichert das TGT zwischen
  • Der Webbrowser auf dem Clientcomputer ist für die Verwendung von SPNEGO und Kerberos konfiguriert
  • Die Webanwendung ist auch so konfiguriert, dass sie SPNEGO und Kerberos unterstützt
  • Die Webanwendung stellt den Webbrowser vor die Herausforderung, auf eine geschützte Ressource zuzugreifen
  • Das Serviceticket wird als SPNEGO-Token verpackt und als HTTP-Header ausgetauscht

5. Anforderungen

Bevor wir mit der Entwicklung einer Webanwendung fortfahren können, die den Kerberos-Authentifizierungsmodus unterstützt, müssen wir einige grundlegende Einstellungen vornehmen. Lassen Sie uns diese Aufgaben schnell erledigen.

5.1. KDC einrichten

Das Einrichten einer Kerberos-Umgebung für die Verwendung in der Produktion geht über den Rahmen dieses Lernprogramms hinaus. Dies ist leider keine triviale Aufgabe und auch fragil. Es gibt verschiedene Optionen, um eine Implementierung von Kerberos zu erhalten, sowohl Open Source- als auch kommerzielle Versionen:

  • MIT stellt die Implementierung von Kerberos v5 für mehrere Betriebssysteme zur Verfügung
  • Apache Kerby ist eine Erweiterung von Apache Directory, die eine Java Kerberos-Bindung bereitstellt
  • Windows Server von Microsoft unterstützt Kerberos v5, das nativ von Active Directory unterstützt wird
  • Heimdel hat eine Implementierung von Kerberos v5

The actual set-up of KDC and related infrastructure is dependent on the provider and should be followed from their respective documentation. However, Apache Kerby can be run inside a Docker container, which makes it platform-neutral.

5.2. Setting up Users in KDC

We need to set up two users — or, as they call it, principals — in KDC. We can use the “kadmin” command-line tool for this purpose. Let's suppose we've created a realm called “baeldung.com” in the KDC database and logged in to “kadmin” with a user having admin privileges.

We'll create our first user, whom we wish to authenticate from a web browser, with:

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

We'll also need to register our web application with the KDC:

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

Note the convention for naming the principal here, as this must match the domain on which the application is accessible from the web browser. The web browser automatically tries to create a Service Principal Name (SPN) with this convention when presented with a “Negotiate” challenge.

We also need to export this as a keytab file to make it available to the web application:

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

This should give us a file named “baeldung.keytab”.

5.3. Browser Configuration

We need to enable the web browser that we use to access a protected resource on the web application for the “Negotiate” authentication scheme. Fortunately, most of the modern web browsers like Chrome support “Negotiate” as an authentication scheme by default.

Additionally, we can configure the browser to provide “Integrated Authentication”. In this mode, when presented with the “Negotiate” challenge, the browser tries to make use of the cached credentials in the host machine, which has already been logged into a KDC principal. However, we'll not use this mode in here to keep things explicit.

5.4. Domain Configuration

It is understandable that we may not have actual domains to test our web application. But sadly, we can't use localhost or 127.0.0.1 or any other IP address with Kerberos authentication. There is, however, an easy solution to this, which involves setting up entries in the “hosts” file like:

demo.kerberos.bealdung.com 127.0.0.1

6. Spring to Our Rescue!

Finally, as we've got the basics clear, it is time to test the theory. But, won't it be cumbersome to create a web application supporting SPNEGO and Kerberos? Not if we use Spring. Spring has a Kerberos Extension as part of Spring Security that supports SPNEGO with Kerberos seamlessly.

Almost all we have to do is just configurations in Spring Security to enable SPNEGO with Kerberos. We'll use Java-style configurations here, but an XML configuration can be set up as easily. We can extend the WebSecurityConfigurerAdapter class to configure all we need.

6.1. Maven Dependencies

The first thing we have to set up are the dependencies:

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

These dependencies are available for download from Maven Central.

6.2. SPNEGO Configurations

Firstly, SPNEGO is integrated into Spring Security as a Filter in HTTPSecurity:

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

This only shows the part required to configure SPNEGO Filter and is not a complete HTTPSecurity configuration, which should be configured as per application security requirements.

Next, we need to provide the SPNEGO Filter as Bean:

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

6.3. Kerberos Configurations

In addition, We can configure Kerberos by adding AuthenticationProvider to AuthenticationManagerBuilder in Spring Security:

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

The first thing we have to provide is a KerberosAuthenticationProvider as a Bean. This is an implementation of AuthenticationProvider, and this is where we set SunJaasKerberosClient as a KerberosClient:

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

Next, we also have to provide a KerberosServiceAuthenticationProvider as a Bean. This is the class that validates Kerberos Service Tickets or SPNEGO Tokens:

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

Lastly, we need to provide a SunJaasKerberosTicketValidator as a Bean. This is an implementation of KerberosTicketValidator and uses SUN JAAS Login Module:

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

6.4. User Details

We've seen references to a UserDetailsService in our AuthenticationProvider earlier, so why do we need it? Well, as we've come to know Kerberos, it is purely an authentication mechanism that is ticket-based.

So, while it's able to identify the user, it doesn't provide other details related to the user, like their authorizations. We need a valid UserDetailsService provided to our AuthenticationProvider to fill this gap.

6.5. Running the Application

This is pretty much what we need to set up a web application with Spring Security enabled for SPNEGO with Kerberos. When we boot up the web application and access any page therein, the web browser should prompt for username and password, prepare a SPNEGO token with Service Ticket, and send it to the application.

The application should be able to process it using the credentials in the keytab file and respond with successful authentication.

However, as we saw earlier, setting up a working Kerberos environment is complicated and quite brittle. If things don't work as expected, it's worthwhile to check all the steps again. A simple mistake like mismatch in the domain name can lead to failure with error messages that aren't particularly helpful.

7. Practical Use of SPNEGO and Kerberos

Now that we've seen how Kerberos authentication works and how we can use SPNEGO with Kerberos in web applications, we may question the need for it. While this makes complete sense to use it as an SSO mechanism within an enterprise network, why should we use this in web applications?

Well, for one, even after so many years, Kerberos is still very actively used within enterprise applications, especially Windows-based applications. If an organization has several internal and external web applications, it does make sense to extend the same SSO infrastructure to cover them all. This makes it much easier for administrators and users of an organization to have a seamless experience through disparate applications.

8. Conclusion

Zusammenfassend haben wir in diesem Tutorial die Grundlagen des Kerberos-Authentifizierungsprotokolls verstanden. Wir haben auch SPNEGO als Teil der GSS-API besprochen und wie wir es verwenden können, um die Kerberos-basierte Authentifizierung in einer Webanwendung über HTTP zu erleichtern. Darüber hinaus haben wir versucht, eine kleine Webanwendung zu erstellen, die die integrierte Unterstützung von Spring Security für SPNEGO mit Kerberos nutzt.

Dieses Tutorial bietet nur einen kurzen Einblick in einen leistungsstarken und bewährten Authentifizierungsmechanismus. Wir haben eine Fülle von Informationen zur Verfügung, um mehr zu lernen und möglicherweise noch mehr zu schätzen!

Wie immer ist der Code auf GitHub zu finden.