Java >> Java Tutorial >  >> Tag >> Spring

Beispiel für die Spring Boot-Anwendungsauthentifizierung mit AWS Cognito

Spring

In diesem Beitrag möchte ich ein Beispiel für die Authentifizierung von Spring Boot-Anwendungen mit AWS Cognito zeigen. Ich werde zwei Flüsse zeigen –

  1. OIDC-Authentifizierung
  2. SAML-Authentifizierung

AWS Cognito

AWS Cognito ist ein Webservice von AWS. Cognito ist sowohl ein Benutzerverzeichnis als auch ein Dienst für Authentifizierungsmechanismen. In der Unternehmensbranche hat jede Anwendung aus Benutzersicht zwei Anforderungen.

  1. Benutzerverzeichnis und Synchronisierung
  2. Benutzerauthentifizierung

Cognito erleichtert dies, indem es die Erstellung eines Benutzerpools oder eines Identitätspools ermöglicht. Sobald Sie einen Pool haben, können Sie eine Anwendung mit den verschiedenen Einstellungen für die Authentifizierung konfigurieren. Ein weiterer großer Vorteil von Cognito besteht darin, dass es branchenübliche Sicherheitsauthentifizierungsprotokolle wie OAuth 2.0, OpenID Connect und SAML bietet.

Es gibt ebenso andere Funktionen wie die Handhabung des Benutzerzugriffs, aber wir werden im Rahmen dieses Beitrags nicht näher darauf eingehen. In diesem Beitrag werde ich weiter zeigen, wie wir einen Benutzerpool erstellen und eine Anwendung konfigurieren können, um diesen Benutzerpool zu verwenden.

Spring Boot-Anwendung

Wir werden eine einfache Spring Boot-Anwendung verwenden. Wir werden diese Anwendung zur Authentifizierung in AWS Cognito integrieren.

Spring Boot-Setup

Fügen Sie die folgenden Abhängigkeiten in der Gradle-Datei hinzu


	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'

Und die application.properties benötigt oauth2-Konfigurationseigenschaften:


# ====================================================================================
## 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

Sicherheitskonfiguration

Unsere Main Controller-Klasse sieht wie folgt aus:



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

Wenn wir also auf unsere Anwendung zugreifen, wird sie zur Authentifizierung auf die AWS Cognito-Benutzeroberfläche umgeleitet. Basierend auf dem ausgewählten Flow OIDC oder SAML erfolgt die Authentifizierung.

SecurityConfig sieht wie folgt aus:


@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)
                ;

    }
}

Unsere einfache Indexvorlage sieht wie folgt aus:


<!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>

Erstellen Sie einen Benutzerpool

Nachdem Sie sich bei der AWS-Konsole angemeldet haben, wählen Sie Cognito als AWS-Service aus. Der erste Bildschirm zeigt Ihnen zwei Optionen – Erstellen Sie einen Benutzerpool und Erstellen Sie einen Identitätspool.

Wir wählen Benutzerpool erstellen aus.

Geben Sie einen passenden Namen für Ihren Benutzerpool ein und wählen Sie Step through settings aus. Dadurch können wir alle Einstellungen ändern, die wir für unseren Anwendungsfall nicht verwenden möchten.

Wählen Sie nun Benutzerpoolattribute für Benutzer aus. Diese Attribute ermöglichen es uns, den Benutzer zu identifizieren und was ein Benutzer während der Authentifizierung eingeben kann.

Für unsere Demo haben wir als Attribute E-Mail-Adresse, Nachname und Vorname ausgewählt. Der Benutzer meldet sich also mit einer E-Mail-Adresse bei der Anwendung an.

Für die Passwortrichtlinie haben wir festgelegt, dass das Passwort eine Mindestlänge von 8 haben sollte und alphanumerisch mit Groß- und Kleinbuchstaben sein sollte.

Die meisten anderen Einstellungen werden wir als Standard auswählen. Für App Clients Step wählen wir die benutzername- und passwortbasierte Authentifizierung für den Auth-Flow.

Anwendungs-Client-Konfiguration

Sobald wir einen Benutzerpool erstellt haben, werden wir den nächsten Satz von Konfigurationen durchlaufen, einschließlich des Anwendungsclients. In dieser Konfiguration konfigurieren wir unsere Anwendung, die den Benutzerpool verwendet.

Wir müssen den Identitätsanbieter und den Cognito-Benutzerpool aktivieren.

Konfigurieren des Verbundidentitätsanbieters

