H· Hawiyati Documentation
Documentation Hawiyati

Guide d'intégration

Connectez vos applications à Hawiyati via SAML 2.0, OpenID Connect, SCIM 2.0 ou FIDO2/WebAuthn. Ce guide couvre tous les protocoles pris en charge avec les flux détaillés, les références de configuration et les listes de contrôle de sécurité.

Documentation Hawiyati

Connectez vos applications à Hawiyati via SAML 2.0, OpenID Connect, SCIM 2.0 ou FIDO2/WebAuthn. Ce guide couvre tous les protocoles pris en charge avec les flux détaillés, les références de configuration et les listes de contrôle de sécurité.

Comparaison des protocoles

SAML 2.0 OIDC
Format du jetonAssertion XML signée (XML-DSig)JWT signé (RS256)
Liaison de transportHTTP-POST, HTTP-RedirectHTTPS uniquement (redirections navigateur + appel serveur-à-serveur)
Cas d'usage principalSSO d'entreprise, applications legacyApplications web modernes, SPA, mobile, API
DécouverteÉchange de métadonnées XMLDocument de découverte OIDC (/.well-known/openid-configuration)
DéconnexionSLO (Single Logout) — propagation en éventailDéconnexion initiée par RP ou déconnexion en canal arrière
Sensibilité à l'horloge±30 secondes de tolérance sur les horodatages±60 secondes de tolérance sur exp
Statut HawiyatiProduction (pile personnalisée — pas OpenSAML)Production (pile personnalisée — pas Nimbus)
Recommandation Utilisez SAML 2.0 pour les applications d'entreprise existantes qui disposent déjà d'une configuration SP SAML. Utilisez OIDC pour toutes les nouvelles applications — il est plus léger, utilise des jetons JSON standard et bénéficie d'une meilleure prise en charge de bibliothèques pour les frameworks modernes et les applications mobiles.

SAML 2.0 — Quand l'utiliser

  • L'application cible dispose déjà d'une config SP SAML (Salesforce, SAP, SharePoint)
  • SSO navigateur requis et OIDC non disponible
  • Intégration fournisseur legacy sans support OIDC
  • La politique de l'organisation impose SAML pour tout le SSO

OIDC — Quand l'utiliser

  • Construction d'une nouvelle application web, SPA ou mobile
  • Authentification service-à-service nécessaire
  • Prise en charge standard de bibliothèques JWT préférée
  • Actualisation de jeton et accès hors ligne requis

SAML 2.0 — Vue d'ensemble et métadonnées

Hawiyati implémente une pile Fournisseur d'identité SAML 2.0 personnalisée. La première étape de toute intégration SAML est l'échange de métadonnées entre le FI et votre Fournisseur de services (SP).

Point de terminaison des métadonnées FI

Hawiyati publie ses métadonnées FI à une URL bien connue. Configurez cette URL dans votre SP ou téléchargez et importez le XML manuellement.

GET https://<idp-host>/saml/metadata
Content-Type: application/xml

