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é.
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 jeton | Assertion XML signée (XML-DSig) | JWT signé (RS256) |
| Liaison de transport | HTTP-POST, HTTP-Redirect | HTTPS uniquement (redirections navigateur + appel serveur-à-serveur) |
| Cas d'usage principal | SSO d'entreprise, applications legacy | Applications web modernes, SPA, mobile, API |
| Découverte | Échange de métadonnées XML | Document de découverte OIDC (/.well-known/openid-configuration) |
| Déconnexion | SLO (Single Logout) — propagation en éventail | Dé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 Hawiyati | Production (pile personnalisée — pas OpenSAML) | Production (pile personnalisée — pas Nimbus) |
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ées | Valeur |
|---|---|
| Entity ID | Configuré 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 |
| WantAuthnRequestsSigned | false (requêtes signées acceptées mais non obligatoires par défaut) |
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
Accédez à https://<admin-host>/ et connectez-vous avec un compte opérateur admin.
Accédez à Applications dans la barre latérale gauche et cliquez sur Nouvelle application.
Choisissez le type de protocole SAML 2.0 et remplissez les champs d'enregistrement du SP.
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
| Champ | Requis | Description |
|---|---|---|
entityId | Oui | Entity ID du SP. Doit correspondre exactement à ce que le SP envoie dans l'Issuer de l'AuthnRequest. |
displayName | Oui | Nom lisible affiché dans la console d'administration |
active | Oui | Mettre à false pour désactiver le SP sans le supprimer |
acceptedAuthMethods | Non | Restreint les méthodes d'auth : pwd, totp, email_otp, sms_otp, fido2. Vide = toutes. |
saml.acsUrl | Oui | URL du Service de consommation d'assertions (ACS). Hawiyati POSTe la SAMLResponse ici. |
saml.nameIdFormat | Non | URI du format NameID. Défaut : unspecified. |
saml.singleLogoutServiceUrl | Non | Point de terminaison SLO du SP. Requis pour que le SLO fonctionne. |
saml.wantAssertionsSigned | Non | Défaut true. Signe l'élément Assertion avec la clé privée du FI. |
saml.signatureRequired | Non | Défaut false. Rejette les AuthnRequests non signées si true. |
saml.encryptAssertions | Non | Défaut false. Chiffre l'assertion avec le certificat public du SP (AES-256-GCM + RSA-OAEP). |
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.
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.
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>
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.
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.).
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)
POST https://app.example.com/saml/acs
SAMLResponse=<base64-encoded-xml>
RelayState=<valeur-opaque-originale>
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.
/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
| Format | URI | Valeur | Quand l'utiliser |
|---|---|---|---|
| Unspecified (défaut) | ...nameid-format:unspecified | Nom d'utilisateur | Le SP accepte tout identifiant chaîne |
| Email address | ...nameid-format:emailAddress | E-mail de l'utilisateur | Le SP utilise l'e-mail comme identifiant principal et celui-ci est stable |
| Persistent | ...nameid-format:persistent | UUID interne de l'utilisateur | Identifiant opaque durable ; n'expose pas de DCP |
| Transient | ...nameid-format:transient | Aléatoire par session | Pré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'attribut | Contenu |
|---|---|
email | Adresse e-mail de l'utilisateur |
displayName | Prénom + nom, ou nom d'utilisateur si non défini |
firstName | Prénom |
lastName | Nom de famille |
username | Nom d'utilisateur du compte |
groups | Liste 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
Le SP envoie une LogoutRequest SAML à /saml/slo (liaison HTTP-Redirect ou HTTP-POST) incluant le SessionIndex de l'assertion originale.
La session FI est invalidée dans Redis. Tous les jetons de session sont révoqués.
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.
Hawiyati retourne une LogoutResponse au SP initiateur, complétant le flux SLO.
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
SessionIndexde 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
Audiencecorrespond exactement à votre entityId - Valider le
Recipientdans SubjectConfirmationData correspond à votre URL ACS - Appliquer les conditions temporelles : rejeter les assertions où
NotOnOrAfterest 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ôme | Cause probable | Résolution |
|---|---|---|
missing_saml_request | AuthnRequest non envoyée par le SP | Vérifier que le SP construit et envoie le paramètre SAMLRequest |
AudienceRestrictionViolation | Incompatibilité entityId SP | Comparer Audience dans l'assertion avec l'entityId dans l'enregistrement Hawiyati |
RecipientMismatch | Incompatibilité URL ACS | Mettre à jour acsUrl dans l'enregistrement SP pour correspondre exactement à l'URL ACS du SP |
SignatureValidationFailure | Mauvais certificat de signature dans le SP | Télécharger le certificat FI depuis /saml/metadata et le réimporter dans le SP |
| Le SLO ne déconnecte pas les autres apps | singleLogoutServiceUrl manquant | Ajouter l'URL SLO à tous les enregistrements SP devant participer |
Échecs d'horloge (NotYetValid) | Dérive d'horloge serveur | Synchroniser 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
| Champ | Valeur |
|---|---|
issuer | Configuré 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éponse | code |
| Types de grant | authorization_code, refresh_token |
| Portées | openid, profile, email, phone, address, offline_access |
| Algorithme de signature | RS256 |
| Méthodes PKCE | S256 (requis), plain (déconseillé) |
| Méthodes d'auth client | none, client_secret_basic, client_secret_post |
| Type de sujet | public (UUID stable par utilisateur) |
| Enregistrement dynamique | Non 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
http://localhost:8080/callback pour le développement.
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.
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);
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
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.
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
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>
{
"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"
}
| Jeton | Durée de vie |
|---|---|
| Code d'autorisation | 60 secondes |
| Jeton d'accès | 3600 secondes (1 heure) |
| Jeton d'identité (ID Token) | 3600 secondes (1 heure) |
| Jeton de rafraîchissement | 2 592 000 secondes (30 jours) |
Ne jamais ignorer la validation. Effectuez toutes les vérifications avant d'établir une session utilisateur.
- Décoder l'en-tête JWT ; vérifier que
algestRS256 - Récupérer la clé publique depuis JWKS en utilisant le
kidde l'en-tête - Vérifier la signature RS256 contre la clé publique
- Vérifier que
isscorrespond à l'émetteur du document de découverte - Vérifier que
audcorrespond à votreclient_id - Vérifier
exp > maintenant(±60s de tolérance de dérive d'horloge) - Vérifier que
noncecorrespond à la valeur stockée en session - Utiliser
sub(pas l'email) comme identifiant utilisateur stable
OIDC — Claims du jeton et gestion des clés
Claims standard du jeton d'identité
| Claim | Description |
|---|---|
iss | Émetteur — émetteur OIDC configuré de Hawiyati |
sub | Sujet — UUID interne stable de l'utilisateur (utiliser comme identifiant utilisateur) |
aud | Audience — votre client_id |
exp | Expiration (epoch Unix) |
iat | Émis à (epoch Unix) |
auth_time | Moment où l'utilisateur s'est effectivement authentifié |
nonce | Écho du nonce de la requête d'autorisation |
at_hash | 128 bits de gauche de SHA-256(access_token), encodé base64url |
Claims par portée
| Portée | Claims inclus |
|---|---|
profile | name, given_name, family_name, preferred_username, picture, locale, birthdate |
email | email, email_verified |
phone | phone_number, phone_number_verified |
address | address (structuré : formatted, street_address, locality, region, postal_code, country) |
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>
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
statevalidé sur chaque callback — protection CSRF noncevalidé dans le jeton d'identité — protection anti-rediffusionaudvalidé contre votre propreclient_id- Signature du jeton vérifiée via la clé publique JWKS — jamais ignorée dans aucun chemin de code
code_verifiergé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_secretdans les variables d'environnement ou un gestionnaire de secrets — jamais dans le code source- Tous les URI de redirection sont HTTPS en production
expdu jeton d'identité vérifié avant d'accepter le jetonsub(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
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.
Points de terminaison pris en charge
| Point de terminaison | Méthodes | Description |
|---|---|---|
/scim/v2/Users | GET, POST, PATCH, DELETE | Gestion des ressources utilisateurs |
/scim/v2/Users/{id} | GET, PUT, PATCH, DELETE | Opérations sur un utilisateur individuel |
/scim/v2/Groups | GET, POST, PATCH, DELETE | Gestion des ressources de groupes |
/scim/v2/Groups/{id} | GET, PUT, PATCH, DELETE | Opérations sur un groupe individuel |
/scim/v2/ServiceProviderConfig | GET | Capacités du serveur SCIM |
/scim/v2/Schemas | GET | Définitions de schémas |
Schéma d'extension SCIM Hawiyati
| Champ d'extension | Type | Description |
|---|---|---|
externalId | string | Identifiant propre au SP ; stocké dans users.external_id |
sourceInstanceId | string | Identifie quelle instance SP a provisionné cet utilisateur |
pendingApproval | boolean | Positionne l'indicateur pendingApproval sur le compte utilisateur |
Flux de provisionnement
Le compte est créé dans Hawiyati avec active=false, pendingApproval=true — état MIGRATED_UNCLAIMED.
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.
L'utilisateur arrive dans Hawiyati, complète la vérification d'identité, enrôle ses justificatifs et réclame le compte.
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
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.
navigator.credentials.create({ publicKey: options }) — déclenche l'interface utilisateur de l'authentificateur (Touch ID, Windows Hello, clé de sécurité physique, etc.).
Hawiyati vérifie l'attestationObject, l'authenticatorData et le clientDataJSON. La clé publique est stockée — jamais la clé privée.
Flux d'authentification
Hawiyati génère un défi aléatoire et un objet PublicKeyCredentialRequestOptions avec la liste des credentials enregistrés.
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.
Hawiyati vérifie la signature contre la clé publique stockée, vérifie le compteur de signatures (protection anti-clonage) et valide l'origine.