Java >> Java tutorial >  >> Tag >> Spring

Eksempel på Spring Boot Application Authentication med AWS Cognito

Spring

I dette indlæg planlægger jeg at vise et eksempel på Spring Boot Application-godkendelse med AWS Cognito. Jeg vil vise to flows –

  1. OIDC-godkendelse
  2. SAML-godkendelse

AWS Cognito

AWS Cognito er en webservice fra AWS. Cognito er en brugermappe såvel som en godkendelsesmekanismetjeneste. I virksomhedsindustrien har hver applikation to krav fra et brugerperspektiv.

  1. Brugerkatalog og synkronisering
  2. Brugergodkendelse

Cognito gør dette lettere ved at tillade oprettelsen af ​​en brugerpulje eller en identitetspulje. Når du har en pulje, kan du konfigurere en applikation med de forskellige indstillinger for godkendelse. En anden stor fordel ved Cognito er, at det tilbyder branchestandard sikkerhedsgodkendelsesprotokoller som OAuth 2.0, OpenID Connect, SAML.

Der er lige så andre funktioner som brugeradgangshåndtering, men vi vil ikke gå i detaljer om det som en del af dette indlæg. I dette indlæg vil jeg yderligere vise, hvordan vi kan oprette en brugerpulje og konfigurere en applikation til at bruge den brugerpulje.

Spring Boot Application

Vi vil bruge en simpel Spring Boot Application. Vi vil integrere denne applikation med AWS Cognito til godkendelse.

Opsætning af forårsstart

Tilføj følgende afhængigheder i Gradle-filen


	implementation 'org.springframework.boot:spring-boot-starter-security'
	implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
	implementation 'org.springframework.boot:spring-boot-starter-web'
	implementation 'org.springframework.security:spring-security-oauth2-client'
	implementation 'org.springframework.security:spring-security-oauth2-jose'

Og application.properties skal bruge oauth2-konfigurationsegenskaber:


# ====================================================================================
## SSL Keystore for HTTPS
# ====================================================================================
#security.require-ssl=true
server.port=8743
server.ssl.key-store-password=******
server.ssl.key-store=classpath:sssstore.p12
server.ssl.key-store-type=PKCS12
server.ssl.key-alias=selfsigned_localhost
# =====================================================================================
spring.security.oauth2.client.registration.cognito.clientId=7mtivo8jobdtd6dvocldkmu6qk
spring.security.oauth2.client.registration.cognito.clientSecret=*********
spring.security.oauth2.client.registration.cognito.scope=openid
spring.security.oauth2.client.registration.cognito.redirect-uri=https://localhost:8743/login/oauth2/code/cognito
spring.security.oauth2.client.registration.cognito.clientName=SpringBootCognitoDemo
spring.security.oauth2.client.registration.cognito.authorization-grant-type=authorization_code
spring.security.oauth2.client.provider.cognito.issueUri=https://cognito-idp.{awszone}.amazonaws.com/{userPoolId}
spring.security.oauth2.client.provider.cognito.authorization-uri=https://{customDomain}.auth.{awszone}.amazoncognito.com/oauth2/authorize
spring.security.oauth2.client.provider.cognito.token-uri=https://{customDomain}.auth.{awszone}.amazoncognito.com/oauth2/token
spring.security.oauth2.client.provider.cognito.jwk-set-uri=https://cognito-idp.{awszone}.amazonaws.com/{userPoolId}/.well-known/jwks.json
spring.security.oauth2.client.provider.cognito.user-name-attribute= cognito:username

Sikkerhedskonfiguration

Vores Main Controller-klasse vil se ud som nedenfor:



@Controller
public class MainController
{
    @GetMapping("/")
    public String home(Model model, Principal principal)
    {
        model.addAttribute("username", principal.getName());
        return "index";
    }
}

Så når vi får adgang til vores applikation, vil den omdirigere til AWS Cognito UI for godkendelse. Baseret på det valgte flow OIDC eller SAML, vil godkendelsen ske.

SecurityConfig vil være som nedenfor:


@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter
{
    @Autowired
    public CustomLogoutSuccessHandler customLogoutSuccessHandler;

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception
    {
        httpSecurity.csrf()
                .and()
                .authorizeRequests()
                .anyRequest()
                .authenticated()
                .and()
                .oauth2Login()
                .and()
                .logout()
                .logoutUrl("/logout")
                .logoutSuccessHandler(customLogoutSuccessHandler)
                ;

    }
}

Vores enkle indeksskabelon vil se ud som nedenfor:


<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <meta content="width=device-width, initial-scale=1" name="viewport">
    <title>Cognito Demo</title>
</head>
<body>
<div class="container">
    <h1 class="title">OAuth 2.0 Spring Security Cognito Demo</h1>
    <div>
        <div class="box">
            Hello, <strong th:text="${username}"></strong>!
        </div>
        <a th:href="@{/logout}" class="btn btn-primary">Logout</a>
    </div>
</div>
</body>
</html>

Opret en brugergruppe

