Passer au contenu principal

Intégration WSO2 Identity Server avec Spring Boot et Spring Security – Protocole SAML2

Ce guide vise à illustrer l’intégration possible entre WSO2 Identity Server et le framework Spring pour le développement d’applications, pour réaliser l’authentification des utilisateurs à l’aide du protocole SAML2.

À cet effet, l’index ci-dessous doit être suivi:

  1. À propos de SAML2
  2. Conditions requises pour développer un projet au Spring
  3. Glossaire des termes
  4. Créer un project a Spring
    1. Avant de créer un projet
    2. Créer un projet au Spring
    3. Configuration du projet Spring Boot
    4. Configuration de la sécurité de Project Spring
    5. Explications du code précédent
    6. Création de classes de service et de modèle
    7. Créer une classe de contrôleur
  5. Créer un fournisseur de services WSO2
    1. Essais – Création d’un utilisateur de test
  6. Conclusions et Résultats

1. À propos de SAML2

SAML2 (Security Assertion Markup Language 2.0) est une version du standard SAML pour l’échange d’identités d’authentification et d’autorisation entre les domaines de sécurité. Il s’agit d’un protocole basé sur XML qui utilise des jetons de sécurité contenant des assertions et des informations utilisateur.

Il permet une authentification unique (SSO) interdomaine basée sur le Web, ce qui permet de réduire les frais administratifs liés à la distribution de plusieurs jetons d’authentification à l’utilisateur.

2. Conditions requises pour développer un projet au Spring

Afin de développer un projet au Spring, les conditions suivantes doivent être remplies:

  • Java 1.8 ou plus.
  • Maven.
  • IDE de développement Web, tel que STS, Eclipse, ou autre.

La configuration SAML avec WSO2 Identity Server nécessite la version 5.7 ou ultérieure.

3. Glossaire des termes

Afin de comprendre le processus de création de projet Spring, il est nécessaire de se familiariser avec certains concepts de base, comme expliqué ci-dessous:  

Mot Description
SAML Le langage SAML (Security Assertion Markup Language) est un document XML signé numériquement. Il comprend des informations sur les systèmes utilisateur, source et cible qui prévoient d’utiliser ce document XML, en plus d’autres informations requises pour valider la signature XML.
IdP Le fournisseur d’identité (IDP) est un système capable d’identifier l’utilisateur et d’émettre le document SAML signé.
SP Le fournisseur de services (SP) est un système qui reçoit du XML SAML.
Metadata Un document XML qui contient des informations sur l’identité et le fournisseur de services. Le fournisseur d’identité émet des métadonnées XML lorsqu’un fournisseur de services enregistre l’application.
Single Sign-on (SSO) Authentification unique ou SSO, c’est un processus d’authentification qui permet aux utilisateurs d’utiliser des informations d’identification uniques dans diverses applications au sein d’une organisation.

4. Créer un projet au Spring

4.1 Avant de créer un projet

Spring fournit ci-dessous deux artefacts pour gérer SAML 2.0.

  • spring-security-saml2-core: SAML2 core est une extension de Spring Security pour prendre en charge le traitement SAML de base pour l’authentification unique.
  • spring-security-saml-dsl-core: saml dsl est utilisé avec SAML 2 core, qui contient la configuration de base pour le mappage des demandes, le filtrage et la configuration du fournisseur d’authentification.

Nous pouvons utiliser le noyau SAML2 seul, mais nous devons configurer le mappage des demandes, les filtres, l’authentification, le contexte SAML et de nombreux autres détails communs à la plupart des applications. Afin d’éviter tout cela, nous n’utilisons que saml dsl. spring-security-saml-dsl-core, car il contient les détails d’affectation de demande suivants, qui sont configurés par défaut:

  • /saml/metadata: cette affectation permet d’afficher et de lire le fichier de métadonnées.
  • /saml/login: responsable de la génération de la demande de connexion et de la redirection vers la page IDP pour la connexion.
  • /saml/logout: utilisé pour fermer la session et supprimer la session globale ou locale.
  • /saml/SSO: il s’agit de l’URL de rappel réussie et IDP utilise cette affectation de demande pour publier le SAML.

