Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Importer
52 vues10 pages

Guide Saml

Transféré par

OUSSAMA TOUIJER

Droits d'auteur :

© All Rights Reserved
Téléchargez comme PDF, TXT ou lisez en ligne sur Scribd
Télécharger au format pdf ou txt

Guide Saml

Transféré par

OUSSAMA TOUIJER
52 vues10 pages

Titre original

GUIDE SAML

Copyright

© © All Rights Reserved

Formats disponibles

PDF, TXT ou lisez en ligne sur Scribd

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

© All Rights Reserved
Téléchargez comme PDF, TXT ou lisez en ligne sur Scribd
Télécharger au format pdf ou txt
52 vues10 pages

Guide Saml

Transféré par

OUSSAMA TOUIJER

Droits d'auteur :

© All Rights Reserved
Téléchargez comme PDF, TXT ou lisez en ligne sur Scribd
Télécharger au format pdf ou txt
Vous êtes sur la page 1/ 10

# Premiers pas avec Spring Boot et SAML

Si vous devez utiliser SAML avec Spring Boot, ce screencast devrait le rendre rapide et facile.

**Conditions préalables**:

- https://adoptium.net/[Java 17] : je recommande d'utiliser https://sdkman.io/[SDKMAN!] pour gérer


et installer plusieurs versions de Java.

Ajouter une application SAML sur Okta

===

. Pour commencer, vous aurez besoin d'un compte développeur Okta. Vous pouvez en créer un sur
https://developer.okta.com/signup[developer.okta.com/signup] ou installer
https://cli.okta.com[Okta CLI] et exécuter « okta register ».

. Connectez-vous à votre compte et accédez à **Applications** > **Create App Integration**.


Sélectionnez **SAML 2.0** et cliquez sur **Next**. Nommez votre application comme « Spring
Boot SAML » et cliquez sur **Next**.

. Utilisez les paramètres suivants :

* Single sign on URL: `\http://localhost:8080/login/saml2/sso/okta`

* Use this for Recipient URL and Destination URL: (the default)

* Audience URI: `\http://localhost:8080/saml2/service-provider-metadata/okta`

. Cliquez sur **Next**. Sélectionnez les options suivantes:

* I'm an Okta customer adding an internal app


* This is an internal app that we have created

. Sélectionnez **Finish**.

. Scroll down to the **SAML Signing Certificates** and go to **SHA-2** > **Actions** > **View IdP
Metadata**. You can right-click and copy this menu item's link or open its URL. Copy the resulting
link to your clipboard.

. Go to your app's **Assignment** tab and assign access to the **Everyone** group.

Create a Spring Boot app with SAML support

===

. Create a Spring Boot app using https://start.spring.io[start.spring.io]. Select the following options:

* Project: *Gradle*

* Spring Boot: *3.0.6*

* Dependencies: *Spring Web*, *Spring Security*, *Thymeleaf*

. Add a `HomeController.java` pour renseigner les informations de l'utilisateur authentifié.

.`HomeController.java`

----

package com.example.demo;

import org.springframework.security.core.annotation.AuthenticationPrincipal;

import
org.springframework.security.saml2.provider.service.authentication.Saml2AuthenticatedPrincipal;

import org.springframework.stereotype.Controller;

import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller

