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

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:  

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ù:

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ù:

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ù:

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ù:

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

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.

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.

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:

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:

• 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.

• 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.

• 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

2. 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:

• http://stuff.gpul.org/2004_cripto/doc/chuleta_openssl.pdf
• https://docs.wso2.com/display/IS570/Configuring+Single+Sign-On
• https://docs.spring.io/spring-security/site/docs/5.2.1.RELEASE/reference/htmlsingle/#saml2
• https://docs.wso2.com/display/IS570/Configuring+Inbound+Provisioning+for+a+Service+Provider
• https://medium.com/@piraveenaparalogarajah/add-saml-authentication-to-spring-boot-app-with-wso2-is-17ed3d12c60d
• https://mencrypto.com/saml2-with-spring-and-wso2-is/
• http://www.techsams.com/java/spring/sso/onelogin/single-sign-on-with-spring-saml.html
• https://github.com/Mencrypto/SSOWSO2ISSPRING
• https://spring.io/blog/2013/07/03/spring-security-java-config-preview-web-security/#wsca
• https://dzone.com/articles/get-started-with-spring-boot-saml-and-okta
• https://blog.joshsoftware.com/2020/04/22/single-sign-on-with-saml-and-spring-boot/