SPID/CIE OpenID Connect¶
SPID e CIE id sono i Sistemi Pubblici di Identità Digitale Italiani e adottano gli standard OpenID Connect Core, International Government Assurance Profile (iGov) for OpenID Connect 1.0 e OpenID Connect Federation 1.0.
Grazie all'identità digitale, la Pubblica Amministrazione e i fornitori di servizi privati forniscono la chiave per accedere ai servizi online attraverso una credenziale unica.
Questa documentazione contiene le specifiche tecniche consolidate, conformi alle Linee Guida Nazionali, per migliorare l'esperienza di integrazione alle Federazioni OIDC SPID e CIE id per i Fornitori di Servizio pubblici e privati (RP), Identity Providers (OP) e Soggetti Aggregatori (SA).
In questa documentazione trovi:
- Gli esempi pratici dei Metadata, delle richieste e delle risposte OpenID Connect.
- Come effettuare la registrazione automatica dei RP presso gli OpenID Provider.
- Come un OpenID Provider riconosce e registra dinamicamente un RP.
- Come utilizzare gli endpoint della API della Federazione.
- Come autenticare un utente a SPID e CIE ed ottenere i suoi attributi.
Indice dei contenuti¶
Riferimenti¶
Technical references¶
| OIDC-FED | OpenID Connect Federation 1.0 |
| iGov.OIDC | Varley, M., Grassi, P. "iGov Profile for OpenID Connect", October 2018. |
| OpenID.Core | Sakimura, N., Bradley, J., Jones, M., de Medeiros, B. and C. Mortimore, "OpenID Connect Core 1.0", August 2015. |
| OpenID.Registration | Sakimura, N., Bradley, J., and M. Jones, "OpenID Connect Dynamic Client Registration 1.0," November 2014. |
| OpenID.Discovery | Sakimura, N., Bradley, J., Jones, M., and E. Jay, "OpenID Connect Discovery 1.0," November 2014. |
| RFC 2119 | Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels," BCP 14, RFC 2119, March 1997. |
| RFC 2616 | Fielding, R., Gettys, J., Mogul, J., Frystyk, H., Masinter, L., Leach, P., and T. Berners-Lee, “Hypertext Transfer Protocol -- HTTP/1.1,” RFC 2616, June 1999. |
| RFC 3339 | Klyne, G. and C. Newman, "Date and Time on the Internet: Timestamps", RFC 3339, DOI 10.17487/RFC3339, July 2002. |
| RFC 3986 | Uniform Resource Identifier (URI): Generic Syntax |
| RFC 7009 | Lodderstedt, T., Dronia, S., Scurtescu, M., “OAuth 2.0 Token Revocation,” RFC7009, August 2013. |
| RFC 7159 | Bray, T., “The JavaScript Object Notation (JSON) Data Interchange Format,” RFC 7159, March 2014. |
| RFC 7515 | Jones, M., Bradley, J. and N. Sakimura, "JSON Web Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, May 2015. |
| RFC 7516 | Jones, M., Hildebrand, J., "JSON Web Encryption (JWE)", May 2015. |
| RFC 7517 | Jones, M., "JSON Web Key (JWK)", RFC 7517, DOI 10.17487/RFC7517, May 2015. |
| RFC 7518 | Jones, M., "JSON Web Algorithms (JWA)", May 2015. |
| RFC 7519 | Jones, M., Bradley, J. and N. Sakimura, "JSON Web Token (JWT)", RFC 7519, DOI 10.17487/RFC7519, May 2015. |
| RFC 7523 | Jones, M., Campbell, B., Martimore, C., “JSON Web Token (JWT) Profile for OAuth 2.0 Client Authentication and Authorization Grants”, May 2015. |
| RFC 7636 | Sakimura, N., Bradley, J. and N. Agarwal, "Proof Key for Code Exchange by OAuth Public Clients", RFC 7636, DOI 10.17487/RFC7636, September 2015. |
| RFC 7638 | Jones, M., Sakimura, N., “JSON Web Key (JWK) Thumbprint,”RFC7638, September 2015. |
| RFC 7662 | Richer, J., "OAuth 2.0 Token Introspection", RFC 7662, DOI 10.17487/RFC7662, October 2015. |
| RFC 7591 | Richer, J., Ed., Jones, M., Bradley, J., Machulak, M., and P. Hunt, "OAuth 2.0 Dynamic Client Registration Protocol", RFC 7591, DOI 10.17487/RFC7591, July 2015. |
| RFC 7800 | Jones, M., Bradley, J. and H. Tschofenig, "Proof-of-Possession Key Semantics for JSON Web Tokens (JWTs)", RFC 7800, DOI 10.17487/RFC7800, April 2016. |
| RFC 8174 | Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", RFC 8174, DOI 10.17487/RFC8174, May 2017. |
| RFC 8414 | Jones, M., Sakimura, N., and J. Bradley, "OAuth 2.0 Authorization Server Metadata", RFC 8414, DOI 10.17487/RFC8414, June 2018. |
| RFC 8725 | Jones, M., D. Hardt, Sheffer, Y., "JSON Web Token Best Current Practices", February 2020. |
| RFC 9068 | Bertocci, V., “JSON Web Token (JWT) Profile for OAuth 2.0 Access Token,” RFC9068, October 2021. |
| I-D.ietf-oauth-iss-auth-resp | Selhausen, K. M. Z. and D. Fett, "OAuth 2.0 Authorization Server Issuer Identification", Work in Progress, Internet-Draft, Draft-5, January 2022. |
| I-D.ietf-OAuth-Security-BCP | Lodderstedt, T., Bradley, J., Labunets, A., Fett, D., “OAuth 2.0 Security Best Current Practice”, Draft-19, December 2021. |
| draft-yusef-oauth-nested-jwt | Shekh-Yusef, R., Hardt, D., De Marco, G., “JSON Web Token (JWT) Embedded Tokens”, Draft-06, December 2022. |
| EN319-412-1 | Electronic Signatures and Infrastructures (ESI); Certificate Profiles; |
| E164 | International Telecommunication Union, "E.164: The international public telecommunication numbering plan," 2010. |
| ISO8601-2004 | International Organization for Standardization, "ISO 8601:2004. Data elements and interchange formats - Information interchange - Representation of dates and times," 2004. |
| ICAO-Doc9303 | INTERNATIONAL CIVIL AVIATION ORGANIZATION, "Machine Readable Travel Documents, Seventh Edition, 2015, Part 3: Specifications Common to all MRTDs", 2015 |
| ISO3166 | ISO, "ISO 3166-1:1997. Codes for the representation of names of countries and their subdivisions |
Normativa Nazionale ed Europea¶
| CAD | DL 7 March 2005 n.82: "Codice dell'amministrazione digitale." (GU Serie Generale n.112 16-05-2005 - Suppl. Ordinario n. 93) |
| DL-SEMPLIFICAZIONI | DL 16 July 2020 n.76: "Misure urgenti per la semplificazione e l'innovazione digitale." (20A04921) (GU Serie Generale n.228 14-09-2020 - Suppl. Ordinario n. 33) and its conversion into Law, with amendments, Law 11 September 2020 n. 120. |
| EIDAS | Regulation (Eu) No 910/2014 of the European Parliament and of the Council 23 July 2014 "on electronic identification and trust services for electronic transactions in the internal market and repealing Directive 1999/93/EC." |
Riferimenti normativi SPID¶
L'avvio del Sistema SPID, per sua natura e complessità, può richiedere di intervenire su diversi aspetti con specificazioni, chiarimenti, note informative e casi esemplificativi, al fine di dare supporto ad una migliore applicazione e comprensione dei Regolamenti SPID già emanati dall'AgID in conformità con quanto prescritto dall'art.4 del DPCM 24 ottobre 2014.
Al fine di raccogliere organicamente tali interventi e attribuirvi un carattere cogente che ne comporti l'obbligo di applicazione da parte degli attori convolti nel Sistema SPID, siano essi pubblici che privati, è stata creata la presente sezione “Avvisi SPID” con l'obiettivo di assicurare un'uniforme interpretazione delle regole, degli aspetti tecnici e di quant'altro necessario per il corretto funzionamento del Sistema nel suo complesso.
Le presenti regole tecniche implementano i seguenti avvisi SPID:
| Avviso | Riferimento | Data |
|---|---|---|
| LL.GG. OpenID Connect in SPID | LL.GG. OpenID Connect in SPID | 24/11/2021 |
| Avviso n.41 | Avviso n.41 - Integrazione LL.GG. OpenID Connect in SPID.pdf | 06/05/2022 |
| Tabella Attributi utente v1.3 | Tabella Attributi in SPID - Integrazione LL.GG. OpenID Connect in SPID.pdf | 24/06/2022 |
| Determina SPID OpenID Connect Federation | Regole tecniche per il funzionamento della Federazione SPID OpenID Connect - Integrazione LL.GG. OpenID Connect in SPID.pdf - | 14/09/2022 |
| Linee Guida Attribute Authority SPID | Linee guida recanti le regole tecniche dei gestori di attributi qualificati | 18/07/2022 |
Termini e Acronimi¶
Termini¶
Seguono i termini utilizzati da OIDC-FED#Section_1.2 e in questo documento.
| Autorità di Federazione | Un'entità legale che gestisce la fiducia tra le parti coinvolte nella Federazione e norma il funzionamento e le modalità di registrazione e riconoscimento dei partecipanti. |
| Trust Anchor | Sistema gestito dalla Autorità di Federazione, che rappresenta la Federazione e la sua configurazione. |
| Intermediario | Soggetto Aggregatore (SA), facilita l'ingresso nella Federazione e PUÒ gestire le funzionalità per conto di un suo discendente (aggregato). Pubblica la propria configurazione all'interno della Federazione e le affermazioni di riconoscimento delle parti sue discendenti (aggregati) secondo le regole definite dall'Autorità di Federazione. |
| Foglia | Entità definita dal protocollo OpenID Connect come Relying Party e Provider OpenID. Può anche essere una Attribute Authority (OAuth2 Authorization Server e Resource Server). |
| Entità | Partecipante alla Federazione. Trust Anchor, Intermediario o Foglia. |
| Entity Configuration | Dichiarazione di un'entità, emessa per proprio conto, nella forma di JWT auto firmato RFC 7515 e contenente la sua configurazione. Contiene le chiavi pubbliche di Federazione, i Metadata OIDC, gli URL delle autorità sue superiori e i Trust Mark emessi da autorità riconoscibili nella Federazione che attestano l'aderenza del soggetto a determinati profili. |
| Entity Statement | Dichiarazione di riconoscimento emessa da un'entità superiore (Trust Anchor o Intermediario) riguardante un soggetto discendente (RP, OP, AA o Intermediario) in formato JWT firmato RFC 7515, contenente le chiavi pubbliche del soggetto discendente, i Trust Mark emessi per i quali è emettitore e la politica dei Metadata da applicare ai Metadata del soggetto. |
| Trust Mark | JWT firmato RFC 7515 dall'ente emettitore e relativo ad un partecipante. Attesta la conformità di questo ai profili riconoscibili all'interno Federazione (RP pubblico o privato, Soggetto Aggregatore Pubblico o Privato, etc.). La Foglia che acquisisce il marchio di fiducia durante il processo di onboarding DEVE includere questo nella sua Entity Configuration. |
| Metadata | Documento che descrive l'implementazione di una entità OpenID Connect o OAuth2. Le implementazioni di ogni Entità condividono i Metadata per stabilire una base di fiducia e interoperabilità. |
| Metadata policy | Il Trust Anchor pubblica le regole e le politiche da applicare sui Metadata dei discendenti, specificando quali valori o sottoinsiemi di valori sono consentiti per un dato parametro di Metadata. |
| Authority hint | Array di valori URL contenente gli identificativi delle Entità superiori, Trust Anchor o Intermediario, che emettono un Entity Statement per i propri discendenti. |
| Federation Entity Discovery | Raccolta di Entity Configuration e Statement. Inizia da un'Entità Foglia fino al raggiungimento del Trust Anchor. |
| Trust Chain | Procedura di validazione della sequenza di Entity Configuration e Statement raccolta mediante Federation Entity Discovery, il cui esito positivo è un Metadata finale relativo ad una Entità e la data di scadenza entro la quale la Trust Chain deve essere aggiornata. |
| Onboarding | Procedura di registrazione di una nuova entità all'interno della Federazione SPID e CIE |
| Federation Endpoint | Endpoint definit in OIDC Federation 1.0, usati per prendere e risolvere gli statement delle entità, interrogare una lista di tutte le entità subordinate e verificare lo stato dei Trust Mark. |
Acronimi¶
In questa sezione sono definiti tutti gli acronimi utilizzati all'interno del testo.
| SPID | Sistema Pubblico di Identità Digitale italiano, la cui Authorità di Federazione è la AgID (Agenzia per l'Italia Digitale). |
| CIE id | Sistema Pubblico di Identità Digitale italiano basato sulla Carta d'Identità Elettronica (CIE), di cui il Ministero dell'Interno è l'Autorità di Federazione. La gestione tecnica e operativa è affidata all'Istituto Poligrafico e Zecca dello Stato (IPZS). |
| OIDC | OpenID Connect. |
| OIDC-FED | OIDC Federation 1.0. |
| FA | Autorità di Federazione (Federation Authority). |
| TA | OIDC Federation Trust Anchor. |
| AgID | Agenzia per l'Italia Digitale, FA/TA di SPID. |
| MinInterno | Ministero dell'Interno, FA/TA di CIE id. |
| OP | OpenID Provider (Entità Foglia). |
| RP | Relying Party (Entità Foglia). |
| SA | Soggetti Aggregatori. Entità Intermediarie che possono gestire tutti gli aspetti della Federazione di uno o più RP. |
| AA | Attribute Authority, Gestore degli Attributi qualificati (Entità Foglia). |
| TM | Trust Mark. |
| EC | Entity Configuration. |
| ES | Entity Statement. |
| URL | Uniform Resource Locator, corrispondente ad un indirizzo web. |
| JWT | Vedi RFC 7519 Jones, M., Bradley, J. and N. Sakimura, "JSON Web Token (JWT)", RFC 7519, DOI 10.17487/RFC7519, May 2015. |
| RS | OAuth2 Resource Server. |
| $JWT | Il valore di un JWT (JSON Web Token). |
Convenzioni e Termini normativi¶
Le parole chiave "DEVE" e "DEVONO", "NON DEVE" e "NON DEVONO", "RICHIEDE" e "RICHIESTO", "NON DEVE", "DOVREBBE", "NON DOVREBBE", "RACCOMANDATO", "PUÒ" e "OPZIONALE" nel presente documento devono essere interpretate come descritte nel BCP 14 RFC 2119 RFC 8174 quando e solo quando appaiono in maiuscolo.
Le notazioni [...] e ... indicano che il testo è stato troncato per esigenze editoriali.
base64url denota la codifica URL-safe base64 senza padding definita in RFC 7515#section-2.
Tutti gli esempi contenuti in questo documento sono da considerarsi come non normativi.
Avvertimento
Tutti gli esempi contenuti in questa documentazione sono da intendersi come non normativi
Le Federazioni eID Italiane¶
Una Federazione delle Identità Digitali è una infrastruttura all'interno della quale tante organizzazioni, afferenti a domini differenti, aderiscono ad un medesimo quadro regolatorio per costruire un meccanismo di fiducia sia amministrativo, mediante la stipula di convenzioni e accreditamento presso una o più autorità super partes, che tecnologico, mediante l'adozione di standard di interoperabilità sicuri che consentono l'interscambio dei dati.
Questa configurazione stabilisce i livelli di garanzia e di sicurezza adeguati affinchè un individuo possa autenticarsi presso un servizio web (Service Provider) mediante la propria identità digitale, rilasciata da un altro servizio web (Identity Provider).
I partecipanti (RP o OP), che si riconoscono all'interno della medesima Federazione, ottengono i Metadata gli uni degli altri. I Metadata contengono le chiavi pubbliche per le operazioni di firma digitale e criptazione e le definizioni necessarie all'interscambio delle informazioni.
I Metadata sono certificati da un parte fidata che all'interno della Federazione SPID è AgID, mentre all'interno della Federazione CIE è il Ministero dell'Interno. Questi corrispondono alla Autorità di Federazione.
SPID e CIE id implementano OpenID Connect Federation 1.0 e ne estendono alcune funzionalità, realizzano una implementazione concreta e producono le buone pratiche per la sua adozione. Per approfondimenti allo standard si rimanda alle specifiche ufficiali OIDC-FED e alla sezione Differenze con OIDC Federation 1.0.
OpenID Connect Federation¶
La Federazione OIDC produce una infrastruttura della fiducia che è:
- Dinamica. La fiducia può essere stabilita dinamicamente durante la prima richiesta di autenticazione. Le Autorità della Federazione espongono un endpoint che fornisce "dichiarazioni" firmate riguardanti le entità discendenti. Queste contengono le chiavi pubbliche dei discendenti e la politica dei Metadata. Le Autorità della Federazione possono disabilitare un'entità nella Federazione in qualsiasi momento, semplicemente smettendo di emettere le dichiarazioni inerenti a questa.
- Scalabile. Riduce significativamente i costi di onboarding, in accordo al principio di delega, con l'istituzione di entità intermediarie (SA).
- Trasparente. Qualsiasi Entità coinvolta nella Federazione può in ogni momento costruire la fiducia autonomamente e in modo sicuro. Inoltre, la composizione della Federazione, in tutte le sue parti, diventa navigabile mediante la sua API, in tempo reale.
Schema ad albero con le Autorità di Federazione SPID e CIE id e, salendo, gli OP che non hanno Intermediari, gli RP e gli Intermediari che a loro volta Aggregano altri RP.
Configurazione della Federazione¶
La configurazione della Federazione è pubblicata dal Trust Anchor all'interno della sua Entity Configuration, disponibile presso un web path ben noto e corrispondente a .well-known/openid-federation.
Tutti i partecipanti DEVONO ottenere, prima della fase di esercizio, la configurazione della Federazione e mantenerla aggiornata su base giornaliera. All'interno della configurazione della Federazione sono pubblicate le chiave pubbliche del Trust Anchor usate per le operazioni di firma, il numero massimo di Intermediari consentiti tra una Foglia e il Trust Anchor (max_path length) e le autorità abilitate all'emissione dei Trust Mark (trust_mark_issuers).
Si veda qui un esempio non normativo di Entity Configuration response Trust Anchor
Si veda la Sezione dedicata alle Entity Configuration per ulteriori dettagli.
Modalità di partecipazione¶
Per aderire alle Federazioni SPID e CIE id un partecipante deve pubblicare la propria configurazione (Entity Configuration) presso il proprio web endpoint .well-known/openid-federation.
Gli incaricati tecnici ed amministrativi della Foglia completano la procedura amministrativa per la registrazione di una nuova Entità o l'aggiornamento di un'Entità preesistente definita dalla Autorità di Federazione o da un suo Intermediario (SA).
L'Autorità di Federazione o il suo Intermediario, dopo aver effettuato tutti i controlli amministrativi e tecnici richiesti, registra le chiavi pubbliche della Foglia e rilascia una prova di adesione alla Federazione sotto forma di Trust Mark (TM).
La Foglia DEVE includere il TM all'interno della propria configurazione di Federazione (Entity Configuration) come prova del buon esito del processo di onboarding.
L'Autorità di Federazione o suo Intermediario DEVE pubblicare la dichiarazione di riconoscimento della Foglia (Entity Statement) contenente le chiavi pubbliche di Federazione della Foglia e i TM a questa rilasciati.
Entity Configuration¶
Un'Entity Configuration (EC) è un Metadata di Federazione in formato Jose e firmato da una Entità e riguardante se stessa, pubblicato presso il web endpoint .well-known/openid-federation.
Firma della Entity Configuration¶
Tutte le operazioni di verifica della firma relative agli ES, EC e TM sono eseguite con le chiavi pubbliche di Federazione. Per quanto riguarda gli algoritmi di firma supportati si veda la Sezione Algoritmi Crittografici.
Avvertimento
Distinguiamo le chiavi di Federazione da quelle di OIDC Core. Queste ultime risiedono nei Metadata OIDC. Un EC contiene sia le chiavi pubbliche di Federazione che i Metadata OIDC. Le chiavi di Federazione DOVREBBERO essere diverse da quelle di OIDC Core.
Entity Configuration - claim comuni¶
| Claim | Descrizione | Supportato da |
|---|---|---|
| iss | String. Identificativo dell'entità che lo emette. | |
| sub | String. Identificativo del soggetto a cui è riferito. | |
| iat | UNIX Timestamp con l'istante di generazione del JWT, codificato come NumericDate come indicato in RFC 7519 | |
| exp | UNIX Timestamp con l'istante di scadenza del JWT, codificato come NumericDate come indicato in RFC 7519. | |
| jwks | Un JSON Web Key Set (JWKS) RFC 7517 che rappresenta la parte pubblica delle chiavi di firma dell'entità interessata. Ogni JWK nel set JWK DEVE avere un ID di chiave (claim kid). | |
| metadata | JSON Object. Ogni chiave dell'oggetto JSON rappresenta un identificatore del tipo di Metadata e ogni valore DEVE essere un oggetto JSON che rappresenta i Metadata secondo lo schema di Metadata di quel tipo. Una configurazione di entità PUÒ contenere più dichiarazioni di Metadata, ma solo una per ogni tipo di Metadata (<entity_type>). I tipi consentiti sono i seguenti:
|
Avvertimento
All'interno dell'EC i valori degli attributi iss e sub contengono il medesimo valore (URL).
Entity Configuration Foglia e intermediari¶
Gli EC delle entità Foglia e intermediari, in aggiunta ai claim precedentemente definiti, contengono anche i seguenti claim:
| Claim | Descrizione | Supportato da |
|---|---|---|
| authority_hints | Array di URL. Contiene una lista di URL delle entità superiori, quali TA o SA che POSSONO emettere un ES relativo a questo soggetto. | |
| trust_marks | Un array JSON contenente i Trust Mark. Vedere la Sezione Trust Mark. Obbligatorio per tutti i partecipanti fatta esclusione del Trust Anchor. |
Entity Configuration Trust Anchor¶
Gli EC di un TA, in aggiunta ai claim comuni a tutti i partecipanti, contengono anche i seguenti:
Vedi anche
Entity Statement¶
Il componente basilare per costruire una Catena di Fiducia (Trust Chain) è l'Entity Statement (ES), un JWT firmato che contiene la chiavi pubbliche dell' Entità discendente (subject) e ulteriori dati usati per controllare il processo di risoluzione della Trust Chain.
Una entità pubblica un ES relativo ad un suo discendente presso il proprio Fetch Endpoint. L'entità superiore PUÒ definire le policy sui metadata per un soggetto discendente e pubblicare i TM da lei emessi per questo.
Firma di Entity Statement¶
Si applicano le medesime considerazioni fatte per gli EC e riportate nella sezione Firma della Entity Configuration.
Entity Statement¶
Gli ES emessi dal TA o da un suo Intermediario per i propri diretti discendenti, DEVONO contenere i seguenti attributi:
| Claim | Descrizione | Supportato da |
|---|---|---|
| iss | Si rimanda alla specifica OIDC-FED Sezione 3.1 per i dettagli. | |
| sub | Si rimanda alla specifica OIDC-FED Sezione 3.1 per i dettagli. | |
| iat | Si rimanda alla specifica OIDC-FED Sezione 3.1 per i dettagli. | |
| exp | Si rimanda alla specifica OIDC-FED Sezione 3.1 per i dettagli. | |
| jwks | JWKS di Federazione dell'entità sub. Si rimanda alla specifica OIDC-FED Sezione 3.1 per i dettagli. | |
| metadata_policy | JSON Object che descrive un criterio di Metadata. Ogni chiave dell'oggetto JSON rappresenta un identificatore del tipo di Metadata e ogni valore DEVE essere un oggetto JSON che rappresenta la politica dei Metadata in base allo schema di quel tipo di Metadata. Si rimanda alla specifica OIDC-FED Section 5.1 per i dettagli implementativi. | |
| trust_marks | JSON Array contenente i Trust Mark emessi da se stesso per il soggetto discendente. | |
| constraints | PUÒ contenere il claim allowed_leaf_entity_types per restringere i tipi di Entità riconoscobili per il suo discendente (esempio: solo RP). |
Metadata Policy¶
Trust Anchors e Intermediari (SA) DEVONO pubblicare una policy relativa ai rispettivi discendenti nell'Entity Statement ad essi riferito. La Metadata Policy si DEVE applicare a cascata su tutti i discendenti.
Metadata Policy di un TA per un RP¶
Di seguito vengono riportati i claim che DEVONO essere considerati nel parametro metadata di tipo openid_realying_party all'interno della policy che il TA stabilisce per un RP suo discendente diretto.
| Claim | Operazioni / Valori | Supportato da |
|---|---|---|
| jwks | Operazioni: value Valori: DEVE contenere i JWKS del RP relativi alle operazioni di Core essential = true |
|
| grant_types | Operazioni: subset_of, super_set Valori: DEVE contenere authorization_code e refresh_token essential = true |
|
| id_token_signed_response_alg | Operazioni: one_of Valori: DEVE contenere uno degli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| id_token_encrypted_response_alg | Operazioni: one_of Valori: DEVE contenere uno degli algoritmi definiti nella Sezione Algoritmi Crittografici essential = false |
|
| id_token_encrypted_response_enc | Operazioni: one_of Valori: DEVE contenere uno degli algoritmi definiti nella Sezione Algoritmi Crittografici essential = false |
|
| userinfo_signed_response_alg | Operazioni: one_of Valori: DEVE contenere uno degli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| userinfo_encrypted_response_alg | Operazioni: one_of Valori: DEVE contenere uno degli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| userinfo_encrypted_response_enc | Operazioni: one_of Valori: DEVE contenere uno degli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| token_endpoint_auth_method | Operazioni: one_of Valori: DEVE essere private_key_jwt essential = true |
|
| client_registration_types | Operazioni: subset_of Valori: DEVE essere automatic essential = true |
|
| redirect_uris | Operazioni: essential = true |
|
| client_id | Operazioni: essential = true |
|
| response_types | Operazioni: value Valori: DEVE essere code essential = true |
Metadata Policy di un TA per un SA¶
Di seguito vengono riportati i claim che DEVONO essere considerati nel parametro metadata di tipo openid_relying_party all'interno della policy che il TA stabilisce per un SA. Questa policy DEVE essere applicata a cascata ai metadata dei RP discendenti diretti (aggregati) del SA.
| Claim | Operazioni / Valori | Supportato da |
|---|---|---|
| grant_types | Operazioni: subset_of, superset_of Valori: DEVE contenere authorization_code e refresh_token essential = true |
|
| id_token_signed_response_alg | Operazioni: one_of Valori: DEVE contenere uno degli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| id_token_encrypted_response_alg | Operazioni: one_of Valori: DEVE contenere gli algoritmi definiti nella Sezione Algoritmi Crittografici essential = false |
|
| id_token_encrypted_response_enc | Operazioni: one_of Valori: DEVE contenere uno degli algoritmi definiti nella Sezione Algoritmi Crittografici essential = false |
|
| userinfo_signed_response_alg | Operazioni: one_of Valori: DEVE contenere uno degli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| userinfo_encrypted_response_alg | Operazioni: one_of Valori: DEVE contenere uno degli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| userinfo_encrypted_response_enc | Operazioni: one_of Valori: DEVE contenere uno degli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| token_endpoint_auth_method | Operazioni: one_of Valori: DEVE essere private_key_jwt essential = true |
|
| client_registration_types | Operazioni: subset_of Valori: DEVE essere automatic essential = true |
|
| redirect_uris | Operazioni: essential = true |
|
| client_id | Operazioni: essential = true |
|
| response_types | Operazioni: value Valori: DEVE essere code essential = true |
Metadata Policy di un SA per una RP¶
Di seguito vengono riportati i claim che DEVONO essere considerati nel parametro metadata di tipo openid_relying_party all'interno della policy che il SA stabilisce per un RP suo discendente diretto (Aggregato).
| Claim | Operazioni / Valori | Supportato da |
|---|---|---|
| jwks | Operazioni: value Valori: DEVE contenere i JWKS del RP relativi alle operazioni di Core essential = true |
Metadata Policy di un TA per un OP¶
Di seguito vengono riportati i claim che DEVONO essere considerati nel parametro metadata di tipo openid_provider all'interno della policy che il TA stabilisce per un RP suo discendente diretto.
| Claim | Operazioni / Valori | Supportato da |
|---|---|---|
| jwks | Operazioni: value Valori: DEVE contenere i JWKS del OP relativi alle operazioni di Core essential = true |
|
| revocation_endpoint_auth_methods_supported | Operazioni: subset_of Valori: DEVE essere private_key_jwt essential = true |
|
| code_challenge_methods_supported | Operazioni: subset_of Valori: DEVE essere S256 essential = true |
|
| scopes_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere openid, offline_access. Per CIE id PUÒ contenere anche profile, email. essential = true |
|
| response_types_supported | Operazioni: subset_of Valori: DEVE essere code. essential = true |
|
| response_modes_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere form_post, query. essential = true |
|
| grant_types_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere refresh_token, authorization_code. essential = true |
|
| acr_values_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere https://www.spid.gov.it/SpidL1, https://www.spid.gov.it/SpidL2, https://www.spid.gov.it/SpidL3. essential = true |
|
| subject_types_supported | Operazioni: subset_of Valori: DEVE essere pairwise. essential = true |
|
| id_token_signing_alg_values_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere gli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| id_token_encryption_alg_values_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere gli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| id_token_encryption_enc_values_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere gli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| userinfo_signing_alg_values_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere gli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| userinfo_encryption_alg_values_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere gli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| userinfo_encryption_enc_values_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere gli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| token_endpoint_auth_methods_supported | Operazioni: subset_of Valori: DEVE essere private_key_jwt essential = true |
|
| token_endpoint_auth_signing_alg_values_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere gli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| claims_parameter_supported | Operazioni: value Valori: DEVE essere true essential = true |
|
| request_parameter_supported | Operazioni: value Valori: DEVE essere true essential = true |
|
| authorization_response_iss_parameter_supported | Operazioni: value Valori: DEVE essere true essential = true |
|
| client_registration_types_supported | Operazioni: subset_of Valori: DEVE essere automatic essential = true |
|
| request_authentication_methods_supported | Operazioni: value Valori: DEVE essere request_object essential = true |
|
| request_authentication_signing_alg_values_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere gli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| request_object_signing_alg_values_supported | Operazioni: subset_of, superset_of Valori: DEVE contenere gli algoritmi definiti nella Sezione Algoritmi Crittografici essential = true |
|
| issuer | Operazioni: essential = true |
|
| authorization_endpoint | Operazioni: essential = true |
|
| token_endpoint | Operazioni: essential = true |
|
| userinfo_endpoint | Operazioni: essential = true |
|
| introspection_endpoint | Operazioni: essential = true |
|
| revocation_endpoint | Operazioni: essential = true |
Vedi anche
Trust Mark¶
I Trust Mark (TM), letteralmente tradotti come Marchi di Fiducia, sono JWT firmati RFC 7515 e rappresentano la dichiarazione di conformità ad un insieme ben definito di requisiti di fiducia e/o di interoperabilità o un accordo tra le parti coinvolte all'interno della Federazione.
Lo scopo principale dei TM è quello di esporre alcune informazioni non richieste dal protocollo OpenID Connect Core ma che risultano utili in contesto Federativo.
Esempi tipici includono il codice di identificazione nazionale o internazionale dell'entità (Codice Fiscale, IPA Code, Partita IVA, VAT Number), i contatti istituzionali e altro, come definito in OIDC-FED. Ulteriori dati possono essere aggiunti dal soggetto che li emette.
I TM sono emessi e firmati, durante il processo di registrazione di una nuova entità di tipo Foglia (Onboarding), dal (TA) o suoi Intermediari (SA) o da Gestori Qualificati di Attributi (AA), se definiti all'interno dell'attributo trust_mark_issuers, pubblicato all'interno dell'Entity Configuration del TA.
Di seguito un esempio non normativo dell'oggetto trust_mark_issuers all'interno della Entity Configuration del TA.
{
"trust_mark_issuers":{
"https://registry.agid.gov.it/openid_relying_party/public/":[
"https://registry.spid.agid.gov.it/",
"https://public.intermediate.spid.it/"
],
"https://registry.agid.gov.it/openid_relying_party/private/":[
"https://registry.spid.agid.gov.it/",
"https://private.other.intermediate.it/"
]
}
}
Ogni entità partecipante DEVE esporre nella propria configurazione (EC) i TM rilasciati dalle autorità che li emettono.
Nello scenario CIE / SPID, un TM viene firmato dal TA MinInterno / Agid o loro Intermediari (SA) o Gestori Qualificati di Attributi (AA).
Il TA definisce i soggetti abilitati all'emissione dei TM riconoscibili all'interno della Federazione, mediante il claim trust_mark_issuers, presente all'interno del proprio Entity Configuration. Il valore dell'attributo trust_mark_issuers è composto da un oggetto JSON avente come chiavi gli identificativi dei TM e come valori la lista degli identificativi (URL) delle entità abilitate ad emetterli.
I Trust Mark rappresentano il primo filtro per l'instaurazione della fiducia tra le parti, sono elementi indispensabili per avviare la risoluzione dei metadati. In loro assenza una entità non è riconoscibile come partecipante all’interno della Federazione.
All’interno della Federazione SPID i Trust Mark presentano degli identificativi univoci (claim id) in formato URL che adottano la seguente struttura: https:// <domain> / <entity_role> / [<trustmark_profile> /] [estensione /]
Alcuni esempi non normativi sono di seguito riportati:
- TM RP public: https://registry.agid.gov.it/openid_relying_party/public/
- TM SA private: https://registry.agid.gov.it/intermediate/private/
- TM AA: https://registry.agid.gov.it/oauth_resource/public/
La tabella seguente definisce i <entity_role> riconoscibili all'interno delle Federazioni SPID e CIE id:
| tipo | descrizione | entità |
|---|---|---|
| openid_relying_party | l'entità nel claim sub è un RP. | RP |
| openid_provider | l'entità nel claim sub è un OP. | OP |
| intermediate | l'entità nel claim sub è un Soggetto Aggregatore. | SA |
| oauth_resource | l'entità nel claim sub è una Attribute Authority. | AA |
La tabella seguente definisce i <trustmark_profile> riconoscibili all'interno delle Federazioni SPID e CIE id:
| profilo | descrizione | Entità |
|---|---|---|
| public | l'entità nel claim sub appartiene alla pubblica amministrazione italiana. | RP, OP, SA, AA |
| private | l'entità nel claim sub appartiene al settore privato. | RP, OP, SA, AA |
federation_entity Trust Mark¶
In aggiunta ai claim dei profili public e private, il profilo intermediate individua i SA e aggiunge le estensioni full e light all'interno del claim sa_profile, a seconda della modalità con cui operano rispetto ai Soggetti Aggregati
Vedi anche
Si veda Sezione Soggetti aggregatori nel contesto Federativo
oauth_resource Trust Mark¶
In aggiunta ai claim dei profili public e private, il profilo oauth_resource individua le AA e aggiunge i seguenti claim obbligatori:
| Claim | Descrizione |
|---|---|
| policy_uri | URL dove è disponibile la privacy policy dell'AA. |
| tos_uri | URL dove è disponibile la info policy dell'AA. |
| claims | Lista di JSON Object che definiscono gli attributi dell’utente richiesti dall'AA. Esempio: {"https://attributes.eid.gov.it/fiscal_number":{"essential":true}, "email":{"essential":true},} |
| service_documentation | URL dove è disponibile il documento OAS3 che descrive il funzionamento dei servizi dell'AA. |
Validazione dei Trust Mark¶
Esistono due modi per validare un Trust Mark:
- Validazione statica. Il Trust Mark viene validato mediante la chiave pubblica dell'autorità che lo ha emesso (attributo iss), sulla base della corrispondenza dell'attributo sub con il medesimo attributo della Entity Configuration in cui è contenuto e sulla base del valore di scadenza (attributo exp).
- Validazione dinamica. I partecipanti della Federazione possono interrogare l'endpoint trust mark status erogato dal suo emettitore (attributo iss) per la verifica in tempo reale dei TM da lui emessi.
Tutte le entità che rilasciano Trust Mark DEVONO esporre un endpoint di Trust Mark status per consentire la validazione dinamica.
Vedi anche
- OIDC-FED Sezione .5.3.2.
Revoca dei Trust Mark¶
Un Trust Mark può essere revocato in qualsiasi momento solo ed esclusivamente dal soggetto che lo ha emesso. Ad esempio, in caso di esclusione di un Soggetto Aggregato da parte della Autorità di Federazione, questa comunica al Soggetto Aggregatore l'esclusione dell'Aggregato. Di conseguenza il SA DEVE revocare il TM per il suo discendente.
Nota
Nel caso di revoca di un TM, la validazione dinamica darà esito negativo, mentre la validazione statica continuerà a dare esito positivo, a meno di rotazioni delle chiavi crittografiche di firma del soggetto che ha rilasciato il TM.
Composizione dei Trust Mark¶
Gli attributi definiti all'interno dei TM aderiscono a quanto definito all'interno dello standard OIDC Federation 1.0 (OIDC-FED). Segue la lista.
| Claim | Descrizione | Supportato da |
|---|---|---|
| iss | String. URL che identifica univocamente l'Autorità che lo ha emesso. | |
| sub | String. URL che identifica univocamente il soggetto per il quale il Trust Mark è stato emesso. | |
| id | String. Identificativo univoco del Trust Mark. È un URL con la seguente struttura: <TA domain>/<entity_type>/<trustmark_profile>/ es. non normativo: https://registry.interno.gov.it/openid_relying_party/public/ |
|
| iat | UNIX Timestamp con l'istante di generazione del JWT, codificato come NumericDate come indicato in RFC 7519 | |
| logo_uri | String. Un URL che punta al logo rappresentante il Trust Mark. | |
| exp | UNIX Timestamp con l'istante di scadenza del JWT, codificato come NumericDate come indicato in RFC 7519 | |
| ref | String. URL che punta a informazioni presenti sul web relative a questo Trust Mark. | |
| organization_type | String. Specifica se l'ente appartiene alla pubblica amministrazione italiana o al settore privato (public o private) | |
| id_code | Oggetto JSON. Contiene uno o più codici di identificazione dell'organizzazione. I claim disponibili sono: - ipa_code: OBBLIGATORIO nel caso di organizzazione pubblica. - aoo_code: OPZIONALE. - uo_code: OPZIONALE. - vat_number: OBBLIGATORIO per organizzazione privata se non presente fiscal_number. - fiscal_number: OBBLIGATORIO per organizzazione privata se non presente vat_number. | |
| String. Email istituzionale o PEC dell'organizzazione. | ||
| organization_name | String. Il nome completo dell'entità che fornisce i servizi | |
| sa_profile | String. RICHIESTO per SA. Specifica il profilo dell’Aggregatore, full o light. |
Avvertimento
Il valore contenuto nel parametro exp NON DEVE essere superiore alla durata delle convenzioni stipulate in fase di onboarding tra l'Entità che rilascia i Trust Mark e le organizzazioni che lo ricevono.
Vedi anche
- OIDC-FED Sezione 5.3.1.
- Esempi non normativi: Trust Mark issued by TA to a RP, Trust Mark issued by TA to a SA, Trust Mark issued by SA to a RP,
Soggetti Aggregatori¶
Un SA può registrare RP preesistenti e già conformi allo standard OIDC-FED, afferenti a domini esterni al proprio oppure mascherare dietro di sé i propri discendenti. Nel primo caso il SA è di tipo Trasparente (Aggregatore Light) mentre nel secondo caso è di tipo Proxy (Aggregatore Full).
I SA Light registrano RP preesistenti e conformi a OIDC-FED e pubblicano gli ES a questi riferiti.
I SA Full provvedono a costruire una interfaccia di autenticazione e federazione per conto dei propri aggregati, mediante risorse web solitamente esposte all'interno del proprio dominio. Questa tipologia di Aggregatore espone le seguenti risorse per ogni suo aggregato:
- .well-known/openid-federation, contenente la Entity Configuration del proprio discendente (aggregato);
- Authorization callback endpoint per l'acquisizione dell'auth code da parte del OP (redirect_uri).
Il SA di tipo Full DEVE aggiungere almeno uno dei codici identificativi presenti nell'id_code (così come definito nella Sezione Composizione dei Trust Mark), all'interno del web path che compone il client_id, questo identifica univocamente all'interno della federazione l'aggregato <SA_domain>/<id_code>/. Se sono disponibili più di un codice identificativo, il SA PUÒ riportarli nel web path come nel seguente esempio: <SA_domain>/ipa_code/aoo_code/.
Nella seguente tabella sono presenti alcuni esempi non normativi per evidenziare le differenze tra gli aggregati Light e Full:
| Modalità Light | Modalità Full | |
|---|---|---|
| client_id | https://www.rp.it/ | https://www.sa.it/<id_code>/ |
| redirect_uri | https://www.rp.it/callback/ | https://www.sa.it/<id_code>/callback/ |
| authorization endpoint | https://www.rp.it/authorization/ | https://www.sa.it/<id_code>/authorization/ |
| Entity Configuration | https://www.rp.it/.well-known/openid-federation | https://www.sa.it/<id_code>/.well-known/openid-federation |
Acquisire i Metadata¶
In questa sezione sono illustrate le modalità di mutuo riconoscimento dei partecipanti all'interno della medesima federazione, le modalità con le quali i partecipanti ottengono i metadata gli uni degli altri in maniera sicura.
Relying Party¶
Il RP ottiene la lista degli OP in formato JSON interrogando l'endpoint list disponibile presso il Trust Anchor. Per ogni soggetto contenuto nella risposta dell'endpoint list e corrispondente ad un OP, il RP richiede ed ottiene l'Entity Configuration presso l'OP.
Per ogni EC degli OP, il RP verifica la firma del contenuto adoperando la chiave pubblica ottenuta dall'Entity Statement rilasciato dalla Trust Anchor per gli OP. Verifica la firma dell'Entity Configuration degli OP usando la chiave pubblica ottenuta dall'Entity Statement rilasciato dal TA.
Il RP applica infine le politiche pubblicate dal Trust Anchor sui Metadata dell'OP e salva il Metadata finale associandolo ad una data di scadenza (claim exp). La data di scadenza corrisponde al valore di exp più basso ottenuto da tutti gli elementi che compongono la Trust Chain. Periodicamente il RP aggiorna i Metadata di tutti gli OP rinnovando la Trust Chain relativa a questi.
Ottenuti i Metadata finali di tutti i OpenID Connect Provider, il RP genera lo SPID Button o il CIE id Button e lo pubblica all'interno della pagina di autenticazione destinata agli utenti.
La procedura di Federation Entity Discovery risulta semplificata per i RP, perché all'interno della Federazione non è consentita l'esistenza di Intermediari tra gli OP ed il loro Trust Anchor.
La procedura di Federation Entity Discovery a partire dalla Foglia fino al Trust Anchor. Dall'Entity Statement rilasciato da un superiore si ottiene la chiave pubblica per la validazione dell'Entity Configuration dell'entità discendente.
OpenID Provider¶
Quando un Provider (OP) riceve una richiesta di autorizzazione da parte di un RP non precedentemente riconosciuto, avviene la procedura di automatic client registration. Sono di seguito descritte le operazioni compiute dal OP per registrare un RP dinamicamente.
La registrazione di un RP dalla prospettiva di un OP che per la prima volta riceve una richiesta di autorizzazione dal RP e avvia il processo di Federation Entity Discovery e salvataggio della Trust Chain.
L'OP estrae l'identificativo univoco (client_id) dall'oggetto request contenuto all'interno della Authorization Request ed effettua una richiesta di Entity Configuration presso il RP. Ottiene l'Entity Configuration del RP e convalida la firma dei Trust Mark riconoscibili all'interno della Federazione [1].
Se il RP non espone all'interno della sua configurazione nessun Trust Mark riconoscibile per il profilo di RP (vedi Sezione Trust Mark) il Provider DEVE rifiutare l'autorizzazione con un messaggio di errore come definito nella Sezione Gestione degli errori di Federazione.
Se il Provider convalida con successo almeno un Trust Mark per il profilo RP contenuto all'interno della configurazione del RP richiedente, estrae le entità superiori contenute nel claim authority_hints ed avvia la fase di Federation Entity Discovery. Ne consegue il calcolo della Trust Chain e l'ottenimento del Metadata finale.
Durante il Federation Entity Discovery, il Provider richiede ad una o più entità superiori [2] l'Entity Statement relativo al RP e ottiene la chiave pubblica con la quale valida la configurazione del RP, fino a giungere al Trust Anchor. Infine applica la politica dei Metadata pubblicata dal Trust Anchor e salva il risultante Metadata finale del RP associandolo ad una data di scadenza, oltre la quale rinnoverà il Metadata secondo le modalità di rinnovo della Trust Chain.
Ottenuto il Metadata finale, il Provider valida la richiesta del RP secondo le modalità definite in questo documento.
Nei casi in cui un RP avesse come entità superiore un SA e non direttamente il TA, la procedura di acquisizione e validazione dell'Entity Configuration del RP avviene mediante l'Entity Statement pubblicato dal SA nei confronti del RP e mediante la convalida dell'Entity Configuration del SA con l'Entity Statement emesso dalla TA in relazione al SA. Se la soglia del massimo numero di Intermediari verticali, definita dal valore di max_path_length, viene superata, l'OP blocca il processo di Federation Entity Discovery e rigetta la richiesta del RP.
| [1] | I Trust Mark di Federazione sono configurati nel claim trust_mark_issuers e contenuti nell'Entity Configuration del Trust Anchor. |
| [2] | Un RP può esporre più di una entità superiore all'interno del proprio claim di authority_hints. Si pensi ad un RP che partecipa sia alla Federazione SPID che a quella CIE. Inoltre un RP può risultare come aggregato di molteplici Intermediari, sia questi SPID o CIE. |
Ogni partecipante espone la propria configurazione e i propri Trust Mark. Il collegamento tra una Foglia e il Trust Anchor avviene in maniera diretta oppure mediante un Intermediario (Soggetto Aggregatore) come in Figura.
Accesso alla Entity Configuration¶
In questa sezione viene descritto come individuare per un determinato soggetto l'URL RFC 3986 per il download della Entity Configuration.
La risorsa attraverso la quale un partecipante pubblica la sua configurazione (Entity Configuration) corrisponde al webpath .well-known/openid-federation e DEVE essere appesa all'URL che identifica il soggetto.
Esempi:
- con identificativo del soggetto pari a
https://rp.example.itil risultante URL di Entity Configuration è
https://rp.example.it/.well-known/oidc-federation.- con identificativo del soggetto pari
https://rp.servizi-spid.it/oidc/il risultante URL di Entity Configuration è
https://rp.servizi-spid.it/oidc/.well-known/oidc-federation.
Se l'URL che identifica il soggetto non presenta il simbolo di slash finale ("/"), è necessario aggiungerlo prima di concatenare il web path della risorsa .well-known.
Una volta che un RP viene riconosciuto come parte della Federazione, ottiene il permesso di effettuare una Richiesta di Autenticazione. L'OP che non ha interagito prima d'ora con un RP che fa la richiesta, è in grado di risolvere la fiducia mediante l'API di federazione (Federation Entity Discovery e produzione della Trust Chain). L'OP inizia richiedendo la Entity Configuration del RP al .well-known endpoint del RP e, seguendo il percorso dato dall'authority_hint, raggiunge la radice del Trust, cioè il TA. In ogni passo della catena l'OP può eseguire tutti i controlli di sicurezza richiedendo le dichiarazioni di entità da ciascuna entità e convalidando i Trust Mark e le firme. La figura che segue dà un esempio rappresentativo di come funziona la catena del Trust.
The Federation Entity Discovery process to build a Trust Chain and obtain the final Metadata.
Endpoint di Federazione¶
Tutte le entità DEVONO contenere i seguenti endpoint:
- /.well-known/openid-federation: fornisce l'Entity Configuration (per maggiori dettagli vedi OIDC-FED Section 6)
- resolve entity statement endpoint: fornisce il metadata finale, la Trust Chain e i Trust Mark relativi ad un altro soggetto. Per maggiori dettagli vedi OIDC-FED Section 7.2.
Avvertimento
Il resolve entity statement endpoint NON DEVE restituire alcuna informazione relativa ad un soggetto del quale non ha precedentemente raccolto gli statement e calcolato la Trust Chain. Nel caso in cui i TM non siano più validi al momento della richiesta, questi NON DEVONO essere inclusi nella risposta.
Le Entità di tipo TA o SA DEVONO offrire i seguenti endpoint, in aggiunta agli endpoint di federazione sopra riportati:
- fetch entity statement endpoint: fornisce gli ES relativi ad un soggetto discendente diretto. Per ottenere un ES è necessario indicare almeno l'identificativo dell'entità di cui si vuole ottenere lo statement. (per maggiori dettagli vedi OIDC-FED Section 7.1)
- trust mark status endpoint: permette a un'entità di verificare se un TM è ancora attivo o no. La query DEVE essere inviata al soggetto che ha rilasciato quel TM. (per maggiori dettagli vedi OIDC-FED Section 7.4)
- entity listing endpoint: fornisce la lista delle entità discendenti registrate presso il TA o un SA (per maggiori dettagli vedi OIDC-FED Section 7.3)
Un'entità di tipo AA, oltre agli endpoint di Federazione comuni a tutte le entità, DEVE riportare anche il trust mark status endpoint per consentire la validazione dinamica dei TM rilasciati dall'AA.
Gestione degli errori di federazione¶
In caso di errore durante le operazioni di federazione, le entità DEVONO rappresentare i messaggi di anomalia come descritto di seguito.
| Claim | Descrizione | Supportato da |
|---|---|---|
| Errore | Vedi Codici di errori | |
| Descrizione dell'errore | Descrizione più dettagliata dell'errore, finalizzata ad aiutare lo sviluppatore per eventuale debugging. |
Codici di errore di Federation¶
Metadata¶
OIDC-FED utilizza ed estende i claim dei Metadata così come definiti all'interno delle specifiche di OpenID Connect Discovery 1.0 (OpenID.Discovery) e OpenID Connect Dynamic Client Registration 1.0 (OpenID.Registration) rispettivamente per OP e RP.
In OIDC-FED il Metadata OIDC relativo a RP e OP viene definito all'interno del claim metadata e del suo sotto claim <entity_type>, all'interno dell'Entity Configuration, come oggetto JSON.
OpenID Connect Provider Metadata (OP)¶
Un OP DEVE pubblicare all'interno del suo EC un Metadata da federation_entity e uno da openid_provider come riportato nel seguente esempio:
L'EC di un OP DEVE configurare un metadata di tipo "federation_entity" e contenere almeno i seguenti parametri obbligatori:
| Claim | Descrizione | Supportato da |
|---|---|---|
| organization_name | Vedi Sezione 4.8 di OIDC-FED | |
| homepage_uri | Vedi Sezione 4.8 di OIDC-FED | |
| policy_uri | Vedi Sezione 4.8 di OIDC-FED | |
| logo_uri | URL del logo dell'entità; DEVE essere in formato SVG. Vedi Sezione 4.8 di OIDC-FED | |
| contacts | PEC istituzionale dell'ente. Vedi Sezione 4.8 di OIDC-FED | |
| federation_resolve_endpoint | Vedi Sezione Endpoint di Federazione e OIDC-FED Section 4.6 |
L'EC di un OP DEVE configurare un metadata di tipo "openid_provider" DEVE contenere almeno i seguenti parametri obbligatori:
| Claim | Descrizione | Supportato da |
|---|---|---|
| issuer | Vedi OpenID.Discovery#OP_Metadata. DEVE essere valorizzato con un HTTPS URL che identifica univocamente l'OP. | |
| authorization_endpoint | Vedi OpenID.Discovery#OP_Metadata. | |
| token_endpoint | Vedi OpenID.Discovery#OP_Metadata. | |
| userinfo_endpoint | Vedi OpenID.Discovery#OP_Metadata. | |
| introspection_endpoint | Vedi RFC 8414#page-4. | |
| revocation_endpoint | Vedi RFC 8414#page-4. | |
| revocation_endpoint_auth_methods_supported | Vedi RFC 8414#page-4. Il valore supportato è private_key_jwt | |
| code_challenge_methods_supported | Vedi RFC 8414#page-4. L'OP DEVE supportare S256 (vedi RFC 7636#section-4.3). | |
| scopes_supported | Vedi OpenID.Discovery#OP_Metadata. I valori supportati sono openid e offline_access. CIE id supporta anche profile, email. Per maggiori dettagli vedi Sezione User Claims. | |
| response_types_supported | Vedi OpenID.Discovery#OP_Metadata. Il valore supportato è code. | |
| response_modes_supported | Vedi OpenID.Discovery#OP_Metadata. I valori supportati sono form_post e query. | |
| grant_types_supported | Vedi OpenID.Discovery#OP_Metadata. I valori supportati sono refresh_token e authorization_code. | |
| acr_values_supported | Vedi OpenID.Discovery#OP_Metadata. I valori supportati sono:
|
|
| subject_types_supported | Vedi OpenID.Discovery#OP_Metadata. Il valore supportato è pairwise. | |
| id_token_signing_alg_values_supported | Vedi OpenID.Discovery#OP_Metadata. Vedi signature Algoritmi crittografici. | |
| id_token_encryption_alg_values_supported | See OpenID.Discovery#OP_Metadata. Vedi key encryption Algoritmi crittografici. | |
| id_token_encryption_enc_values_supported | See OpenID.Discovery#OP_Metadata. Vedi content encryption Algoritmi crittografici. | |
| userinfo_signing_alg_values_supported | Vedi OpenID.Discovery#OP_Metadata. Vedi signature Algoritmi crittografici. | |
| userinfo_encryption_alg_values_supported | Vedi OpenID.Discovery#OP_Metadata. Vedi key encryption Algoritmi crittografici. | |
| userinfo_encryption_enc_values_supported | Vedi OpenID.Discovery#OP_Metadata. Vedi content encryption Algoritmi crittografici. | |
| request_object_signing_alg_values_supported | Vedi OpenID.Discovery#OP_Metadata. Vedi signature Algoritmi crittografici. | |
| token_endpoint_auth_methods_supported | Vedi OpenID.Discovery#OP_Metadata. Il valore supportato è private_key_jwt | |
| token_endpoint_auth_signing_alg_values_supported | Vedi OpenID.Discovery#OP_Metadata. Vedi signature Algoritmi crittografici. | |
| claims_supported | Vedi OpenID.Discovery#OP_Metadata. Vedi Attributi Utente per maggiori dettagli. | |
| claims_parameter_supported | Vedi OpenID.Discovery#OP_Metadata. Il valore supportato è true. | |
| request_parameter_supported | Vedi OpenID.Discovery#OP_Metadata. Il valore supportato è true. | |
| authorization_response_iss_parameter_supported | Vedi RFC 9207#section-3. Deve valere true. | |
| jwks | Vedi OIDC-FED Section 4.2 e JWK. | |
| client_registration_types_supported | Vedi OIDC-FED Section 4.2. Il valore supportato è automatic. | |
| request_authentication_methods_supported | Vedi OIDC-FED Section 4.2. Il valore supportato è request_object. | |
| request_authentication_signing_alg_values_supported | Vedi OIDC-FED Section 4.2. Vedi signature Algoritmi crittografici. |
Avvertimento
Il Metadata "openid_provider" DEVE adottare il parametro jwks o signed_jwks_uri come normato da OID-FED invece del parametro jwks_uri come richiesto in OpenID.Discovery#OP_Metadata.
Vedi anche
OpenID Connect Relying Party Metadata (RP)¶
Un RP DEVE pubblicare all'interno del suo EC un Metadata di tipo federation_entity e uno di tipo openid_relying_party come riportato nel seguente esempio:
Il Metadata di tipo "federation_entity" DEVE contenere almeno i seguenti parametri obbligatori:
| Claim | Descrizione | Supportato da |
|---|---|---|
| organization_name | Vedi Sezione 4.8 di OIDC-FED | |
| homepage_uri | Vedi Sezione 4.8 di OIDC-FED | |
| policy_uri | Vedi Sezione 4.8 di OIDC-FED | |
| logo_uri | (RACCOMANDATO) URL del logo dell'entità; DEVE essere in formato SVG. Vedi Sezione 4.8 di OIDC-FED | |
| contacts | PEC istituzionale dell'ente. Vedi Sezione 4.8 di OIDC-FED | |
| federation_resolve_endpoint | Vedi Sezione Endpoint di Federazione e OIDC-FED Section 4.6 |
Il Metadata di tipo "openid_relying_party" DEVE contenere almeno i seguenti parametri obbligatori:
| Claim | Descrizione | Supportato da |
|---|---|---|
| redirect_uris | Vedi OpenID.Registration#ClientMetadata. È obbligatorio l'uso dello schema HTTPS nel caso di client web-based. | |
| grant_types | Vedi OpenID.Registration#ClientMetadata. I valori ammissibili authorization_code e refresh_token. | |
| jwks | Vedi OpenID.Registration#ClientMetadata e JWK. | |
| signed_jwks_uri | Vedi OIDC-FED. | |
| id_token_signed_response_alg | Vedi OpenID.Registration#ClientMetadata. Vedi signature Algoritmi crittografici. | |
| id_token_encrypted_response_alg | OPZIONALE. Se presente, l'OP DEVE restituire l'ID Token firmato e cifrato. Vedi OpenID.Registration#ClientMetadata. Vedi key encryption Algoritmi crittografici. | |
| id_token_encrypted_response_enc | Vedi OpenID.Registration#ClientMetadata. Obbligatorio solo nel caso sia presente anche il parametro id_token_encrypted_response_alg. Vedi content encryption Algoritmi crittografici. | |
| userinfo_signed_response_alg | Vedi OpenID.Registration#ClientMetadata. Vedi signature Algoritmi crittografici. | |
| userinfo_encrypted_response_alg | Vedi OpenID.Registration#ClientMetadata. Vedi key encryption Algoritmi crittografici. | |
| userinfo_encrypted_response_enc | Vedi OpenID.Registration#ClientMetadata. Vedi content encryption Algoritmi crittografici. | |
| token_endpoint_auth_method | Vedi OpenID.Registration#ClientMetadata. Il valore richiesto è private_key_jwt. | |
| client_id | Vedi OpenID.Registration. DEVE essere valorizzato con un HTTPS URL che identifica univocamente il RP. | |
| client_registration_types | Vedi OIDC-FED Section 4.1. Il valore richiesto è automatic. | |
| response_types | Array dei valori di response_type previsti da OAuth 2.0 che il RP userà nelle richieste di autenticazione. Deve contenere il valore code. |
Nota
Gli URI presenti nel parametro redirect_uris POSSONO anche usare eventuali schemi custom (ad es. myapp://) al fine di supportare applicazioni mobili.
Metadata di Trust Anchor (TA) e Intermediari (SA)¶
Un TA e un SA DEVONO pubblicare all'interno del loro EC un Metadata da federation_entity come riportato nel seguente esempio:
L'EC di un TA e di SA DEVE configurare un metadata di tipo "federation_entity" e contenere almeno i seguenti parametri obbligatori:
| Claim | Descrizione | Supportato da |
|---|---|---|
| organization_name | Vedi Sezione 4.8 di OIDC-FED | |
| homepage_uri | Vedi Sezione 4.8 di OIDC-FED | |
| policy_uri | Vedi Sezione 4.8 di OIDC-FED | |
| logo_uri | URL del logo dell'entità; DEVE essere in formato SVG. Vedi Sezione 4.8 di OIDC-FED | |
| contacts | PEC istituzionale dell'ente. Vedi Sezione 4.8 di OIDC-FED | |
| federation_fetch_endpoint | Vedi Sezione Endpoint di Federazione e OIDC-FED Section 4.8 | |
| federation_list_endpoint | Vedi Sezione Endpoint di Federazione e OIDC-FED Section 4.8 | |
| federation_trust_mark_status_endpoint | Vedi Sezione Endpoint di Federazione e OIDC-FED Section 4.8 | |
| federation_resolve_endpoint | Vedi Sezione Endpoint di Federazione e OIDC-FED Section 4.8 |
Metadata Attribute Authority¶
Una AA DEVE pubblicare, all'interno del suo EC, un Metadata federation_entity e un Metadata oauth_resource e, se le risorse sono protette, DEVE anche pubblicare un Metadata oauth_authorization_server.
Il Metadata di tipo "federation_entity" DEVE contenere almeno i seguenti parametri obbligatori:
| Claim | Descrizione | Supportato da |
|---|---|---|
| organization_name | Vedi Sezione 4.8 di OIDC-FED | |
| homepage_uri | Vedi Sezione 4.8 di OIDC-FED | |
| policy_uri | Vedi Sezione 4.8 di OIDC-FED | |
| logo_uri | URL del logo dell'entità; DEVE essere in formato SVG. Vedi Sezione 4.8 di OIDC-FED | |
| contacts | PEC istituzionale dell'ente. Vedi Sezione 4.8 di OIDC-FED | |
| federation_trust_mark_status_endpoint | Vedi Sezione Endpoint di Federazione e OIDC-FED Section 4.8 | |
| federation_resolve_endpoint | Vedi Sezione Endpoint di Federazione e OIDC-FED Section 4.8 |
Il Metadata di tipo "oauth_authorization_server" DEVE contenere almeno i seguenti parametri obbligatori:
| Claim | Descrizione | Supportato da |
|---|---|---|
| issuer | Vedi RFC 8414#page-4. DEVE essere valorizzato con un HTTPS URL che identifica univocamente l'AA. | |
| authorization_endpoint | Solo per Attribute Authority private flow. Vedi LG-AA and RFC 8414#page-4. | |
| token_endpoint | Vedi RFC 8414#page-4. | |
| jwks | Vedi JWK. | |
| scopes_supported | Vedi RFC 8414#page-4. | |
| response_types_supported | Vedi RFC 8414#page-4, | |
| grant_types_supported | Vedi RFC 8414#page-4 e RFC 8623. | |
| token_endpoint_auth_methods_supported | Vedi RFC 8414#page-4. Il valore supportato è private_key_jwt. | |
| token_endpoint_auth_signing_alg_values_supported | Vedi RFC 8414#page-4. Vedi signature Algoritmi crittografici. | |
| op_policy_uri | Vedi RFC 8414#page-4. | |
| op_tos_uri | Vedi RFC 8414#page-6. | |
| dpop_signing_alg_values_supported | Vedi OAuth-DPoP. Vedi signature Algoritmi crittografici. |
Il Metadata di tipo "oauth_resource" DEVE contenere almeno i seguenti parametri obbligatori:
| Claim | Descrizione | Supportato da |
|---|---|---|
| resource | Vedi OAuth-RS. Una o più HTTPS URL che identificano gli endpoint delle risorse protette. |
Flusso di autenticazione¶
Gli schemi di autenticazioni "Entra con SPID" e "Entra con CIE" implementano il flusso OpenID Connect Authorization Code Flow con l'estensione PKCE (Proof Key for Code Exchange, RFC 7636). Questo flusso restituisce un Authorization Code che può essere utilizzato per ottenere un ID Token e un Access Token e se possibile anche un Refresh Token. L'Authorization Code Flow ottiene l'Authorization Code dall'Authorization Endpoint dell'OpenID Provider e tutti i token sono restituiti dal Token Endpoint.
Segue la descrizione dei passaggi, come da numerazione indicata in figura.
- L'Utente, nella pagina di accesso del Relying Party (RP):
- Seleziona il pulsante "Entra con SPID" o "Entra con CIE";
- Nel caso SPID, seleziona l'OP con cui autenticarsi.
- Il RP prepara una Richiesta di Autorizzazione con i parametri necessari previsti da PKCE e la invia all'Authorization Endpoint dell'OP.
- L'OP autentica l'utente mediante l'inserimento delle credenziali e ottiene il consenso per l'accesso agli attributi dell'utente da parte del RP.
- L'OP reindirizza l'utente all'URL contenuto nel parametro redirect_uri specificato dal RP, passando un Authorization Code nell'Authorization Response.
- Il RP invia l'Authorization Code ricevuto al Token Endpoint dell'OP.
- Il Token Endpoint dell'OP rilascia un ID Token, un Access Token e se previsto un Refresh Token.
- Il RP riceve e valida l'Access Token e l'ID Token. Per chiedere gli attributi che erano stati autorizzati dall'utente al punto 3, invia una richiesta all'UserInfo Endpoint dell'OP utilizzando l'Access Token per l'autenticazione all'interno della intestazione HTTP Authorization.
- Lo UserInfo Endpoint dell'OP verifica la validità dell'Access Token e rilascia gli attributi richiesti al RP.
Authorization endpoint (Authentication)¶
Request¶
Per avviare il processo di autenticazione, il RP reindirizza l'utente all'Authorization Endpoint dell'OP selezionato, inviando una richiesta HTTP contenente il parametro request in formato JWT firmato e contenente l'Authorization Request firmata dal RP.
Per veicolare la richiesta, il RP PUÒ utilizzare i metodi POST e GET. Mediante il metodo POST i parametri DEVONO essere trasmessi utilizzando la Form Serialization. Mediante il metodo GET i parametri DEVONO essere trasmessi utilizzando la Query String Serialization. Per maggiori dettagli vedi OpenID.Core#Serializations.
Avvertimento
Il parametro scope DEVE essere trasmesso sia come parametro nella chiamata HTTP sia all'interno dell'oggetto request e i loro valori DEVONO corrispondere.
I parametri client_id e response_type DOVREBBERO essere trasmessi sia come parametri sulla chiamata HTTP sia all'interno dell'oggetto request.
I parametri client_id e response_type DEVONO essere trasmessi sia come parametri sulla chiamata HTTP sia all'interno dell'oggetto request e i loro valori DEVONO corrispondere, in caso contrario solo i parametri all’interno dell’oggetto request DEVONO essere considerati.
Vedi anche
Di seguito i parametri obbligatori nella richiesta di autenticazione HTTP.
| Parametro | Descrizione | Supportato da |
|---|---|---|
| scope | Riporta di valori di scope supportati dall'OP e definiti dal parametro scopes_supported nel Metadata OP. DEVE essere presente almeno il valore openid. | |
| code_challenge | Vedi RFC 7636#section-4.2. | |
| code_challenge_method | Come definito dal parametro code_challenge_methods_supported nel Metadata OP. | |
| request | Vedi OpenID.Core#JWTRequests. DEVE essere un JWT firmato. |
Di seguito una tabella che riporta la composizione dell'header del JWT.
| Jose Header | Descrizione | Supportato da |
|---|---|---|
| alg | Vedi RFC 7516#section-4.1.1. Vedi Algoritmi crittografici.. | |
| kid | Vedi RFC 7638#section_3. |
Nota
Il parametro typ se omesso assume il valore implicito di JWT.
Il payload del JWT contiene i seguenti parametri obbligatori.
| Claim | Descrizione | Supportato da |
|---|---|---|
| client_id | Vedi OpenID.Registration. DEVE essere valorizzato con un HTTPS URL che identifica univocamente il RP. | |
| code_challenge | Come definito nella Tabella dei parametri HTTP. | |
| code_challenge_method | Come definito nella Tabella dei parametri HTTP. | |
| nonce | Vedi OpenID.Core#AuthRequest. DEVE essere una stringa casuale di almeno 32 caratteri alfanumerici. Questo valore sarà restituito nell'ID Token fornito dal Token Endpoint, in modo da consentire al client di verificare che sia uguale a quello inviato nella richiesta di autenticazione. | |
| prompt | Vedi OpenID.Core#AuthRequest. I valori consentiti sono: consent: Se non è già attiva una sessione di Single Sign-On, l'OP fa una richiesta di autenticazione all'utente. Quindi chiede il consenso al trasferimento degli attributi. consent login: l'OP forza una richiesta di autenticazione all'utente. Quindi chiede il consenso al trasferimento degli attributi. |
|
| redirect_uri | Vedi OpenID.Core#AuthRequest. DEVE essere una URL indicata nel Metadata RP. | |
| response_type | Vedi OpenID.Core#AuthRequest. Come definito dal parametro response_types_supported nel Metadata OP. | |
| scope | Come definito nella Tabella dei parametri HTTP. | |
| acr_values | Vedi OpenID.Core#AuthRequest. Come definito dal parametro acr_values_supported nel Metadata OP. Valori di riferimento della classe di contesto dell'Authentication Request. DEVE essere una stringa separata da uno spazio, che specifica i valori "acr" richiesti in ordine di preferenza. L'OP PUÒ utilizzare un'autenticazione ad un livello più alto di quanto richiesto. Tale scelta non DEVE comportare un esito negativo della richiesta. | |
| claims | Vedi OpenID.Core#ClaimsRequestParameter. Vedi Sezione "Parametri scope e claims". | |
| state | Vedi OpenID.Core#AuthRequest. DEVE essere una stringa casuale di almeno 32 caratteri alfanumerici. Identificativo univoco della sessione lato RP. Questo valore verrà restituito al client nella risposta al termine dell'autenticazione. | |
| exp | UNIX Timestamp con l'istante di scadenza del JWT, codificato come NumericDate come indicato in RFC 7519 | |
| iat | UNIX Timestamp con l'istante di generazione del JWT, codificato come NumericDate come indicato in RFC 7519 | |
| iss | DEVE corrispondere al client_id. | |
| aud | DEVE corrispondere all'identificativo del OP (parametro issuer presente nel Metadata OP.) | |
| ui_locales | Lingue preferibili per visualizzare le pagine dell’OP. L’OP può ignorare questo parametro se non dispone di nessuna delle lingue indicate. Lista di codici RFC5646 separati da spazi. |
Nota
PKCE è un'estensione del protocollo OAuth 2.0 prevista anche nel profilo iGov (International Government Assurance Profile for OAuth 2.0) e finalizzata ad evitare un potenziale attacco attuato con l'intercettazione dell'authorization code. Consiste nella generazione di un codice (code verifier) e del suo hash (code challenge). Il code challenge viene inviato all'OP nella richiesta di autenticazione.
Quando il RP contatta il Token Endpoint al termine del flusso di autenticazione, invia il code verifier originariamente creato, in modo che l'OP possa confrontare che il suo hash corrisponda con quello acquisito nella richiesta di autenticazione.
Di seguito un script Python di esempio per generare i parametri richiesti.
import hashlib
import base64
import re
import os
import random
def get_pkce(code_challenge_method: str = "S256", code_challenge_length: int = 64):
hashers = {"S256": hashlib.sha256}
code_verifier_length = random.randint(43, 128)
code_verifier = base64.urlsafe_b64encode(os.urandom(code_verifier_length)).decode("utf-8")
code_verifier = re.sub("[^a-zA-Z0-9]+", "", code_verifier)
code_challenge = hashers.get(code_challenge_method)(
code_verifier.encode("utf-8")
).digest()
code_challenge = base64.urlsafe_b64encode(code_challenge).decode("utf-8")
code_challenge = code_challenge.replace("=", "")
return {
"code_verifier": code_verifier,
"code_challenge": code_challenge,
"code_challenge_method": code_challenge_method,
}
Parametri scope e claims¶
Per la definizione del parametro claims e la modalità di utilizzo per la richiesta degli attributi dell'utente si può fare riferimento a OpenID.Core#ClaimsParameter.
Response¶
Un'Authentication response è un messaggio di risposta di autorizzazione OAuth 2.0 restituito dall'authorization endpoint dell'OpenID Provider (OP) al termine del flusso di autenticazione. L'OP reindirizzerà l'utente all'url contenuto nel parametro redirect_uri specificato nella richiesta di autorizzazione, aggiungendo i parametri della risposta.
Vedi anche
Se l'autenticazione è avvenuta con successo, l'OpenID Provider (OP), reindirizza l'utente aggiungendo i seguenti parametri obbligatori come query parameters al redirect_uri (come definito in OpenID.Core#AuthResponse):
Esempio di Authorization Response dell'OP:
Gestione degli errori¶
In caso di errore, l'OP o il RP rappresentano i messaggi di anomalia relativi agli scambi OpenID Connect, come descritti nelle relative tabelle definite dalle Linee Guida UX SPID.
| Claim | Descrizione | Supportato da |
|---|---|---|
| Errore | Vedi Codici di errori | |
| Descrizione dell'errore | Descrizione più dettagliata dell'errore, finalizzata ad aiutare lo sviluppatore per eventuale debugging. Questo messaggio non è destinato ad essere visualizzato all'utente (a tal fine si faccia riferimento alle Linee Guida UX SPID) | |
| state | Parametro obbligatorio solo nel caso di risposta di errore alla Authentication Request e DEVE essere uguale al valore state incluso nella Authentication Request. Il RP DEVE verificare che corrisponda a quello inviato nella Authentication Request. |
Codici di errore¶
| Errore | Descrizione | Codice HTTP | Supportato da |
|---|---|---|---|
| access_denied | L’OP ha negato l’accesso a causa di credenziali non valide o non adeguate al livello SPID richiesto (RFC 6749#section-4.1.2.1). | 302 Found | |
| unauthorized_client | Il client non è autorizzato a richiedere un authorization code (RFC 6749#section-4.1.2.1). | 302 Found | |
| invalid_request | La richiesta non è valida a causa della mancanza o della non correttezza di uno o più parametri (RFC 6749#section-4.1.2.1). | 302 Found | |
| invalid_scope | Sono stati richiesti degli scope non validi (RFC 6749#section-4.1.2.1). | 302 Found | |
| server_error | L’OP ha riscontrato un problema interno (RFC 6749#section-4.1.2.1). | 302 Found | |
| temporarily_unavailable | L’OP ha riscontrato un problema interno temporaneo (RFC 6749#section-4.1.2.1). | 302 Found | |
| unsupported_response_type | Il response_type richiesto non è supportato (RFC 6749#section-4.1.2.1). | 302 Found | |
| login_required | L'OP richiede l'autenticazione da parte dell'utente (OpenID.Core#AuthError). | 302 Found | |
| consent_required | L'OP richiede il consenso esplicito da parte dell'utente (OpenID.Core#AuthError). | 302 Found | |
| request_uri_not_supported | L'OP non supporta l'uso del parametro request_uri (OpenID.Core#AuthError). | 302 Found | |
| registration_not_supported | L'OP non supporta l'uso del parametro registration (OpenID.Core#AuthError). | 302 Found | |
| invalid_request_object | Il parametro request contiene un Request Object non valido (OpenID.Core#AuthError). | 302 Found |
Avvertimento
In caso di URI di reindirizzamento non valido, non corrispondente o mancante, l'OP restituisce 400 Bad Request come codice HTTP.
Token Endpoint¶
Al termine del flusso di autenticazione descritto nel paragrafo precedente, il RP invia una richiesta al Token Endpoint inviando l'authorization code ricevuto dall'OP per ottenere un ID Token e un Access Token ed eventualmente un Refresh Token (se è stata effettuata una richiesta di autenticazione con scope=offline_access e prompt=consent. Vedi la Sezione Refresh Token).
I token restituiti devono essere JWT firmati.
Nota
Il metodo di autenticazione del RP presso il token endpoint è il private_key_jwt (OpenID.Core#ClientAuthentication).
Vedi anche
Request¶
Di seguito i claim che DEVONO essere inseriti nella Token Request.
Esempio di richiesta con authorization code (caso 1)
Esempio di richiesta con Refresh Token (caso 2):
| Claim | Descrizione | Supportato da |
|---|---|---|
| client_id | Vedi OpenID.Registration. DEVE essere valorizzato con un HTTPS URL che identifica univocamente il RP. | |
| client_assertion | JWT firmato con la chiave privata del Relying Party contenente i seguenti parametri:
|
|
| client_assertion_type | Deve assumere il seguente valore: urn:ietf:params:oauth:client-assertion-type:jwt-bearer |
|
| code | Codice di autorizzazione restituito nell'Authentication response. Obbligatorio solo se grant_type è authorization_code | |
| code_verifier | Codice di verifica del code_challenge. Obbligatorio solo se grant_type è authorization_code | |
| grant_type | Tipo di credenziale presentata dal RP per la richiesta corrente. PUÒ assumere uno dei seguenti valori:
|
|
| refresh_token | Obbligatorio solo se grant_type è refresh_token |
Response¶
L'OpenID Provider (OP) restituisce un ID Token e Access Token e un eventuale Refresh Token, in formato JWT firmato.
L'Access Token deve essere formato secondo le indicazioni dello standard "International Government Assurance Profile (iGov) for OAuth 2.0 - Draft 03", section 3.2.1, "JWT Bearer Tokens".
L'ID Token deve essere formato secondo le indicazioni del paragrafo successivo.
La risposta DEVE contenere i seguenti claim.
Esempio di risposta:
HTTP/1.1 200 OK
Last-Modified: Wed, 22 Jul 2018 19:15:56 GMT
Content-Type: application/json
{
"access_token":"dC34Pf6kdG...",
"token_type":"Bearer",
"refresh_token":"wJ848BcyLP...",
"expires_in":1800,
"id_token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY..."
}
| Claim | Descrizione | Supportato da |
|---|---|---|
| access_token | L'Access Token, in formato JWT firmato, consente l'accesso allo UserInfo endpoint per ottenere gli attributi. | |
| token_type | Tipo di Access Token restituito. DEVE essere valorizzato sempre con Bearer | |
| refresh_token | Disponibile sono nel caso di sessione lunga revocabile. Il Refresh Token, in formato JWT firmato, consente di chiamare nuovamente il Token Endpoint per ottenere un nuovo Access Token e un nuovo ID Token. | |
| expires_in | Scadenza dell'Access Token in secondi. | |
| id_token | ID Token in formato JWT (vedi paragrafo successivo) |
Access Token¶
L'Access Token è un JSON Web Token (JWT) firmato che consente l'accesso allo UserInfo endpoint per ottenere gli attributi dell'utente. Di seguito i claim che compongono l'Access Token.
Esempio del contenuto di intestazione di payload di un Access Token:
| Claim | Descrizione | Supportato da |
|---|---|---|
| iss | DEVE essere valorizzato con un HTTPS URL che identifica univocamente l'OP. Il client DEVE verificare che questo valore corrisponda all'OP chiamato. | |
| sub | Vedi OpenID.Core#SubjectIDTypes. DEVE essere di tipo pairwise. | |
| client_id | DEVE essere valorizzato con un HTTPS URL che identifica univocamente il RP. | |
| aud | DEVE contenere un elenco di Resource Server che consumano l'AT. DEVE contenere almeno lo UserInfo Endpoint. | |
| scope | L'OP DOVREBBE inserire il parametro scope come previsto in RFC 9068 Sezione 2.2.3. DEVE coincidere con il valore presente in fase di richiesta di autenticazione. | |
| iat | UNIX Timestamp con l'istante di generazione del JWT, codificato come NumericDate come indicato in RFC 7519 | |
| exp | UNIX Timestamp con l'istante di scadenza del JWT, codificato come NumericDate come indicato in RFC 7519 | |
| jti | DEVE essere una Stringa in formato uuid4. Identificatore unico dell'ID Token che il RP PUÒ utilizzare per prevenirne il riuso, rifiutando l'ID Token se già processato. |
ID Token¶
L'ID Token è un JSON Web Token (JWT) firmato che contiene informazioni sull'utente che ha eseguito l'autenticazione. I RP DEVONO eseguire la validazione dell'ID Token.
Di seguito i claim disponibili nell'ID Token.
Esempio del contenuto di intestazione e di payload di un ID Token:
| Claim | Descrizione | Supportato da |
|---|---|---|
| iss | DEVE essere valorizzato con un HTTPS URL che identifica univocamente l'OP. Il client DEVE verificare che questo valore corrisponda all'OP chiamato. | |
| sub | Vedi OpenID.Core#SubjectIDTypes. DEVE essere di tipo pairwise. | |
| aud | DEVE coincidere con il valore client_id. Il RP DEVE verificare che questo valore corrisponda al proprio client ID. | |
| acr | Livello di autenticazione effettivo. DEVE essere uguale o superiore a quello richiesto dal RP nella Authentication Request. | |
| at_hash | Vedi OpenID.Core#CodeIDToken. Il suo valore è la codifica base64url della prima metà dell'hash calcolato sulla rappresentazione ASCII dell'Access Token, usando l'algoritmo di hashing indicato in alg nell'header dell'ID Token. Il client DEVE verificare che questo valore corrisponda applicando la medesima funzione all'Access Token restituito insieme all'ID Token. | |
| iat | UNIX Timestamp con l'istante di generazione del JWT, codificato come NumericDate come indicato in RFC 7519 | |
| nbf | UNIX Timestamp. Istante di inizio validità del JWT in formato NumericDate, come indicato in RFC 7519. DEVE corrispondere con il valore di iat. | |
| exp | UNIX Timestamp con l'istante di scadenza del JWT, codificato come NumericDate come indicato in RFC 7519 | |
| jti | DEVE essere una Stringa in formato uuid4. Identificatore unico dell'ID Token che il RP PUÒ utilizzare per prevenirne il riuso, rifiutando l'ID Token se già processato. | |
| nonce | Vedi OpenID.Core#AuthRequest. DEVE essere una stringa casuale di almeno 32 caratteri alfanumerici. Questo valore DEVE coincidere con quello inviato dal RP nella richiesta di autenticazione. |
Refresh Token¶
Il Refresh Token è un JWT che PUÒ essere rilasciato dall'OP e che PUÒ essere usato per ottenere un nuovo Access Token che abilita il RP ad accedere allo UserInfo endpoint senza interazione diretta dell'utente.
Il Refresh Token DEVE essere rilasciato in formato JWT, firmato, e contenere almeno i seguenti parametri.
| Claim | Descrizione | Supportato da |
|---|---|---|
| iss | DEVE essere valorizzato con un HTTPS URL che identifica univocamente l'OP. Il RP DEVE verificare che questo valore corrisponda all'OP chiamato. | |
| client_id | DEVE coincidere con il valore client_id. Il RP DEVE verificare che questo valore corrisponda al proprio client ID. | |
| aud | DEVE contenere il Token Endpoint dell'OP. | |
| iat | UNIX Timestamp con l'istante di generazione del JWT, codificato come NumericDate come indicato in RFC 7519 | |
| exp | UNIX Timestamp con l'istante di scadenza del JWT, codificato come NumericDate come indicato in RFC 7519 | |
| jti | DEVE essere una Stringa in formato uuid4. Identificatore unico del Refresh Token che il RP PUÒ utilizzare per prevenirne il riuso, rifiutando il Refresh Token se già processato. |
Periodo di validità di un Refresh Token¶
Il Refresh Token NON DEVE avere una validità (differenza tra iat e exp) superiore a 30 giorni.
Se allo scadere del periodo di validità l'RP effettua una richiesta all'OP, quest'ultimo DEVE restituire un errore nella risposta (Vedi Codici di Errore).
Codici di errore¶
| Claim | Descrizione | Codice HTTP | Supportato da |
|---|---|---|---|
| invalid_client | Problemi durante la client authentication (ad esempio, il client_id è conosciuto, non è fornita l'autenticazione del client o il metodo di autenticazione non è supportato) (RFC 6749#section-5.2). |
401 Unauthorized | |
| unsupported_grant_type | Il parametro grant_type contiene un valore non corretto (RFC 6749#section-5.2). | 400 Bad Request | |
| invalid_grant | I parametri grant_type, code, code_verifier, access_token non sono validi (RFC 6749#section-5.2). | 400 Bad Request | |
| invalid_request | La richiesta non è valida a causa della mancanza o della non correttezza di uno o più parametri (RFC 6749#section-5.2). | 400 Bad Request | |
| server_error | L'OP ha riscontrato un problema interno (RFC 6749#section-5.2). | 500 Internal Server Error | |
| temporarily_unavailable | L'OP ha riscontrato un problema interno temporaneo (RFC 6749#section-5.2). | 503 Service Unavailable |
UserInfo Endpoint¶
Lo UserInfo Endpoint è una risorsa protetta che restituisce gli attributi dell'utente autenticato. Per ottenere gli attributi richiesti, il RP inoltra una richiesta allo UserInfo Endpoint utilizzando l'Access Token.
Request¶
Response¶
Il contenuto del corpo della Response DEVE essere un JWT firmato e cifrato..
L'header JOSE DEVE contenere il parametro cty (Content Type) valorizzato con JWT (vedi RFC 7519#section-5.2).
Lo UserInfo Endpoint restituisce gli attributi utente esplicitamente richiesti tramite il parametro claims o tramite l'utilizzo del parametro scope nella Authentication Request.
Esempio:
HTTP/1.1 200 OK
Last-Modified: Wed, 22 Jul 2018 19:15:56 GMT
Content-Type: application/jose
{
"alg": "RSA-OAEP",
"enc": "A256CBC-HS512",
"kid": "HIvo33-Km7n03ZqKDJfWVnlFudsW28YhQZx5eaXtAKA",
"cty": "JWT"
}
.
{
"iss": "https://op.fornitore_identita.it",
"aud": "https://rp.fornitore_servizio.it",
"iat": 1519032969,
"nbf": 1519032969,
"exp": 1519033149,
"sub": "OP-1234567890",
"name": "Mario",
"family_name": "Rossi",
"https://attributes.spid.gov.it/fiscal_number": "MROXXXXXXXXXXXXX"
}
L'intestazione del JWE DEVE contenere i seguenti parametri:
| Claim | Descrizione | Supportato da |
|---|---|---|
| alg | String. Vedi Algoritmi crittografici.. | |
| kid | Vedi RFC 7638#section_3. | |
| enc | String. Vedi Algoritmi crittografici.. | |
| cty | String. DEVE essere valorizzato con "JWT". |
Il payload del JWE è un JWS contenente all'interno del suo payload i seguenti parametri:
| Claim | Descrizione | Supportato da |
|---|---|---|
| sub | String. Identificatore del soggetto, coincidente con quello già rilasciato nell'ID Token. Il RP DEVE verificare che il valore coincida con quello contenuto nell'ID Token. | |
| iat | UNIX Timestamp con l'istante di generazione del JWT, codificato come NumericDate come indicato in RFC 7519. | |
| exp | UNIX Timestamp con l'istante di scadenza del JWT, codificato come NumericDate come indicato in RFC 7519. | |
| aud | String. Identificatore del soggetto destinatario della response (RP). Il RP DEVE verificare che il valore coincida con il proprio client_id. | |
| iss | String. URI che identifica univocamente l'OP. | |
| <attributo> | I claim richiesti al momento dell'autenticazione. |
L'intestazione del JWS DEVE contenere i seguenti parametri:
| Claim | Descrizione | Supportato da |
|---|---|---|
| alg | String. Vedi Algoritmi crittografici.. | |
| kid | Vedi RFC 7638#section_3. | |
| cty | String. DEVE essere valorizzato con "JWT". |
Codici di errore¶
Come definiti per Token endpoint.
Tabella attributi utente¶
La seguente tabella riporta l'elenco degli attributi utente supportati da SPID e/o CIE. La variable $PREFIX=https://attributes.eid.gov.it rappresenta il namespace.
Esempi¶
Si riportano per comodità gli esempi che danno luogo alla composizione di un unico JSON Object da parte di più attributi ed in particolare i claim "place_of_birth", "address", "document_details", $PREFIX/registered_office.
Si riportano a titolo di esempio due indirizzi italiani:
| Attributo | Esempio codifica OIDC |
|---|---|
| Indirizzo domicilio fisico CAP domicilio fisico Comune domicilio fisico Provincia domicilio fisico Nazione domicilio fisico | "address": {
"street_address":"Via Liszt 21",
"postal_code":"00144",
"locality":"Roma",
"region":"RM",
"country_code":"IT"
}
|
| Indirizzo domicilio fisico CAP domicilio fisico Comune domicilio fisico Provincia domicilio fisico Nazione domicilio fisico | "address": {
"street_address":"S.S. Salaria Km 23,800",
"postal_code":"00015",
"locality":"Monterotondo",
"region":"RM",
"country_code":"IT"
}
|
Vi sono casi, come per gli Stati Uniti d'America, dove oltre alla nazione (US) esiste uno Stato. In tali casi lo Stato è indicato nel campo Provincia. Si riporta il seguente esempio:
| Attributo | Esempio codifica OIDC |
|---|---|
| Indirizzo domicilio fisico CAP domicilio fisico Comune domicilio fisico Provincia domicilio fisico Nazione domicilio fisico | "address":{
"street_address":"503,Washington Avenue",
"postal_code":"12401",
"locality":"Kingston",
"region":"New york",
"country_code":"US"
}
|
Introspection Endpoint (verifica validità token)¶
L'Introspection Endpoint esposto dall'OP consente ai RP di ottenere informazioni su un token in loro possesso, come ad esempio la sua validità.
Vedi anche
Request¶
La richiesta all'Introspection Endpoint consiste nell'invio del token su cui si vogliono ottenere informazioni unitamente a una Client Assertion che consente di autenticare il RP che esegue la richiesta.
Esempio:
POST /introspection HTTP/1.1
Host: https://op.spid.agid.gov.it
Content-Type: application/x-www-form-urlencoded
client_assertion=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiw
ibmFtZSI6IlNQSUQiLCJhZG1pbiI6dHJ1ZX0.LVyRDPVJm0S9q7oiXcYVIIqGWY0wWQlqxvFGYswLF88 … &
client_assertion_type=urn%3Aietf%3Aparams%3Aoauth%3Aclient-assertion-type%3Ajwtbearer&
client_id=https%3A%2F%2Frp.spid.agid.gov.it&
token=eyJhbGciOiJSUzI1NiJ9.eyJleHAiOjE0MTg3MDI0MTQsImF1ZCI6WyJlNzFmYjcyYS05NzRmLT
QwMDEtYmNiNy1lNjdjMmJjMDAzN2YiXSwiaXNzIjoiaHR0cHM6XC9cL2FzLXZhLmV4YW1wbGUuY29tXC8
iLCJqdGkiOiIyMWIxNTk2ZC04NWQzLTQzN2MtYWQ4My1iM2YyY2UyNDcyNDQiLCJpYXQiOjE0MTg2OTg4
MTR9.FXDtEzDLbTHzFNroW7w27RLk5m0wprFfFH7h4bdFw5fR3pwiqejKmdfAbJvN3_yfAokBv06we5RA
RJUbdjmFFfRRW23cMbpGQCIk7Nq4L012X_1J4IewOQXXMLTyWQQ_BcBMjcW3MtPrY1AoOcfBOJPx1k2jw
RkYtyVTLWlff6S5gKciYf3b0bAdjoQEHd_IvssIPH3xuBJkmtkrTlfWR0Q0pdpeyVePkMSI28XZvDaGnxA4j7QI5loZYeyzGR9
h70xQLVzqwwl1P0-F_0JaDFMJFO1yl4IexfpoZZsB3HhF2vFdL6D_lLeHRyH2g2OzF59eMIsM_Ccs4G47862w…
Response¶
L'Introspection Endpoint risponde con un oggetto JSON definito come segue.
Esempio:
{
"active":true
}
Codici di errore¶
Come definiti per Token endpoint.
Revocation Endpoint¶
Un RP PUÒ chiedere la revoca di un Access Token o di un Refresh Token emesso da un OP.
L'OP DEVE revocare il token specificato nella richiesta.
Nota
Il metodo di autenticazione del RP presso il revocation endpoint DEVE essere private_key_jwt (vedi il parametro revocation_endpoint_auth_methods_supported nella Sezione Metadata OP)
Vedi anche
Request¶
La richiesta al Revocation Endpoint consiste nell'invio del token che si vuole revocare unitamente a una Client Assertion che consente di identificare il RP che esegue la richiesta.
Esempio:
POST /revoke HTTP/1.1
Host: https://op.spid.agid.gov.it
Content-Type: application/x-www-form-urlencoded
client_assertion=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiw
ibmFtZSI6IlNQSUQiLCJhZG1pbiI6dHJ1ZX0.LVyRDPVJm0S9q7oiXcYVIIqGWY0wWQlqxvFGYswLF88&
client_assertion_type=urn%3Aietf%3Aparams%3Aoauth%3Aclient-assertion-type%3Ajwtbearer&
client_id=https%3A%2F%2Frp.spid.agid.gov.it&
token=eyJhbGciOiJSUzI1NiJ9.eyJleHAiOjE0MTg3MDI0MTQsImF1ZCI6WyJlNzFmYjcyYS05NzRmLT
QwMDEtYmNiNy1lNjdjMmJjMDAzN2YiXSwiaXNzIjoiaHR0cHM6XC9cL2FzLXZhLmV4YW1wbGUuY29tXC8
iLCJqdGkiOiIyMWIxNTk2ZC04NWQzLTQzN2MtYWQ4My1iM2YyY2UyNDcyNDQiLCJpYXQiOjE0MTg2OTg4
MTR9.FXDtEzDLbTHzFNroW7w27RLk5m0wprFfFH7h4bdFw5fR3pwiqejKmdfAbJvN3_yfAokBv06we5RA
RJUbdjmFFfRRW23cMbpGQCIk7Nq4L012X_1J4IewOQXXMLTyWQQ_BcBMjcW3MtPrY1AoOcfBOJPx1k2jw
RkYtyVTLWlff6S5gKciYf3b0bAdjoQEHd_IvssIPH3xuBJkmtkrTlfWR0Q0pdpeyVePkMSI28XZvDaGnxA4j7QI5loZYeyzGR9
h70xQLVzqwwl1P0-F_0JaDFMJFO1yl4IexfpoZZsB3HhF2vFdL6D_lLeHRyH2g2OzF59eMIsM_Ccs4G47862w
Response¶
Il Revocation Endpoint risponde con un codice HTTP 200, anche nel caso in cui il token indicato non esista o sia già stato revocato (in modo da non rilasciare informazioni).
Codici di errore¶
Come definiti per Token endpoint.
Logout¶
Algoritmi crittografici¶
Tutti i partecipanti devono pubblicare gli algoritmi supportati di criptazione e firma all'interno dei propri metadata. Tali agoritmi sono utilizzati per tutte le operazioni di cifratura e firma previsti da OIDC core e di Federation.
Nota
La lunghezza delle chiavi RSA deve essere pari o superiore a 2048 bit. Si raccomanda una lunghezza di 4096 bit.
In SPID e CIE id i seguenti algoritmi DEVONO essere supportati:
| Algoritmi | Operazioni | Riferimento | Supportato da |
|---|---|---|---|
| RS256 | Signature | OpenID.Core and RFC7518. | |
| RS512 | Signature | RFC7518 | |
| RSA-OAEP | Key Encryption | RFC7518. | |
| RSA-OAEP-256 | Key Encryption | RFC7516. | |
| A128CBC-HS256 | Content Encryption | RFC7516. | |
| A256CBC-HS512 | Content Encryption | RFC7516. |
In SPID e CIE id è RACCOMANDATO il supporto per i seguenti algoritmi:
| Algoritmi | Operazioni | Riferimento | Applicabile a |
|---|---|---|---|
| ES256 | Signature | OpenID.Core and RFC7518. | |
| ES512 | Signature | RFC7518. | |
| PS256 | Signature | RFC7518. | |
| PS512 | Signature | RFC7518. | |
| ECDH-ES | Key Encryption | RFC7518. | |
| ECDH-ES+A128KW | Key Encryption | RFC7518. | |
| ECDH-ES+A256KW | Key Encryption | RFC7518. |
In SPID e CIE id i seguenti algoritmi NON DEVONO essere supportati:
| Algoritmi | Operazioni | Riferimenti | Applicabile a |
|---|---|---|---|
| none | Signature | RFC7518. | |
| RSA_1_5 | Key Encryption | RFC7516. | |
| HS256 | Signature | RFC7518. | |
| HS384 | Signature | RFC7518. | |
| HS512 | Signature | RFC7518. |
Retention Policy¶
Gestione dei Log di un OP e di un RP¶
Gli OP e gli RP DEVONO mantenere:
Un registro delle transazioni contenente i log relativi ai messaggi scambiati. I messaggi memorizzati e mantenuti nel registro DEVONO essere almeno i seguenti:
Trust Chain relativa all'Entità con la quale è avvenuta la transazione, composta da:
- L'Entity Configuration del Entità con la quale è avvenuta la transazione.
- [Solo per OP] L'Entity Statement del SA riferito al RP (se presente).
- L'Entity Statement del TA riferito al suo discendente.
- L'Entity Configuration del TA.
AuthenticationRequest
AuthenticationResponse relativa all'AuthenticationRequest
TokenRequest relativa all'AuthenticationRequest
TokenResponse relativa alla TokenRequest
L'eventuale UserInfoRequest relativa alla TokenRequest
L'eventuale UserInfoResponse relativa alla UserInfoRequest
L'eventuale RevocationRequest relativa alla TokenRequest
L'eventuale RevocationResponse relativa alla RevocationRequest
Avvertimento
Le informazioni contenute nei registri DEVONO essere mantenute e gestite per una durata non inferiore a 24 mesi nel pieno rispetto delle vigenti normative nazionali ed europee in materia di privacy. L’accesso ai dati DEVE essere riservato a personale incaricato. Al fine di garantire la confidenzialità DEVONO essere adottati meccanismi di cifratura dei dati o impiegati sistemi di basi di dati (DBMS) che realizzano la persistenza cifrata delle informazioni. Infine, nella memorizzazione dei dati DEVONO essere garantite le proprietà di integrità e non ripudio.
Registro storico delle chiavi pubbliche di Federazione¶
Al fine di consentire la verifica dei messaggi scambiati dalle Entità che partecipano alla federazione e delle relative Trust Chain, il TA DEVE pubblicare lo storico delle proprie chiavi pubbliche (JWKS) di federazione all'interno di un registro reso disponibile a tutti i partecipanti tramite l'endpoint /.well-known/openid-federation-historical-jwks. Per ulteriori dettagli tecnici si rimanda alla Sezione 7.5 di OIDC-FED.
Avvertimento
Le chiavi che non sono sono più attive da più di 24 mesi POSSONO essere rimosse dal registro a discrezione del TA.
Differenze tra SPID e CIE id¶
In questa sezione sono riportate le principali differenze tra i profili implementativi SPID e CIE id.
Metadata¶
Nei metadata OP e RP per CIE id sono presenti i parametri che abilitano la cifratura dell'ID Token (vedi le sezioni relative al Metadata OP e al Metadata RP). SPID non consente la cifratura dell'ID Token, dunque tali parametri non sono richiesti.
Inoltre, il metadata OP per CIE id richiede anche il parametro revocation_endpoint_auth_methods_supported, non richiesto da SPID.
Authorization Endpoint¶
SPID, al contrario di CIE id, prevede l'inserimento obbligatorio dei parametri client_id e response_type nella richiesta HTTP. Inoltre, CIE id prevede come obbligatorio il parametro iss nella response per mitigare gli attacchi di tipo mix-up I-D.ietf-OAuth-Security-BCP.
Parametri Scope e Claims¶
CIE id consente di richiedere gli attributi dell'utente sia tramite il parametro claims nella richiesta di autenticazione e sia tramite il parametro scope, abilitando in quest'ultimo i valori profile e email.
SPID non consente l'utilizzo di profile e email nel parametro scope.
Per ulteriori dettagli vedi la sezione Parametri Scope e claims.
ID Token¶
SPID non consente di rilasciare gli attributi dell'utente all'interno dell'ID Token. In CIE id gli attributi dell'utente sono disponibili sia nell'ID Token e sia nella UserInfo response. Inoltre, il CIE id supporta la criptazione dell'ID Token.
Refresh Token¶
SPID prevede l'utilizzo del Refresh Token per abilitare le sessioni lunghe rinnovabili così come definito nelle LL.GG. OpenID Connect in SPID e nell' Avviso n.41 . Consente, infatti, di ottenere, oltre all'Access Token, l'ID Token valido esclusivamente per SPID livello 1.
In CIE id il Refresh Token non consente di ottenere l'ID Token e non è utilizzabile dagli RP per ottenere una nuova autenticazione dell'utente con l'OP o rinnovare una sessione preesistente. In CIE id il Refresh Token è usato per ottenere dallo UserInfo endpoint esclusivamente il medesimo set di attributi dell'utente richiesti in fase di autenticazione iniziale, per il quale l'utente ha espresso il consenso esplicito. Per ulteriori dettagli si veda la sezione Refresh Token.
UserInfo Endpoint¶
CIE id supporta entrambi i metodi HTTP GET e HTTP POST per le richieste allo UserInfo endpoint. SPID consente solo l'utilizzo del metodo HTTP GET.
Introspection Endpoint¶
CIE id prevede il solo parametro active nella risposta dell'Introspection endpoint. SPID aggiunge ulteriori parametri come specificato nella sezione Introspection Endpoint.
Revocation Endpoint e Logout¶
Entrambi SPID e CIE id prevedono che il RP effettui una richiesta di revoca dell'Access Token in fase di logout dell'utente. In SPID la revoca di un Access Token implica anche la revoca dell'eventuale Refresh Token ancora attivo ad esso collegato e la scadenza della sessione di Single Sign-On se ancora attiva.
In CIE id, invece, la revoca di un Access Token non prevede la revoca del relativo Refresh Token, allo stesso tempo la richiesta di revoca di un Refresh Token determina anche la revoca di tutti i relativi token ancora attivi.
Differenze con OIDC iGov¶
CIE OpenID Connect e SPID OpenID Connect sono basati su iGov.OIDC con le seguenti differenze:
- La sezione 2.1 di iGov riporta vtr, acr_values e PKCE come OPZIONALI, sia in SPID che in CIE id PKCE e acr_values sono RICHIESTI. In entrambe le implementazioni di SPID e CIE, si è adottato acr_values al posto di vtr.
- L'Authentication Response nel flusso di autenticazione di CIE impone l'uso del claim iss per evitare l'attacco mix-up I-D.ietf-OAuth-Security-BCP. L'uso di questo claim è OPZIONALE in SPID.
- La sezione 2.4 di iGov stabilisce "Gli RP POSSONO opzionalmente mandare richieste all'Authorization Endpoint usando il parametro request." Sia in SPID che in CIE id, l'uso del parametro request è RICHIESTO.
- La sezione 3.1 di iGov stabilisce che "in caso di utilizzo di vtr nella richiesta di autenticazione, l'ID Token DEVE contenere i seguenti claim RICHIESTI, cioè: vot e vtm ". Considerando che vtr non è usato in SPID e CIE id, i claim appena citati non vengono inclusi all'interno dell'ID Token.
- La sezione 3.1 di iGov stabilisce che "il claim auth-time nell'ID Token è RACCOMANDATO". SPID e CIE id non adottano questo claim nell'ID Token.
- L'ID Token, sia in SPID che in CIE id, DEVE avere il claim acr RICHIESTO, mentre questo è opzionale nell'iGov draft iGov.
- L'ID Token, sia in SPID che in CIE id, ha il requisito del claim at_hash RICHIESTO. Questo è OPZIONALE in OIDC-CORE è assente in iGOV.
- Sia in SPID che in CIE id, l'identificatore del soggetto DEVE essere pairwised.
- La UserInfo Response, sia in SPID che in CIE id, DEVE essere un Nested JWT, firmato con la chiave privata dell'emettitore e cifrato con la chiave pubblica del RP.
- Il JWT firmato della UserInfo Response DEVE avere i claim iss, sub, aud, iat e exp.
- La sezione 3.4 di iGov stabilisce "Gli OpenID Provider POSSONO accettare oggetti request by reference usando il parametro request_uri". Questo parametro è intercambiabile con il parametro request. SPID e CIE id adottano solamente il parametro request.
- Sezione 3.8. La registrazione dinamica di iGOV specifica che la registrazione dinamica del client è obbligatoria. Sia in CIE id che in SPID, la registrazione automatica OIDC del client è OBBLIGATORIA, mentre la registrazione dinamica OIDC del client NON DOVREBBE essere supportata.
- Nella sezione 4.2 di iGOV gli scope openid, offline_access, profile e email vengono usati in CIE id OpenID Connect proposal e non considerano gli altri scope raccomandati nel profilo iGov, cioè: doc.
- Nella sezione 4.2 di iGOV gli scope openid, offline_access vengono usati in SPID OpenID Connect proposal e non considerano gli altri scope raccomandati nel profilo iGov, cioè: doc.
- La sezione 4.3 di iGov definisce la politica relativa all'oggetto userinfo del claim request. In CIE id, definiamo la politica per entrambi gli oggetti userinfo e ID Token.
- Nelle sezioni 3.7 e 2.5 di iGOV, i Metadata sia di SPID che di CIE id vengono distribuiti secondo le modalità definite nella sezione "3. Metadata".
- L'Access Token è un JWT firmato in conformità a RFC 9068.
Differenze con OIDC Federation¶
In questa sezione sono elencate le differenze che intercorrono tra lo standard ufficiale e l'implementazione SPID e CIE.
Client Registration¶
SPID e CIE supportano esclusivamente automatic_client_registration. La modalità explicit client registration non è supportata.
Trust Mark¶
L'esposizione dei Trust Mark in SPID e CIE è obbligatoria. Per approfondimenti sulla ragione dell'obbligo dei Trust Mark si rimanda alla sezione Considerazioni di Sicurezza.
Claim non supportati negli Entity Statement¶
Poiché SPID e CIE non necessitano di alcun claim aggiuntivo in ambito federativo, non necessitano del claim crit. Inoltre non sono supportati i claim aud, naming_constraints, policy_language_crit e trust_anchor_id. L'eventuale presenza di questi claim non presenta alcuna implicazione, questi verranno semplicemente ignorati fino ad ulteriori avvisi che li normino.
Considerazioni di Sicurezza¶
In questa sezione descriviamo alcune considerazioni di sicurezza in ambito OIDC Federation.
Trust Mark come deterrente contro gli abusi¶
L'implementazione dei Trust Mark e il filtro su questi in fase di Federation Entity Discovery risulta necessario contro gli attacchi destinati al consumo delle risorse. Un OP attaccato con un numero ingente di connessioni presso il suo endpoint di authorization, contenenti client_id e authority_hints fasulli, produrrebbe svariate connessioni verso sistemi di terze parti nel tentativo di trovare un percorso verso la TA e instaurare la fiducia con il richiedente.
L'OP DEVE validare staticamente il TM oppure DEVE escludere a priori la richiesta ove il TM non risultasse presente, in caso di assenza o non validità di un TM la procedura di Federation Entity Discovery NON DEVE essere avviata e NON DEVE creare di conseguenza connessioni verso sistemi di terze parti.
Numero Massimo di authority_hints¶
All'interno di una Federazione il Trust Anchor decide quante intermediazioni consentire tra di lui e le Foglie, mediante la constraint denominata max_path_length. Questo tipo di relazione è di tipo verticale, dalla Foglia alla radice. Questo attributo se valorizzato ad esempio con un valore numerico intero pari a 1 indica che soltanto un SA è consentito tra una Foglia e il TA.
Ogni Foglia DEVE pubblicare i suoi superiori all'interno della lista contenuta nel claim authority_hints. Una Foglia all'interno della Federazione PUÒ avere superiori afferenti a diverse Federazioni. L'analisi dei superiori disponibili introduce un modello di navigazione orizzontale, ad esempio un OP tenta di trovare il percorso più breve verso il Trust Anchor attraverso tutti gli URL contenuti all'interno dell'array authority_hints prima di fare un ulteriore movimento verticale, a salire, verso uno degli Intermediari presenti in questo array.
La soglia max_path_length si applica per la navigazione verticale e superata questa soglia senza aver trovato il TA, la procedura di Federation Entity Discovery DEVE essere interrotta. Si faccia l'esempio di un RP discendente di un SA che a sua volta è discendente di un altro SA, essendo il valore di max_path_length pari a 1 e, superata questa soglia senza aver trovato il Trust Anchor, la procedura DEVE essere interrotta.
Allo stesso tempo la specifica OIDC Federation 1.0 non definisce un limite per il numero di authority_hints, questo perché nessun Trust Anchor può limitare il numero di Federazioni alle quali un partecipante può aderire. Per questa ragione è utile che gli implementatori adottino un limite massimo del numero di elementi consentiti all'interno dell'Array authority_hint. Questo per evitare che un numero esagerato di URL contenuti nella lista di authority_hints, dovuto ad una cattiva configurazione di una Foglia, produca un consumo di risorse eccessivo.
Resolve endpoint¶
Questo endpoint DEVE rilasciare i Metadata, i Trust Mark e la Trust Chain già precedentemente elaborata e NON DEVE innescare una procedura di Federation Entity Discovery ad ogni richiesta pervenuta, a meno che questo endpoint non venga protetto con un meccanismo di autenticazione dei client, come ad esempio private_key_jwt [OIDC-CORE]. In caso di utilizzo di private_key_jwt il valore presente nel parametro sub del private_key_jwt DEVE coincidere con quello presente nella richiesta al Resolve endpoint.
Buone Pratiche¶
In questa sezione descriviamo alcune buone pratiche per ottenere la massima resa dalle entità di Federazione.
Specializzare le chiavi pubbliche OpenID Core e Federation¶
È buona pratica usare chiavi pubbliche specializzate per i due tipi di operazioni, Core e Federation.
Modalità di aggiornamento dei Metadata OpenID Core¶
L'interoperabilità tra i partecipanti funziona mediante i Metadata ottenuti dal calcolo e dalla conservazione delle Trust Chain. Questo significa che se un OP al tempo T calcola la Trust Chain per un RP e questo al tempo T+n modifica i propri Metadata, l'OP di conseguenza potrebbe incorrere in problematiche di validazione delle richieste di autorizzazione del RP, fino a quando non avrà aggiornato la Trust Chain relativa a questo.
La buona pratica per evitare le interruzioni di servizio relative alle operazioni di OIDC Core è quella di aggiungere le nuove chiavi pubbliche all'interno degli oggetti jwks senza rimuovere i valori preesistenti. Oppure, ad esempio, i nuovi redirect_uri.
In questa maniera dopo il limite massimo di durata delle Trust Chain, definito con il claim exp e pubblicato nella Entity Configuration della TA, si ha la certezza che tutti i partecipanti abbiano rinnovato le loro Trust Chain, e sarà possibile agli amministratori della Foglia rimuovere le vecchie definizioni in cima alla lista.
Esempi¶
In questa sezione sono raccolti tutti gli esempi non normativi delle richieste e delle risposte agli endpoint di Federazione definiti all'interno di questo documento.
Tutte le response di tipo jose sono state decodificate e rappresentate insieme alle loro intestazioni per migliorare la lettura.
EN 1. Entity Configuration Request¶
GET /.well-known/openid-federation HTTP/1.1
Host: rp.example.it
EN 1.1. Entity Configuration Response Relying Party¶
HTTP/1.1 200 OK
Last-Modified: Wed, 22 Jul 2018 19:15:56 GMT
Content-Type: application/entity-statement+jwt
{
"alg": "RS256",
"kid": "2HnoFS3YnC9tjiCaivhWLVUJ3AxwGGz_98uRFaqMEEs",
"typ": "entity-statement+jwt"
}
.
{
"exp": 1649590602,
"iat": 1649417862,
"iss": "https://rp.example.it/",
"sub": "https://rp.example.it/",
"jwks": {
"keys": [
{
"kty": "RSA",
"n": "5s4qi …",
"e": "AQAB",
"kid": "2HnoFS3YnC9tjiCaivhWLVUJ3AxwGGz_98uRFaqMEEs"
}
]
},
"metadata": {
"openid_relying_party": {
"application_type": "web",
"client_id": "https://rp.example.it/",
"client_registration_types": [
"automatic"
],
"jwks": {
"keys": [
{
"kty": "RSA",
"use": "sig",
"n": "1Ta-sE …",
"e": "AQAB",
"kid": "YhNFS3YnC9tjiCaivhWLVUJ3AxwGGz_98uRFaqMEEs"
}
]
},
"client_name": "Name of an example organization",
"contacts": [
"ops@rp.example.it"
],
"grant_types": [
"refresh_token",
"authorization_code"
],
"redirect_uris": [
"https://rp.example.it/oidc/rp/callback/"
],
"response_types": [
"code"
],
"subject_type": "pairwise"
},
"federation_entity": {
"federation_resolve_endpoint": "https://rp.example.it/resolve/",
"organization_name": "PA OIDC Service Provider",
"homepage_uri": "https://rp.example.it",
"policy_uri": "https://rp.example.it/policy",
"logo_uri": "https://rp.example.it/static/logo.svg",
"contacts": [
"tech@example.it"
]
}
},
"trust_marks": [
{
"id": "https://registry.agid.gov.it/openid_relying_party/public/",
"trust_mark": "eyJh …"
}
],
"authority_hints": [
"https://registry.agid.gov.it/"
]
}
EN 1.2. Entity Configuration Response Openid Provider¶
HTTP/1.1 200 OK
Last-Modified: Wed, 22 Jul 2018 19:15:56 GMT
Content-Type: application/entity-statement+jwt
{
"alg": "RS256",
"kid": "dB67gL7ck3TFiIAf7N6_7SHvqk0MDYMEQcoGGlkUAAw",
"typ": "entity-statement+jwt"
}
.
{
"exp": 1649610249,
"iat": 1649437449,
"iss": "https://openid.provider.it/",
"sub": "https://openid.provider.it/",
"jwks": {
"keys": [
{
"kty": "RSA",
"e": "AQAB",
"n": "01_4a …",
"kid": "dB67gL7ck3TFiIAf7N6_7SHvqk0MDYMEQcoGGlkUAAw"
}
]
},
"metadata": {
"openid_provider": {
"authorization_endpoint": "https://openid.provider.it/authorization",
"revocation_endpoint": "https://openid.provider.it/revocation/",
"id_token_encryption_alg_values_supported": [
"RSA-OAEP"
],
"id_token_encryption_enc_values_supported": [
"A128CBC-HS256"
],
"token_endpoint": "https://openid.provider.it/token/",
"userinfo_endpoint": "https://openid.provider.it/userinfo/",
"introspection_endpoint": "https://openid.provider.it/introspection/",
"claims_parameter_supported":true,
"contacts": [
"ops@https://idp.it"
],
"client_registration_types_supported": [
"automatic"
],
"code_challenge_methods_supported": [
"S256"
],
"request_authentication_methods_supported": {
"ar": [
"request_object"
]
},
"acr_values_supported": [
"https://www.spid.gov.it/SpidL1",
"https://www.spid.gov.it/SpidL2",
"https://www.spid.gov.it/SpidL3"
],
"claims_supported": [
"https://attributes.eid.gov.it/spid_code",
"given_name",
"family_name",
"place_of_birth",
"birthdate",
"gender",
"https://attributes.eid.gov.it/company_name",
"https://attributes.eid.gov.it/registered_office",
"https://attributes.eid.gov.it/fiscal_number",
"https://attributes.eid.gov.it/vat_number",
"https://attributes.eid.gov.it/document_details",
"phone_number",
"email",
"address",
"https://attributes.eid.gov.it/eid_exp_date",
"https://attributes.eid.gov.it/e_delivery_service"
],
"grant_types_supported": [
"authorization_code",
"refresh_token"
],
"id_token_signing_alg_values_supported": [
"RS256",
"ES256"
],
"issuer": "https://openid.provider.it/",
"jwks": {
"keys": [
{
"kty": "RSA",
"use": "sig",
"n": "1Ta-sE …",
"e": "AQAB",
"kid": "FANFS3YnC9tjiCaivhWLVUJ3AxwGGz_98uRFaqMEEs"
}
]
},
"scopes_supported": [
"openid",
"offline_access"
],
"logo_uri": "https://openid.provider.it/static/svg/spid-logo-c-lb.svg",
"organization_name": "SPID OIDC identity provider",
"op_policy_uri": "https://openid.provider.it/it/website/legal-information/",
"request_parameter_supported":true,
"request_uri_parameter_supported":true,
"require_request_uri_registration":true,
"response_types_supported": [
"code"
],
"subject_types_supported": [
"pairwise",
"public"
],
"token_endpoint_auth_methods_supported": [
"private_key_jwt"
],
"token_endpoint_auth_signing_alg_values_supported": [
"RS256",
"RS384",
"RS512",
"ES256",
"ES384",
"ES512"
],
"userinfo_encryption_alg_values_supported": [
"RSA-OAEP",
"RSA-OAEP-256"
],
"userinfo_encryption_enc_values_supported": [
"A128CBC-HS256",
"A192CBC-HS384",
"A256CBC-HS512",
"A128GCM",
"A192GCM",
"A256GCM"
],
"userinfo_signing_alg_values_supported": [
"RS256",
"RS384",
"RS512",
"ES256",
"ES384",
"ES512"
],
"request_object_signing_alg_values_supported": [
"RS256",
"RS384",
"RS512",
"ES256",
"ES384",
"ES512"
]
},
"federation_entity": {
"federation_resolve_endpoint": "https://openid.provider.it/resolve/",
"organization_name": "SPID OIDC identity provider",
"homepage_uri": "https://provider.it",
"policy_uri": "https://provider.it/policy",
"logo_uri": "https://provider.it/static/logo.svg",
"contacts": [
"tech@provider.it"
]
}
},
"authority_hints": [
"https://registry.agid.gov.it/"
]
}
EN 1.3. Entity Configuration Response Intermediary¶
HTTP/1.1 200 OK
Last-Modified: Wed, 22 Jul 2018 19:15:56 GMT
Content-Type: application/entity-statement+jwt
{
"alg": "RS256",
"kid": "em3cmnZgHIYFsQ090N6B3Op7LAAqj8rghMhxGmJstqg",
"typ": "entity-statement+jwt"
}
.
{
"exp": 1649631824,
"iat": 1649459024,
"iss": "https://aggregatore.it/",
"sub": "https://aggregatore.it/",
"jwks": {
"keys": [
{
"kty": "RSA",
"e": "AQAB",
"n": "14aW …",
"kid": "em3cmnZgHIYFsQ090N6B3Op7LAAqj8rghMhxGmJstqg"
}
]
},
"metadata": {
"federation_entity": {
"contacts": [
"soggetto@aggregatore.it"
],
"federation_fetch_endpoint": "https://aggregatore.it/fetch/",
"federation_resolve_endpoint": "https://aggregatore.it/resolve/",
"federation_list_endpoint": "https://aggregatore.it/list/",
"homepage_uri": "https://soggetto.aggregatore.it",
"name": "Soggetto Aggregatore di esempio"
},
"trust_mark_issuer": {
"federation_status_endpoint": "https://aggregatore.it/trust_mark_status/",
}
},
"trust_marks": [
{
"id": "https://registry.gov.it/intermediate/private/full/",
"trust_mark": "eyJh …"
}
],
"authority_hints": [
"https://registry.agid.gov.it/"
]
}
EN 1.4. Entity Configuration Response Trust Anchor¶
HTTP/1.1 200 OK
Last-Modified: Wed, 22 Jul 2018 19:15:56 GMT
Content-Type: application/entity-statement+jwt
{
"alg": "RS256",
"kid": "FifYx03bnosD8m6gYQIfNHNP9cM_Sam9Tc5nLloIIrc",
"typ": "entity-statement+jwt"
}
.
{
"exp": 1649375259,
"iat": 1649373279,
"iss": "https://registry.agid.gov.it/",
"sub": "https://registry.agid.gov.it/",
"jwks": {
"keys": [
{
"kty": "RSA",
"n": "3i5vV-_ …",
"e": "AQAB",
"kid": "FifYx03bnosD8m6gYQIfNHNP9cM_Sam9Tc5nLloIIrc"
}
]
},
"metadata": {
"federation_entity": {
"organization_name": "example TA"
"contacts":[
"spid.tech@agid.gov.it"
],
"policy_uri": "https://registry.agid.gov.it/policy",
"homepage_uri": "https://registry.agid.gov.it/",
"logo_uri":"https://registry.agid.gov.it/static/svg/logo.svg",
"federation_fetch_endpoint": "https://registry.agid.gov.it/fetch/",
"federation_resolve_endpoint": "https://registry.agid.gov.it/resolve/",
"federation_list_endpoint": "https://registry.agid.gov.it/list/",
"federation_trust_mark_status_endpoint": "https://registry.agid.gov.it/trust_mark_status/"
}
},
"trust_mark_issuers": {
"https://registry.agid.gov.it/openid_relying_party/public/": [
"https://registry.spid.agid.gov.it/",
"https://public.intermediary.spid.it/"
],
"https://registry.agid.gov.it/openid_relying_party/private/": [
"https://registry.spid.agid.gov.it/",
"https://private.other.intermediary.it/"
]
},
"constraints": {
"max_path_length": 1
}
}
EN 1.5. Trust Mark issued by TA to a RP¶
{
"trust_marks": [
{
"id": "https://registry.interno.gov.it/openid_relying_party/public/",
"iss": "https://registry.interno.gov.it/",
"trust_mark": "$JWT"
}
]
}
Where the $JWT payload is:
{
"id": "https://registry.interno.gov.it/openid_relying_party/public/",
"iss": "https://sa.esempio.it/",
"sub": "https://rp.esempio.it/",
"iat": 1579621160,
"organization_type": "public",
"id_code": {
"ipa_code": "123456",
"aoo_code": "Uff_protocollo"
}
"email": "email_or_pec@rp.it",
"organization_name#it": "Denominazione del RP",
"ref": "https://documentazione_di_riferimento.it/"
}
EN 1.6. Trust Mark issued by TA to a SA¶
{
"trust_marks": [
{
"id": "https://registry.interno.gov.it/intermediate/private/full/",
"iss": "https://registry.interno.gov.it/",
"trust_mark": "$JWT"
}
]
}
Where the $JWT payload is:
{
"id": "https://registry.interno.gov.it/intermediate/private/full/",
"iss": "https://registry.interno.gov.it/",
"sub": "https://sa.esempio.it/",
"iat": 1579621160,
"organization_type": "private",
"id_code": {
"fiscal_number": "1234567890"
}
"email": "email_or_pec@intermediate.it",
"organization_name#it": "Denominazione del SA",
"sa_profile": "full",
"ref": "https://documentazione_di_riferimento.it/"
}
EN 1.7. Trust Mark issued by SA to a RP¶
{
"trust_marks": [
{
"id": "https://registry.interno.gov.it/openid_relying_party/public/",
"iss": "https://sa.esempio.it",
"trust_mark": "$JWT"
}
]
}
Where the $JWT payload is:
{
"id": "https://registry.interno.gov.it/openid_relying_party/public/",
"iss": "https://sa.esempio.it/",
"sub": "https://rp.esempio.it/",
"iat": 1579621160,
"organization_type": "public",
"id_code": {
"ipa_code": "987654",
}
"email": "email_or_pec@rp.it",
"organization_name#it": "Denominazione del RP",
"ref": "https://documentazione_di_riferimento.it/"
}
EN 2. Entity Statement Request¶
EN 2.1 Entity Statement Response¶
HTTP/1.1 200 OK
Last-Modified: Wed, 22 Jul 2018 19:15:56 GMT
Content-Type: application/entity-statement+jwt
{
"alg": "RS256",
"kid": "FifYx03bnosD8m6gYQIfNHNP9cM_Sam9Tc5nLloIIrc",
"typ": "entity-statement+jwt"
}
.
{
"exp": 1649623546,
"iat": 1649450746,
"iss": "https://registry.agid.gov.it/",
"sub": "https://rp.example.it/",
"jwks": {
"keys": [
{
"kty": "RSA",
"n": "5s4qi …",
"e": "AQAB",
"kid": "2HnoFS3YnC9tjiCaivhWLVUJ3AxwGGz_98uRFaqMEEs"
}
]
},
"metadata_policy": {
"openid_relying_party": {
"scope": {
"superset_of": [
"openid"
],
"subset_of": [
"openid",
"offline_access"
]
},
"contacts": {
"add": [
"tech@example.it"
]
}
}
},
"trust_marks": [
{
"id": "https://registry.agid.gov.it/openid_relying_party/public/",
"trust_mark": "eyJhb …"
}
]
}
EN 3. Entity List Request¶
EN 3.1. Entity List Response¶
EN 4. Resolve Entity Statement Endpoint Request¶
EN 4.1. Resolve Entity Statement Endpoint Response¶
HTTP/1.1 200 OK
Last-Modified: Wed, 22 Jul 2018 19:15:56 GMT
Content-Type: application/entity-statement+jwt
{
"alg": "RS256",
"kid": "FifYx03bnosD8m6gYQIfNHNP9cM_Sam9Tc5nLloIIrc",
"typ": "entity-statement+jwt"
}
.
{
"iss": "https://registry.agid.gov.it/",
"sub": "https://rp.example.it/",
"iat": 1649355587,
"exp": 1649410329,
"trust_marks": [
{
"id": "https://registry.agid.gov.it/openid_relying_party/public/",
"trust_mark": "eyJh …"
}
],
"metadata": {
"openid_relying_party": {
"application_type": "web",
"client_id": "https://rp.example.it/",
"client_registration_types": [
"automatic"
],
"jwks": {
"keys": [
{
"kty": "RSA",
"use": "sig",
"n": "…",
"e": "AQAB",
"kid": "5NNNoFS3YnC9tjiCaivhWLVUJ3AxwGGz_98uRFaqMEEs"
}
]
},
"client_name": "Name of an example organization",
"contacts": [
"ops@rp.example.it"
],
"grant_types": [
"refresh_token",
"authorization_code"
],
"redirect_uris": [
"https://rp.example.it/oidc/rp/callback/"
],
"response_types": [
"code"
],
"subject_type": "pairwise"
}
},
"trust_chain": [
"eyJhbGciOiJSUzI1NiIsImtpZCI6Ims1NEhRdERpYnlHY3M5WldWTWZ2aUhm ...",
"eyJhbGciOiJSUzI1NiIsImtpZCI6IkJYdmZybG5oQU11SFIwN2FqVW1BY0JS ...",
"eyJhbGciOiJSUzI1NiIsImtpZCI6IkJYdmZybG5oQU11SFIwN2FqVW1BY0JS ..."
]
}
EN 5. Trust Mark Status Request¶
POST /trust_mark_status HTTP/1.1
Host: registry.agid.gov.it
Content-Type: application/x-www-form-urlencoded
id=https%3A%2F%2registry.agid.gov.it%2Fopenid_relying_party%2Fpublic%2F
&sub=https%3A%2F%2rp.example.it%2F
EN 5.1. Trust Mark Status Response¶
HTTP/1.1 200 OK
Last-Modified: Wed, 22 Jul 2018 19:15:56 GMT
Content-Type: application/json
{"active": true}
EN 6. Authorization Request¶
Example (HTTP request):
Example of JWT payload:
{
"alg": "RS256",
"kid": "2HnoFS3YnC9tjiCaivhWLVUJ3AxwGGz_98uRFaqMEEs"
}
.
{
"client_id": "https://rp.spid.agid.gov.it",
"response_type": "code",
"scope": "openid",
"code_challenge": "qWJlMe0xdbXrKxTm72EpH659bUxAxw80",
"code_challenge_method": "S256",
"nonce": "MBzGqyf9QytD28eupyWhSqMj78WNqpc2",
"prompt": "login",
"redirect_uri": "https://rp.spid.agid.gov.it/callback1",
"acr_values": {
"https://www.spid.gov.it/SpidL1":null,
"https://www.spid.gov.it/SpidL2":null
},
"claims": {
"userinfo": {
"given_name":null,
"family_name":null
}
},
"state": "fyZiOL9Lf2CeKuNT2JzxiLRDink0uPcd"
}
EN 7. Metadata Policy¶
The following example shows a Metadata policy in the Entity Statement provided by a TA and related to an RP
"metadata_policy": {
"openid_relying_party": {
"jwks": {
"value": {
"keys": [
{
"kty": "RSA",
"e": "AQAB",
"use": "sig",
"kid": "....",
"n": "....."
},
{
"kty": "RSA",
"e": "AQAB",
"use": "enc",
"kid": "....",
"n": "....."
}
]
},
"grant_types": {
"subset_of": [
"authorization_code",
"refresh_token"
],
"superset_of": [
"authorization_code"
]
},
"id_token_signed_response_alg": {
"one_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"essential": true
},
"id_token_encrypted_response_alg": {
"one_of": [
"RSA-OAEP",
"RSA-OAEP-256",
"ECDH-ES",
"ECDH-ES+A128KW",
"ECDH-ES+A256KW"
],
"essential": false
},
"id_token_encrypted_response_enc": {
"one_of": [
"A128CBC-HS256",
"A256CBC-HS512"
],
"essential": false
},
"userinfo_signed_response_alg": {
"one_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"essential": true
},
"userinfo_encrypted_response_alg": {
"one_of": [
"RSA-OAEP",
"RSA-OAEP-256",
"ECDH-ES",
"ECDH-ES+A128KW",
"ECDH-ES+A256KW"
],
"essential": true
},
"userinfo_encrypted_response_enc": {
"one_of": [
"A128CBC-HS256",
"A256CBC-HS512"
],
"essential": true
},
"token_endpoint_auth_method": {
"one_of": [
"private_key_jwt"
],
"essential": true
},
"client_registration_types": {
"subset_of": [
"automatic"
],
"essential": true
},
"redirect_uris": {
"essential": true
},
"client_id": {
"essential": true
},
"response_types": {
"value": [
"code"
]
}
}
}
The following example shows a Metadata policy in the Entity Statement provided by a TA and related to an SA
"metadata_policy": {
"openid_relying_party": {
"grant_types": {
"subset_of": [
"authorization_code",
"refresh_token"
],
"superset_of": [
"authorization_code"
]
},
"id_token_signed_response_alg": {
"one_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"essential": true
},
"id_token_encrypted_response_alg": {
"one_of": [
"RSA-OAEP",
"RSA-OAEP-256",
"ECDH-ES",
"ECDH-ES+A128KW",
"ECDH-ES+A256KW"
],
"essential": false
},
"id_token_encrypted_response_enc": {
"one_of": [
"A128CBC-HS256",
"A256CBC-HS512"
],
"essential": false
},
"userinfo_signed_response_alg": {
"one_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"essential": true
},
"userinfo_encrypted_response_alg": {
"one_of": [
"RSA-OAEP",
"RSA-OAEP-256",
"ECDH-ES",
"ECDH-ES+A128KW",
"ECDH-ES+A256KW"
],
"essential": true
},
"userinfo_encrypted_response_enc": {
"one_of": [
"A128CBC-HS256",
"A256CBC-HS512"
],
"essential": true
},
"token_endpoint_auth_method": {
"one_of": [
"private_key_jwt"
],
"essential": true
},
"client_registration_types": {
"subset_of": [
"automatic"
],
"essential": true
},
"redirect_uris": {
"essential": true
},
"client_id": {
"essential": true
},
"response_types": {
"value": [
"code"
]
}
}
}
The following example shows a Metadata policy in the Entity Statement provided by a SA and related to an RP
"metadata_policy": {
"openid_relying_party": {
"jwks": {
"value": {
"keys": [
{
"kty": "RSA",
"e": "AQAB",
"use": "sig",
"kid": "....",
"n": "....."
},
{
"kty": "RSA",
"e": "AQAB",
"use": "enc",
"kid": "....",
"n": "....."
}
]
},
}
}
The following example shows a Metadata policy in the Entity Statement provided by a TA and related to an OP.
"metadata_policy": {
"openid_relying_party": {
"jwks": {
"value": {
"keys": [
{
"kty": "RSA",
"e": "AQAB",
"use": "sig",
"kid": "....",
"n": "....."
},
{
"kty": "RSA",
"e": "AQAB",
"use": "enc",
"kid": "....",
"n": "....."
}
]
},
"revocation_endpoint_auth_methods_supported": {
"subset_of": [
"private_key_jwt"
],
"essential": true
},
"code_challenge_methods_supported": {
"subset_of": [
"S256"
],
"essential": true
},
"scopes_supported": {
"subset_of": [
"openid",
"offline_access",
"profile",
"email"
],
"superset_of": [
"openid",
"offline_access"
]
},
"response_types_supported": {
"subset_of": [
"code"
],
"essential": true
},
"response_modes_supported": {
"subset_of": [
"form_post",
"query"
],
"superset_of": [
"form_post",
"query"
],
"essential": true
},
"grant_types_supported": {
"subset_of": [
"authorization_code",
"refresh_token"
],
"superset_of": [
"authorization_code",
"refresh_token"
],
"essential": true
},
"acr_values_supported": {
"subset_of": [
"https://www.spid.gov.it/SpidL1",
"https://www.spid.gov.it/SpidL2",
"https://www.spid.gov.it/SpidL3"
],
"superset_of": [
"https://www.spid.gov.it/SpidL1",
"https://www.spid.gov.it/SpidL2",
"https://www.spid.gov.it/SpidL3"
],
"essential": true
},
"subject_types_supported": {
"subset_of": [
"pairwise"
],
"essential": true
},
"id_token_signing_alg_values_supported": {
"subset_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"superset_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"essential": true
},
"id_token_encryption_alg_values_supported": {
"subset_of": [
"RSA-OAEP",
"RSA-OAEP-256",
"ECDH-ES",
"ECDH-ES+A128KW",
"ECDH-ES+A256KW"
],
"superset_of": [
"RSA-OAEP",
"RSA-OAEP-256",
"ECDH-ES",
"ECDH-ES+A128KW",
"ECDH-ES+A256KW"
],
"essential": true
},
"id_token_encryption_enc_values_supported": {
"subset_of": [
"A128CBC-HS256",
"A256CBC-HS512"
],
"superset_of": [
"A128CBC-HS256",
"A256CBC-HS512"
],
"essential": true
},
"userinfo_signing_alg_values_supported": {
"subset_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"superset_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"essential": true
},
"userinfo_encryption_alg_values_supported": {
"subset_of": [
"RSA-OAEP",
"RSA-OAEP-256",
"ECDH-ES",
"ECDH-ES+A128KW",
"ECDH-ES+A256KW"
],
"superset_of": [
"RSA-OAEP",
"RSA-OAEP-256",
"ECDH-ES",
"ECDH-ES+A128KW",
"ECDH-ES+A256KW"
],
"essential": true
},
"userinfo_encryption_enc_values_supported": {
"subset_of": [
"A128CBC-HS256",
"A256CBC-HS512"
],
"superset_of": [
"A128CBC-HS256",
"A256CBC-HS512"
],
"essential": true
},
"token_endpoint_auth_methods_supported": {
"subset_of": [
"private_key_jwt"
],
"essential": true
},
"token_endpoint_auth_signing_alg_values_supported": {
"subset_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"superset_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"essential": true
},
"claims_parameter_supported": {
"value": true
},
"request_parameter_supported": {
"value": true
},
"authorization_response_iss_parameter_supported": {
"value": true
},
"client_registration_types_supported": {
"subset_of": [
"automatic"
],
"essential": true
},
"request_authentication_methods_supported": {
"value": {
"authorization_endpoint": [
"request_object"
]
}
},
"request_authentication_signing_alg_values_supported": {
"subset_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"superset_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"essential": true
},
"request_object_signing_alg_values_supported": {
"subset_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"superset_of": [
"RS256",
"RS512",
"ES256",
"ES512",
"PS256",
"PS512"
],
"essential": true
},
"issuer": {
"essential": true
},
"authorization_endpoint": {
"essential": true
},
"token_endpoint": {
"essential": true
},
"userinfo_endpoint": {
"essential": true
},
"introspection_endpoint": {
"essential": true
},
"revocation_endpoint": {
"essential": true
}
}
}
Diventa fornitore di servizi¶
Qui di seguito riportiamo gli indirizzi di riferimento per le procedure di "onboarding" di SPID e CIE, cioè per diventare fornitori di servizi.
Come contribuire¶
Per contribuire clicca in alto a destra sulla icona di GitHub, alla voce "Sorgente" e accedi al repository pubblico.
Se trovi una inesattezza o desideri risolvere un dubbio o semplicemente notificare qualcosa per migliorare questa documentazione, apri una nuova Issue.
A seguito dell'apertura della Issue e dei riscontri ottenuti dalla comunità di Developers italia potrai aprire una nuova Pull Request contenente la modifica o la correzione da te proposta.