"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; const headings = [{ "data": { "id": "cosè-liam", "hProperties": { "id": "cosè-liam" } }, "depth": 2, "value": "Cos'è l'IAM?" }, { "data": { "id": "autenticazione-vs-autorizzazione", "hProperties": { "id": "autenticazione-vs-autorizzazione" } }, "depth": 3, "value": "Autenticazione vs. autorizzazione" }, { "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": "scenario-di-esempio-accedi-con-google", "hProperties": { "id": "scenario-di-esempio-accedi-con-google" } }, "depth": 3, "value": "Scenario di esempio: \"Accedi con Google\"" }, { "data": { "id": "saml", "hProperties": { "id": "saml" } }, "depth": 2, "value": "SAML" }, { "data": { "id": "come-si-confronta-saml-con-oidc", "hProperties": { "id": "come-si-confronta-saml-con-oidc" } }, "depth": 3, "value": "Come si confronta SAML con OIDC?" }, { "data": { "id": "accesso-singolo-sso", "hProperties": { "id": "accesso-singolo-sso" } }, "depth": 2, "value": "Accesso singolo (SSO)" }, { "data": { "id": "come-funziona-il-sso", "hProperties": { "id": "come-funziona-il-sso" } }, "depth": 3, "value": "Come funziona il SSO?" }, { "data": { "id": "esempio-di-sso-basato-su-oidc", "hProperties": { "id": "esempio-di-sso-basato-su-oidc" } }, "depth": 4, "value": "Esempio di SSO Basato su OIDC" }, { "data": { "id": "sso-aziendale", "hProperties": { "id": "sso-aziendale" } }, "depth": 3, "value": "SSO aziendale" }, { "data": { "id": "esempio-aggiunta-di-un-provider-di-sso-aziendale", "hProperties": { "id": "esempio-aggiunta-di-un-provider-di-sso-aziendale" } }, "depth": 4, "value": "Esempio: Aggiunta di un provider di SSO aziendale" }, { "data": { "id": "jwt", "hProperties": { "id": "jwt" } }, "depth": 2, "value": "JWT" }, { "data": { "id": "ricapitolazione", "hProperties": { "id": "ricapitolazione" } }, "depth": 2, "value": "Ricapitolazione" }]; const readingTime = { "minutes": 6, "words": 1845, "text": "6 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: ["Il dominio della ", _jsx(_components.a, { href: "https://auth.wiki/iam", children: "gestione delle identità e degli accessi (IAM)" }), " è diventato più intricato negli ultimi anni. Termini sofisticati come ", _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" }), " e ", _jsx(_components.a, { href: "https://auth.wiki/jwt", children: "JWT" }), " sono usati frequentemente, ma cosa significano? Come funzionano insieme? Esploriamo questi concetti e framework per renderli più comprensibili e pratici."] }), "\n", _jsx(Note, { children: _jsxs(_components.p, { children: ["Ognuno di questi protocolli e framework può essere esplorato in maggiore profondità. Questo articolo mira a fornire una comprensione di base. Per approfondimenti dettagliati su ciascun argomento, visita ", _jsx(_components.a, { href: "https://auth.wiki", children: "Auth Wiki" }), "."] }) }), "\n", _jsxs(_components.h2, { id: "cosè-liam", children: ["Cos'è l'IAM?", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#cosè-liam", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: ["La gestione delle identità e degli accessi (IAM) è un concetto ampio che implica la gestione delle ", _jsx(_components.strong, { children: "identità" }), " digitali e l'implementazione del ", _jsx(_components.strong, { children: "controllo degli accessi" }), ". I framework e i protocolli menzionati in precedenza rientrano nell'IAM, ciascuno affrontando sfide specifiche in questo spazio."] }), "\n", _jsx(_components.p, { children: "In sostanza, l'IAM riguarda:" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Identità" }), ": Una rappresentazione digitale di un utente, servizio o dispositivo. Un'identità include tipicamente attributi come nome, email, ruoli, ecc., per descrivere l'entità."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Accesso" }), ": La capacità di interagire con le risorse, eseguire azioni o utilizzare servizi. L'accesso definisce quali azioni possono essere eseguite su quali risorse."] }), "\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: ["Nel diagramma sopra, un utente (identità) vuole eseguire una richiesta ", _jsx(_components.code, { children: "GET" }), " su un'API (risorsa). Gli attributi dell'utente - nome, email e ruolo - descrivono l'identità."] }), "\n", _jsxs(_components.h3, { id: "autenticazione-vs-autorizzazione", children: ["Autenticazione vs. autorizzazione", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#autenticazione-vs-autorizzazione", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "L'autenticazione e l'autorizzazione appaiono spesso insieme nelle discussioni sull'IAM. Chiarifichiamo le loro definizioni:" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Autenticazione" }), ": Il processo di verifica del possesso di un'identità. Risponde alla domanda: \"Quale identità possiedi?\""] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Autorizzazione" }), ": Il processo di determinazione di quali azioni un'identità autenticata può eseguire su una risorsa. Risponde alla domanda: \"Cosa puoi fare?\""] }), "\n"] }), "\n", _jsx(Note, { title: "Qual è la differenza tra autorizzazione e controllo degli accessi?", children: _jsxs(_components.p, { children: ["L'autorizzazione è un sottoinsieme del controllo degli accessi. Il controllo degli accessi è un concetto più ampio che include l'autorizzazione e altre restrizioni. Per maggiori dettagli, vedi ", _jsx(_components.a, { href: "https://auth.wiki/access-control", children: "controllo degli accessi" }), "."] }) }), "\n", _jsx(_components.p, { children: "Nell'esempio precedente:" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Prima che l'utente (identità) possa eseguire qualsiasi azione, deve completare il processo di ", _jsx(_components.strong, { children: "autenticazione" }), "."] }), "\n", _jsxs(_components.li, { children: ["Dopo l'autenticazione, il sistema deve determinare se l'utente può eseguire una richiesta ", _jsx(_components.code, { children: "GET" }), " (azione) sull'API (risorsa), cioè completare il processo di ", _jsx(_components.strong, { children: "autorizzazione" }), "."] }), "\n"] }), "\n", _jsx(_components.hr, {}), "\n", _jsx(_components.p, { children: "Armati di questa conoscenza di base, smistiamo gli altri acronimi e protocolli." }), "\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" }), ", comunemente chiamato OAuth, è un framework di ", _jsx(_components.strong, { children: "autorizzazione" }), " che consente a un'applicazione di accedere a risorse protette su un'altra applicazione (tipicamente per conto di un utente)."] }), "\n", _jsxs(_components.p, { children: ["Ad esempio, immagina di avere un'applicazione web chiamata ", _jsx(_components.em, { children: "MyApp" }), " che vuole accedere al Google Drive di un utente. Invece di chiedere all'utente di condividere le proprie credenziali di Google Drive, ", _jsx(_components.em, { children: "MyApp" }), " può usare OAuth 2.0 per richiedere il permesso (", _jsx(_components.strong, { children: "autorizzazione" }), ") da Google per accedere al Drive dell'utente."] }), "\n", _jsx(_components.p, { children: "Ecco un diagramma semplificato che illustra il flusso di OAuth:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n autonumber\n actor User\n participant MyApp\n participant Google\n\n User->>MyApp: Apri MyApp e
clic \"Collega Google Drive\"\n MyApp->>Google: Reindirizza a Google
con richiesta di autorizzazione\n Google->>User: Richiedi login a Google\n User->>Google: Accedi\n Google->>User: Chiedi permesso per
accedere a Google Drive\n User->>Google: Concedi l'accesso a MyApp\n Google->>MyApp: Reindirizza a MyApp
con un token di accesso\n MyApp->>Google: Usa il token di accesso per
accedere a Google Drive\n" }) }), "\n", _jsx(_components.p, { children: "In questo flusso:" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.em, { children: "MyApp" }), " è il client (identità) che richiede l'accesso a Google Drive (risorsa)."] }), "\n", _jsxs(_components.li, { children: ["L'utente (proprietario della risorsa) concede a ", _jsx(_components.em, { children: "MyApp" }), " il permesso nel passo 6, completando il processo di ", _jsx(_components.strong, { children: "autorizzazione" }), "."] }), "\n"] }), "\n", _jsx(Note, { children: _jsx(_components.p, { children: "OAuth 2.0 non definisce come gli utenti si autenticano a Google (passi 3 e 4). Questo aspetto è lasciato all'implementazione da parte di Google." }) }), "\n", _jsxs(_components.p, { children: ["Un elemento chiave in OAuth 2.0 è il ", _jsx(_components.strong, { children: "token di accesso" }), ", che il client usa per dimostrare l'autorizzazione dell'utente ad accedere alle risorse. Per approfondire, vedi ", _jsx(_components.a, { href: "https://auth.wiki/access-token", children: "Access token" }), "."] }), "\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)" }), " è uno strato di ", _jsx(_components.strong, { children: "autenticazione" }), " costruito sopra OAuth 2.0. Aggiunge funzionalità specifiche per l'autenticazione, come i ", _jsx(_components.a, { href: "https://auth.wiki/id-token", children: "token ID" }), " e un ", _jsx(_components.a, { href: "https://auth.wiki/userinfo-endpoint", children: "endpoint UserInfo" }), ", rendendolo adatto sia per l'autenticazione che per l'autorizzazione."] }), "\n", _jsxs(_components.p, { children: ["Se rivisitiamo il flusso di OAuth, aggiungendo OIDC si introduce un ", _jsx(_components.strong, { children: "ID token" }), ". Questo token contiene informazioni sull'utente autenticato e consente a MyApp di verificare l'identità dell'utente."] }), "\n", _jsxs(_components.h3, { id: "scenario-di-esempio-accedi-con-google", children: ["Scenario di esempio: \"Accedi con Google\"", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#scenario-di-esempio-accedi-con-google", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "Cambiamo esempio. Se MyApp vuole consentire agli utenti di accedere utilizzando i loro account Google, l'obiettivo si sposta sull'autenticazione piuttosto che sull'accesso alle risorse. In questo caso, OIDC è una scelta migliore. Ecco come appare il flusso OIDC:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n autonumber\n actor User\n participant MyApp\n participant Google\n\n User->>MyApp: Clic \"Accedi con Google\"\n MyApp->>Google: Reindirizza con richiesta di autenticazione\n Google->>User: Richiedi login a Google\n User->>Google: Accedi\n Google->>User: Richiedi permesso per
condividere le informazioni utente\n User->>Google: Concedi permesso\n Google->>MyApp: Reindirizza a MyApp
con token ID e accesso\n MyApp->>MyApp: Verifica ed estrai le informazioni utente
dal token ID\n" }) }), "\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Differenza chiave" }), ": Oltre a un token di accesso, OIDC fornisce un ", _jsx(_components.strong, { children: "token ID" }), ", che consente a MyApp di autenticare l'utente senza necessitare di ulteriori richieste."] }), "\n", _jsxs(_components.p, { children: ["OIDC condivide le definizioni di ", _jsx(_components.a, { href: "https://auth.wiki/oauth-2.0-grant", children: "grant" }), " di OAuth 2.0, garantendo compatibilità e coerenza tra i due framework."] }), "\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)" }), " è un framework basato su XML per lo scambio di dati di ", _jsx(_components.strong, { children: "autenticazione" }), " e ", _jsx(_components.strong, { children: "autorizzazione" }), " tra le parti. SAML, introdotto nei primi anni 2000, è stato ampiamente adottato negli ambienti aziendali."] }), "\n", _jsxs(_components.h3, { id: "come-si-confronta-saml-con-oidc", children: ["Come si confronta SAML con OIDC?", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#come-si-confronta-saml-con-oidc", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "SAML e OIDC sono funzionalmente simili ma differiscono nei dettagli di implementazione:" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "SAML" }), ": Usa asserzioni basate su XML ed è spesso considerato più complesso."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "OIDC" }), ": Utilizza JSON e JWT, rendendolo più leggero e più adatto agli sviluppatori."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Le applicazioni moderne spesso preferiscono OIDC per la sua semplicità e flessibilità, ma SAML rimane prevalente nei sistemi legacy e nei casi d'uso aziendali." }), "\n", _jsxs(_components.h2, { id: "accesso-singolo-sso", children: ["Accesso singolo (SSO)", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#accesso-singolo-sso", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: [_jsx(_components.a, { href: "https://auth.wiki/sso", children: "Accesso singolo (SSO)" }), " è uno schema di ", _jsx(_components.strong, { children: "autenticazione" }), " che consente agli utenti di accedere a più applicazioni e servizi con un unico set di credenziali. Invece di accedere a ciascuna applicazione individualmente, l'utente accede una volta sola e ottiene l'accesso a tutti i sistemi connessi."] }), "\n", _jsxs(_components.h3, { id: "come-funziona-il-sso", children: ["Come funziona il SSO?", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#come-funziona-il-sso", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: ["Il SSO si basa su un ", _jsx(_components.a, { href: "https://auth.wiki/identity-provider", children: "provider di identità (IdP)" }), " centrale per gestire le identità degli utenti. L'IdP autentica l'utente e fornisce servizi come autenticazione e autorizzazione alle applicazioni connesse."] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "graph LR\n User --> AppA\n User --> AppB\n AppA <--> IdP[Provider di Identità]\n AppB <--> IdP\n User -->|SSO| IdP\n" }) }), "\n", _jsx(_components.p, { children: "L'IdP può utilizzare protocolli come OIDC, OAuth 2.0, SAML o altri per fornire questi servizi. Un singolo IdP può supportare più protocolli per soddisfare le esigenze diverse delle varie applicazioni." }), "\n", _jsxs(_components.h4, { id: "esempio-di-sso-basato-su-oidc", children: ["Esempio di SSO Basato su OIDC", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#esempio-di-sso-basato-su-oidc", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "Esploriamo un esempio di SSO basato su 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: Accedi a Applicazione A\n AppA->>IdP: Reindirizza a IdP\n IdP->>User: Richiedi credenziali\n User->>IdP: Fornisci credenziali\n IdP->>AppA: Invia token ID\n AppA->>User: Concedere accesso\n User->>AppB: Accedi a Applicazione B\n AppB->>IdP: Reindirizza a IdP\n IdP->>IdP: Utente già autenticato\n IdP->>AppB: Invia token ID\n AppB->>User: Concedere accesso\n" }) }), "\n", _jsx(_components.p, { children: "In questo flusso, l'utente accede all'IdP una volta sola ed è autenticato su più applicazioni (AppA e AppB)." }), "\n", _jsxs(_components.h3, { id: "sso-aziendale", children: ["SSO aziendale", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#sso-aziendale", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: ["Anche se SSO è un concetto ampio, potresti anche incontrare il termine ", _jsx(_components.a, { href: "https://auth.wiki/enterprise-sso", children: "SSO aziendale" }), ", che si riferisce a un tipo specifico di SSO progettato per ambienti aziendali (tipicamente per dipendenti e partner)."] }), "\n", _jsx(_components.p, { children: "Quando un cliente richiede SSO per la tua applicazione, è importante chiarire le loro esigenze e i protocolli che stanno utilizzando. Nella maggior parte dei casi, ciò significa che per domini email specifici, vogliono che la tua applicazione reindirizzi gli utenti al loro IdP (che implementa l'SSO aziendale) per l'autenticazione." }), "\n", _jsxs(_components.h4, { id: "esempio-aggiunta-di-un-provider-di-sso-aziendale", children: ["Esempio: Aggiunta di un provider di SSO aziendale", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#esempio-aggiunta-di-un-provider-di-sso-aziendale", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "Ecco un esempio semplificato di integrazione di un provider di SSO aziendale (Banana) con la tua applicazione (MyApp):" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n actor User\n participant MyApp\n participant IdP as MyApp IdP\n participant Banana as Banana IdP\n\n User->>MyApp: Clicca \"Accedi\"\n MyApp->>IdP: Reindirizza a IdP\n IdP->>User: Richiedi credenziali\n User->>IdP: Fornisci email Banana\n IdP->>Banana: Reindirizza a Banana IdP\n Banana->>User: Richiedi credenziali\n User->>Banana: Fornisci credenziali\n Banana->>IdP: Invia risposta\n IdP->>MyApp: Invia risposta\n MyApp->>User: Concedere l'accesso a MyApp e mostrare dati dell'utente\n" }) }), "\n", _jsx(Note, { title: "Lo sapevi?", children: _jsx(_components.p, { children: "Reindirizzare all'IdP è un modello comune nei flussi SSO. Questo approccio consente all'IdP di mantenere un punto centrale per le sessioni utente fornendo servizi di autenticazione e autorizzazione a più applicazioni." }) }), "\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)" }), " è uno standard aperto definito nella RFC 7519 che consente la comunicazione sicura tra due parti. È il formato standard per i token ID in OIDC ed è ampiamente utilizzato per i token di accesso OAuth 2.0."] }), "\n", _jsx(_components.p, { children: "Ecco le caratteristiche chiave di JWT:" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Compatti" }), ": I JWT sono oggetti JSON codificati in un formato compatto, il che li rende facili da trasmettere e memorizzare."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Autocontenuti" }), ": I JWT contengono tutte le informazioni necessarie sull'utente e sul token stesso."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Verificabili e cifrabili" }), ": I JWT possono essere firmati e cifrati per garantire integrità dei dati e riservatezza."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Un tipico JWT ha questo aspetto:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { children: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJmb28iLCJuYW1lIjoiSm9obiBEb2UifQ.XM-XSs2Lmp76IcTQ7tVdFcZzN4W_WcoKMNANp925Q9g\n" }) }), "\n", _jsx(_components.p, { children: "Questo JWT è composto da tre parti separate da punti:" }), "\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: "Header" }), ": Contiene i metadati del token, come il tipo di token e l'algoritmo di firma."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Payload" }), ": Contiene informazioni sull'identità e sul token stesso."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Signature" }), ": Verifica l'integrità del token."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Sia l'header che il payload sono oggetti JSON codificati in base64. Il JWT sopra può essere decodificato come segue:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-jsonc", children: "// Header\n{\n \"alg\": \"HS256\",\n \"typ\": \"JWT\"\n}\n// Payload\n{\n \"sub\": \"foo\",\n \"name\": \"John Doe\"\n}\n" }) }), "\n", _jsxs(_components.p, { children: ["Usando JWT, il client può decodificare il token ed estrarre le informazioni dell'utente senza dover fare richieste aggiuntive al provider di identità. Per saperne di più sui JWT, visita ", _jsx(_components.a, { href: "https://auth.wiki/jwt", children: "JSON Web Token (JWT)" }), "."] }), "\n", _jsxs(_components.h2, { id: "ricapitolazione", children: ["Ricapitolazione", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#ricapitolazione", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "Abbiamo coperto molti aspetti in questo articolo. Riassumiamo i punti chiave con un esempio:" }), "\n", _jsxs(_components.p, { children: ["Immagina di avere un'applicazione web, AppA, che richiede una soluzione di ", _jsx(_components.strong, { children: "gestione delle identità e degli accessi (IAM)" }), ". Scegli ", _jsx(_components.strong, { children: "Logto" }), ", un provider di identità che utilizza ", _jsx(_components.strong, { children: "OpenID Connect (OIDC)" }), " per l'autenticazione. Poiché OIDC è costruito su ", _jsx(_components.strong, { children: "OAuth 2.0" }), ", Logto supporta anche l'autorizzazione per la tua applicazione."] }), "\n", _jsxs(_components.p, { children: ["Per ridurre gli attriti per i tuoi utenti, abiliti \"Accedi con Google\" in Logto. Questo utilizza ", _jsx(_components.strong, { children: "OAuth 2.0" }), " per scambiare dati di autorizzazione e informazioni utente tra Logto e Google."] }), "\n", _jsxs(_components.p, { children: ["Dopo che l'utente ha effettuato l'accesso a AppA tramite Logto, AppA riceve un token ID, che è un ", _jsx(_components.strong, { children: "JSON Web Token (JWT)" }), " contenente le informazioni sull'utente."] }), "\n", _jsxs(_components.p, { children: ["Mentre la tua attività cresce, lanci una nuova applicazione, AppB, che ha anch'essa bisogno dell'autenticazione dell'utente. Poiché Logto è già impostato, puoi riutilizzare lo stesso flusso di autenticazione per AppB. I tuoi utenti possono ora accedere sia a AppA che a AppB con un unico set di credenziali, una caratteristica nota come ", _jsx(_components.strong, { children: "accesso singolo (SSO)" }), "."] }), "\n", _jsxs(_components.p, { children: ["Successivamente, un partner commerciale ti chiede di connettere il loro sistema SSO aziendale, che utilizza ", _jsx(_components.strong, { children: "Security Assertion Markup Language (SAML)" }), ". Scopri che Logto supporta connessioni SAML, quindi imposti una connessione tra Logto e il sistema SSO del partner. Ora, gli utenti dell'organizzazione del partner possono accedere anche a AppA e AppB utilizzando le loro credenziali esistenti."] }), "\n", _jsx(_components.hr, {}), "\n", _jsxs(_components.p, { children: ["Spero che questo articolo abbia chiarito questi concetti per te. Per spiegazioni più approfondite ed esempi, consulta ", _jsx(_components.a, { href: "https://auth.wiki", children: "Auth Wiki" }), ". Se stai cercando una soluzione IAM per la tua applicazione, considera l'uso di un servizio gestito come ", _jsx(_components.a, { href: "https://logto.io", children: "Logto" }), " per risparmiare tempo e fatica."] }), "\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."); }