4.2 Créer un projet au Spring

Pour commencer, vous devez créer un archétype de projet. Vous pouvez créer cet archétype à l’URL suivante https://start.spring.io/. Ici, vous devez saisir les informations du projet comme indiqué ci-dessous.

Remarque: vous pouvez également modifier l’outil utilisé pour construire le projet (Maven ou Gradle), le langage (Java, Kotlin, Groovy) et la version de Spring Boot.

Cliquez ensuite sur le bouton «ADD DEPENDENCES» pour ajouter les dépendances nécessaires, à savoir:

  • Spring Boot DevTools
  • Spring Web
  • Spring Security
  • Thymeleaf

Pour terminer, vous devez cliquer sur le bouton «GENERATE», qui générera le projet avec les informations saisies. Il vous demandera ensuite de télécharger le projet.

4.3 Configuration du projet Spring Boot

Une fois le projet téléchargé, il sera décompressé et situé dans un chemin de préférence de l’utilisateur, afin de l’importer dans l’IDE.

Après avoir importé le projet, 2 dépendances supplémentaires seront ajoutées dans le pom, celles-ci spring-security-saml2-core and spring-security-saml-dsl-core.

<!-- SAML2 Dependencies -->
   <dependency>
   <groupId>org.springframework.security.extensions</groupId>
   <artifactId>spring-security-saml2-core</artifactId>
   <version>1.0.3.RELEASE</version>
   </dependency>
   <dependency>
   <groupId>org.springframework.security.extensions</groupId>
   <artifactId>spring-security-saml-dsl-core</artifactId>
   <version>1.0.5.RELEASE</version>
   </dependency>
<!-- SAML2 Dependencies -->

Ensuite, le fichier application.properties sera renommé application.yml, qui se trouve dans le chemin src/main/resources/. Là, vous devez ajouter les variables à utiliser dans la configuration de sécurité de la classe ConfigSecurity.

saml2:
 metadata-path: classpath:static/saml2_metadata.xml
 sp:
   protocol: http
   host: localhost:8080
   path: /
   key-store:
     file: classpath:static/keystore.jks
     alias: saml2cert
     password: cky4159

Où:

Paramètre Valeur Description
saml2.metadata-path classpath:static/saml2_metadata.xml Fichier contenant les métadonnées IdP qui authentifient et autoriseront l’utilisateur.
saml2.sp.protocol http Protocole par lequel la communication sera effectuée (peut également être https).
saml2.sp.host localhost:8080 Hôte auquel la demande GET est envoyée au service SSO.
saml2.sp.path / S’il s’agit d’un chemin autre que celui par défaut.
saml2.sp.key-store.file classpath:static/keystore.jks JKS avec les certificats de sécurité, soit des certificats d’autorisation, soit des certificats de clé publique, ainsi que les clés privées correspondantes, qui sont utilisées, par exemple, dans le cryptage SSL.
saml2.sp.key-store.alias saml2cert Alias clé.
saml2.sp.key-store.password cky4159 Mot de passe utilisé pour le stockage des clés

Une fois l’étape précédente terminée, le dossier statique doit être créé dans le chemin src/main/resources où les fichiers suivants seront déposés. 

  • keystore.jks
  • saml2.cer aussi bien que saml2.pem
  • saml2_metadata.xml

Pour la génération JKS, la commande keytool suivante est utilisée:

keytool -genkey -keyalg RSA -alias saml2cert -keystore keystore.jks

Où:

Paramètre Valeur Description
-genkey   Utilisé pour générer une clé privée.
-keyalg RSA Nom de l’algorithme de clé.
-alias saml2cert alias clé
-keystore keystore.jks Indique un nom de fichier de keystore à générer.

Lors de l’exécution de la commande, un mot de passe pour le KeyStore sera demandé. Ensuite, des informations complémentaires seront demandées, comme indiqué ci-dessous.

Ensuite, la commande keytool suivante doit être exécutée afin de générer le certificat.

