"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; const headings = [{ "data": { "id": "introduzione", "hProperties": { "id": "introduzione" } }, "depth": 2, "value": "Introduzione" }, { "data": { "id": "oauth-20-vs-openid-connect", "hProperties": { "id": "oauth-20-vs-openid-connect" } }, "depth": 2, "value": "OAuth 2.0 vs. OpenID Connect" }, { "data": { "id": "oauth-20", "hProperties": { "id": "oauth-20" } }, "depth": 3, "value": "OAuth 2.0" }, { "data": { "id": "openid-connect-oidc", "hProperties": { "id": "openid-connect-oidc" } }, "depth": 3, "value": "OpenID Connect (OIDC)" }, { "data": { "id": "tipi-di-applicazione", "hProperties": { "id": "tipi-di-applicazione" } }, "depth": 2, "value": "Tipi di applicazione" }, { "data": { "id": "applicazioni-web-che-girano-su-un-server", "hProperties": { "id": "applicazioni-web-che-girano-su-un-server" } }, "depth": 3, "value": "Applicazioni web che girano su un server" }, { "data": { "id": "applicazioni-a-singola-pagina-spas", "hProperties": { "id": "applicazioni-a-singola-pagina-spas" } }, "depth": 3, "value": "Applicazioni a singola pagina (SPAs)" }, { "data": { "id": "applicazioni-mobili", "hProperties": { "id": "applicazioni-mobili" } }, "depth": 3, "value": "Applicazioni mobili" }, { "data": { "id": "applicazioni-machine-to-machine-m2m", "hProperties": { "id": "applicazioni-machine-to-machine-m2m" } }, "depth": 3, "value": "Applicazioni machine-to-machine (M2M)" }, { "data": { "id": "applicazioni-in-esecuzione-su-dispositivi-iot", "hProperties": { "id": "applicazioni-in-esecuzione-su-dispositivi-iot" } }, "depth": 3, "value": "Applicazioni in esecuzione su dispositivi IoT" }, { "data": { "id": "proteggi-la-tua-api", "hProperties": { "id": "proteggi-la-tua-api" } }, "depth": 2, "value": "Proteggi la tua API" }, { "data": { "id": "design-dellautorizzazione", "hProperties": { "id": "design-dellautorizzazione" } }, "depth": 3, "value": "Design dell'autorizzazione" }, { "data": { "id": "token-di-accesso", "hProperties": { "id": "token-di-accesso" } }, "depth": 3, "value": "Token di accesso" }, { "data": { "id": "indicatori-di-risorse", "hProperties": { "id": "indicatori-di-risorse" } }, "depth": 3, "value": "Indicatori di risorse" }, { "data": { "id": "metti-tutto-insieme", "hProperties": { "id": "metti-tutto-insieme" } }, "depth": 2, "value": "Metti tutto insieme" }, { "data": { "id": "note-di-chiusura", "hProperties": { "id": "note-di-chiusura" } }, "depth": 2, "value": "Note di chiusura" }]; const readingTime = { "minutes": 13, "words": 3852, "text": "13 min read" }; const frontmatter = undefined; function _createMdxContent(props) { const _components = { a: "a", blockquote: "blockquote", code: "code", h2: "h2", h3: "h3", li: "li", ol: "ol", p: "p", pre: "pre", span: "span", strong: "strong", ul: "ul", ..._provideComponents(), ...props.components }, {LogtoCloudButton} = _components; if (!LogtoCloudButton) _missingMdxReference("LogtoCloudButton", true); return _jsxs(_Fragment, { children: [_jsxs(_components.h2, { id: "introduzione", children: ["Introduzione", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#introduzione", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "Le applicazioni basate sul cloud sono la tendenza al giorno d'oggi. Mentre il tipo di applicazione varia (web, mobile, desktop, ecc.), hanno tutte un backend cloud che fornisce servizi come storage, computing e database. La maggior parte delle volte, queste applicazioni necessitano di autenticare gli utenti e autorizzarli ad accedere a determinate risorse." }), "\n", _jsx(_components.p, { children: "Mentre sono possibili meccanismi di autenticazione e autorizzazione fai-da-te, la sicurezza è diventata una delle principali preoccupazioni quando si sviluppano applicazioni cloud. Fortunatamente, la nostra industria ha standard collaudati come OAuth 2.0 e OpenID Connect per aiutarci ad implementare autenticazione e autorizzazione sicure." }), "\n", _jsx(_components.p, { children: "Questo post ha le seguenti premesse:" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "Hai una conoscenza di base dello sviluppo di applicazioni (web, mobile o di qualsiasi altro tipo)." }), "\n", _jsx(_components.li, { children: "Hai sentito parlare dei concetti di autenticazione e autorizzazione." }), "\n", _jsxs(_components.li, { children: ["Hai sentito parlare di ", _jsx(_components.a, { href: "https://auth.wiki/oauth-2.0", children: "OAuth 2.0" }), " e ", _jsx(_components.a, { href: "https://auth.wiki/openid-connect", children: "OpenID Connect" }), "."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Sì, \"sentito\" è sufficiente sia per 2 che per 3. Questo post utilizzerà esempi del mondo reale per spiegare i concetti e illustrare il processo con diagrammi. Iniziamo!" }), "\n", _jsxs(_components.h2, { id: "oauth-20-vs-openid-connect", children: ["OAuth 2.0 vs. OpenID Connect", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#oauth-20-vs-openid-connect", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "Se sei familiare con OAuth 2.0 e OpenID Connect, puoi anche continuare a leggere perché copriremo alcuni esempi del mondo reale in questa sezione; se sei nuovo a questi standard, è anche sicuro continuare poiché li introdurremo in modo semplice." }), "\n", _jsxs(_components.h3, { id: "oauth-20", children: ["OAuth 2.0", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#oauth-20", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: [_jsx(_components.a, { href: "https://auth.wiki/oauth-2.0", children: "OAuth 2.0" }), " è un framework di autorizzazione che consente a un'applicazione di ottenere un accesso limitato a risorse protette su un'altra applicazione per conto di un utente o dell'applicazione stessa. La maggior parte dei servizi popolari come Google, Facebook e GitHub utilizzano OAuth 2.0 per il login sociale (ad esempio, \"Accedi con Google\")."] }), "\n", _jsx(_components.p, { children: "Per esempio, hai un'applicazione web MyApp che vuole accedere al Google Drive dell'utente. Invece di chiedere all'utente di condividere le proprie credenziali Google Drive, MyApp può utilizzare OAuth 2.0 per richiedere l'accesso a Google Drive per conto dell'utente. Ecco un flusso semplificato:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n participant User\n participant MyApp\n participant Google\n\n User->>MyApp: Apre MyApp e
clicca su \"Connetti Google Drive\"\n MyApp->>Google: Reindirizza a Google\n Google->>User: Accedi a Google\n User->>Google: Accedi\n Google->>User: Chiedi il permesso
di accedere a Google Drive\n User->>Google: Concedi l'accesso a MyApp\n Google->>MyApp: Reindirizza a MyApp
con dati di autorizzazione (es. token di accesso)\n MyApp->>Google: Accedi al Google Drive dell'utente\n" }) }), "\n", _jsxs(_components.p, { children: ["In questo flusso, MyApp non vede mai le credenziali del Google Drive dell'utente. Invece, riceve un ", _jsx(_components.a, { href: "https://auth.wiki/access-token", children: "token di accesso" }), " da Google che gli consente di accedere a Google Drive per conto dell'utente."] }), "\n", _jsxs(_components.p, { children: ["In termini di OAuth 2.0, MyApp è il ", _jsx(_components.a, { href: "https://auth.wiki/client", children: "client" }), ", Google è sia il ", _jsx(_components.a, { href: "https://auth.wiki/authorization-server", children: "server di autorizzazione" }), " sia il ", _jsx(_components.a, { href: "https://auth.wiki/resource-server", children: "server di risorse" }), " per semplicità. Nel mondo reale, spesso abbiamo server di autorizzazione e di risorse separati per offrire un'esperienza di single sign-on (SSO). Per esempio, Google è il server di autorizzazione e può avere diversi server di risorse come Google Drive, Gmail, e YouTube."] }), "\n", _jsx(_components.p, { children: "Nota che il flusso di autorizzazione effettivo è più complesso di questo. OAuth 2.0 ha diversi tipi di concessione, ambiti e altri concetti di cui dovresti essere a conoscenza. Mettiamolo da parte per ora e passiamo a OpenID Connect." }), "\n", _jsxs(_components.h3, { 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: ["OAuth 2.0 è ottimo per l'autorizzazione, ma potresti notare che non ha un modo per identificare l'utente (cioè, autenticazione). ", _jsx(_components.a, { href: "https://auth.wiki/openid-connect", children: "OpenID Connect" }), " è uno strato di identità sopra OAuth 2.0 che aggiunge capacità di autenticazione."] }), "\n", _jsx(_components.p, { children: "Nell'esempio sopra, MyApp ha bisogno di sapere chi è l'utente prima di avviare il flusso di autorizzazione. Nota che ci sono due utenti coinvolti qui: l'utente di MyApp e l'utente di Google Drive. In questo caso, MyApp ha bisogno di conoscere l'utente della propria applicazione." }), "\n", _jsx(_components.p, { children: "Vediamo un esempio diretto, assumendo che gli utenti possano accedere a MyApp usando nome utente e password:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n participant User\n participant MyApp\n participant IdP as Identity provider (IdP)\n\n User->>MyApp: Apre MyApp e
clicca su \"Accedi\"\n MyApp->>IdP: Reindirizza a IdP\n IdP->>User: Chiedi nome utente e password\n User->>IdP: Inserisci nome utente e password\n IdP->>IdP: Autentica utente\n IdP->>MyApp: Reindirizza a MyApp
con dati di autenticazione e
autorizzazione (es. token ID)\n MyApp->>User: Mostra profilo utente
(tramite token ID o endpoint userinfo)\n" }) }), "\n", _jsxs(_components.p, { children: ["Poiché stiamo autenticando l'utente della nostra propria applicazione, di solito non è necessario chiedere il permesso come ha fatto Google nel flusso OAuth 2.0. Nel frattempo, ci serve qualcosa che possa identificare l'utente. OpenID Connect introduce i concetti come ", _jsx(_components.strong, { children: "token ID" }), " e ", _jsx(_components.strong, { children: "endpoint userinfo" }), " per aiutarci."] }), "\n", _jsxs(_components.blockquote, { children: ["\n", _jsxs(_components.p, { children: ["Potresti notare che il ", _jsx(_components.strong, { children: _jsx(_components.a, { href: "https://auth.wiki/identity-provider", children: "provider di identità (IdP)" }) }), " è un nuovo partecipante autonomo nel flusso. È lo stesso del ", _jsx(_components.strong, { children: "server di autorizzazione" }), " in OAuth 2.0, ma per maggiore chiarezza, usiamo il termine IdP per mostrare che è responsabile dell'autenticazione e gestione delle identità degli utenti."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Quando la tua azienda cresce, potresti avere più applicazioni che condividono lo stesso database utenti. Proprio come OAuth 2.0, OpenID Connect ti consente di avere un unico server di autorizzazione che può autenticare gli utenti per più applicazioni. Se l'utente è già connesso a un'applicazione, non ha bisogno di inserire nuovamente le proprie credenziali quando un'altra applicazione li reindirizza a IdP. Il flusso può essere completato automaticamente senza interazione dell'utente. Questo si chiama single sign-on (SSO)." }), "\n", _jsx(_components.p, { children: "Ancora una volta, questo è un flusso altamente semplificato e ci sono più dettagli \"sotto il cofano\". Per ora, passiamo alla sezione successiva per evitare un sovraccarico di informazioni." }), "\n", _jsxs(_components.h2, { id: "tipi-di-applicazione", children: ["Tipi di applicazione", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#tipi-di-applicazione", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: ["Nella sezione precedente, abbiamo utilizzato applicazioni web come esempi mentre il mondo è più vario di così. Per un provider di identità, il linguaggio di programmazione esatto, il framework o la piattaforma che usi non importa molto. In pratica, una notevole differenza è se l'applicazione è un ", _jsx(_components.a, { href: "https://auth.wiki/client#public-clients", children: "client pubblico" }), " o un ", _jsx(_components.a, { href: "https://auth.wiki/client#private-clients", children: "client privato (affidabile)" }), ":"] }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Client pubblico" }), ": Un client che non può mantenere riservate le proprie credenziali, il che significa che il proprietario della risorsa (utente) può accedervi. Per esempio, un'applicazione web che gira in un browser (es. applicazione a pagina singola)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Client privato" }), ": Un client che ha la capacità di mantenere riservate le proprie credenziali senza esporle agli utenti (proprietari delle risorse). Per esempio, un'applicazione web che gira su un server (es. applicazione web lato server) o un servizio API."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Con questo in mente, vediamo come OAuth 2.0 e OpenID Connect possono essere utilizzati in diversi tipi di applicazione." }), "\n", _jsxs(_components.blockquote, { children: ["\n", _jsx(_components.p, { children: "\"Applicazione\" e \"client\" possono essere usati in modo intercambiabile nel contesto di questo post." }), "\n"] }), "\n", _jsxs(_components.h3, { id: "applicazioni-web-che-girano-su-un-server", children: ["Applicazioni web che girano su un server", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#applicazioni-web-che-girano-su-un-server", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "L'applicazione gira su un server e serve pagine HTML agli utenti. Molti framework web popolari come Express.js, Django e Ruby on Rails rientrano in questa categoria; anche i framework backend-for-frontend (BFF) come Next.js e Nuxt.js sono inclusi. Queste applicazioni hanno le seguenti caratteristiche:" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "Poiché un server consente solo accesso privato (non c'è modo per gli utenti pubblici di vedere il codice o le credenziali del server), è considerato un client privato." }), "\n", _jsx(_components.li, { children: "Il flusso generale di autenticazione degli utenti è lo stesso di quello discusso nella sezione \"OpenID Connect\"." }), "\n", _jsx(_components.li, { children: "L'applicazione può utilizzare il token ID emesso dal provider di identità (cioè, il provider di OpenID Connect) per identificare l'utente e visualizzare contenuti specifici per l'utente." }), "\n", _jsxs(_components.li, { children: ["Per mantenere l'applicazione sicura, di solito si usa il ", _jsx(_components.strong, { children: "flusso del codice di autorizzazione" }), " per l'autenticazione degli utenti e ottenere i token."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Nel frattempo, l'applicazione potrebbe dover accedere ad altri servizi API interni in un'architettura di microservizi; o potrebbe essere un'applicazione monolitica che necessita di controllo degli accessi per diverse parti dell'applicazione. Ne parleremo nella sezione \"Proteggi la tua API\"." }), "\n", _jsxs(_components.h3, { id: "applicazioni-a-singola-pagina-spas", children: ["Applicazioni a singola pagina (SPAs)", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#applicazioni-a-singola-pagina-spas", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "L'applicazione gira nel browser di un utente e comunica con il server tramite API. React, Angular e Vue.js sono framework popolari per costruire SPAs. Queste applicazioni hanno le seguenti caratteristiche:" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "Poiché il codice dell'applicazione è visibile al pubblico, è considerato un client pubblico." }), "\n", _jsx(_components.li, { children: "Il flusso generale di autenticazione degli utenti è lo stesso di quello discusso nella sezione \"OpenID Connect\"." }), "\n", _jsx(_components.li, { children: "L'applicazione può utilizzare il token ID emesso dal provider di identità (cioè, il provider di OpenID Connect) per identificare l'utente e visualizzare contenuti specifici per l'utente." }), "\n", _jsxs(_components.li, { children: ["Per mantenere l'applicazione sicura, di solito si usa il ", _jsx(_components.strong, { children: "flusso del codice di autorizzazione con PKCE (Proof Key for Code Exchange)" }), " per l'autenticazione degli utenti e ottenere token."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Di solito, le SPAs devono accedere ad altri servizi API per il recupero e l'aggiornamento dei dati. Ne parleremo nella sezione \"Proteggi la tua API\"." }), "\n", _jsxs(_components.h3, { id: "applicazioni-mobili", children: ["Applicazioni mobili", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#applicazioni-mobili", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "L'applicazione gira su un dispositivo mobile (iOS, Android, ecc.) e comunica con il server tramite API. Nella maggior parte dei casi, queste applicazioni hanno le stesse caratteristiche delle SPAs." }), "\n", _jsxs(_components.h3, { id: "applicazioni-machine-to-machine-m2m", children: ["Applicazioni machine-to-machine (M2M)", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#applicazioni-machine-to-machine-m2m", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: ["Le applicazioni ", _jsx(_components.a, { href: "https://auth.wiki/machine-to-machine", children: "machine-to-machine" }), " sono ", _jsx(_components.a, { href: "https://auth.wiki/client", children: "client" }), " che girano su un server (macchina) e comunicano con altri server. Queste applicazioni hanno le seguenti caratteristiche:"] }), "\n", _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "Come le applicazioni web che girano su un server, le applicazioni M2M sono client privati." }), "\n", _jsx(_components.li, { children: "L'applicazione potrebbe non aver bisogno di identificare l'utente; invece, deve autenticarsi per accedere ad altri servizi." }), "\n", _jsx(_components.li, { children: "L'applicazione può utilizzare il token di accesso emesso dal provider di identità (cioè, il provider di OAuth 2.0) per accedere ad altri servizi." }), "\n", _jsxs(_components.li, { children: ["Per mantenere l'applicazione sicura, di solito si usa il ", _jsx(_components.strong, { children: "flusso delle credenziali del client" }), " per ottenere token di accesso."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Quando si accede ad altri servizi, l'applicazione potrebbe dover fornire il token di accesso nell'intestazione della richiesta. Ne parleremo nella sezione \"Proteggi la tua API\"." }), "\n", _jsxs(_components.h3, { id: "applicazioni-in-esecuzione-su-dispositivi-iot", children: ["Applicazioni in esecuzione su dispositivi IoT", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#applicazioni-in-esecuzione-su-dispositivi-iot", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "L'applicazione gira su un dispositivo IoT (es. dispositivi domotici intelligenti, indossabili, ecc.) e comunica con il server tramite API. Queste applicazioni hanno le seguenti caratteristiche:" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "A seconda delle capacità del dispositivo, può essere un client pubblico o privato." }), "\n", _jsx(_components.li, { children: "Il flusso generale di autenticazione può essere diverso da quello discusso nella sezione \"OpenID Connect\" a seconda delle capacità del dispositivo. Per esempio, alcuni dispositivi potrebbero non avere uno schermo per consentire agli utenti di inserire le proprie credenziali." }), "\n", _jsx(_components.li, { children: "Se il dispositivo non ha bisogno di identificare l'utente, potrebbe non essere necessario utilizzare token ID o endpoint userinfo; invece, può essere trattato come un'applicazione machine-to-machine (M2M)." }), "\n", _jsxs(_components.li, { children: ["Per mantenere l'applicazione sicura, potrebbe usare il ", _jsx(_components.strong, { children: "flusso del codice di autorizzazione con PKCE (Proof Key for Code Exchange)" }), " per l'autenticazione dell'utente e ottenere token o il ", _jsx(_components.strong, { children: "flusso delle credenziali del client" }), " per ottenere token di accesso."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Quando comunica con il server, il dispositivo potrebbe dover fornire il token di accesso nell'intestazione della richiesta. Ne parleremo nella sezione \"Proteggi la tua API\"." }), "\n", _jsxs(_components.h2, { id: "proteggi-la-tua-api", children: ["Proteggi la tua API", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#proteggi-la-tua-api", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: ["Con OpenID Connect, è possibile identificare l'utente e recuperare dati specifici dell'utente tramite ", _jsx(_components.a, { href: "https://auth.wiki/id-token", children: "token ID" }), " o ", _jsx(_components.a, { href: "https://auth.wiki/userinfo-endpoint", children: "endpoint userinfo" }), ". Questo processo si chiama autenticazione. Ma probabilmente non vuoi esporre tutte le tue risorse a tutti gli utenti autenticati, per esempio, solo gli amministratori possono accedere alla pagina di gestione degli utenti."] }), "\n", _jsx(_components.p, { children: "Qui entra in gioco l'autorizzazione. Ricorda che OAuth 2.0 è un framework di autorizzazione, e OpenID Connect è uno strato di identità sopra OAuth 2.0; il che significa che puoi anche usare OAuth 2.0 quando OpenID Connect è già in atto." }), "\n", _jsxs(_components.p, { children: ["Ricordiamo l'esempio che abbiamo utilizzato nella sezione \"OAuth 2.0\": MyApp vuole accedere al Google Drive dell'utente. Non è pratico permettere a MyApp di accedere a tutti i file dell'utente in Google Drive. Invece, MyApp dovrebbe dichiarare esplicitamente cosa vuole accedere (es. accesso solo in lettura ai file in una cartella specifica). In termini di OAuth 2.0, questo si chiama ", _jsx(_components.strong, { children: "ambito" }), "."] }), "\n", _jsxs(_components.blockquote, { children: ["\n", _jsx(_components.p, { children: "Potresti vedere il termine \"permesso\" usato in modo intercambiabile con \"ambito\" nel contesto di OAuth 2.0 poiché a volte \"ambito\" è ambiguo per utenti non tecnici." }), "\n"] }), "\n", _jsx(_components.p, { children: "Quando l'utente concede l'accesso a MyApp, il server di autorizzazione emette un token di accesso con l'ambito richiesto. Il token di accesso viene quindi inviato al server di risorse (Google Drive) per accedere ai file dell'utente." }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n participant User\n participant MyApp\n participant Google\n\n User->>MyApp: Apre MyApp e
clicca su \"Connetti Google Drive\"\n MyApp->>Google: Reindirizza a Google\n Google->>User: MyApp vuole accedere al tuo
Google Drive con ambito \"solo lettura\"\n User->>Google: Va bene, concedi l'accesso a MyApp\n Google->>MyApp: Reindirizza a MyApp
con dati di autorizzazione (es. token di accesso)\n MyApp->>Google: Accedi al Google Drive dell'utente
con token di accesso e ambito\n" }) }), "\n", _jsx(_components.p, { children: "Naturalmente, possiamo sostituire Google Drive con i nostri servizi API. Per esempio, MyApp ha bisogno di accedere al OrderService per recuperare la cronologia degli ordini dell'utente. Questa volta, poiché l'autenticazione dell'utente viene già effettuata dal provider di identità e sia MyApp che OrderService sono sotto il nostro controllo, possiamo evitare di chiedere all'utente di concedere l'accesso; MyApp può inviare direttamente la richiesta a OrderService con il token di accesso emesso dal provider di identità." }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n participant User\n participant MyApp\n participant OrderService\n\n User->>MyApp: Apri cronologia ordini\n MyApp->>OrderService: Recupera la mia cronologia ordini (con token di accesso)\n OrderService->>MyApp: Restituisce cronologia ordini\n MyApp->>User: Visualizza cronologia ordini\n" }) }), "\n", _jsxs(_components.p, { children: ["Il token di accesso potrebbe contenere un ", _jsx(_components.code, { children: "read:order" }), " ", _jsx(_components.a, { href: "https://auth.wiki/scope", children: "ambito" }), " per indicare che l'utente può leggere la propria cronologia ordini."] }), "\n", _jsxs(_components.p, { children: ["Ora, supponiamo che l'utente inserisca accidentalmente un URL della pagina amministratore nel browser. Poiché l'utente non è un amministratore, non c'è l'ambito ", _jsx(_components.code, { children: "admin" }), " nel token di accesso. OrderService rifiuterà la richiesta e restituirà un messaggio di errore."] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n participant User\n participant MyApp\n participant OrderService\n\n User->>MyApp: Apri pagina amministratore\n MyApp->>OrderService: Recupera pagina amministratore (con token di accesso)\n OrderService->>MyApp: Errore: Accesso negato\n MyApp->>User: Visualizza messaggio di errore\n" }) }), "\n", _jsx(_components.p, { children: "In questo caso, OrderService potrebbe restituire un codice di stato 403 Forbidden per indicare che l'utente non è autorizzato ad accedere alla pagina amministratore." }), "\n", _jsx(_components.p, { children: "Per le applicazioni machine-to-machine (M2M), nessun utente è coinvolto nel processo. Le applicazioni possono richiedere direttamente token di accesso dal provider di identità e utilizzarli per accedere ad altri servizi. Lo stesso concetto si applica: il token di accesso contiene gli ambiti necessari per accedere alle risorse." }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n participant MyApp\n participant OrderService\n\n MyApp->>OrderService: Recupera tutti gli ordini (con token di accesso)\n OrderService->>MyApp: Restituisce tutti gli ordini\n" }) }), "\n", _jsxs(_components.h3, { id: "design-dellautorizzazione", children: ["Design dell'autorizzazione", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#design-dellautorizzazione", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: ["Possiamo vedere due cose importanti da considerare quando si progetta l'", _jsx(_components.a, { href: "https://auth.wiki/authorization", children: "autorizzazione" }), " per proteggere i tuoi servizi API:"] }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Ambiti" }), ": Definire quali risorse il client può accedere. Gli ambiti possono essere dettagliati (es. ", _jsx(_components.code, { children: "read:order" }), ", ", _jsx(_components.code, { children: "write:order" }), ") o più generali (es. ", _jsx(_components.code, { children: "order" }), ") a seconda delle tue esigenze."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Controllo degli accessi" }), ": Definire chi può avere ambiti specifici. Per esempio, solo gli amministratori possono avere l'ambito ", _jsx(_components.code, { children: "admin" }), "."] }), "\n"] }), "\n", _jsxs(_components.p, { children: ["Per quanto riguarda il ", _jsx(_components.a, { href: "https://auth.wiki/access-control", children: "controllo degli accessi" }), ", alcuni approcci popolari sono:"] }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Controllo degli accessi basato sui ruoli (RBAC)" }), ": Assegnare ruoli agli utenti e definire quali ruoli possono accedere a quali risorse. Per esempio, un ruolo di amministratore può accedere alla pagina amministratore."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Controllo degli accessi basato su attributi (ABAC)" }), ": Definire policy basate su attributi (es. dipartimento dell'utente, posizione, ecc.) e prendere decisioni di controllo degli accessi basate su questi attributi. Per esempio, un utente del dipartimento \"Ingegneria\" può accedere alla pagina ingegneria."] }), "\n"] }), "\n", _jsx(_components.p, { children: "Vale la pena menzionare che per entrambi gli approcci, il modo standard per verificare il controllo degli accessi è controllare gli ambiti dei token di accesso, invece di ruoli o attributi. I ruoli e gli attributi possono essere molto dinamici e gli ambiti sono più statici, il che rende molto più facile gestirli." }), "\n", _jsxs(_components.p, { children: ["Per informazioni dettagliate sul controllo degli accessi, puoi fare riferimento a ", _jsx(_components.a, { href: "https://blog.logto.io/rbac-and-abac", children: "RBAC e ABAC: I modelli di controllo degli accessi che dovresti conoscere" }), "."] }), "\n", _jsxs(_components.h3, { id: "token-di-accesso", children: ["Token di accesso", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#token-di-accesso", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: ["Sebbene abbiamo menzionato il termine \"", _jsx(_components.a, { href: "https://auth.wiki/access-token", children: "token di accesso" }), "\" molte volte, non abbiamo discusso come ottenerne uno. In OAuth 2.0, un token di accesso viene emesso dal server di autorizzazione (provider di identità) dopo un flusso di autorizzazione riuscito."] }), "\n", _jsx(_components.p, { children: "Diamo un'occhiata più da vicino all'esempio di Google Drive e supponiamo di utilizzare il flusso del codice di autorizzazione:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n autonumber\n participant User\n participant MyApp\n participant Google\n\n User->>MyApp: Apre MyApp e
clicca su \"Connetti Google Drive\"\n MyApp->>Google: Reindirizza a Google\n Google->>User: Accedi a Google\n User->>Google: Accedi\n Google->>User: Chiedi il permesso
di accedere a Google Drive\n User->>Google: Concedi l'accesso a MyApp\n Google->>MyApp: Reindirizza a MyApp
con dati di autorizzazione (es. codice di autorizzazione)\n MyApp->>Google: Usa il codice di autorizzazione per
scambiare il token di accesso\n Google->>MyApp: Restituisce il token di accesso\n MyApp->>Google: Accedi al Google Drive dell'utente con token di accesso\n" }) }), "\n", _jsx(_components.p, { children: "Ci sono alcuni passaggi importanti nel flusso per l'emissione del token di accesso:" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Passaggio 2 (Reindirizza a Google): MyApp reindirizza l'utente a Google con una ", _jsx(_components.strong, { children: "richiesta di autorizzazione" }), ". Tipicamente, questa richiesta include le seguenti informazioni:", "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Quale client (MyApp) sta iniziando la richiesta" }), "\n", _jsx(_components.li, { children: "Quali ambiti sta richiedendo MyApp" }), "\n", _jsx(_components.li, { children: "Dove Google dovrebbe reindirizzare l'utente dopo che l'autorizzazione è completata" }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["Passaggio 5 (Chiedi il permesso di accedere a Google Drive): Google chiede all'utente di concedere l'accesso a MyApp. L'utente può scegliere di concedere o negare l'accesso. Questo passaggio si chiama ", _jsx(_components.strong, { children: "consenso" }), "."] }), "\n", _jsxs(_components.li, { children: ["Passaggio 7 (Reindirizza a MyApp con dati di autorizzazione): Questo passaggio è stato appena introdotto nel diagramma. Piuttosto che restituire il token di accesso direttamente, Google restituisce un ", _jsx(_components.strong, { children: "codice di autorizzazione" }), " una tantum a MyApp per uno scambio più sicuro. Questo codice viene utilizzato per ottenere il token di accesso."] }), "\n", _jsxs(_components.li, { children: ["Passaggio 8 (Usa il codice di autorizzazione per scambiare il token di accesso): Anche questo è un nuovo passaggio. MyApp invia il codice di autorizzazione a Google per scambiare il token di accesso. Come provider di identità, Google comporrà il contesto della richiesta e deciderà se emettere un token di accesso:", "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Il client (MyApp) è chi dichiara di essere" }), "\n", _jsx(_components.li, { children: "L'utente ha concesso l'accesso al client" }), "\n", _jsx(_components.li, { children: "L'utente è chi dichiara di essere" }), "\n", _jsx(_components.li, { children: "L'utente ha gli ambiti necessari" }), "\n", _jsx(_components.li, { children: "Il codice di autorizzazione è valido e non scaduto" }), "\n"] }), "\n"] }), "\n"] }), "\n", _jsx(_components.p, { children: "L'esempio sopra presuppone che il server di autorizzazione (provider di identità) e il server di risorse siano gli stessi (Google). Se sono separati, prendendo l'esempio di MyApp e OrderService, il flusso sarà simile a questo:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n autonumber\n participant User\n participant MyApp\n participant IdP as Identity provider (IdP)\n participant OrderService\n\n User->>MyApp: Apre MyApp e
clicca su \"Accedi\"\n MyApp->>IdP: Reindirizza a IdP\n IdP->>User: Chiedi nome utente e password\n User->>IdP: Inserisci nome utente e password\n IdP->>IdP: Autentica utente\n IdP->>MyApp: Reindirizza a MyApp
con dati di autorizzazione (es. codice di autorizzazione)\n MyApp->>IdP: Usa il codice di autorizzazione per
scambiare token (token ID, token di accesso)\n IdP->>MyApp: Restituisce token\n MyApp->>OrderService: Recupera la mia cronologia ordini (con token di accesso)\n OrderService->>OrderService: Verifica token di accesso\n OrderService->>MyApp: Restituisce cronologia ordini\n" }) }), "\n", _jsx(_components.p, { children: "In questo flusso, il server di autorizzazione (IdP) emette sia un ID token sia un token di accesso a MyApp (passaggio 8). L'ID token viene utilizzato per identificare l'utente, e il token di accesso viene utilizzato per accedere ad altri servizi come OrderService. Poiché sia MyApp che OrderService sono servizi di prima parte, di solito non chiedono all'utente di concedere l'accesso; invece, si affidano al controllo degli accessi nel provider di identità per determinare se l'utente può accedere alle risorse (cioè se il token di accesso contiene gli ambiti necessari)." }), "\n", _jsx(_components.p, { children: "Infine, vediamo come il token di accesso viene utilizzato nelle applicazioni machine-to-machine (M2M). Poiché nessun utente è coinvolto nel processo e l'applicazione è affidabile, può richiedere direttamente un token di accesso dal provider di identità:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "sequenceDiagram\n autonumber\n participant MyApp\n participant IdP as Identity provider (IdP)\n participant OrderService\n\n MyApp->>IdP: Richiede token di accesso\n IdP->>MyApp: Restituisce token di accesso\n MyApp->>OrderService: Recupera tutti gli ordini (con token di accesso)\n OrderService->>OrderService: Verifica token di accesso\n OrderService->>MyApp: Restituisce tutti gli ordini\n" }) }), "\n", _jsx(_components.p, { children: "Il controllo degli accessi può ancora essere applicato qui. Per OrderService, non importa chi sia l'utente o quale applicazione sta richiedendo i dati; si interessa solo del token di accesso e degli ambiti che contiene." }), "\n", _jsxs(_components.blockquote, { children: ["\n", _jsxs(_components.p, { children: ["Di solito, i token di accesso sono codificati come JSON Web Token (JWT). Per saperne di più sui JWT, puoi fare riferimento a ", _jsx(_components.a, { href: "https://blog.logto.io/what-is-jwt", children: "Cos'è JSON Web Token (JWT)?" }), "."] }), "\n"] }), "\n", _jsxs(_components.h3, { id: "indicatori-di-risorse", children: ["Indicatori di risorse", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#indicatori-di-risorse", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "OAuth 2.0 introduce il concetto di ambiti per il controllo degli accessi. Tuttavia, potresti rapidamente renderti conto che gli ambiti non sono sufficienti:" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["OpenID Connect definisce un insieme di ambiti standard come ", _jsx(_components.code, { children: "openid" }), ", ", _jsx(_components.code, { children: "offline_access" }), " e ", _jsx(_components.code, { children: "profile" }), ". Potrebbe essere confuso mescolare questi ambiti standard con i tuoi ambiti personalizzati."] }), "\n", _jsx(_components.li, { children: "Potresti avere più servizi API che condividono lo stesso nome di ambito ma hanno significati diversi." }), "\n"] }), "\n", _jsxs(_components.p, { children: ["Una soluzione comune è aggiungere suffissi (o prefissi) ai nomi degli ambiti per indicare la risorsa (servizio API). Per esempio, ", _jsx(_components.code, { children: "read:order" }), " e ", _jsx(_components.code, { children: "read:product" }), " sono più chiari di ", _jsx(_components.code, { children: "read" }), " e ", _jsx(_components.code, { children: "read" }), ". Un'estensione di OAuth 2.0 ", _jsx(_components.a, { href: "https://tools.ietf.org/html/rfc8707", children: "RFC 8707" }), " introduce un nuovo parametro ", _jsx(_components.code, { children: "resource" }), " per indicare il ", _jsx(_components.strong, { children: "server di risorse" }), " a cui il client vuole accedere."] }), "\n", _jsxs(_components.p, { children: ["In realtà, i servizi API sono di solito definiti da URL, quindi è più naturale utilizzare gli URL come ", _jsx(_components.a, { href: "https://auth.wiki/resource-indicator", children: "indicatori di risorse" }), ". Per esempio, l'API OrderService può essere rappresentata come:"] }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { children: "https://api.example.com/orders\n" }) }), "\n", _jsxs(_components.p, { children: ["Come puoi vedere, il parametro porta la comodità di utilizzare gli URL delle risorse effettive nelle richieste di autorizzazione e nei token di accesso. Vale la pena menzionare che l'RFC 8707 potrebbe non essere implementato da tutti i provider di identità. Dovresti verificare la documentazione del tuo provider di identità per vedere se supporta il parametro ", _jsx(_components.code, { children: "resource" }), " (Logto lo supporta)."] }), "\n", _jsxs(_components.p, { children: ["In sintesi, il parametro ", _jsx(_components.code, { children: "resource" }), " può essere utilizzato nelle richieste di autorizzazione e nei token di accesso per indicare la risorsa a cui il client vuole accedere."] }), "\n", _jsxs(_components.blockquote, { children: ["\n", _jsxs(_components.p, { children: ["Non ci sono restrizioni sull'accessibilità degli indicatori di risorse, cioè l'indicatore di risorse non deve essere un URL reale che punta a un servizio API. Quindi il nome \"indicatore di risorse\" riflette adeguatamente il suo ruolo nel processo di autorizzazione. Puoi usare URL virtuali per rappresentare le risorse che vuoi proteggere. Per esempio, puoi definire un URL virtuale ", _jsx(_components.code, { children: "https://api.example.com/admin" }), " nella tua applicazione monolitica per rappresentare la risorsa che solo gli amministratori possono accedere."] }), "\n"] }), "\n", _jsxs(_components.h2, { id: "metti-tutto-insieme", children: ["Metti tutto insieme", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#metti-tutto-insieme", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsx(_components.p, { children: "A questo punto, abbiamo coperto le basi di OAuth 2.0 e OpenID Connect, e come usarli in diversi tipi di applicazione e scenari. Sebbene li abbiamo discussi separatamente, puoi combinarli secondo le tue esigenze aziendali. L'architettura generale può essere semplice come questa:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart LR\n MyApp --- IdP\n" }) }), "\n", _jsx(_components.p, { children: "O un po' più complessa:" }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart LR\n WA[Applicazione web] --- IdP[Provider di identità]\n MA[Applicazione mobile] --- IdP\n OS[OrderService] --- IdP\n AS[AdminService] --- IdP\n WA --- OS\n MA --- OS\n SA[Applicazione a singola pagina] --- IdP\n SA --- AS\n OS --- AS\n" }) }), "\n", _jsx(_components.p, { children: "Man mano che la tua applicazione cresce, vedrai che il provider di identità (IdP) gioca un ruolo critico nell'architettura; ma non si riferisce direttamente ai tuoi obiettivi aziendali. Anche se è un'ottima idea affidarlo a un fornitore affidabile, dobbiamo scegliere il provider di identità con saggezza. Un buon provider di identità può semplificare notevolmente il processo, ridurre lo sforzo di sviluppo e salvarti da potenziali insidie di sicurezza." }), "\n", _jsxs(_components.h2, { id: "note-di-chiusura", children: ["Note di chiusura", _jsx(_components.a, { "aria-hidden": "true", tabIndex: "-1", href: "#note-di-chiusura", children: _jsx(_components.span, { children: "#" }) })] }), "\n", _jsxs(_components.p, { children: ["Per le moderne applicazioni cloud, il provider di identità (o server di autorizzazione) è il luogo centrale per l'", _jsx(_components.a, { href: "https://auth.wiki/authentication", children: "autenticazione" }), ", la ", _jsx(_components.a, { href: "https://auth.wiki/iam", children: "gestione delle identità" }), " e il ", _jsx(_components.a, { href: "https://auth.wiki/access-control", children: "controllo degli accessi" }), " degli utenti. Anche se abbiamo discusso molti concetti in questo post, ci sono ancora molte sfumature da considerare quando si implementa un tale sistema. Se sei interessato ad approfondire, puoi consultare il nostro blog per articoli più dettagliati."] }), "\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."); }