public class HomeController {

@RequestMapping("/")

public String home(@AuthenticationPrincipal Saml2AuthenticatedPrincipal principal, Model


model) {

model.addAttribute("name", principal.getName());

model.addAttribute("emailAddress", principal.getFirstAttribute("email"));

model.addAttribute("userAttributes", principal.getAttributes());

return "home";

----

Home.html

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="https://www.thymeleaf.org"

xmlns:sec="https://www.thymeleaf.org/thymeleaf-extras-springsecurity6">

<head>

<title>Spring Boot and SAML</title>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>

</head>

<body>

<h1>Welcome</h1>

<p>You are successfully logged in as <span sec:authentication="name"></span></p>

<p>Your email address is <span th:text="${emailAddress}"></span>.</p>


<p>Your authorities are <span sec:authentication="authorities"></span>.</p>

<h2>All Your Attributes</h2>

<dl th:each="userAttribute : ${userAttributes}">

<dt th:text="${userAttribute.key}"></dt>

<dd th:text="${userAttribute.value}"></dd>

</dl>

<form th:action="@{/logout}" method="post">

<button id="logout" type="submit">Logout</button>

</form>

</body>

</html>

----------

Application.yml:

spring:

security:

saml2:

relyingparty:

registration:

okta:

assertingparty:

metadata-uri: <your-metadata-uri>
Mettez à jour `build.gradle` pour ajouter la dépendance SAML de Spring Security :

----

repositories {

...

maven { url "https://build.shibboleth.net/nexus/content/repositories/releases/" }

dependencies {

constraints {

implementation "org.opensaml:opensaml-core:4.1.1"

implementation "org.opensaml:opensaml-saml-api:4.1.1"

implementation "org.opensaml:opensaml-saml-impl:4.1.1"

...

implementation 'org.springframework.security:spring-security-saml2-service-provider'

----

. Ouvrez `\http://localhost:8080` dans votre navigateur préféré et connectez-vous avec les


informations d'identification que vous avez utilisées pour créer votre compte.

. Si vous essayez de vous déconnecter, cela ne fonctionnera pas. Réparons ça.


Ajouter la fonctionnalité de déconnexion:
1- Modifiez votre application sur Okta et accédez à General > SAML Settings > Edit.
2- Poursuivez jusqu'à l'étape de Configure SAML et Show Advanced Settings. Avant de
pouvoir activer la déconnexion unique, vous devrez créer et télécharger un certificat pour
sign la requête de déconnexion sortante.

EXPLICATION: la génération d'une clé privée et d'un certificat auto-signé est une pratique
standard pour sécuriser les échanges de messages SAML, y compris les requêtes de logout,
entre votre application Spring Boot et le fournisseur d'identité Okta. Cela contribue à
maintenir la confidentialité, l'intégrité et l'authenticité des communications dans un
environnement SAML.

3- Vous pouvez créer une clé privée et un certificat en utilisant OpenSSL.

Répondez à au moins l'une des questions avec une valeur, et cela devrait fonctionner.
(Dans le terminal de IJ)

openssl req -newkey rsa:2048 -nodes -keyout local.key -x509 -days 365 -out local.crt

4- Copiez les fichiers générés dans le répertoire src/main/resources de votre application.


Configurez signing and singlelogout dans le fichier application.yml :

spring:
security:
saml2:
relyingparty:
registration:
okta:
assertingparty:
...
signing:
credentials:
- private-key-location: classpath:local.key
certificate-location: classpath:local.crt
singlelogout:
binding: POST
response-url: "{baseUrl}/logout/saml2/slo"

5- Upload local.crt vers votre application Okta (Browse files). Selectionner Enable Single
Logout and use the following values:

• Single Logout URL: http://localhost:8080/logout/saml2/slo


C'est l'URL à laquelle Okta enverra les requêtes de logout . Cette URL
correspond à la configuration que vous avez définie dans votre
application Spring Boot.
• SP Issuer: http://localhost:8080/saml2/service-provider-metadata/okta
C'est l'identifiant de votre fournisseur de service (SP) pour le logout. Cela
identifie de manière unique votre application Spring Boot pour Okta.

6- Terminez la configuration de votre application Okta, redémarrez votre


application Spring Boot, et la déconnexion devrait fonctionner.

Customize authorities with Spring Security SAML

Cette étape est importante car elle permet d'adapter l'attribution des rôles aux
besoins spécifiques de votre application en exploitant les informations fournies par le
fournisseur d'identité (Okta). Cela donne plus de flexibilité pour gérer les
autorisations des utilisateurs en fonction de leur contexte ou de leur groupe
d'appartenance.

1- Modifiez les paramètres SAML de votre application Okta et remplissez la


section Group Attribute Statements.

Name: groups (Ce champ spécifie le nom de l'attribut que vous souhaitez récupérer de Okta)
Name format: Unspecified (Ce champ indique le format dans lequel le nom de l'attribut sera
fourni)
Filter: Matches regex and use .* for the value (Ce champ spécifie le filtre qui sera
appliqué aux valeurs de l'attribut récupéré -> ce qui signifie qu'il utilisera une expression régulière
pour correspondre à toutes les valeurs possibles. L'expression régulière .* correspond à n'importe
quelle séquence de caractères.)

2- Juste au-dessus, vous pouvez ajouter d'autres déclarations d'attributs. Par


exemple :

Name Name format Value

email Unspecified user.email

firstName Unspecified user.firstName

lastName Unspecified user.lastName

Save
3- Créez une classe SecurityConfiguration qui remplace la configuration par
défaut et utilise un convertisseur pour traduire les valeurs dans l'attribut
groups en autorisations de Spring Security.

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.convert.converter.Converter;

import org.springframework.security.authentication.ProviderManager;

import org.springframework.security.config.annotation.web.builders.HttpSecurity;

import org.springframework.security.core.GrantedAuthority;

import org.springframework.security.core.authority.SimpleGrantedAuthority;

import org.springframework.security.saml2.provider.service.authentication.OpenSaml4AuthenticationProvider;

import
org.springframework.security.saml2.provider.service.authentication.OpenSaml4AuthenticationProvider.ResponseT
oken;

import org.springframework.security.saml2.provider.service.authentication.Saml2AuthenticatedPrincipal;

import org.springframework.security.saml2.provider.service.authentication.Saml2Authentication;

import org.springframework.security.web.SecurityFilterChain;

import static org.springframework.security.config.Customizer.withDefaults;

@Configuration

public class SecurityConfiguration {

@Bean

SecurityFilterChain configure(HttpSecurity http) throws Exception {


// Crée un fournisseur d'authentification SAML basé sur OpenSAML 4

OpenSaml4AuthenticationProvider authenticationProvider = new OpenSaml4AuthenticationProvider();

// Configure le convertisseur qui traduira les valeurs dans l'attribut "groups" en autorisations Spring Security

authenticationProvider.setResponseAuthenticationConverter(groupsConverter());

http.authorizeHttpRequests(authorize -> authorize

.anyRequest().authenticated())

.saml2Login(saml2 -> saml2

.authenticationManager(new ProviderManager(authenticationProvider))) // Configure le gestionnaire


d'authentification SAML

.saml2Logout(withDefaults());

return http.build();

// Définit le convertisseur qui traduira les valeurs dans l'attribut "groups" en autorisations Spring Security

private Converter<OpenSaml4AuthenticationProvider.ResponseToken, Saml2Authentication>


groupsConverter() {

// Définit le convertisseur par défaut pour la réponse d'authentification SAML

Converter<ResponseToken, Saml2Authentication> delegate =

OpenSaml4AuthenticationProvider.createDefaultResponseAuthenticationConverter();

return (responseToken) -> {

Saml2Authentication authentication = delegate.convert(responseToken);

Saml2AuthenticatedPrincipal principal = (Saml2AuthenticatedPrincipal) authentication.getPrincipal();

List<String> groups = principal.getAttribute("groups");

Set<GrantedAuthority> authorities = new HashSet<>();

if (groups != null) {
// Pour chaque groupe, crée une autorité Spring Security et l'ajoute à la liste des autorités

groups.stream().map(SimpleGrantedAuthority::new).forEach(authorities::add);

} else {

// Si pas de groupes, conserve les autorités existantes

authorities.addAll(authentication.getAuthorities());

// Retourne une nouvelle instance de l'objet Saml2Authentication avec les autorités mises à jour

return new Saml2Authentication(principal, authentication.getSaml2Response(), authorities);

};

4- Redémarrez votre application et connectez-vous. Vous devriez voir les


groupes de votre utilisateur en tant qu'autorisations.

Vous aimerez peut-être aussi