# Exemple développement :
GET https://dev.hawiyati.org:8085/saml/metadata
Champ de métadonnéesValeur
Entity IDConfiguré via HAWIYATI_IDP_ENTITY_ID (défaut dev : http://localhost:8085)
Point de terminaison SSO (HTTP-POST)https://<idp-host>/saml/sso
Point de terminaison SSO (HTTP-Redirect)https://<idp-host>/saml/sso
Point de terminaison SLO (HTTP-Redirect)https://<idp-host>/saml/slo
Point de terminaison SLO (HTTP-POST)https://<idp-host>/saml/slo
WantAuthnRequestsSignedfalse (requêtes signées acceptées mais non obligatoires par défaut)
Note sur le certificat Les métadonnées n'intègrent pas actuellement le certificat de signature du FI. Obtenez-le séparément auprès de votre administrateur Hawiyati et importez-le dans le SP manuellement, ou configurez le SP pour le récupérer et le vérifier à l'exécution via l'URL des métadonnées.

SAML 2.0 — Enregistrement du SP

Enregistrez votre Fournisseur de services dans Hawiyati via l'interface de la console d'administration ou en modifiant directement sp-registry.yml. Les deux méthodes écrivent dans le même magasin sous-jacent.

Méthode A — Console d'administration

1
Se connecter à la console d'administration

Accédez à https://<admin-host>/ et connectez-vous avec un compte opérateur admin.

2
Ouvrir Applications

Accédez à Applications dans la barre latérale gauche et cliquez sur Nouvelle application.

3
Sélectionner SAML 2.0

Choisissez le type de protocole SAML 2.0 et remplissez les champs d'enregistrement du SP.

4
Enregistrer — aucun redémarrage requis

Le SP est enregistré immédiatement. Les modifications se propagent via Redis pub/sub en ~10 secondes.

Méthode B — sp-registry.yml (Infrastructure as Code)

Ajoutez l'entrée SP directement dans dist/config/hawiyati-infra/sp-registry.yml. Le service infra recharge au démarrage.

Entrée SAML minimale

service-providers:
  - type: SAML
    entityId: https://app.example.com/saml/metadata
    displayName: Application Exemple
    active: true
    saml:
      acsUrl: https://app.example.com/saml/acs
      nameIdFormat: urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress
      wantAssertionsSigned: true

Entrée SAML complète avec toutes les options

service-providers:
  - type: SAML
    entityId: https://app.example.com/saml/metadata   # Doit correspondre exactement à l'entityID du SP
    displayName: Application Exemple
    description: Portail intranet département finance
    logoUri: https://app.example.com/assets/logo.png
    contacts: [email protected]
    active: true
    acceptedAuthMethods: [pwd, totp, fido2]            # Vide = toutes les méthodes
    saml:
      acsUrl: https://app.example.com/saml/acs
      metadataUrl: https://app.example.com/saml/metadata
      nameIdFormat: urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress
      assertionConsumerServiceBinding: urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST
      singleLogoutServiceUrl: https://app.example.com/saml/logout
      singleLogoutServiceBinding: urn:oasis:names:tc:SAML:2.0:bindings:HTTP-Redirect
      allowedAttributes: [email, displayName, groups]
      signatureRequired: false        # Exiger des AuthnRequests signées
      wantAssertionsSigned: true      # Hawiyati signe l'Assertion
      encryptAssertions: false        # Chiffrer l'assertion pour ce SP
      signingCertPath:                # Chemin du cert de signature SP (PEM)
      encryptionCertPath:             # Chemin du cert de chiffrement SP (PEM)

Référence d'enregistrement SP

ChampRequisDescription
entityIdOuiEntity ID du SP. Doit correspondre exactement à ce que le SP envoie dans l'Issuer de l'AuthnRequest.
displayNameOuiNom lisible affiché dans la console d'administration
activeOuiMettre à false pour désactiver le SP sans le supprimer
acceptedAuthMethodsNonRestreint les méthodes d'auth : pwd, totp, email_otp, sms_otp, fido2. Vide = toutes.
saml.acsUrlOuiURL du Service de consommation d'assertions (ACS). Hawiyati POSTe la SAMLResponse ici.
saml.nameIdFormatNonURI du format NameID. Défaut : unspecified.
saml.singleLogoutServiceUrlNonPoint de terminaison SLO du SP. Requis pour que le SLO fonctionne.
saml.wantAssertionsSignedNonDéfaut true. Signe l'élément Assertion avec la clé privée du FI.
saml.signatureRequiredNonDéfaut false. Rejette les AuthnRequests non signées si true.
saml.encryptAssertionsNonDéfaut false. Chiffre l'assertion avec le certificat public du SP (AES-256-GCM + RSA-OAEP).
Flux SSO SAML 2.0 initié par le fournisseur de services
Le fournisseur de services valide la liaison de requête, la signature, l'émetteur, la destination, l'audience et les contraintes temporelles.

SAML 2.0 — Flux SSO initié par le SP

Le flux SSO standard initié par le SP en 7 étapes. Comprendre chaque étape est essentiel pour diagnostiquer les problèmes d'intégration.

1
L'utilisateur accède au SP

L'utilisateur navigue vers une ressource protégée sur le SP (ex. https://app.example.com/tableau-de-bord). Le SP détecte l'absence de session active.

2
Le SP construit l'AuthnRequest

Le SP construit une AuthnRequest SAML (encodée en Base64 + deflate) et redirige le navigateur vers le point de terminaison SSO du FI avec les paramètres SAMLRequest et RelayState optionnel.

GET https://<idp>/saml/sso
  ?SAMLRequest=<base64-deflate-encoded-authnrequest>
  &RelayState=<état-opaque-sp>
3
Hawiyati valide l'AuthnRequest

Hawiyati décode et valide : l'émetteur (entityId du SP), la destination, le format. Vérifie si une session FI existe déjà pour le cookie du navigateur.

4
L'utilisateur s'authentifie auprès de Hawiyati

L'utilisateur saisit ses identifiants sur la page de connexion Hawiyati. La politique d'authentification pour ce SP est évaluée. L'utilisateur complète les étapes MFA requises (TOTP, FIDO2, OTP, etc.).

5
Hawiyati construit la SAMLResponse signée
Champs de l'assertion :
  NotBefore:    maintenant − 30 secondes (tolérance décalage horloge)
  NotOnOrAfter: maintenant + 3600 secondes (1 heure)
  Recipient:    URL ACS du SP
  Audience:     entityId du SP
  Signature:    XML-DSig sur l'élément Assertion (RSA-SHA256)
6
Le navigateur auto-soumet vers l'URL ACS
POST https://app.example.com/saml/acs
  SAMLResponse=<base64-encoded-xml>
  RelayState=<valeur-opaque-originale>
7
Le SP valide et crée la session

Le SP valide : la signature de l'assertion, la restriction d'audience, le destinataire, les conditions temporelles (NotOnOrAfter), le InResponseTo correspondant à l'identifiant de requête d'origine, la détection de rediffusion. En cas de succès, crée une session locale.

SSO initié par le FI Également pris en charge. La requête arrive à /saml/sso sans valeur InResponseTo. Le SP doit être configuré pour accepter les réponses non sollicitées pour que les flux initiés par le FI fonctionnent.

SAML 2.0 — Attributs et formats NameID

Formats NameID

FormatURIValeurQuand l'utiliser
Unspecified (défaut)...nameid-format:unspecifiedNom d'utilisateurLe SP accepte tout identifiant chaîne
Email address...nameid-format:emailAddressE-mail de l'utilisateurLe SP utilise l'e-mail comme identifiant principal et celui-ci est stable
Persistent...nameid-format:persistentUUID interne de l'utilisateurIdentifiant opaque durable ; n'expose pas de DCP
Transient...nameid-format:transientAléatoire par sessionPréservation de la vie privée ; le SP doit être sans état

Mapping des attributs

Seuls les attributs listés dans allowedAttributes sont transmis. Si la liste est vide, aucun attribut n'est transmis — seul le sujet NameID est attesté.

Nom de l'attributContenu
emailAdresse e-mail de l'utilisateur
displayNamePrénom + nom, ou nom d'utilisateur si non défini
firstNamePrénom
lastNameNom de famille
usernameNom d'utilisateur du compte
groupsListe des noms de groupes séparés par des virgules

SAML 2.0 — Déconnexion unique (SLO)

Hawiyati prend en charge la déconnexion unique (SLO) initiée par le SP et par le FI. Le SLO met fin à la session FI et envoie des demandes de déconnexion à tous les SP enregistrés ayant participé à la session.

SLO initié par le SP

1
Le SP envoie la LogoutRequest

Le SP envoie une LogoutRequest SAML à /saml/slo (liaison HTTP-Redirect ou HTTP-POST) incluant le SessionIndex de l'assertion originale.

2
Hawiyati met fin à la session FI

La session FI est invalidée dans Redis. Tous les jetons de session sont révoqués.

3
Propagation aux autres SP

Hawiyati envoie des demandes de déconnexion à tous les autres SP associés à la même session FI qui ont singleLogoutServiceUrl configuré. La non-réponse d'un SP est tolérée.

4
LogoutResponse retournée

Hawiyati retourne une LogoutResponse au SP initiateur, complétant le flux SLO.

Avertissement de compatibilité SLO Les implémentations SLO varient considérablement selon les fournisseurs. Testez toujours le flux SLO complet de bout en bout avec chaque SP. Certains SP omettent le SessionIndex ou utilisent une liaison différente de celle configurée.

Exigences SLO

  • L'enregistrement du SP doit inclure singleLogoutServiceUrl
  • Le SP doit implémenter le point de terminaison récepteur SLO et mettre fin à sa session locale
  • Le SP doit stocker le SessionIndex de l'assertion SSO et l'inclure dans les LogoutRequests

SAML 2.0 — Liste de contrôle sécurité

Avant de passer en production, vérifiez tous ces points côté SP :

  • Valider la signature de l'assertion sur chaque réponse SSO — ne jamais ignorer en production
  • Valider la restriction Audience correspond exactement à votre entityId
  • Valider le Recipient dans SubjectConfirmationData correspond à votre URL ACS
  • Appliquer les conditions temporelles : rejeter les assertions où NotOnOrAfter est dépassé (±30s de tolérance)
  • Implémenter la détection de rediffusion : stocker et rejeter les identifiants d'assertion déjà vus
  • Utiliser HTTPS pour votre URL ACS en production — HTTP permet l'interception d'assertions
  • Ne jamais journaliser le XML brut de l'assertion en production (contient des DCP)
  • Tester le SLO de bout en bout — un SLO défaillant permet aux sessions de persister après la déconnexion du FI
  • Planifier la rotation des certificats FI — configurer le SP pour accepter deux certificats pendant le chevauchement

Résolution des problèmes SAML

SymptômeCause probableRésolution
missing_saml_requestAuthnRequest non envoyée par le SPVérifier que le SP construit et envoie le paramètre SAMLRequest
AudienceRestrictionViolationIncompatibilité entityId SPComparer Audience dans l'assertion avec l'entityId dans l'enregistrement Hawiyati
RecipientMismatchIncompatibilité URL ACSMettre à jour acsUrl dans l'enregistrement SP pour correspondre exactement à l'URL ACS du SP
SignatureValidationFailureMauvais certificat de signature dans le SPTélécharger le certificat FI depuis /saml/metadata et le réimporter dans le SP
Le SLO ne déconnecte pas les autres appssingleLogoutServiceUrl manquantAjouter l'URL SLO à tous les enregistrements SP devant participer
Échecs d'horloge (NotYetValid)Dérive d'horloge serveurSynchroniser les horloges serveur avec NTP ; Hawiyati applique ±30s de tolérance

OIDC — Vue d'ensemble et découverte

Hawiyati agit en tant que Fournisseur OpenID Connect implémentant OIDC Core 1.0 avec le flux de code d'autorisation. Les applications délèguent l'authentification et reçoivent un jeton d'identité (ID Token) signé RS256.

Document de découverte OIDC

Hawiyati publie un document de découverte — utilisez toujours la découverte automatique plutôt que des URL codées en dur.

GET https://federation.dev.hawiyati.org:8087/.well-known/openid-configuration
ChampValeur
issuerConfiguré par déploiement (hawiyati.oidc.issuer)
authorization_endpoint{base-url}/oidc/authorize
token_endpoint{base-url}/oidc/token
userinfo_endpoint{base-url}/oidc/userinfo
jwks_uri{base-url}/oidc/jwks
end_session_endpoint{base-url}/oidc/logout

Fonctionnalités prises en charge

FonctionnalitéValeur
Types de réponsecode
Types de grantauthorization_code, refresh_token
Portéesopenid, profile, email, phone, address, offline_access
Algorithme de signatureRS256
Méthodes PKCES256 (requis), plain (déconseillé)
Méthodes d'auth clientnone, client_secret_basic, client_secret_post
Type de sujetpublic (UUID stable par utilisateur)
Enregistrement dynamiqueNon supporté — enregistrer via sp-registry.yml ou la console d'administration

OIDC — Enregistrement du client

Chaque partie de confiance doit être enregistrée dans le registre SP avant d'initier l'authentification. Hawiyati ne prend pas en charge l'enregistrement dynamique de clients.

Enregistrement via sp-registry.yml

- type: OIDC
  entityId: mon-app                          # identifiant unique
  displayName: Mon Application
  description: Portail RH interne
  active: true

  oidc:
    clientId: mon-app                        # envoyé dans les requêtes d'autorisation
    clientName: Mon Application
    redirectUris:
      - https://app.example.com/callback    # correspondance exacte — pas de jokers
    postLogoutRedirectUris:
      - https://app.example.com/
    scopes: [openid, profile, email]
    responseTypes: [code]
    tokenEndpointAuthMethod: client_secret_basic
    clientSecret: ${MON_APP_SECRET_CLIENT}   # laisser vide pour les clients publics
    requirePkce: true
    frontchannelLogoutUri: https://app.example.com/logout/fc
Correspondance URI de redirection Hawiyati applique une correspondance URI exacte — pas de jokers ni de correspondance de préfixe. Enregistrez chaque variante URI que vous utiliserez, y compris http://localhost:8080/callback pour le développement.
Flux OIDC Code d'autorisation avec PKCE
L'état, le nonce, le PKCE, l'émetteur, la signature, l'audience et la validation temporelle lient les échanges navigateur et jeton.

OIDC — Flux Code d'autorisation avec PKCE

L'unique flux pris en charge par Hawiyati. Le PKCE (S256) est requis pour tous les clients publics et fortement recommandé pour les clients confidentiels.

1
Générer les valeurs PKCE et l'état

Avant la redirection, générez la paire PKCE, l'état (CSRF) et le nonce (anti-rediffusion) côté serveur. Stockez-les dans la session côté serveur — jamais dans le navigateur.

// code_verifier : 32 octets aléatoires, encodage base64url sans rembourrage (43 caractères)
byte[] bytes = new byte[32];
new SecureRandom().nextBytes(bytes);
String codeVerifier = Base64.getUrlEncoder().withoutPadding()
    .encodeToString(bytes);

// code_challenge : SHA-256 des octets ASCII du vérificateur, encodage base64url
byte[] digest = MessageDigest.getInstance("SHA-256")
    .digest(codeVerifier.getBytes(StandardCharsets.US_ASCII));
String codeChallenge = Base64.getUrlEncoder().withoutPadding()
    .encodeToString(digest);
2
Rediriger l'utilisateur vers le point de terminaison d'autorisation
GET /oidc/authorize
  ?response_type=code
  &client_id=mon-app
  &redirect_uri=https%3A%2F%2Fapp.example.com%2Fcallback
  &scope=openid%20profile%20email
  &state=<état-aléatoire>
  &nonce=<nonce-aléatoire>
  &code_challenge=<base64url-sha256-du-vérificateur>
  &code_challenge_method=S256
3
L'utilisateur s'authentifie auprès de Hawiyati

Hawiyati affiche la page de connexion, évalue la politique d'authentification pour ce client et demande les étapes MFA requises. En cas de succès, redirige avec un code d'autorisation.

4
Gérer le callback
GET /callback?code=<code-autorisation>&state=<votre-état>

// Vérifier que l'état correspond à la session — c'est la vérification CSRF
// Les codes d'autorisation expirent en 60 secondes — échanger immédiatement
5
Échanger le code contre des jetons (serveur-à-serveur)
POST /oidc/token
Content-Type: application/x-www-form-urlencoded
Authorization: Basic <base64(client_id:client_secret)>  # clients confidentiels

grant_type=authorization_code
&code=<code-reçu>
&redirect_uri=https%3A%2F%2Fapp.example.com%2Fcallback
&client_id=mon-app
&code_verifier=<code-vérificateur-original>
6
Recevoir le jeton d'identité et le jeton d'accès
{
  "access_token":  "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
  "id_token":      "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
  "refresh_token": "rt_...",          // seulement avec la portée offline_access
  "token_type":    "Bearer",
  "expires_in":    3600,
  "scope":         "openid profile email"
}
JetonDurée de vie
Code d'autorisation60 secondes
Jeton d'accès3600 secondes (1 heure)
Jeton d'identité (ID Token)3600 secondes (1 heure)
Jeton de rafraîchissement2 592 000 secondes (30 jours)
7
Valider le jeton d'identité

Ne jamais ignorer la validation. Effectuez toutes les vérifications avant d'établir une session utilisateur.

  1. Décoder l'en-tête JWT ; vérifier que alg est RS256
  2. Récupérer la clé publique depuis JWKS en utilisant le kid de l'en-tête
  3. Vérifier la signature RS256 contre la clé publique
  4. Vérifier que iss correspond à l'émetteur du document de découverte
  5. Vérifier que aud correspond à votre client_id
  6. Vérifier exp > maintenant (±60s de tolérance de dérive d'horloge)
  7. Vérifier que nonce correspond à la valeur stockée en session
  8. Utiliser sub (pas l'email) comme identifiant utilisateur stable

OIDC — Claims du jeton et gestion des clés

Claims standard du jeton d'identité

ClaimDescription
issÉmetteur — émetteur OIDC configuré de Hawiyati
subSujet — UUID interne stable de l'utilisateur (utiliser comme identifiant utilisateur)
audAudience — votre client_id
expExpiration (epoch Unix)
iatÉmis à (epoch Unix)
auth_timeMoment où l'utilisateur s'est effectivement authentifié
nonceÉcho du nonce de la requête d'autorisation
at_hash128 bits de gauche de SHA-256(access_token), encodé base64url

Claims par portée

PortéeClaims inclus
profilename, given_name, family_name, preferred_username, picture, locale, birthdate
emailemail, email_verified
phonephone_number, phone_number_verified
addressaddress (structuré : formatted, street_address, locality, region, postal_code, country)
Claims manquants Les claims ne sont présents que lorsque l'attribut sous-jacent existe dans l'enregistrement utilisateur. Les attributs manquants sont silencieusement omis. Concevez votre SP pour gérer gracieusement les claims optionnels.

Gestion des clés JWKS

GET /oidc/jwks

{
  "keys": [
    {
      "kty": "RSA",
      "alg": "RS256",
      "use": "sig",
      "kid": "hawiyati-signing-key-1",
      "n": "...",
      "e": "AQAB"
    }
  ]
}

Utilisez le kid de l'en-tête JWT pour sélectionner la clé correspondante. Mettez en cache la réponse JWKS et actualisez-la uniquement lors de la rencontre d'un kid inconnu.

OIDC — Déconnexion

Déconnexion initiée par la partie de confiance

Pour mettre fin à la session Hawiyati, redirigez le navigateur de l'utilisateur vers le point de terminaison de fin de session :

GET /oidc/logout
  ?id_token_hint=<id_token>
  &post_logout_redirect_uri=https%3A%2F%2Fapp.example.com%2F
  &state=<état-optionnel>
Invalidation de double session requise Mettre fin à la session Hawiyati ne détruit pas automatiquement la session de votre application. Invalidez votre propre session avant ou immédiatement après l'initiation de la redirection. Le post_logout_redirect_uri doit être enregistré dans postLogoutRedirectUris de votre client. Les URI non enregistrées sont ignorées. Hawiyati identifie votre client via id_token_hint (ou un paramètre client_id) ; sans l'un des deux, l'utilisateur arrive sur la page de connexion Hawiyati au lieu de votre URI.

Déconnexion en canal arrière

Lorsqu'un utilisateur se déconnecte de Hawiyati, le FI envoie par POST un JWT logout_token signé au backchannelLogoutUri enregistré pour votre application. Votre point de terminaison doit retourner 200 OK.

Rafraîchissement du jeton

POST /oidc/token
Content-Type: application/x-www-form-urlencoded
Authorization: Basic <base64(client_id:client_secret)>

grant_type=refresh_token
&refresh_token=<jeton-refresh-stocké>
&client_id=mon-app

Les jetons de rafraîchissement expirent après 30 jours. Le jeton de rafraîchissement peut être renouvelé — stockez toujours le dernier retourné.

OIDC — Liste de contrôle sécurité

  • Paramètre state validé sur chaque callback — protection CSRF
  • nonce validé dans le jeton d'identité — protection anti-rediffusion
  • aud validé contre votre propre client_id
  • Signature du jeton vérifiée via la clé publique JWKS — jamais ignorée dans aucun chemin de code
  • code_verifier généré avec ≥32 octets d'entropie, stocké côté serveur uniquement
  • Échange de jetons (POST /oidc/token) effectué serveur-à-serveur — jamais depuis le navigateur
  • client_secret dans les variables d'environnement ou un gestionnaire de secrets — jamais dans le code source
  • Tous les URI de redirection sont HTTPS en production
  • exp du jeton d'identité vérifié avant d'accepter le jeton
  • sub (pas l'email) utilisé comme identifiant utilisateur stable
  • La déconnexion met fin à la fois à la session Hawiyati et à la session de votre propre application
Cycle de vie du provisionnement et de la réconciliation SCIM
Les identifiants externes stables et la réconciliation maintiennent la cohérence entre la source cliente et l'état des comptes Hawiyati.

SCIM 2.0 — Provisionnement entrant et diffusion sortante

Hawiyati agit à la fois comme serveur SCIM 2.0 pour le provisionnement entrant d'utilisateurs et de groupes, et comme client SCIM 2.0 pour la diffusion sortante vers les applications en aval. Votre outil de gouvernance des identités (ex. AD, Okta ou un provisionnement personnalisé) agit comme client SCIM en amont ; Hawiyati propage ensuite les événements de cycle de vie aux cibles SCIM configurées en aval.

Entrant + sortant Hawiyati prend en charge les deux directions : il accepte le provisionnement SCIM depuis les systèmes IdM en amont (entrant) et diffuse les événements de cycle de vie (création, mise à jour, suppression) vers les applications SCIM en aval (sortant). Configurez les cibles sortantes dans la console d'administration sous SCIM › Cibles de diffusion sortante.

Points de terminaison pris en charge

Point de terminaisonMéthodesDescription
/scim/v2/UsersGET, POST, PATCH, DELETEGestion des ressources utilisateurs
/scim/v2/Users/{id}GET, PUT, PATCH, DELETEOpérations sur un utilisateur individuel
/scim/v2/GroupsGET, POST, PATCH, DELETEGestion des ressources de groupes
/scim/v2/Groups/{id}GET, PUT, PATCH, DELETEOpérations sur un groupe individuel
/scim/v2/ServiceProviderConfigGETCapacités du serveur SCIM
/scim/v2/SchemasGETDéfinitions de schémas

Schéma d'extension SCIM Hawiyati

Champ d'extensionTypeDescription
externalIdstringIdentifiant propre au SP ; stocké dans users.external_id
sourceInstanceIdstringIdentifie quelle instance SP a provisionné cet utilisateur
pendingApprovalbooleanPositionne l'indicateur pendingApproval sur le compte utilisateur
Champs explicitement exclus L'extension SCIM ne prend PAS en charge les champs de justificatifs, de niveau d'assurance ou de KYC. L'envoi de ces champs dans une requête SCIM entraînera une erreur ou sera silencieusement ignoré. Les niveaux d'assurance sont définis exclusivement via le flux KYC — jamais via SCIM.

Flux de provisionnement

1
Le SP provisionne l'utilisateur via POST /scim/v2/Users

Le compte est créé dans Hawiyati avec active=false, pendingApproval=true — état MIGRATED_UNCLAIMED.

2
Jeton de réclamation généré

Un jeton de réclamation aléatoire de 256 bits (stockage HMAC-SHA256, TTL 15 min, usage unique) est généré. Un lien de réclamation est retourné ou envoyé par e-mail à l'utilisateur.

3
L'utilisateur suit le lien de réclamation

L'utilisateur arrive dans Hawiyati, complète la vérification d'identité, enrôle ses justificatifs et réclame le compte.

4
Le compte passe à ACTIF

active=true, pendingApproval=false. L'utilisateur peut maintenant s'authentifier auprès des SP enregistrés.

Exemple : Créer un utilisateur

POST /scim/v2/Users
Authorization: Bearer <jeton>
Content-Type: application/json

{
  "schemas": [
    "urn:ietf:params:scim:schemas:core:2.0:User",
    "urn:hawiyati:scim:extension"
  ],
  "userName": "[email protected]",
  "name": { "givenName": "Alice", "familyName": "Martin" },
  "emails": [{ "value": "[email protected]", "primary": true }],
  "phoneNumbers": [{ "value": "+213555001234", "primary": true }],
  "active": true,
  "urn:hawiyati:scim:extension": {
    "externalId": "ext-utilisateur-9876",
    "sourceInstanceId": "sp-finance-prod",
    "pendingApproval": true
  }
}

FIDO2 / WebAuthn / Passkeys

Hawiyati prend en charge FIDO2/WebAuthn pour une authentification résistante au phishing. Seule la clé publique est stockée — la clé privée ne quitte jamais le dispositif authentificateur.

Flux d'enregistrement

1
Le serveur émet le défi d'enregistrement

Hawiyati génère un défi aléatoire et un objet PublicKeyCredentialCreationOptions comprenant l'ID du RP, le handle utilisateur et les algorithmes pris en charge.

2
Le navigateur appelle l'API WebAuthn

navigator.credentials.create({ publicKey: options }) — déclenche l'interface utilisateur de l'authentificateur (Touch ID, Windows Hello, clé de sécurité physique, etc.).

3
Le serveur vérifie et stocke

Hawiyati vérifie l'attestationObject, l'authenticatorData et le clientDataJSON. La clé publique est stockée — jamais la clé privée.

Flux d'authentification

1
Le serveur émet le défi d'authentification

Hawiyati génère un défi aléatoire et un objet PublicKeyCredentialRequestOptions avec la liste des credentials enregistrés.

2
L'authentificateur signe

navigator.credentials.get({ publicKey: options }) — l'utilisateur vérifie sa présence via biométrie ou code PIN. L'authentificateur signe le défi avec la clé privée.

3
Le serveur vérifie la signature

Hawiyati vérifie la signature contre la clé publique stockée, vérifie le compteur de signatures (protection anti-clonage) et valide l'origine.

Niveau d'assurance accordé par FIDO2 Une authentification FIDO2 réussie accorde AAL2 (Niveau d'assurance d'authentification 2). Elle n'élève pas le niveau d'assurance identitaire (IAL) — les deux métriques sont indépendantes.