Wie bereits erwähnt, werden wir auch einen SAML-Identitätsanbieter für die Authentifizierung konfigurieren. In diesem Fall lautet der Ablauf Anwendung -> AWS Cognito -> SAML-Identitätsanbieter.

Anwendung in Okta konfigurieren

Für diese Demo verwenden wir Okta als SAML-Identitätsanbieter. Melden Sie sich bei der Okta-Administratorkonsole an und konfigurieren Sie wie folgt eine neue Anwendung für die SAML-Integration:

Geben Sie im nächsten Schritt die Single-Sign-On-URL an, und dies ist https://{yourcustomdomainfromcognito}.auth.{awszone}.amazoncognito.com . Wir müssen auch den Zielgruppen-URI (SP-Entitäts-ID) angeben. In diesem Fall fungiert Cognito als Dienstanbieter für Okta.

Wir müssen auch Attribute Statements konfigurieren wie oben gezeigt. Das sind die Attribute, die wir in unseren Cognito-Benutzerattributen konfiguriert haben – E-Mail, Vorname, Familienname.

Stellen Sie grundsätzlich sicher, dass sich der Benutzer, den Sie verwenden möchten, im Okta-Benutzerverzeichnis befindet. Es wird derselbe Benutzer sein, den wir entweder im Cognito-Benutzerpool konfigurieren oder durch die Anmeldung erstellen müssen.

Federated Identity Provider in Cognito konfigurieren

  • Wählen Sie in unserer Benutzerpoolkonfiguration Federated Identity Provider aus.
  • Wählen Sie die SAML-Option und Cognito zeigt Ihnen, dass Sie eine Metadatendatei oder eine Metadaten-URL für den Identitätsanbieter hochladen müssen. In unserem Fall ist dies https://dev-19753289.okta.com/app/exkmt322q1Kl15Rsk5d6/sso/saml/metadata .
  • Geben Sie einen Namen für Federated Identity Provider ein und speichern Sie die Änderungen.

Wenn wir also zu den App-Client-Einstellungen zurückkehren, sollte eine Option zur Auswahl von Federated Identity Provider angezeigt werden. Mit der neuen Konfiguration sehen unsere Einstellungen wie folgt aus:

Stellen Sie auf jeden Fall sicher, dass die Benutzerattribute (Vorname, Familienname und E-Mail) in Cognito bearbeitbar sind.

Wir haben jedoch unsere Konfiguration abgeschlossen. Jetzt können wir die Demo zeigen.

Demo der Spring Boot-Anwendungsauthentifizierung mit AWS Cognito

Wenn ich jetzt meine Anwendung ausführe und unter https://localhost:8743/ darauf zugreife , sehe ich den folgenden Bildschirm, um einen Identitätsanbieter auszuwählen, mit dem ich mich authentifizieren möchte:

Trotzdem können wir Okta oder Cognito User Pool verwenden, um uns anzumelden.

SAML-Flow

  1. Der Benutzer greift auf die Anwendung zu, die die OAuth-Anforderung des Autorisierungscodeflusses an Cognito sendet
  2. Cognito sendet SAML-Anfrage an Okta.
  3. Der Benutzer gibt Anmeldeinformationen auf dem Okta-Anmeldebildschirm ein.
  4. Okta sendet die SAML-Antwort am Endpunkt https://{customdomain}.auth.{awszone}.amazoncognito.com/saml2/idpresponse zurück an Cognito
  5. Cognito verarbeitet die SAML-Antwort und generiert einen Authentifizierungscode und eine Antwort zurück an die Anwendung.
  6. Die Anwendung verwendet den Authentifizierungscode, um das Token von Cognito abzurufen, und authentifiziert den Benutzer bei der Überprüfung des Tokens.

Vor allem nach erfolgreicher Authentifizierung sieht der Benutzer

Anstelle von Okta hatten wir die Cognito-Anmeldung auf demselben Home Realm Discovery-Bildschirm gewählt, wir sehen nach erfolgreicher Authentifizierung Folgendes:

Schlussfolgerung

In diesem Beitrag habe ich gezeigt, wie wir AWS Cognito für die Authentifizierung mit der Spring Boot-Anwendung verwenden können. Darüber hinaus hilft Cognito bei der Konfiguration von Benutzern sowie beim Entfernen von Boilerplate-Code von Sicherheitsabläufen.

Wenn Sie mein E-Book Simplifying Spring Security noch nicht gekauft haben, ist es hier erhältlich.


Java-Tag