"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; const headings = [{ "data": { "id": "quest-ce-que-liam-", "hProperties": { "id": "quest-ce-que-liam-" } }, "depth": 2, "value": "Qu'est-ce que l'IAM ?" }, { "data": { "id": "authentification-vs-autorisation", "hProperties": { "id": "authentification-vs-autorisation" } }, "depth": 3, "value": "Authentification vs autorisation" }, { "data": { "id": "oauth", "hProperties": { "id": "oauth" } }, "depth": 2, "value": "OAuth" }, { "data": { "id": "openid-connect-oidc", "hProperties": { "id": "openid-connect-oidc" } }, "depth": 2, "value": "OpenID Connect (OIDC)" }, { "data": { "id": "scénario-dexemple--se-connecter-avec-google", "hProperties": { "id": "scénario-dexemple--se-connecter-avec-google" } }, "depth": 3, "value": "Scénario d'exemple : \"Se connecter avec Google\"" }, { "data": { "id": "saml", "hProperties": { "id": "saml" } }, "depth": 2, "value": "SAML" }, { "data": { "id": "comment-saml-se-compare-t-il-à-oidc-", "hProperties": { "id": "comment-saml-se-compare-t-il-à-oidc-" } }, "depth": 3, "value": "Comment SAML se compare-t-il à OIDC ?" }, { "data": { "id": "single-sign-on-sso", "hProperties": { "id": "single-sign-on-sso" } }, "depth": 2, "value": "Single sign-on (SSO)" }, { "data": { "id": "comment-fonctionne-le-sso-", "hProperties": { "id": "comment-fonctionne-le-sso-" } }, "depth": 3, "value": "Comment fonctionne le SSO ?" }, { "data": { "id": "exemple-de-sso-basé-sur-oidc", "hProperties": { "id": "exemple-de-sso-basé-sur-oidc" } }, "depth": 4, "value": "Exemple de SSO basé sur OIDC" }, { "data": { "id": "sso-dentreprise", "hProperties": { "id": "sso-dentreprise" } }, "depth": 3, "value": "SSO d'entreprise" }, { "data": { "id": "exemple--ajout-dun-fournisseur-de-sso-dentreprise", "hProperties": { "id": "exemple--ajout-dun-fournisseur-de-sso-dentreprise" } }, "depth": 4, "value": "Exemple : ajout d'un fournisseur de SSO d'entreprise" }, { "data": { "id": "jwt", "hProperties": { "id": "jwt" } }, "depth": 2, "value": "JWT" }, { "data": { "id": "récapitulatif", "hProperties": { "id": "récapitulatif" } }, "depth": 2, "value": "Récapitulatif" }]; const readingTime = { "minutes": 7, "words": 2044, "text": "7 min read" }; const frontmatter = undefined; function _createMdxContent(props) { const _components = { a: "a", code: "code", em: "em", h2: "h2", h3: "h3", h4: "h4", hr: "hr", li: "li", p: "p", pre: "pre", span: "span", strong: "strong", ul: "ul", ..._provideComponents(), ...props.components }, {LogtoCloudButton, Note} = _components; if (!LogtoCloudButton) _missingMdxReference("LogtoCloudButton", true); if (!Note) _missingMdxReference("Note", true); return _jsxs(_Fragment, { children: [_jsxs(_components.p, { children: ["Le domaine de la ", _jsx(_components.a, { href: "https://auth.wiki/iam", children: "gestion des identités et des accès (IAM)" }), " est devenu plus complexe ces dernières années. Les termes habituels comme ", _jsx(_components.a, { href: "https://auth.wiki/oauth", children: "OAuth" }), ", ", _jsx(_components.a, { href: "https://auth.wiki/openid-connect", children: "OpenID Connect (OIDC)" }), ", ", _jsx(_components.a, { href: "https://auth.wiki/saml", children: "SAML" }), ", ", _jsx(_components.a, { href: "https://auth.wiki/single-sign-on", children: "SSO" }), " et ", _jsx(_components.a, { href: "https://auth.wiki/jwt", children: "JWT" }), " sont souvent utilisés, mais que signifient-ils ? Comment fonctionnent-ils ensemble ? Explorons ces concepts et cadres pour les rendre plus compréhensibles et pratiques."] }), "\n", _jsx(Note, { children: _jsxs(_components.p, { children: ["Chacun de ces protocoles et cadres peut être exploré en profondeur. Cet article vise à fournir une compréhension fondamentale. Pour des informations détaillées sur chaque sujet, visitez ", _jsx(_components.a, { href: "https://auth.wiki", children: "Auth Wiki" }), "."] }) }), "\n", _jsxs(_components.h2, { id: "quest-ce-que-liam-", children: ["Qu'est-ce que l'IAM ?", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#quest-ce-que-liam-", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: ["La gestion des identités et des accès (IAM) est un concept large qui implique la gestion des ", _jsx(_components.strong, { children: "identités" }), " numériques et la mise en œuvre du ", _jsx(_components.strong, { children: "contrôle d'accès" }), ". Les cadres et protocoles mentionnés précédemment relèvent de l'IAM, chacun abordant des défis spécifiques dans ce domaine."] }), "\n", _jsx(_components.p, { children: "En essence, l'IAM concerne :" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Identité" }), " : Une représentation numérique d'un utilisateur, d'un service ou d'un appareil. Une identité inclut généralement des attributs tels que le nom, l'email, les rôles, etc., pour décrire l'entité."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Accès" }), " : La capacité à interagir avec des ressources, effectuer des actions ou utiliser des services. L'accès définit quelles actions peuvent être effectuées sur quelles ressources."] }), "\n"] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "graph LR\n subgraph User\n Name\n Email\n Role\n end\n\n API\n\n User -->|GET| API\n" }) }), "\n", _jsxs(_components.p, { children: ["Dans le diagramme ci-dessus, un utilisateur (identité) souhaite effectuer une requête ", _jsx(_components.code, { children: "GET" }), " sur une API (ressource). Les attributs de l'utilisateur - nom, email et rôle - décrivent l'identité."] }), "\n", _jsxs(_components.h3, { id: "authentification-vs-autorisation", children: ["Authentification vs autorisation", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#authentification-vs-autorisation", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "L'authentification et l'autorisation apparaissent souvent ensemble dans les discussions sur l'IAM. Clarifions leurs définitions :" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Authentification" }), " : Le processus de vérification de la propriété d'une identité. Il répond à la question : \"Quelle identité possédez-vous ?\""] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Autorisation" }), " : Le processus de détermination des actions qu'une identité authentifiée peut effectuer sur une ressource. Il répond à la question : \"Que pouvez-vous faire ?\""] }), "\n"] }), "\n", _jsx(Note, { title: "Quelle est la différence entre l'autorisation et le contrôle d'accès ?", children: _jsxs(_components.p, { children: ["L'autorisation est un sous-ensemble du contrôle d'accès. Le contrôle d'accès est un concept plus large qui inclut l'autorisation et d'autres restrictions. Pour plus de détails, voir ", _jsx(_components.a, { href: "https://auth.wiki/access-control", children: "contrôle d'accès" }), "."] }) }), "\n", _jsx(_components.p, { children: "Dans l'exemple précédent :" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Avant que l'utilisateur (identité) puisse effectuer des actions, il doit compléter le processus d'", _jsx(_components.strong, { children: "authentification" }), "."] }), "\n", _jsxs(_components.li, { children: ["Après l'authentification, le système doit déterminer si l'utilisateur peut effectuer une requête ", _jsx(_components.code, { children: "GET" }), " (action) sur l'API (ressource), c'est-à-dire compléter le processus d'", _jsx(_components.strong, { children: "autorisation" }), "."] }), "\n"] }), "\n", _jsx(_components.hr, {}), "\n", _jsx(_components.p, { children: "Armés de cette connaissance fondamentale, démystifions les autres acronymes et protocoles." }), "\n", _jsxs(_components.h2, { id: "oauth", children: ["OAuth", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#oauth", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: [_jsx(_components.a, { href: "https://auth.wiki/oauth-2.0", children: "OAuth 2.0" }), ", communément appelé OAuth, est un cadre d'", _jsx(_components.strong, { children: "autorisation" }), " qui permet à une application d'accéder à des ressources protégées sur une autre application (typiquement au nom d'un utilisateur)."] }), "\n", _jsxs(_components.p, { children: ["Par exemple, imaginez que vous avez une application web appelée ", _jsx(_components.em, { children: "MonAppli" }), " qui souhaite accéder au Google Drive d'un utilisateur. Au lieu de demander à l'utilisateur de partager ses identifiants Google Drive, ", _jsx(_components.em, { children: "MonAppli" }), " peut utiliser OAuth 2.0 pour demander l'autorisation (", _jsx(_components.strong, { children: "autorisation" }), ") de Google pour accéder au Drive de l'utilisateur."] }), "\n", _jsx(_components.p, { children: "Voici un diagramme simplifié illustrant le processus OAuth :" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n autonumber\n actor User\n participant MonAppli\n participant Google\n\n User->>MonAppli: Ouvrir MonAppli et
cliquer sur \"Connecter Google Drive\"\n MonAppli->>Google: Redirection vers Google
avec demande d'autorisation\n Google->>User: Demande de connexion à Google\n User->>Google: Se connecter\n Google->>User: Demande l'autorisation d'accéder
à Google Drive\n User->>Google: Accorder l'accès à MonAppli\n Google->>MonAppli: Redirection vers MonAppli
avec un jeton d'accès\n MonAppli->>Google: Utiliser le jeton d'accès pour
accéder à Google Drive\n" }) }), "\n", _jsx(_components.p, { children: "Dans ce processus :" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.em, { children: "MonAppli" }), " est le client (identité) demandant l'accès à Google Drive (ressource)."] }), "\n", _jsxs(_components.li, { children: ["L'utilisateur (propriétaire de la ressource) accorde à ", _jsx(_components.em, { children: "MonAppli" }), " la permission à l'étape 6, complétant le processus d'", _jsx(_components.strong, { children: "autorisation" }), "."] }), "\n"] }), "\n", _jsx(Note, { children: _jsx(_components.p, { children: "OAuth 2.0 ne définit pas comment les utilisateurs s'authentifient auprès de Google (étapes 3 et 4). Cet aspect est laissé à l'implémentation par Google." }) }), "\n", _jsxs(_components.p, { children: ["Un élément clé de OAuth 2.0 est le ", _jsx(_components.strong, { children: "jeton d'accès" }), ", que le client utilise pour démontrer l'autorisation de l'utilisateur à accéder aux ressources. Pour en savoir plus, consultez ", _jsx(_components.a, { href: "https://auth.wiki/access-token", children: "Jeton d'accès" }), "."] }), "\n", _jsxs(_components.h2, { id: "openid-connect-oidc", children: ["OpenID Connect (OIDC)", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#openid-connect-oidc", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: [_jsx(_components.a, { href: "https://auth.wiki/openid-connect", children: "OpenID Connect (OIDC)" }), " est une couche d'", _jsx(_components.strong, { children: "authentification" }), " construite sur OAuth 2.0. Elle ajoute des fonctionnalités spécifiquement pour l'authentification, telles que les ", _jsx(_components.a, { href: "https://auth.wiki/id-token", children: "jetons d'identité" }), " et un ", _jsx(_components.a, { href: "https://auth.wiki/userinfo-endpoint", children: "point de terminaison UserInfo" }), ", ce qui la rend adaptée à la fois pour l'authentification et l'autorisation."] }), "\n", _jsxs(_components.p, { children: ["Si nous revisitons le flux OAuth, ajouter OIDC introduit un ", _jsx(_components.strong, { children: "jeton d'identité" }), ". Ce jeton contient des informations sur l'utilisateur authentifié et permet à MonAppli de vérifier l'identité de l'utilisateur."] }), "\n", _jsxs(_components.h3, { id: "scénario-dexemple--se-connecter-avec-google", children: ["Scénario d'exemple : \"Se connecter avec Google\"", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#scénario-dexemple--se-connecter-avec-google", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "Changeons d'exemple. Si MonAppli veut permettre aux utilisateurs de se connecter en utilisant leurs comptes Google, l'objectif se déplace vers l'authentification plutôt que l'accès aux ressources. Dans ce cas, OIDC est plus adapté. Voici à quoi ressemble le flux OIDC :" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n autonumber\n actor User\n participant MonAppli\n participant Google\n\n User->>MonAppli: Cliquer sur \"Se connecter avec Google\"\n MonAppli->>Google: Redirection avec demande d'authentification\n Google->>User: Demande de connexion à Google\n User->>Google: Se connecter\n Google->>User: Demander l'autorisation de
partager les informations de l'utilisateur\n User->>Google: Accorder la permission\n Google->>MonAppli: Redirection vers MonAppli
avec jetons d'identité et d'accès\n MonAppli->>MonAppli: Vérifier et extraire les
informations utilisateur du jeton d'identité\n" }) }), "\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Différence essentielle" }), " : En plus d'un jeton d'accès, OIDC fournit un ", _jsx(_components.strong, { children: "jeton d'identité" }), ", qui permet à MonAppli d'authentifier l'utilisateur sans nécessiter de demandes supplémentaires."] }), "\n", _jsxs(_components.p, { children: ["OIDC partage les définitions de ", _jsx(_components.a, { href: "https://auth.wiki/oauth-2.0-grant", children: "délégation" }), " d'OAuth 2.0, garantissant la compatibilité et la cohérence entre les deux cadres."] }), "\n", _jsxs(_components.h2, { id: "saml", children: ["SAML", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#saml", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: [_jsx(_components.a, { href: "https://auth.wiki/saml", children: "Security Assertion Markup Language (SAML)" }), " est un cadre basé sur XML pour échanger des données d'", _jsx(_components.strong, { children: "authentification" }), " et d'", _jsx(_components.strong, { children: "autorisation" }), " entre des parties. SAML, introduit au début des années 2000, a été largement adopté dans les environnements d'entreprise."] }), "\n", _jsxs(_components.h3, { id: "comment-saml-se-compare-t-il-à-oidc-", children: ["Comment SAML se compare-t-il à OIDC ?", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#comment-saml-se-compare-t-il-à-oidc-", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "SAML et OIDC sont fonctionnellement similaires mais diffèrent dans leurs détails de mise en œuvre :" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "SAML" }), " : Utilise des assertions basées sur XML et est souvent considéré comme plus complexe."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "OIDC" }), " : Utilise JSON et JWT, ce qui le rend plus léger et plus convivial pour les développeurs."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Les applications modernes préfèrent souvent OIDC pour sa simplicité et sa flexibilité, mais SAML reste répandu dans les systèmes hérités et les cas d'utilisation en entreprise." }), "\n", _jsxs(_components.h2, { id: "single-sign-on-sso", children: ["Single sign-on (SSO)", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#single-sign-on-sso", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: [_jsx(_components.a, { href: "https://auth.wiki/sso", children: "Single sign-on (SSO)" }), " est un schéma d'", _jsx(_components.strong, { children: "authentification" }), " qui permet aux utilisateurs d'accéder à plusieurs applications et services avec une seule série d'identifiants. Au lieu de se connecter individuellement à chaque application, l'utilisateur se connecte une fois et accède à tous les systèmes connectés."] }), "\n", _jsxs(_components.h3, { id: "comment-fonctionne-le-sso-", children: ["Comment fonctionne le SSO ?", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#comment-fonctionne-le-sso-", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: ["Le SSO repose sur un ", _jsx(_components.a, { href: "https://auth.wiki/identity-provider", children: "fournisseur d'identité (IdP)" }), " central pour gérer les identités des utilisateurs. L'IdP authentifie l'utilisateur et fournit des services tels que l'authentification et l'autorisation aux applications connectées."] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "graph LR\n User --> AppA\n User --> AppB\n AppA <--> IdP[Identity Provider]\n AppB <--> IdP\n User -->|SSO| IdP\n" }) }), "\n", _jsx(_components.p, { children: "L'IdP peut utiliser des protocoles comme OIDC, OAuth 2.0, SAML, ou d'autres pour offrir ces services. Un seul IdP peut prendre en charge plusieurs protocoles pour répondre aux besoins divers des différentes applications." }), "\n", _jsxs(_components.h4, { id: "exemple-de-sso-basé-sur-oidc", children: ["Exemple de SSO basé sur OIDC", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#exemple-de-sso-basé-sur-oidc", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "Explorons un exemple de SSO basé sur OIDC :" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n actor User\n participant AppA\n participant AppB\n participant IdP\n\n User->>AppA: Accéder à l'application A\n AppA->>IdP: Redirection vers IdP\n IdP->>User: Demander les identifiants\n User->>IdP: Fournir les identifiants\n IdP->>AppA: Envoyer le jeton d'identité\n AppA->>User: Accorder l'accès\n User->>AppB: Accéder à l'application B\n AppB->>IdP: Redirection vers IdP\n IdP->>IdP: Utilisateur déjà authentifié\n IdP->>AppB: Envoyer le jeton d'identité\n AppB->>User: Accorder l'accès\n" }) }), "\n", _jsx(_components.p, { children: "Dans ce flux, l'utilisateur se connecte à l'IdP une fois et est authentifié sur plusieurs applications (AppA et AppB)." }), "\n", _jsxs(_components.h3, { id: "sso-dentreprise", children: ["SSO d'entreprise", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#sso-dentreprise", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: ["Bien que le SSO soit un concept large, vous pouvez également rencontrer le terme ", _jsx(_components.a, { href: "https://auth.wiki/enterprise-sso", children: "SSO d'entreprise" }), ", qui se réfère à un type spécifique de SSO conçu pour les environnements d'entreprise (typiquement pour les employés et les partenaires)."] }), "\n", _jsx(_components.p, { children: "Lorsqu'un client demande le SSO pour votre application, il est important de clarifier ses besoins et les protocoles qu'il utilise. Dans la plupart des cas, cela signifie que pour des domaines email spécifiques, ils veulent que votre application redirige les utilisateurs vers leur IdP (qui implémente le SSO d'entreprise) pour l'authentification." }), "\n", _jsxs(_components.h4, { id: "exemple--ajout-dun-fournisseur-de-sso-dentreprise", children: ["Exemple : ajout d'un fournisseur de SSO d'entreprise", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#exemple--ajout-dun-fournisseur-de-sso-dentreprise", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "Voici un exemple simplifié d'intégration d'un fournisseur de SSO d'entreprise (Banana) avec votre application (MonAppli) :" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n actor User\n participant MonAppli\n participant IdP as MonAppli IdP\n participant Banana as Banana IdP\n\n User->>MonAppli: Cliquer sur \"Se connecter\"\n MonAppli->>IdP: Redirection vers l'IdP\n IdP->>User: Demander les identifiants\n User->>IdP: Fournir l'email Banana\n IdP->>Banana: Redirection vers Banana IdP\n Banana->>User: Demander les identifiants\n User->>Banana: Fournir les identifiants\n Banana->>IdP: Envoyer la réponse\n IdP->>MonAppli: Envoyer la réponse\n MonAppli->>User: Accorder l'accès à MonAppli et afficher les données utilisateur\n" }) }), "\n", _jsx(Note, { title: "Le saviez-vous ?", children: _jsx(_components.p, { children: "La redirection vers l'IdP est un modèle courant dans les flux SSO. Cette approche permet à l'IdP de maintenir un point central pour les sessions utilisateur tout en offrant des services d'authentification et d'autorisation à plusieurs applications." }) }), "\n", _jsxs(_components.h2, { id: "jwt", children: ["JWT", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#jwt", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: [_jsx(_components.a, { href: "https://auth.wiki/jwt", children: "JSON Web Token (JWT)" }), " est une norme ouverte définie dans la RFC 7519 qui permet une communication sécurisée entre deux parties. C'est le format standard pour les jetons d'identité dans OIDC et est largement utilisé pour les jetons d'accès OAuth 2.0."] }), "\n", _jsx(_components.p, { children: "Voici les caractéristiques clés de JWT :" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Compact" }), " : Les JWT sont des objets JSON encodés dans un format compact, ce qui les rend faciles à transmettre et à stocker."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Autonome" }), " : Les JWT contiennent toutes les informations nécessaires sur l'utilisateur et le jeton lui-même."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Vérifiable et encryptable" }), " : Les JWT peuvent être signés et chiffrés pour assurer l'intégrité et la confidentialité des données."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Un JWT typique ressemble à ceci :" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { children: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmb28iLCJuYW1lIjoiSm9obiBEb2UifQ.XM-XSs2Lmp76IcTQ7tVdFcZzN4W_WcoKMNANp925Q9g\n" }) }), "\n", _jsx(_components.p, { children: "Ce JWT se compose de trois parties séparées par des points :" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { children: "{{header}}.{{payload}}.{{signature}}\n" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "En-tête" }), " : Contient des métadonnées sur le jeton, telles que le type de jeton et l'algorithme de signature."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Charge utile" }), " : Contient des informations sur l'identité et le jeton lui-même."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Signature" }), " : Vérifie l'intégrité du jeton."] }), "\n"] }), "\n", _jsx(_components.p, { children: "L'en-tête et la charge utile sont des objets JSON encodés en base64. Le JWT ci-dessus peut être décodé comme suit :" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-jsonc", children: "// En-tête\n{\n \"alg\": \"HS256\",\n \"typ\": \"JWT\"\n}\n// Charge utile\n{\n \"sub\": \"foo\",\n \"name\": \"John Doe\"\n}\n" }) }), "\n", _jsxs(_components.p, { children: ["Grâce au JWT, le client peut décoder le jeton et extraire les informations de l'utilisateur sans faire de demandes supplémentaires au fournisseur d'identité. Pour en savoir plus sur le JWT, visitez ", _jsx(_components.a, { href: "https://auth.wiki/jwt", children: "JSON Web Token (JWT)" }), "."] }), "\n", _jsxs(_components.h2, { id: "récapitulatif", children: ["Récapitulatif", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#récapitulatif", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "Nous avons couvert beaucoup de sujets dans cet article. Résumons les points clés avec un exemple :" }), "\n", _jsxs(_components.p, { children: ["Imaginez que vous avez une application web, AppA, qui nécessite une solution de ", _jsx(_components.strong, { children: "gestion des identités et des accès (IAM)" }), ". Vous choisissez ", _jsx(_components.strong, { children: "Logto" }), ", un fournisseur d'identité qui utilise ", _jsx(_components.strong, { children: "OpenID Connect (OIDC)" }), " pour l'authentification. Comme OIDC est construit sur ", _jsx(_components.strong, { children: "OAuth 2.0" }), ", Logto prend également en charge l'autorisation pour votre application."] }), "\n", _jsxs(_components.p, { children: ["Pour réduire les frictions pour vos utilisateurs, vous activez \"Se connecter avec Google\" dans Logto. Cela utilise ", _jsx(_components.strong, { children: "OAuth 2.0" }), " pour échanger des données d'autorisation et des informations utilisateur entre Logto et Google."] }), "\n", _jsxs(_components.p, { children: ["Après que l'utilisateur se soit connecté à AppA via Logto, AppA reçoit un jeton d'identité, qui est un ", _jsx(_components.strong, { children: "JSON Web Token (JWT)" }), " contenant les informations de l'utilisateur."] }), "\n", _jsxs(_components.p, { children: ["À mesure que votre entreprise se développe, vous lancez une nouvelle application, AppB, qui nécessite également l'authentification des utilisateurs. Comme Logto est déjà configuré, vous pouvez réutiliser le même flux d'authentification pour AppB. Vos utilisateurs peuvent désormais se connecter à la fois à AppA et à AppB avec un seul jeu d'identifiants, une fonctionnalité connue sous le nom de ", _jsx(_components.strong, { children: "single sign-on (SSO)" }), "."] }), "\n", _jsxs(_components.p, { children: ["Plus tard, un partenaire commercial vous demande de connecter leur système de SSO d'entreprise, qui utilise le ", _jsx(_components.strong, { children: "Security Assertion Markup Language (SAML)" }), ". Vous découvrez que Logto prend en charge les connexions SAML, vous configurez donc une connexion entre Logto et le système SSO du partenaire. Désormais, les utilisateurs de l'organisation du partenaire peuvent également se connecter à AppA et AppB en utilisant leurs identifiants existants."] }), "\n", _jsx(_components.hr, {}), "\n", _jsxs(_components.p, { children: ["J'espère que cet article a clarifié ces concepts pour vous. Pour des explications et exemples plus approfondis, consultez ", _jsx(_components.a, { href: "https://auth.wiki", children: "Auth Wiki" }), ". Si vous cherchez une solution IAM pour votre application, envisagez d'utiliser un service géré comme ", _jsx(_components.a, { href: "https://logto.io", children: "Logto" }), " pour gagner du temps et des efforts."] }), "\n", _jsx(LogtoCloudButton, {})] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = { ..._provideComponents(), ...props.components }; return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { headings, readingTime, frontmatter, default: MDXContent }; function _missingMdxReference(id, component) { throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it."); }