Pengenalan Pengesahan SPNEGO / Kerberos pada Musim Bunga

1. Gambaran keseluruhan

Dalam tutorial ini, kita akan memahami asas-asas protokol pengesahan Kerberos. Kami juga akan melindungi keperluan SPNEGO berkaitan dengan Kerberos.

Akhirnya, kita akan melihat bagaimana memanfaatkan pelanjutan Spring Security Kerberos untuk membuat aplikasi yang diaktifkan untuk Kerberos dengan SPNEGO.

Sebelum kita meneruskan, perlu diperhatikan bahawa tutorial ini akan memperkenalkan banyak istilah baru bagi mereka yang belum berpengalaman di kawasan ini. Oleh itu, kami akan meluangkan masa di muka untuk membuat liputan.

2. Memahami Kerberos

Kerberos adalah Protokol Pengesahan Rangkaian yang dikembangkan di Massachusetts Institute of Technology (MIT) pada awal tahun lapan puluhan. Seperti yang anda ketahui, ini agak lama dan bertahan dalam ujian masa. Pelayan Windows banyak menyokong Kerberos sebagai mekanisme pengesahan dan bahkan menjadikannya pilihan pengesahan lalai.

Secara teknikalnya, Kerberos adalah protokol pengesahan berdasarkan tiket yang membolehkan nod dalam rangkaian komputer saling mengenali antara satu sama lain.

2.1. Kes Penggunaan Mudah untuk Kerberos

Mari kita buat situasi hipotesis untuk menunjukkan ini.

Katakan bahawa pengguna, melalui pelanggan melnya di mesinnya, perlu menarik e-melnya dari pelayan e-mel pada mesin lain di rangkaian yang sama. Terdapat keperluan yang jelas untuk pengesahan di sini. Pelanggan mel dan pelayan mel mesti dapat mengenal pasti dan mempercayai antara satu sama lain agar mereka dapat berkomunikasi dengan selamat.

Bagaimana Kerberos dapat menolong kita di sini? Kerberos memperkenalkan pihak ketiga yang disebut Key Distribution Center (KDC) , yang mempunyai kepercayaan bersama dengan setiap simpul dalam rangkaian. Mari kita lihat bagaimana ini dapat berfungsi dalam kes kita:

2.2. Aspek Utama Protokol Kerberos

Walaupun ini mungkin terdengar esoteris, ini cukup mudah dan kreatif dalam menjamin komunikasi melalui rangkaian yang tidak terjamin. Sebilangan masalah yang dikemukakan di sini cukup dianggap biasa di era TLS di mana sahaja!

Walaupun perbincangan terperinci mengenai Protokol Kerberos tidak mungkin dilakukan di sini, mari kita teliti beberapa aspek penting:

  • Kepercayaan antara node (pelanggan dan pelayan) dan KDC dianggap wujud di sini dalam bidang yang sama
  • Kata laluan tidak pernah ditukar melalui rangkaian
  • Kepercayaan antara pelanggan dan pelayan tersirat berdasarkan fakta bahawa mereka dapat menyahsulitkan mesej dengan kunci yang dikongsi hanya dengan KDC
  • Kepercayaan antara pelanggan dan pelayan adalah saling
  • Pelanggan dapat menyimpan cache tiket untuk penggunaan berulang hingga habis masa berlakunya, memberikan satu pengalaman masuk
  • Mesej Authenticator didasarkan pada cap waktu dan dengan itu hanya baik untuk satu kali penggunaan
  • Ketiga-tiga pihak di sini mesti mempunyai masa yang agak segerak

Walaupun ini hanya menggaru permukaan protokol pengesahan yang indah ini, itu cukup untuk membuat kita mengikuti tutorial kita.

3. Memahami SPNEGO

SPNEGO bermaksud Mekanisme Rundingan API GSS-Simple dan Dilindungi. Cukup nama! Mari kita lihat dahulu apa singkatan GSS-API. Antaramuka Program Aplikasi Perkhidmatan Keselamatan Generik (GSS-API) tidak lain adalah standard IETF untuk pelanggan dan pelayan berkomunikasi secara selamat dan vendor-agnostik.

