streamalism.org

1. Oversikt

I denne veiledningen vil vi diskutere hvordan du implementerer SSO - Single Sign On - ved hjelp av Spring Security OAuth og Spring Boot.

Vi bruker tre separate applikasjoner:

• En autorisasjonsserver - som er den sentrale autentiseringsmekanismen
• To klientapplikasjoner: applikasjonene som bruker SSO

Svært enkelt sagt, når en bruker prøver å få tilgang til en sikret side i klientappen, blir de omdirigert for å autentisere først via autentiseringsserveren.

Og vi skal bruke Godkjennelseskoden gi typen ut av OAuth2 for å drive delegeringen av autentisering.

Merk: denne artikkelen bruker Spring OAuth arvprosjekt. For versjonen av denne artikkelen som bruker den nye Spring Security 5-stakken, kan du ta en titt på artikkelen vår Simple Single Sign-On with Spring Security OAuth2.

2. Klientappen

La oss starte med vår klientapplikasjon; Vi bruker selvfølgelig Spring Boot for å minimere konfigurasjonen:

2.1. Maven avhengigheter

Først trenger vi følgende avhengigheter i vår pom.xml:

 org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter-security org.springframework.security.oauth.boot spring-security-oauth2-autoconfigure 2.0.1.RELEASE org.springframework.boot spring-boot-starter-thymeleaf org.thymeleaf.extras thymeleaf-extras-springsecurity4 

2.2. Sikkerhetskonfigurasjon

Neste, den viktigste delen, sikkerhetskonfigurasjonen av klientapplikasjonen vår:

@Configuration @ EnableOAuth2Sso offentlig klasse UiSecurityConfig utvider WebSecurityConfigurerAdapter {@Override public void configure (HttpSecurity http) kaster Unntak {http.antMatcher ("/ **") .authorizeRequests () .antMatchers ("/", "/ login **" .permitAll () .anyRequest () .authenticated (); }}

Kjernen i denne konfigurasjonen er selvfølgelig @ EnableOAuth2Sso kommentar vi bruker for å aktivere Single Sign On.

Merk at vi må utvide WebSecurityConfigurerAdapter - uten den vil alle banene være sikret - slik at brukerne blir omdirigert for å logge på når de prøver å få tilgang til en hvilken som helst side. I vårt tilfelle her er indeks- og påloggingssidene de eneste sidene som er tilgjengelige uten autentisering.

Til slutt definerte vi også en RequestContextListener bønne for å håndtere forespørsler.

Og application.yml:

server: port: 8082 servlet: context-path: / ui session: cookie: name: UISESSION security: basic: enabled: false oauth2: client: clientId: SampleClientId clientSecret: secret accessTokenUri: // localhost: 8081 / auth / oauth / token userAuthorizationUri: // localhost: 8081 / auth / oauth / authorize resource: userInfoUri: // localhost: 8081 / auth / user / me spring: thymeleaf: cache: false

Noen raske notater:

• vi deaktiverte standard grunnleggende godkjenning
• accessTokenUri er URI for å skaffe Access Tokens
• userAuthorizationUri er autorisasjons-URI som brukere vil bli omdirigert til
• userInfoUri URI for brukerens endepunkt for å innhente gjeldende brukerdetaljer

Legg også merke til at vi i vårt eksempel her rullet ut autorisasjonsserveren vår, men selvfølgelig kan vi også bruke andre tredjepartsleverandører som Facebook eller GitHub.

2.3. Front End

La oss ta en titt på front-end-konfigurasjonen av klientapplikasjonen vår. Vi kommer ikke til å fokusere på det her, hovedsakelig fordi vi allerede dekket inn på nettstedet.

Vår klientapplikasjon her har en veldig enkel front-end; her er index.html:

 Logg Inn

Og securePage.html:

 Velkommen, Navn

De securePage.html siden trengte brukerne å bli godkjent. Hvis en ikke-godkjent bruker prøver å få tilgang securePage.html, blir de omdirigert til påloggingssiden først.

3. Auth-serveren

La oss nå diskutere autorisasjonsserveren vår her.

3.1. Maven avhengigheter

Først må vi definere avhengighetene i vår pom.xml:

 org.springframework.boot spring-boot-starter-web org.springframework.security.oauth spring-security-oauth2 2.3.3.RELEASE 

3.2. OAuth-konfigurasjon

Det er viktig å forstå at vi skal kjøre autorisasjonsserveren og ressursserveren sammen her, som en enkelt distribuerbar enhet.

La oss starte med konfigurasjonen av ressursserveren vår - som også fungerer som vår primære oppstartsapplikasjon:

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

Deretter konfigurerer vi autorisasjonsserveren vår:

@Configuration @EnableAuthorizationServer offentlig klasse AuthServerConfig utvider AuthorizationServerConfigurerAdapter {@Autowired private BCryptPasswordEncoder passwordEncoder; @Override public void configure (AuthorizationServerSecurityConfigurer oauthServer) kaster unntak {oauthServer.tokenKeyAccess ("permitAll ()") .checkTokenAccess ("isAuthenticated ()"); } @ Override public void configure (ClientDetailsServiceConfigurer clients) kaster unntak {clients.inMemory () .withClient ("SampleClientId") .secret (passwordEncoder.encode ("secret")) .authorizedGrantTypes ("autorisasjonskode") .scopes ("user_info" ) .autoApprove (true) .redirectUris ("// localhost: 8082 / ui / login", "// localhost: 8083 / ui2 / login"); }}

Legg merke til hvordan vi bare aktiverer en enkel klient som bruker Godkjennelseskoden tilskuddstype.

Legg også merke til hvordan godkjenne automatisk er satt til sant slik at vi ikke blir omdirigert og promotert for å manuelt godkjenne noen omfang.

3.3. Sikkerhetskonfigurasjon

Først deaktiverer vi standard grunnleggende godkjenning via vår application.properties:

server.port = 8081 server.servlet.context-path = / auth

La oss nå gå til konfigurasjonen og definere en enkel påloggingsmekanisme:

@Configuration @Order (1) offentlig klasse SecurityConfig utvider WebSecurityConfigurerAdapter {@Override-beskyttet ugyldig konfigurasjon (HttpSecurity http) kaster Unntak {http.requestMatchers () .antMatchers ("/ login", "/ oauth / authorize") .and (). authorizeRequests () .anyRequest (). autentisert () .and () .formLogin (). permitAll (); } @ Override beskyttet tom konfigurering (AuthenticationManagerBuilder auth) kaster Unntak {auth.inMemoryAuthentication () .withUser ("john") .passord (passwordEncoder (). Koding ("123")) .roles ("USER"); } @Bean public BCryptPasswordEncoder passwordEncoder () {return new BCryptPasswordEncoder (); }}

Merk at vi brukte enkel autentisering i minnet, men vi kan ganske enkelt erstatte den med en egendefinert userDetailsService.

3.4. Brukerens sluttpunkt

Til slutt vil vi lage vårt brukerendepunkt vi brukte tidligere i vår konfigurasjon:

@RestController offentlig klasse UserController {@GetMapping ("/ bruker / meg") offentlig Hovedbruker (rektor) {retur rektor; }}

Naturligvis vil dette returnere brukerdataene med en JSON-representasjon.

4. Konklusjon

I denne raske opplæringen fokuserte vi på å implementere Single Sign-On ved hjelp av Spring Security Oauth2 og Spring Boot.

Som alltid kan hele kildekoden finnes på GitHub.