keytool -export -keystore keystore.jks -alias saml2cert -file saml2.cer

Où:

Paramètre Valeur Description
-export   Utilisé pour exporter une clé privée.
-keystore keystore.jks Spécifie le fichier jks qui sera lu pour générer le certificat.
-alias saml2cert Alias à rechercher dans le KeyStore.
-file saml2.cer Fichier de certificat vers lequel la clé publique sera exportée.

Remarque: lors de l’exportation du certificat, le mot de passe KeyStore sera demandé.

Enfin, la commande OpenSSL est exécutée pour la génération du fichier pem.

openssl x509 -inform der -in saml2.cer -out saml2.pem

Où:

Paramètre Valeur Description
-inform der Le fichier d’entrée ou de sortie se trouve dans le format de configuration, qui peut être PEM ou DER.
-in saml2.cert Le CSR pour la signature est dans le fichier donné en tant qu’élément.
-out saml2.pem Le certificat signé sera stocké dans le fichier donné.

Après avoir effectué les étapes précédentes, nous procédons à la configuration de la connexion du projet à WSO2 Identity Server à l’aide de Spring Security.

4.4 Configuration de la sécurité de Project Spring

Tout d’abord, vous devez créer un nouveau package (com.example.demo.sso) dans le projet dans lequel la classe SecurityConfig sera créée, où les paramètres de sécurité par défaut sont déterminés en fonction de spring-security-saml-dsl-core à l’aide de méthode saml (), comme indiqué ci-dessous:

package com.example.demo.sso;
import static org.springframework.security.extensions.saml2.config.SAMLConfigurer.saml;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import com.example.demo.services.SamlUserService;
@EnableWebSecurity
@Configuration
@EnableGlobalMethodSecurity(securedEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
   @Value("${saml2.metadata-path}")
   private String metadataPath;
   @Value("${saml2.sp.protocol}")
   private String spProtocol;
   @Value("${saml2.sp.host}")
   private String spHost;
   @Value("${saml2.sp.path}")
   private String spBashPath;
   @Value("${saml2.sp.key-store.file}")
   private String keyStoreFile;
   @Value("${saml2.sp.key-store.password}")
   private String keyStorePassword;
   @Value("${saml2.sp.key-store.alias}")
   private String keyStoreAlias;
   @Autowired
   private SamlUserService samlUserService;
 @Override
 protected void configure(final HttpSecurity http) throws Exception {
   http
     .csrf().and()
     .authorizeRequests()
       .antMatchers("/saml/**").permitAll()
       .anyRequest().authenticated()
       .and()
     .apply(saml())
         .userDetailsService(samlUserService)
       .serviceProvider()
         .protocol(spProtocol)
         .hostname(spHost)
         .basePath(spBashPath)
         .keyStore()
           .storeFilePath(keyStoreFile)
           .keyPassword(keyStorePassword)
           .keyname(keyStoreAlias)
         .and()
       .and()
       .identityProvider()
         .metadataFilePath(metadataPath)
       .and()
   .and();
 }
}

4.5 Explications du code précédent

Remarque Description
@EnableWebSecurity Entrée qui permet à Spring de rechercher et d’appliquer automatiquement la classe à la WebSecurity globale.

Fournit la configuration via HttpSecurity, permet de configurer l’accès en fonction des modèles d’URL, des points de terminaison d’authentification, des pilotes, etc.

@Configuration Entrée chargée de définir ce qu’est une classe de configuration pour le framework Spring.
@EnableGlobalMethodSecurity Fournit la sécurité AOP dans les méthodes. Certaines des entrées qu’il active sont PreAuthorize, PostAuthorize, et il prend également en charge JSR-250.

secureEnabled: définit si les entrées sécurisées de Spring Security doivent être activées.

Extension de la classe

Extension de la classe abstraite WebSecurityConfigurerAdapter fournit une classe de base pratique pour créer une instance WebSecurityConfigurer, qui permet la personnalisation de WebSecurity, permettant ainsi de remplacer les méthodes.