SPNEGO adalah bahagian dari GSS-API untuk klien dan pelayan untuk merundingkan pilihan mekanisme keselamatan yang akan digunakan, misalnya, Kerberos atau NTLM.

4. Mengapa Kita Perlu SPNEGO Dengan Kerberos?

Seperti yang kita lihat di bahagian sebelumnya, Kerberos adalah Protokol Pengesahan Rangkaian murni yang beroperasi terutamanya di lapisan pengangkutan (TCP / UDP). Walaupun ini bagus untuk banyak kes penggunaan, ini tidak memenuhi syarat untuk web moden. Sekiranya kita mempunyai aplikasi yang beroperasi pada abstraksi yang lebih tinggi, seperti HTTP, tidak mungkin menggunakan Kerberos secara langsung.

Di sinilah SPNEGO membantu kami. Dalam kes aplikasi web, komunikasi terutama berlaku antara penyemak imbas web seperti Chrome dan pelayan web seperti Tomcat yang menghosting aplikasi web melalui HTTP. Sekiranya diaktifkan, mereka dapat merundingkan Kerberos sebagai mekanisme keselamatan melalui SPNEGO dan menukar tiket sebagai token SPNEGO melalui HTTP .

Jadi bagaimana ini mengubah senario kita yang disebutkan sebelumnya? Mari ganti pelanggan mel mudah kami dengan penyemak imbas web dan pelayan mel dengan aplikasi web:

Oleh itu, tidak banyak yang berubah berbanding dengan gambarajah sebelumnya kecuali komunikasi antara pelanggan dan pelayan berlaku secara eksplisit melalui HTTP sekarang. Mari kita fahami ini dengan lebih baik:

  • Mesin pelanggan mengesahkan KDC dan menyimpan TGT
  • Penyemak imbas web pada mesin pelanggan dikonfigurasi untuk menggunakan SPNEGO dan Kerberos
  • Aplikasi web juga dikonfigurasi untuk menyokong SPNEGO dan Kerberos
  • Aplikasi web melemparkan cabaran "Rundingan" kepada penyemak imbas web yang cuba mengakses sumber yang dilindungi
  • Tiket Perkhidmatan dibungkus sebagai token SPNEGO dan ditukar sebagai header HTTP

5. Keperluan

Sebelum kita dapat mengembangkan aplikasi web yang menyokong mod pengesahan Kerberos, kita mesti mengumpulkan beberapa persediaan asas. Mari kita laksanakan tugas-tugas ini dengan cepat.

5.1. Menubuhkan KDC

Menyiapkan persekitaran Kerberos untuk penggunaan pengeluaran adalah di luar skop tutorial ini. Sayangnya ini bukan tugas yang remeh dan rapuh juga. Terdapat beberapa pilihan yang tersedia untuk mendapatkan pelaksanaan Kerberos, baik versi sumber terbuka dan komersial:

  • MIT menjadikan pelaksanaan Kerberos v5 tersedia untuk pelbagai sistem operasi
  • Apache Kerby adalah lanjutan untuk Direktori Apache, yang menyediakan pengikatan Java Kerberos
  • Pelayan Windows dari Microsoft menyokong Kerberos v5 yang disokong secara asli oleh Active Directory
  • Heimdel mempunyai pelaksanaan 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

Kesimpulannya, dalam tutorial ini, kami memahami asas-asas protokol pengesahan Kerberos. Kami juga membincangkan SPNEGO sebagai bagian dari GSS-API dan bagaimana kami dapat menggunakannya untuk memudahkan pengesahan berasaskan Kerberos dalam aplikasi web melalui HTTP. Selanjutnya, kami cuba membina aplikasi web kecil yang memanfaatkan sokongan dalaman Spring Security untuk SPNEGO dengan Kerberos.

Tutorial ini hanya memberikan sekilas cepat mengenai mekanisme pengesahan yang kuat dan diuji masa. Terdapat banyak maklumat yang tersedia untuk kita belajar lebih banyak dan mungkin lebih menghargai!

Seperti biasa, kodnya boleh didapati di GitHub.