Når du logger ind på AWS-konsollen, skal du vælge Cognito som AWS-tjeneste. Den første skærm viser dig to muligheder – Opret en brugerpulje og Opret en identitetspulje.

Vi vælger Opret en brugerpulje.

Indtast et passende navn til din brugerpulje, og vælg Gå gennem indstillinger. Dette vil give os mulighed for at ændre alle indstillinger, som vi ikke ønsker at bruge til vores use case.

Vælg nu brugerpuljeattributter for brugere. Disse attributter giver os mulighed for at identificere brugeren, og hvad en bruger kan indtaste under godkendelse.

Til vores demo har vi valgt e-mailadresse, efternavn og fornavn som attributter. Så brugeren vil logge ind på applikationen ved hjælp af en e-mailadresse.

For adgangskodepolitik har vi indstillet, at adgangskoden skal være af minimumlængde 8, skal være alfanumerisk med store og små bogstaver.

De fleste af de andre indstillinger vil vi vælge som standard. For App Clients Step vælger vi brugernavn og adgangskodebaseret godkendelse til Auth Flow.

Konfiguration af applikationsklient

Når vi har oprettet en brugerpulje, fortsætter vi med at træde gennem det næste sæt konfigurationer, og det inkluderer applikationsklienten. I denne konfiguration konfigurerer vi vores applikation, der vil bruge brugerpuljen.

Vi er nødt til at aktivere identitetsudbyder og Cognito User Pool.

Konfiguration af Federation Identity Provider

Som tidligere nævnt vil vi også konfigurere en SAML-identitetsudbyder til godkendelse. I dette tilfælde vil flowet være applikation -> AWS Cognito -> SAML Identity Provider.

Konfigurer applikation i Okta

Til denne demo vil vi bruge Okta som SAML Identity Provider. Log ind på Okta administratorkonsol, konfigurer en ny applikation til SAML-integration som nedenfor:

På næste trin skal du angive Single Sign On URL, og denne vil være https://{yourcustomdomainfromcognito}.auth.{awszone}.amazoncognito.com . Vi skal også levere Audience URI (SP Entity ID). I dette tilfælde vil Cognito fungere som tjenesteudbyder for Okta.

Vi skal også konfigurere Attribute Statements som vist ovenfor. Det er de attributter, vi har konfigureret i vores Cognito-brugerattributter – email, given_name, family_name.

Grundlæggende skal du sørge for, at den bruger, du planlægger at bruge, er i Okta Users Directory. Det vil være den samme bruger, som vi enten skal konfigureres i Cognito User Pool eller oprettes ved tilmelding.

Konfigurer Federated Identity Provider i Cognito

  • Vælg Federated Identity Provider i vores brugerpuljekonfiguration.
  • Vælg muligheden for SAML, og Cognito vil vise dig at uploade en metadatafil eller metadata-URL for identitetsudbyder. I vores tilfælde vil det være https://dev-19753289.okta.com/app/exkmt322q1Kl15Rsk5d6/sso/saml/metadata .
  • Skriv et navn for Federated Identity Provider, og gem ændringerne.

Derfor, hvis vi går tilbage til App Client Settings, bør vi se en mulighed for at vælge Federated Identity Provider. Med den nye konfiguration vil vores indstillinger se ud som nedenfor:

Under alle omstændigheder skal du sørge for, at brugerattributterne (given_name, family_name og email) i Cognito er redigerbare.

Vi har dog afsluttet vores konfiguration. Nu kan vi vise demoen.

Demo af Spring Boot Application Authentication med AWS Cognito

Hvis jeg nu kører min applikation og får adgang til den på https://localhost:8743/ , vil jeg se følgende skærmbillede for at vælge en identitetsudbyder at autentificere med:

Ikke desto mindre kan vi bruge Okta eller Cognito User Pool til at logge ind.

SAML Flow

  1. Brugeren får adgang til den applikation, der sender OAuth-anmodning om autorisationskodeflow til Cognito
  2. Cognito sender SAML-anmodning til Okta.
  3. Brugeren indtaster legitimationsoplysninger på okta-loginskærmen.
  4. Okta sender SAML-svaret tilbage til Cognito ved slutpunkt https://{customdomain}.auth.{awszone}.amazoncognito.com/saml2/idpresponse
  5. Cognito behandler saml-svaret og genererer godkendelseskode og svar tilbage til applikationen.
  6. Applikationen bruger godkendelseskode til at hente token fra Cognito og autentificerer brugeren ved bekræftelse af token.

Frem for alt, efter vellykket godkendelse, vil brugeren se

I stedet for Okta havde vi valgt Cognito login på den samme Home Realm Discovery-skærm, vi vil se følgende efter vellykket godkendelse:

Konklusion

I dette indlæg viste jeg, hvordan vi kan bruge AWS Cognito til godkendelse med Spring Boot-applikationen. Desuden hjælper Cognito med at konfigurere brugere samt at fjerne standardkode for sikkerhedsflows.

Afslutningsvis, hvis du ikke har købt min e-bog Simplifying Spring Security, er den tilgængelig her.


Java tag