streamalism.org

Sikkerhedstop

Jeg annoncerede netop det nye Learn Spring Security-kursus, inklusive det fulde materiale med fokus på den nye OAuth2-stak i Spring Security 5:

>> KONTROLLER KURSEN

1. Oversigt

I denne vejledning giver vi en oversigt over Spring Security Kerberos.

Vi skriver en Kerberos-klient i Java, der autoriserer sig selv til at få adgang til vores Kerberized-tjeneste. Og vi kører vores eget indlejrede nøgledistributionscenter for at udføre fuld Kerberos-godkendelse fra ende til ende. Alt det uden nogen ekstern infrastruktur krævet takket være Spring Security Kerberos.

2. Kerberos og dets fordele

Kerberos er en netværksgodkendelsesprotokol, som MIT oprettede i 1980'erne, specielt nyttig til centralisering af godkendelse på et netværk.

I 1987 udgav MIT det til Open Source-samfundet, og det er stadig under aktiv udvikling. I 2005 blev den kanoniseret som en IETF-standard underRFC 4120.

Normalt er Kerberos det bruges i virksomhedsmiljøer. Derinde beskytter det miljøet på en sådan måde, at bruger behøver ikke at godkende hver tjeneste separat. Denne arkitektoniske løsning er kendt somEnkelt login.

Kort sagt, Kerberos er et billetsystem. En bruger godkender en gang og modtager en Ticket-tildelende Ticket (TGT). Derefter udveksler netværksinfrastrukturen den TGT med servicebilletter. Disse servicebilletter giver brugeren mulighed for at interagere med infrastrukturtjenester, så længe TGT er gyldig, hvilket normalt er i et par timer.

Så det er dejligt, at brugeren kun logger på én gang. Men der er også en sikkerhedsfordel: I et sådant miljø er det brugerens adgangskode sendes aldrig over netværket. I stedet bruger Kerberos det som en faktor til at generere en anden hemmelig nøgle, der bliver brugt til beskedkryptering og dekryptering.

En anden fordel er det vi kan administrere brugere fra et centralt sted, sig en der er bakket op af LDAP. Derfor, hvis vi deaktiverer en konto i vores centraliserede database for en given bruger, tilbagekalder vi hans adgang i vores infrastruktur. Således behøver administratorerne ikke at tilbagekalde adgangen separat i hver tjeneste.

Introduktion til SPNEGO / Kerberos Authentication in Spring giver et dybtgående overblik over teknologien.

3. Kerberiseret miljø

Så lad os skabe et miljø til autentificering med Kerberos-protokollen. Miljøet vil bestå af tre separate applikationer, der kører samtidigt.

Først, vi har et nøgledistributionscenter der fungerer som godkendelsespunkt. Dernæst skriver vi en klient og et serviceapplikation, som vi konfigurerer til at bruge Kerberos-protokollen.

Nu kræver kørsel af Kerberos lidt installation og konfiguration. Vi vil dog udnytte Spring Security Kerberos, så vi kører Key Distribution Center programmatisk i integreret tilstand. Også den MiniKdc vist nedenfor er nyttigt i tilfælde af integrationstest med Kerberized-infrastruktur.

3.1. Kørsel af et nøgledistributionscenter

Først lancerer vi vores Key Distribution Center, der udsteder TGT'erne til os:

Streng [] config = MiniKdcConfigBuilder.builder () .workDir (prepareWorkDir ()) .principals ("client / localhost", "HTTP / localhost") .confDir ("minikdc-krb5.conf") .keytabName ("eksempel.keytab ") .build (); MiniKdc.main (config);

Dybest set har vi givet MiniKdc et sæt principals og en konfigurationsfil; derudover har vi fortalt MiniKdc hvad man skal kalde tastaturfane det genererer.

MiniKdc vil generere en krb5.conf fil, som vi leverer til vores klient- og serviceapplikationer. Denne fil indeholder de oplysninger, hvor vores KDC kan findes - værten og porten for et givet område.

MiniKdc.hoved starter KDC og skal sende noget som:

Standalone MiniKdc kører ----------------------------------------------- ---- Realm: EXAMPLE.COM Kører på: localhost: localhost krb5conf:. \ Spring-sikkerhed-sso \ spring-sikkerhed-sso-kerberos \ krb-test-workdir \ krb5.conf oprettet tastatur:. \ Spring-sikkerhed -sso \ spring-security-sso-kerberos \ krb-test-workdir \ example.keytab med principals: [client / localhost, HTTP / localhost]

3.2. Klientapplikation

Vores klient vil være en Spring Boot-applikation, der bruger en RestTemplate at foretage opkald til eksterne en REST API.

Men det skal vi brug KerberosRestTemplate i stedet. Det skal bruge tastaturfanen og klientens hoved:

@Configuration public class KerberosConfig {@Value ("$ {app.user-principal: client / localhost}") privat strengprincip; @Value ("$ {app.keytab-location}") privat streng keytabLocation; @Bean public RestTemplate restTemplate () {returner ny KerberosRestTemplate (keytabLocation, principal); }}

Og det er det! KerberosRestTemplate forhandler klientsiden af ​​Kerberos-protokollen for os.

Så lad os oprette en hurtig klasse, der spørger nogle data fra en Kerberized-tjeneste, hostet ved slutpunktet app.access-url:

@Service klasse SampleClient {@Value ("$ {app.access-url}") privat streng slutpunkt; private RestTemplate restTemplate; // constructor, getter, setter String getData () {return restTemplate.getForObject (endpoint, String.class); }}

Så lad os oprette vores serviceapplikation nu, så denne klasse har noget at ringe til!

3.3. Serviceapplikation

Vi bruger Spring Security og konfigurerer det med de relevante Kerberos-specifikke bønner.

Bemærk også, at tjenesten vil have sin hoved og også bruge tastaturfanen:

@Configuration @EnableWebSecurity offentlig klasse WebSecurityConfig udvider WebSecurityConfigurerAdapter {@Value ("$ {app.service-principal: HTTP / localhost}") privat streng servicePrincipal; @Value ("$ {app.keytab-location}") privat streng keytabLocation; @ Override beskyttet ugyldig konfiguration (HttpSecurity http) kaster undtagelse {http .authorizeRequests () .antMatchers ("/", "/ home"). PermitAll () .anyRequest (). Godkendt (). Og () .exceptionHandling (). authenticationEntryPoint (spnegoEntryPoint ()). og () .formLogin () .loginPage ("/ login"). permitAll () .and () .logout (). permitAll () .and () .addFilterBefore (spnegoAuthenticationProcessingFilter (authenticationManagerBean) ), BasicAuthenticationFilter.class); } @ Override beskyttet ugyldig konfiguration (AuthenticationManagerBuilder auth) kaster Undtagelse {auth .authenticationProvider (kerberosAuthenticationProvider ()) .authenticationProvider (kerberosServiceAuthenticationProvider ()); } @Bean public KerberosAuthenticationProvider kerberosAuthenticationProvider () {KerberosAuthenticationProvider provider = new KerberosAuthenticationProvider (); // leverandørkonfigurationsreturudbyder; } @Bean public SpnegoEntryPoint spnegoEntryPoint () {returner nye SpnegoEntryPoint ("/ login"); } @Bean public SpnegoAuthenticationProcessingFilter spnegoAuthenticationProcessingFilter (AuthenticationManager authenticationManager) {SpnegoAuthenticationProcessingFilter filter = new SpnegoAuthenticationProcessingFilter (); // returfilter til filterkonfiguration; } @Bean public KerberosServiceAuthenticationProvider kerberosServiceAuthenticationProvider () {KerberosServiceAuthenticationProvider provider = new KerberosServiceAuthenticationProvider (); // udbyder af auth-udbyderkonfiguration } @Bean offentlig SunJaasKerberosTicketValidator sunJaasKerberosTicketValidator () {SunJaasKerberosTicketValidator ticketValidator = ny SunJaasKerberosTicketValidator (); // validatorkonfiguration returbilletValidator; }}

Bemærk, at vi har konfigureret Spring Security til SPNEGO-godkendelse. På denne måde vil vi være i stand til at autentificere via HTTP-protokollen, selvom vi også kan opnå SPNEGO-godkendelse med core Java.

4. Testning

Nu kører vi en integrationstest for at vise det vores klient henter data med succes fra en ekstern server via Kerberos-protokollen. For at køre denne test skal vi have vores infrastruktur kørende, så MiniKdc og vores serviceapplikation skal begge startes.

Dybest set bruger vi vores SampleClient fra klientapplikationen for at anmode om vores serviceapplikation. Lad os teste det:

@Autowired privat SampleClient sampleClient; @Test offentlig ugyldighed givenKerberizedRestTemplate_whenServiceCall_thenSuccess () {assertEquals ("data fra kerberiseret server", sampleClient.getData ()); }

Bemærk, at vi også kan bevise, at KerberizedRestTemplate er vigtigt ved at ramme tjenesten uden den:

@ Test offentlig ugyldighed givenRestTemplate_whenServiceCall_thenFail () {sampleClient.setRestTemplate (ny RestTemplate ()); assertThrows (RestClientException.class, sampleClient :: getData); }

Som en sidebemærkning er der en chance vores anden test kunne genbruge den billet, der allerede er gemt i legitimationscachen. Dette ville ske på grund af den automatiske SPNEGO-forhandling, der blev brugt i HttpUrlConnection.

Som resultat, dataene kan faktisk returnere og ugyldiggør vores test. Afhængigt af vores behov kan vi derefter deaktivere brug af billetcache via systemegenskaben http.use.global.creds = falsk.

5. Konklusion

I denne vejledning vi udforskede Kerberos til centraliseret brugeradministration og hvordan Spring Security understøtter Kerberos-protokollen og SPNEGO-godkendelsesmekanismen.

Vi brugte MiniKdc at stå op for en integreret KDC og også skabe en meget enkel Kerberized klient og server. Denne opsætning var praktisk til udforskning og især praktisk, da vi oprettede en integrationstest for at teste tingene ud.

Nu har vi lige ridset overfladen. For at dykke dybere skal du tjekke Kerberos wiki-siden eller dens RFC. Den officielle dokumentationsside vil også være nyttig. Bortset fra det, for at se, hvordan tingene kunne gøres i core java, viser følgende Oracle's tutorial det i detaljer.

Som normalt kan koden findes på vores GitHub-side.

Sikkerhedsbund

Jeg annoncerede netop det nye Learn Spring Security-kursus, inklusive det fulde materiale med fokus på den nye OAuth2-stak i Spring Security 5:

>> KONTROLLER KURSEN