L’entrée @EnableWebSecurity et la classe WebSecurityConfigurerAdapter fonctionnent ensemble pour fournir une sécurité Web. En étendant WebSecurityConfigurerAdapter et avec quelques lignes de code, les éléments suivants peuvent être atteints:

  • Exiger que l’utilisateur soit authentifié avant d’accéder à une URL dans notre application
  • Possibilité de créer un utilisateur avec le nom d’utilisateur «N», le mot de passe «C» et le rôle «R».
  • Active l’authentification HTTP de base et basée sur les formulaires.
  • Spring Security générera automatiquement une page de connexion et une page de réussite de déconnexion pour vous.

Écraser la configuration

Comme expliqué ci-dessus, l’entrée @EnableWebSecurity aide à la configuration d’un HttpSecurity, qui est similaire à l’élément XML <http> de Spring Security dans la configuration de l’espace de noms.

Cela permet la mise en place d’une sécurité Web pour des requêtes http spécifiques. Il sera appliqué à toutes les demandes par défaut.

Méthode Description
.csrf().and() Ajoute la prise en charge de CSRF (falsification de requêtes intersites). Il est activé par défaut lorsque le constructeur prédéfini WebSecurityConfigurerAdapter est utilisé.
.authorizeRequests()

.antMatchers(“/saml/**”).permitAll()

.anyRequest().authenticated()

.and()

Il permet la restriction d’accès basée sur HttpServletRequest.

Avec la configuration antMatchers, l’authentification est requise uniquement à l’URL «/ saml / **» et accordera l’accès à tous les utilisateurs.

.apply(saml())

.userDetailsService(samlUserService)

.serviceProvider()

.protocol(spProtocol)

.hostname(spHost)

.basePath(spBashPath)

.keyStore()

.storeFilePath(keyStoreFile)

.keyPassword(keyStorePassword)

.keyname(keyStoreAlias)

.and()

.and()

Appliquez un SecurityConfigurer à ce SecurityBuilder, en remplaçant tout SecurityConfigurer de la même classe.

La chose importante à noter est la méthode saml (), qui est une méthode statique qui renvoie l’instance singleton SAMLConfigurer contenant les détails du fournisseur d’attribution de demande d’authentification, de filtrage et SAML2.

Lorsqu’une application reçoit la réponse SAML, elle validera d’abord le XML SAML. La validation comprend les identifiants de source et de destination, l’heure de la session, la signature, etc.

Si la réponse XML est valide, SAML DSL appellera la méthode userDetailsService, qui a créé un service utilisateur personnalisé pour convertir le XML en un modèle utilisateur personnalisé.

En ce qui concerne la configuration dans la section serviceProvider (), souvent, lorsqu’un utilisateur se connecte avec succès, l’IDP publie une réponse SAML dans / saml / SSO du fournisseur de services.

Dès réception du SAML, un fournisseur de services validera le XML. Dans le cadre du processus de validation, il recherchera l’identification de l’entité, la destination, l’audience et d’autres détails. Lorsqu’une demande est publiée dans l’instance localhost, elle vérifie l’attribut de destination avec le domaine de l’instance locale. Si les deux (attribut cible SAML et nom de l’instance locale) ne correspondent pas, la demande de validation échouera.

.identityProvider()

.metadataFilePath(metadataPath)

.and()

La méthode metadataFilePath () recherche les métadonnées dans le fichier xml IdP, qui authentifie et autorise l’utilisateur. Pour cet exemple, il s’agira du résident IdP de WSO2.

Les attributs

Comme on peut le voir dans la classe SecurityConfig, les attributs suivants ont été déclarés et obtiendront leur valeur principalement à partir du fichier application.yml.

Attributs Valeur
metadataPath ${saml2.metadata-path}
spProtocol ${saml2.sp.protocol}
spHost ${saml2.sp.host}
spBashPath ${saml2.sp.path}
keyStoreFile ${saml2.sp.key-store.file}
keyStorePassword ${saml2.sp.key-store.password}
keyStoreAlias ${saml2.sp.key-store.alias}
samlUserService Customized service to obtain information from the authorized user.

4.6 Création de classes de service et de modèle

Dans l’interface SAMLUserDetailsService, les données SAML sont utilisées pour obtenir des informations sur l’utilisateur. En implémentant l’interface, ils placent l’utilisateur dans un magasin de données arbitraire basé sur les informations présentes dans SAMLCredential et renvoient ces données dans un formulaire d’objet UserModel spécifique à l’application.

Comme pour l’explication précédente, vous devez créer un nouveau package avec le fichier com.example.demo.services où vous allez créer une classe java appelée SamlUserService. En son sein, une simple analyse des informations sera effectuée pour une utilisation optimale par la suite.

package com.example.demo.services;
import java.util.HashMap;
import java.util.Map;
import org.opensaml.saml2.core.Attribute;
import org.opensaml.xml.schema.XSString;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.saml.SAMLCredential;
import org.springframework.security.saml.userdetails.SAMLUserDetailsService;
import org.springframework.stereotype.Service;
import com.example.demo.models.UserModel;
@Service
public class SamlUserService implements SAMLUserDetailsService {
   @Override
   public Object loadUserBySAML(SAMLCredential credential) throws UsernameNotFoundException {
       Map<String, String> attributes = new HashMap<String, String>();
       String userID = credential.getNameID().getValue();
       for (Attribute element : credential.getAttributes()) {
           String name = element.getName().replace("http://wso2.org/claims/", "");
           XSString value = (XSString) element.getAttributeValues().get(0);
           attributes.put(name, value.getValue());
       }
       return new UserModel(userID, attributes.get("givenname"), attributes.get("emailaddress"));
   }
}

Lors de l’écrasement de la méthode, loadUserBySAML () identifie le compte local de l’utilisateur référencé dans les données de l’assertion SAML et renvoie l’objet UserModel qui décrit l’utilisateur (id, givenname et emailladdress).

Un nouveau package doit être créé qui sera nommé com.example.demo.models, et où une classe java nommée UserModel sera créée. En son sein, les informations utilisateur seront gérées de manière plus simple.

package com.example.demo.models;
import lombok.Getter;
import lombok.ToString;
@Getter
@ToString
public class UserModel {
   private String id;
   private String givenname;
   private String emailaddress;
   public UserModel(String id, String givenname, String emailaddress) {
       this.id = id;
       this.givenname = givenname;
       this.emailaddress = emailaddress;
   }
   public String getId() {
       return id;
   }
   public void setId(String id) {
       this.id = id;
   }
   public String getGivenname() {
       return givenname;
   }
   public void setGivenname(String givenname) {
       this.givenname = givenname;
   }
   public String getEmailaddress() {
       return emailaddress;
   }
   public void setEmailaddress(String emailaddress) {
       this.emailaddress = emailaddress;
   }
  
}

Remarque: les notes @Getter et @ToString permettent à la bibliothèque lombok de générer automatiquement la méthode par défaut.

4.7 Créer une classe de contrôleur

L’un des avantages de l’utilisation de Spring pour créer des services Web RESTful sont les requêtes HTTP, qui peuvent être gérées par un contrôleur. Ces composants sont identifiés par la note @RestController ou @Controller.

Comme spécifié dans le fichier application.yml, le chemin sera «/», qui, via l’entrée @GetMapping, entrera la méthode d’index pour convertir la méthode getPrincipal () en UserModel. Cela est possible, car dans la classe de configuration SecurityConfig, il a été indiqué que SamlUserService serait en charge de la classe UserDetails, qui a été modifiée dans la réponse par UserModel.

Plus tard, un nouveau package doit être créé qui sera nommé com.example.demo.controllers et plus tard une classe Java appelée LoginController sera générée.

package com.example.demo.controllers;
import org.springframework.security.providers.ExpiringUsernameAuthenticationToken;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import com.example.demo.models.UserModel;
@Controller
@RequestMapping(path = "/", method = RequestMethod.GET)
public class LoginController {
   @GetMapping(path = "/")
   public ModelAndView index(ExpiringUsernameAuthenticationToken userToken) {
       ModelAndView mav = new ModelAndView("index");
       UserModel user = (UserModel) userToken.getPrincipal();
       mav.addObject("user", user);
       return mav;   
   }
}

Créer du HTML et du CSS

Afin d’interagir avec le formulaire affiché par WSO2 Identity Server lors de l’authentification des utilisateurs, une page html doit être créée. Afin de terminer ce processus, il doit être créé dans le dossier src / main / resources / templates le fichier index.html, dans lequel les données utilisateur qui sont traitées dans la classe UserModel seront référencées. Dans le contrôleur, il a été renommé user (ligne 20 de la classe Controller).

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Expires" content="-1" />
<meta http-equiv="Cache-Control" content="private" />
<meta http-equiv="Cache-Control" content="no-store" />
<meta http-equiv="Pragma" content="no-cache" />
<link th:href="@{/styles/cssandjs/main.css}" rel="stylesheet" />
<title>Spring Security SAML Example</title>
</head>
<body>
   <img src="/styles/image/spring-boot-600x300.png" style="width: 10%">
   <img src="/styles/image/tech-spring-security.width-1024.png"
       style="width: 13%">
   <img src="/styles/image/WSO2_Software_Logo.png" style="width: 10%">
   <div class="login">
       <h1>Congratulations on logging in with SAML2</h1>
       <h1>
           Welcome <span style="font-weight: bold" th:text="${user.id}"></span>
       </h1>
       <a href="/saml/logout/"><button
               class="btn btn-primary btn-block btn-large">Logout</button> </a>
   </div>
   <p>&nbsp;</p>
   <p>&nbsp;</p>
   <div>
       <table style="width: 0%">
       <thead>
           <tr>
               <th>Atribute</th>
               <th>Value</th>
           </tr>
       </thead>
           <tbody>
               <tr>
                   <td>givenname</td>
                   <td><span th:text="${user.givenname}"></span></td>
               </tr>
               <tr>
                   <td>emailaddress</td>
                   <td><span th:text="${user.emailaddress}"></span></td>
               </tr>
           </tbody>
       </table>
   </div>
</body>
</html>

Puisqu’il s’agit d’un fichier html, vous pouvez inclure les performances avec des classes css, qui peuvent être en fonction des préférences de chaque personne. Pour plus d’informations, vous pouvez visiter https://templated.co/. Ajoutez simplement la référence de classe css, qui doit être créée dans le chemin src/main/resources/styles/cssandjs dans le html avec l’instruction suivante.

<link th:href="@{/styles/cssandjs/main.css}" rel="stylesheet" />

5. Créer un fournisseur de services WSO2

Pour démarrer le service WSO2 Identity Server, s’il n’est pas activé, la commande suivante doit être exécutée dans le dossier bin de la distribution WSO2 Identity Server en cours de traitement.

sh wso2server.sh

Une fois le service lancé, les instructions suivantes doivent être suivies:

  • Connectez-vous à la console d’administration avec l’utilisateur administrateur.

  • Accédez au Main Menu pour accéder au Identity menu(menu Identité).
  • Cliquez sur  «Add under Service Providers».
  • Remplissez le formulaire avec les informations suivantes:
  • Nom du fournisseur de services: SpringSAML2
  • Description: Spring Security avec SAML2
  • Cliquez sur «Register» pour ajouter le nouveau fournisseur de services.

  • «The Service Providers screen» sera celui qui apparaîtra, dans lequel le certificat d’application doit être collé dans «Application Certificate file». Si vous ne disposez pas du certificat, suivez les étapes ci-dessous:
    • Accédez au dossier WSO2IdentityServer/version/repository/resources/security
    • Ouvrez un terminal et exécutez les commandes suivantes pour exporter le certificat Keystone.
    • Le certificat exporté sera au format binaire.
keytool -export -keystore wso2carbon.jks -alias wso2carbon -file wso2carbon.crt
  • Convertissez le certificat chiffré binaire précédent en certificat chiffré PEM.
openssl x509 -inform der -in wso2carbon.crt -out wso2carbon.pem
  • Dans les informations sur le fournisseur de services, cliquez sur les boutons fléchés pour développer les formulaires Configuration de la revendication et Configuration de l’authentification entrante. Ici vous trouverez:
  • Configuration de la revendication: où les revendications qui seront envoyées dans les assertions sont configurées, dans lequel le dialecte des revendications locales (wso2.org) sera utilisé.

  • Inbound Authentication Configuration: la responsabilité du composant d’authentification entrant est d’identifier et d’analyser toutes les demandes d’authentification entrantes, puis de générer la réponse correspondante. Un authentificateur entrant donné comprend deux parties:
    • Application Processor ou Processeur d’application
    • Response Generator ou Générateur de réponse

Configurer l’Inbound Authentication, cliquez sur le bouton «Configure», qui vous redirigera vers le formulaire qui demandera les informations nécessaires pour établir la connexion entre WSO2 Identity Server et l’application qui a été précédemment générée.

Remplissez le formulaire avec les informations suivantes:

Champs Valeur Description
Issuer http://localhost:8080/saml/metadata Il s’agit de l ‘<élément saml: Issuer> contenant l’identifiant unique du fournisseur de services. Il s’agit également de la valeur de l’expéditeur, spécifiée dans la demande d’authentification SAML émise par le fournisseur de services.
Assertion Consumer URLs http://localhost:8080

http://localhost:8080/saml/SSO

http://localhost:8080/saml/metadata

Il s’agit de l’URL vers laquelle le navigateur doit être redirigé après une authentification réussie.
Enable Response Signing Selected Signez les réponses SAML2 renvoyées après le processus d’authentification.
Enable Signature Validation in Authentication Requests and Logout Requests Selected Cela spécifie que le fournisseur d’identité doit valider la signature de la demande d’authentification SAML2 et la demande de déconnexion SAML2 envoyée par le fournisseur de services.
Enable Single Logout Selected Si l’authentification unique est activée, le fournisseur d’identité envoie des demandes d’approbation à tous les fournisseurs de services.
Enable Attribute Profile Selected Le serveur d’identité prend en charge un profil d’attribut de base dans lequel le fournisseur d’identité peut inclure les attributs de l’utilisateur dans les instructions SAML dans le cadre de la déclaration d’attribut.
Always Include Attributes in the Response Selected Le fournisseur d’identité inclut toujours les valeurs des attributs liés aux instructions sélectionnées dans la déclaration d’attribut SAML.
Enable IdP Initiated SSO Selected Lorsqu’elle est activée, le fournisseur de services n’est pas obligé de soumettre l’application SAML2.

Ensuite, cliquez sur le bouton «Update» pour mettre à jour les informations dans la section «Service Provider».

Une fois la configuration dans la section «Service Provider» terminée, il ne reste plus qu’à obtenir «Identity Provider metadata». Pour ce faire, cliquez sur l’option «Option résident» dans «Fournisseur d’identité»

Cliquez sur le bouton «Inbound Authentication Configuration forms», développez l’onglet «SAML2 Web SSO Configuration», puis cliquez sur le bouton «Download SAML Metadata».

Une fois les métadonnées téléchargées, le fichier xml sera renommé saml2_metadata et placé dans le chemin src/main/resources/static.

5.1 Essais – Création d’un utilisateur de test

Afin de créer un nouvel utilisateur dans la console d’administration WSO2 Identity Server, les étapes suivantes doivent être suivies:

  • Cliquez sur «Add», sous «Users and Roles».
  • Cliquez sur «Add New User», sur la page où la console a été redirigée.
  • Il vous sera demandé de remplir un formulaire contenant des informations de base sur l’utilisateur,«Username» et «Password» telles que le nom d’utilisateur et le mot de passe:
Champ Valeur
Username Prueba
Password qazse4159
Confirm Password qazse4159

  • Ensuite, le message indiquant que le nouvel utilisateur a été ajouté avec succès doit être affiché.

  • Cela affichera la liste des utilisateurs enregistrés. Vous devez cliquer sur l’option «User Profile» de l’utilisateur nouvellement créé, qui affichera un nouveau formulaire contenant plus d’informations sur l’utilisateur.
Champ Valeur Obligatoire
First Name prueba
Last Name prueba
Organization  
Country  
Email prueba@prueba.com
Telephone  
Mobile  
IM  
URL  
Department  

  • Cliquez maintenant sur «Add» sous «Users and Roles».
  • Cliquez sur «Add New Role» sur la page vers laquelle la console a été redirigée.
  • Il vous sera demandé de remplir un formulaire contenant des informations de base sur le rôle.

Champ Valeur
Role Name Login
  • Ensuite, vous devez cliquer sur le bouton «Next». Ceci permet d’afficher la liste des autorisations que le rôle peut avoir, dans ce rôle, sélectionnez uniquement l’autorisation de connexion.

Finally, you must click on the Finish button.

  • You must click List, in Users and Roles, and then in the Users option the list of users will be shown.

In the users’ options, click on the Assign Roles option in the Test user that was created. Performing this action will display another list with the roles that can be assigned to the user, select the Login role.

  • Une fois le rôle sélectionné, cliquez sur le bouton «Finish».

Une fois les étapes précédentes terminées, vous devrez exécuter le projet Maven qui a été généré lors des étapes précédentes.Vous pouvez le faire de plusieurs manières, comme indiqué ci-dessous:

  1. Depuis l’IDE, vous devez sélectionner le dossier du projet par un clic droit et dans l’option «Run As the Spring Boot App»
  • Si vous ne trouvez pas l’option mentionnée ci-dessus dans l’IDE, vous devez télécharger un module complémentaire intitulé Spring Tool Suite (STS). Pour les utilisateurs d’Eclipse, vous devez aller dans Aide -> Eclipse MarketPlace
  1. Depuis la console. Vous devez le placer dans le terminal sur le dossier racine du projet et exécuter ce qui suit par ligne de commande:
mvn clean install
  • Ensuite:
java -jar target/demo-0.0.1-SNAPSHOT.jar
  • Entrez maintenant l’URL: http://localhost:8080/

Ici, le formulaire d’authentification WSO2 Identity Server sera affiché et dans lequel les informations d’identification utilisateur précédemment créées sont entrées.

Ensuite, l’application SpringSAML2 demande l’accès aux informations de profil de l’utilisateur.

Pour cet essai, sélectionnez l’option «Select All» et cliquez sur le bouton «Approve». Vous serez alors dirigé vers la page qui a été créée dans le projet (index.html), et elle affichera les informations de base de l’utilisateur (nom et e-mail).

6. CONCLUSIONS ET RÉSULTATS

Comme indiqué dans ce didacticiel, en utilisant le framework Spring (Spring Boot et Spring Security), vous pouvez établir une connexion à l’aide du protocole SAML2 vers WSO2 Identity Server d’une manière plus simple et plus rapide.

Il était également possible d’examiner les composants et les protocoles qui interagissent pour authentifier et autoriser l’utilisateur lorsqu’il essaie de se connecter.

En conclusion, le projet a couvert les points suivants:

  1. L’utilisateur entre dans l’application via l’URL: http: // localhost: 8080
  2. Le contrôleur de Spring intercepte la requête.
  3. La demande d’authentification de l’utilisateur est envoyée au SP.
  4. Le SP génère une demande d’authentification, puis envoie la demande et l’utilisateur à l’IdP.
  5. Vérifiez la base de données (H2) pour les informations utilisateur, qui sont par défaut dans WSO2 Identity Server.
  6. L’IdP authentifie l’utilisateur et renvoie la réponse d’authentification et les informations utilisateur au SP.
  7. Le SP vérifie la réponse de l’IdP et envoie la demande à la ressource qui renvoie le contenu initialement demandé (Spring Security).
  8. Il crée le mappage de la réponse à la requête, à afficher dans le html.

Les références:

Articles connexes

Suivre l'actualité,les dernières nouvelles, des articles, des guides et des opinions de Chakray.