# Applicazioni

Registri applicazioni per il single sign-on tramite OpenID Connect, SAML 2.0 o WS-Federation, dal catalogo o personalizzate, e ne controlli l'accesso.

Un'**applicazione** è qualsiasi cosa a cui i Suoi utenti accedono tramite la piattaforma: un'app web, un'app mobile, un'app single-page, un servizio che chiama un'API o un'applicazione aziendale legacy. La registrazione di un'applicazione stabilisce il rapporto di fiducia tra essa e il Single Sign-On della piattaforma e indica alla piattaforma come emettere token o Assertion per essa.

Le applicazioni si gestiscono nell'Admin Console in **Integrazioni → Applicazioni**.

## La pagina Applicazioni

La pagina Applicazioni elenca tutto ciò che ha registrato, suddiviso in tre schede:

- **Applicazioni**: le app a cui le persone accedono, in due sezioni. Le **Applicazioni di integrazione** sono app aggiunte dal catalogo integrato (indicate come *SSO Integration*), ciascuna con i valori predefiniti di protocollo del fornitore. Le **Applicazioni personalizzate** sono app interattive che Lei ha configurato autonomamente per OIDC, SAML o WS-Federation.
- **Macchine**: servizi machine-to-machine che si autenticano con un client secret e a cui nessuna persona accede mai, oltre alle applicazioni di solo provisioning.
- **Registrazioni dinamiche**: gli initial access token e le applicazioni che si sono registrate autonomamente. Vedere [Registrazione dinamica dei client](https://dts-identity.com/it/docs/integrations/dynamic-client-registration.md).

Ogni riga mostra l'attività di accesso dell'app: un numero di accessi e un *orario dell'ultimo accesso*, oppure **Nessun accesso effettuato** (app interattive) / **Mai utilizzato** (machine-to-machine) se non è mai stata chiamata.

Utilizzi la **casella di ricerca** sopra l'elenco per filtrare la scheda corrente per nome, tipo, client ID o integrazione. Un banner sui limiti compare nella parte superiore quando si avvicina al numero di applicazioni consentito dal Suo piano.

Due pulsanti avviano una nuova app: **Sfoglia le integrazioni** (il catalogo) e **Crea app personalizzata**. Cerchi prima nel catalogo: creare un'app personalizzata ha senso solo quando non esiste alcuna integrazione per la Sua destinazione.

## Protocolli

La piattaforma emette l'identità tramite tre protocolli. Ne sceglie uno quando crea l'applicazione:

- **OpenID Connect (OIDC)**: lo standard moderno per applicazioni web, single-page, mobile e machine-to-machine. Supporta l'authorization code flow con PKCE, i refresh token, il device authorization grant, le client credentials e il back-channel logout.
- **SAML 2.0**: lo standard SSO aziendale consolidato. La piattaforma agisce come Identity Provider ed emette Assertion firmate (facoltativamente cifrate), supportando l'accesso avviato dall'IdP e dall'SP e il Single Logout.
- **WS-Federation**: per Relying Party più datate orientate a Microsoft (ad esempio Exchange OWA). La piattaforma emette token SAML 1.1 firmati tramite un Security Token Service.

### Quale protocollo scegliere [#which-protocol-to-choose]

Scelga **OIDC** ogni volta che è possibile: per tutto ciò che sviluppa autonomamente e per qualsiasi applicazione di terze parti che lo supporti. Copre ogni tipo di applicazione, dalle app browser alle machine-to-machine, ed è il protocollo in cui risiedono le funzionalità di sicurezza più recenti (PKCE, DPoP, i profili Financial-grade API, token exchange). Scelga **SAML 2.0** quando l'applicazione non supporta nient'altro, cosa ancora comune nel software aziendale consolidato; l'esperienza di accesso per gli utenti è la stessa. **WS-Federation** esiste per le Relying Party legacy; non lo scelga per nulla di nuovo.

## Tipi di applicazione

Quando crea un'applicazione personalizzata sceglie un **tipo**, che imposta valori di protocollo predefiniti sensati e determina quale configurazione viene mostrata:

| Tipo | Protocollo | Da utilizzare per |
|---|---|---|
| **Applicazione web (lato server)** | OIDC | App web lato server in grado di mantenere riservato un client secret. |
| **Applicazione single-page** | OIDC | App browser senza backend; si autenticano con PKCE, senza client secret. |
| **Applicazione nativa** | OIDC | App mobile e desktop; si autenticano con PKCE, senza client secret. |
| **Applicazione per dispositivi** | OIDC | Dispositivi con input limitato che utilizzano il device authorization flow. |
| **Machine-to-machine** | OIDC | Accesso da servizio a servizio con il grant client credentials; nessun accesso interattivo. |
| **Applicazione SAML** | SAML 2.0 | Un Service Provider SAML che considera attendibile la piattaforma come proprio Identity Provider. |
| **Applicazione WS-Federation** | WS-Federation | Una Relying Party che utilizza token SAML 1.1. |
| **Solo provisioning** | – | Un'applicazione in cui si esegue solo il provisioning degli account, senza Single Sign-On. Vedere [Provisioning delle applicazioni](https://dts-identity.com/it/docs/integrations/application-provisioning.md). |

Il fatto che un'applicazione possa mantenere riservato un secret (web, machine-to-machine) o meno (single-page, nativa, per dispositivi) determina come si autentica presso il token endpoint e se viene emesso un client secret. Quando sceglie un tipo, la piattaforma normalizza i grant type e i response type consentiti in base a esso: non li imposta manualmente.

### Scegliere un tipo OIDC in base alla forma di deployment [#choosing-an-oidc-type-by-deployment-shape]

Per un'app OIDC personalizzata, scelga il tipo in base a dove viene eseguito il codice e a quale credenziale è in grado di proteggere:

| Forma di deployment | Tipo | Credenziale | Flusso consigliato |
|---|---|---|---|
| App web lato server (con un backend in grado di mantenere un secret) | Applicazione web (lato server) | Client secret (confidential) | Authorization code |
| App single-page (eseguita nel browser) | Applicazione single-page | Nessuna (public client) | Authorization code + PKCE |
| App mobile / desktop | Applicazione nativa | Nessuna (public client) | Authorization code + PKCE |
| Servizio backend senza utente (da server a server) | Machine-to-machine | Client secret (confidential) | Client credentials, vedere [API](https://dts-identity.com/it/docs/integrations/apis.md) |

Un **public client** (single-page, nativo, per dispositivi) non può custodire un secret in modo sicuro, quindi non riceve mai un client secret utilizzabile e si affida a PKCE per proteggere lo scambio dell'authorization code. Utilizzi un tipo confidential solo quando la Sua app può memorizzare un secret lato server.

Un'app browser può chiamare gli endpoint token e userinfo solo dall'origine (schema, host e porta) di uno dei suoi redirect URI; le richieste da qualsiasi altra origine vengono rifiutate.

## Aggiungere un'applicazione

### Dal catalogo

Il catalogo contiene integrazioni predefinite per le applicazioni più comuni. Ciascuna include i valori di protocollo predefiniti corretti, una configurazione guidata con i valori esatti da incollare nell'applicazione di destinazione e, dove disponibile, un modello di provisioning. L'aggiunta avviene in due fasi:

1. Vada in **Integrazioni → Applicazioni**, scelga **Sfoglia le integrazioni** e selezioni l'applicazione.
2. Legga la **schermata dei prerequisiti e del consenso**. Elenca ciò di cui l'integrazione ha bisogno (ad esempio un account amministrativo nel sistema di destinazione) e quali accessi utilizzerà. Confermi per proseguire.
3. Compili il breve modulo di configurazione specifico dell'integrazione (ad esempio il dominio o il sottodominio dell'applicazione) e crei l'app.
4. L'applicazione viene creata con i valori predefiniti del catalogo già applicati; ne affini poi la configurazione nelle schede descritte di seguito.

Alcuni comportamenti del catalogo da conoscere:

- Le **integrazioni a istanza singola** possono essere configurate una sola volta: se una è già configurata, il catalogo ne impedisce una seconda. La maggior parte delle integrazioni può essere aggiunta più volte (ad esempio una per ambiente).
- Le **voci del catalogo disabilitate** non possono essere aggiunte; compaiono a titolo di riferimento, ma il flusso di creazione le rifiuta.
- Alcune voci del catalogo sono **di solo provisioning**: creano account a valle ma non forniscono l'accesso. Vedere [Provisioning delle applicazioni](https://dts-identity.com/it/docs/integrations/application-provisioning.md).
- I riquadri del catalogo riportano un'**etichetta di maturità**. Un'integrazione consolidata non ne mostra alcuna; una più recente è contrassegnata come **beta** (funzionante, ancora in fase di perfezionamento) oppure **experimental** (in fase iniziale, potrebbe cambiare). In produzione preferisca le integrazioni stabili e testi un'integrazione beta o experimental prima di farvi affidamento.

Ogni integrazione del catalogo include nel flusso di creazione una **configurazione guidata** con i valori esatti da incollare nell'applicazione di destinazione (e, dove il provisioning è supportato, i passaggi SCIM). I passaggi specifici di ogni applicazione si trovano in tale configurazione guidata anziché in questa documentazione, così restano allineati con l'integrazione.

**Nota sulla scelta:** cerchi nel catalogo prima di creare un'app personalizzata. Un'integrazione del catalogo Le risparmia il cablaggio del protocollo e, dove disponibile, il mapping del provisioning. Crei un'app personalizzata solo quando nessuna integrazione corrisponde alla Sua destinazione.

[Image: L'elenco delle applicazioni nell'Admin Console]

### Come applicazione personalizzata

1. Nella pagina Applicazioni, scelga **Crea applicazione**.
2. Inserisca un **nome** e scelga il **tipo** (vedere la tabella sopra).
3. Salvi. La piattaforma crea l'applicazione con i valori di protocollo predefiniti per quel tipo. Per le applicazioni SAML e WS-Federation genera inoltre automaticamente un certificato di firma.
4. Apra l'applicazione e la configuri nelle schede descritte di seguito.

I client OpenID Connect possono anche registrarsi autonomamente, autorizzati da un initial access token emesso da Lei. Vedere [Registrazione dinamica dei client](https://dts-identity.com/it/docs/integrations/dynamic-client-registration.md).

## Configurare un'applicazione

Ogni applicazione si apre con una serie di schede. Le schede e i campi visualizzati dipendono dal protocollo e dal tipo.

### Impostazioni generali

Disponibili per ogni applicazione:

- **Nome** e **Descrizione**.
- **Contatti**: le persone a cui rivolgersi in merito all'applicazione, scelte tra i dipendenti. Hanno solo valore informativo: i contatti non ricevono alcun diritto. Le integrazioni del catalogo offrono lo stesso campo nella scheda **Impostazioni**.
- **Logo dell'applicazione** e **Application URI**: utilizzati per presentare l'applicazione nel portale app dell'utente. È possibile impostare un secondo logo, facoltativo, per la modalità scura; sostituisce il logo standard mentre il tema scuro è attivo ed è consigliabile impostarlo per i loghi che sono essi stessi scuri. Le applicazioni create dal catalogo delle integrazioni prendono entrambi i loghi dalla voce del catalogo.
- **Display in the app portal**: se gli utenti finali vedono l'applicazione come un riquadro che possono avviare. Le integrazioni del catalogo offrono lo stesso interruttore nella scheda **Impostazioni**; una nuova integrazione è inizialmente visibile (a meno che la sua voce del catalogo non indichi diversamente) e la Sua scelta viene mantenuta nei salvataggi successivi. Il riquadro compare solo se l'integrazione fornisce un URL dell'applicazione, cosa che molte integrazioni SAML non fanno; la scheda Impostazioni lo segnala quando è così.

La sezione **Azioni distruttive** in fondo contiene: rotazione del client secret, rinnovo del certificato di firma, modifica del tipo di applicazione ed eliminazione dell'applicazione. Ciascuna Le chiede di confermare digitando il nome dell'applicazione.

### Impostazioni OpenID Connect

Per le applicazioni OIDC si configurano:

- **Client ID**: generato automaticamente; di sola lettura.
- **Client secret**: emesso per le applicazioni confidential (web, machine-to-machine). Viene mostrato mascherato, con i comandi per copiarlo e visualizzarlo. Vedere [Ruotare un client secret](#rotating-a-client-secret).
- **Token endpoint authentication method**: il modo in cui l'applicazione si autentica presso il token endpoint: un client secret nel corpo o nell'header della richiesta, **Private Key JWT** (l'applicazione firma un'assertion con la propria chiave privata, quindi non viene scambiato alcun secret condiviso), oppure nessuno per i public client. Nei deployment dedicati con un edge Mutual TLS sono offerti anche due metodi basati su certificato: **Mutual TLS (certificato autofirmato)**, in cui il certificato client presentato deve corrispondere a uno registrato in [Chiavi client](#registering-client-keys), e **Mutual TLS (certificato firmato da una CA)**, in cui il certificato viene verificato rispetto a un'autorità di certificazione fornita dal cliente e abbinato tramite il suo subject (compili esattamente uno tra subject DN o DNS SAN). Negli altri deployment i due metodi sono visibili ma disabilitati. Vedere [Sicurezza Financial-grade API](#financial-grade-api-security).
- **Grant types**: i flussi che l'applicazione può utilizzare. Le caselle di controllo visualizzate dipendono dal tipo:
  - *Per conto di un utente*: authorization code, refresh token (e implicit, dove ancora necessario; un access token da un flusso implicit o hybrid viene emesso solo con `response_mode=form_post`, mai nel fragment dell'URL).
  - *Per conto proprio*: client credentials (machine-to-machine).
  - **Token exchange**: scambia un token con un altro, utilizzato quando un servizio deve chiamare un'API a valle come l'utente originale (delega) anziché come sé stesso.

  I response type derivano dai grant consentiti; non vengono impostati separatamente.
- **Redirect URI** e **Post-logout redirect URI**: vedere [Redirect URI e post-logout URI](#redirect-and-post-logout-uris).
- **Back-channel logout URI**: un endpoint server che la piattaforma chiama per disconnettere l'utente da questa applicazione quando la sua sessione termina.
- **URI di avvio dell'accesso**: utilizzato per l'accesso all'applicazione avviato dall'IdP.
- **Rafforzamento del protocollo**: interruttori che possono essere utilizzati singolarmente oppure far parte di un [profilo di sicurezza](#financial-grade-api-security), che in tal caso li imposta e li blocca:
  - **Require proof of possession (DPoP)**: lega gli access token emessi alla chiave dell'applicazione, così un token rubato non può essere riutilizzato.
  - **Richiedi token di accesso associati al certificato (mTLS)**: lega invece gli access token emessi al certificato client TLS dell'applicazione. Offerto nei deployment dedicati con un edge Mutual TLS; non può essere combinato con il requisito DPoP.
  - **Richiedi Pushed Authorization Requests (PAR)**: l'applicazione invia prima i propri parametri di autorizzazione alla piattaforma tramite back-channel e reindirizza l'utente con un breve riferimento, così i parametri non compaiono mai nell'URL del browser. Offerto solo per le applicazioni che utilizzano l'authorization endpoint.
  - **Richiedi un request object firmato (JAR)**: i parametri di autorizzazione vengono accettati solo all'interno di un JWT firmato dall'applicazione. È necessario registrare prima una chiave client o un JWKS URI, altrimenti nessuna richiesta di autorizzazione può riuscire. Richiede l'abbonamento Advanced o Pro, come le chiavi client da cui dipende; senza di esso l'interruttore è visibile ma disabilitato, e un'impostazione effettuata in precedenza resta in vigore.
- **Richiedi il consenso dell'utente**: chiede all'utente il consenso prima dell'emissione dei token.
- **Durata dell'ID token** e **durata massima dell'autenticazione**: vedere [Durata dei token e logout](#token-lifetimes-and-logout).

- **OIDC discovery URL**: l'URL `.well-known/openid-configuration`, di sola lettura, che l'applicazione utilizza per trovare gli endpoint e le chiavi di firma della piattaforma. Lo fornisca al Suo integratore.

I claim che l'applicazione riceve effettivamente si configurano nella sua scheda **Attributi**, vedere [Attributi e claim](#attributes-and-claims).

### Redirect URI e post-logout URI [#redirect-and-post-logout-uris]

Una mancata corrispondenza del redirect URI è la causa più comune di un SSO non funzionante, quindi configuri questi valori con attenzione.

- **Redirect URI**: gli URL di callback esatti a cui la piattaforma può rimandare l'utente dopo l'accesso. Obbligatori per l'authorization code flow. La corrispondenza è **esatta**: una barra finale, una porta diversa oppure `http` anziché `https` portano la piattaforma a rifiutare la risposta e l'utente vede un errore invece di accedere. Se l'URL inviato dalla Sua app non compare in questo elenco, l'accesso non riesce.
- **Post-logout redirect URI**: gli URL di ritorno a cui la piattaforma può rimandare l'utente dopo la disconnessione.

Può indicare **più voci**, una per riga, per coprire più ambienti. Eviti **wildcard** e **`localhost`** nelle registrazioni di produzione: ampliano le destinazioni verso cui un attaccante può reindirizzare. Aggiunga invece un'app di sviluppo separata con il proprio URI localhost.

Per **SAML** e **WS-Federation**, l'equivalente è l'elenco consentito degli URL ACS / reply URL: quando la Request non indica una destinazione di ritorno, la piattaforma utilizza la **prima voce (predefinita)**. Per SAML la porta predefinita viene ignorata nel confronto tra URL ACS e Issuer, quindi `https://host:443/...` e `https://host/...` valgono come la stessa voce.

> **Risoluzione dei problemi: l'accesso restituisce un errore anziché l'app:** l'URL di callback inviato dalla Sua applicazione non è presente tra i redirect URI (o differisce per una barra, la porta o lo schema). Copi l'URL esatto dall'errore o dalla configurazione della Sua app e lo aggiunga qui.

### Impostazioni SAML

Per le applicazioni SAML si configura la connessione al Service Provider (SP). La scheda è suddivisa in cinque sezioni, nell'ordine in cui le si affronta: **Origine della configurazione**, **Single Sign-On**, **Single Logout**, **Firma e crittografia** e **Dati dell'Identity Provider**. Il mapping degli attributi si trova nella propria scheda **Attributi**, vedere [Attributi e claim](#attributes-and-claims).

#### Origine della configurazione [#configuration-source]

Scelga una delle tre modalità:

- **URL**: incolli l'URL dei metadati dell'SP e salvi. L'URL viene convalidato al salvataggio: se non è raggiungibile o non restituisce metadati SAML validi, il salvataggio viene rifiutato, così un'origine non funzionante non viene mai memorizzata. (Un pulsante **Test** verifica l'URL prima del salvataggio.) Facoltativamente, attivi l'**aggiornamento automatico** e scelga un intervallo (da ogni 5 minuti fino a una volta al giorno) per recuperare nuovamente i metadati secondo una pianificazione, così una modifica di certificato o endpoint lato SP viene recepita senza reimportazione; se in seguito un aggiornamento pianificato non riesce, compare un avviso in [Problemi](https://dts-identity.com/it/docs/monitoring/issues.md). L'aggiornamento automatico funziona solo con un URL `https://`. Applica le rotazioni dei certificati, l'endpoint di logout, i flag di firma e le modifiche all'assertion consumer service su un host già utilizzato dall'SP, e registra ogni modifica applicata nell'[audit log](https://dts-identity.com/it/docs/monitoring/audit-logs.md). Un nuovo entity ID o un assertion consumer service su un **nuovo host** non viene applicato automaticamente, poiché è lì che arriva ogni risposta di accesso dell'applicazione: l'applicazione mantiene i metadati attuali e un problema Le chiede di verificare la modifica. Utilizzi **Recupera ora** per applicarla, oppure per aggiornare immediatamente in qualsiasi momento. Lasci disattivato l'aggiornamento automatico per importare i metadati una sola volta e mantenerli fissi.
- **File**: trascini l'XML dei metadati dell'SP.
- **Manuale**: compili manualmente i campi nelle sezioni seguenti.

Nelle due modalità basate sui metadati, i valori ricavati dai metadati sono mostrati **in sola lettura nella sezione a cui appartengono**: l'Entity ID e gli endpoint ACS dell'SP in *Single Sign-On*, il suo endpoint di logout in *Single Logout* e i suoi certificati, insieme ai flag di firma dichiarati, in *Firma e crittografia*. Non è quindi mai necessario leggere l'XML dei metadati per sapere cosa è in vigore. I campi di input corrispondenti sono nascosti finché è attiva un'importazione e i loro valori memorizzati non vengono toccati, quindi tornando a **Manuale** si ripristina quanto inserito manualmente l'ultima volta.

#### Single Sign-On [#single-sign-on]

- **URI dell'Assertion Consumer Service**: dove viene inviata l'Assertion SAML. Obbligatorio. Quando l'SP avvia una Request senza indicare un ACS, viene utilizzato il primo URL ACS (predefinito).
- **Metodo dell'Assertion Consumer Service**: come viene consegnata l'Assertion: **POST**, **Redirect** oppure *uguale alla Request*.
- **Audience**: l'identificatore dell'SP. Viene utilizzato come Audience quando un accesso inizia senza una SAML Request, quindi resta modificabile anche nelle modalità basate sui metadati.
- **Accesso IdP-initiated**: consente di avviare un accesso da qui anziché dall'SP, ad esempio dal riquadro nel portale app.

#### Single Logout [#single-logout]

- **URI del servizio di Single Logout** e il relativo **metodo**: dove vengono inviati i messaggi di logout SAML per questo SP. Se impostato, l'applicazione partecipa al **Single Logout**: la disconnessione dalla piattaforma, o da un'altra applicazione partecipante, termina anche la sessione presso questo SP. Nelle modalità basate sui metadati entrambi i valori vengono importati dai metadati dell'SP (si preferisce POST quando l'SP pubblica entrambi i Binding) e mantenuti allineati a ogni aggiornamento dei metadati, quindi vanno inseriti manualmente solo in modalità manuale. Quando i metadati non dichiarano alcun endpoint di logout, la sezione lo indica.
- **Trasmissione del logout**: mostra se un logout da server a server è mai riuscito per questa applicazione e quando è riuscito l'ultima volta.

Il modo in cui la Request raggiunge l'SP non richiede alcuna configurazione. Mentre l'utente si disconnette in un browser, il logout viene consegnato tramite il browser stesso (un frame nascosto per ogni applicazione), il che consente a ciascun SP di cancellare i propri cookie di sessione. Quando una sessione termina senza browser (una sessione terminata da un amministratore, una sessione inattiva, una sessione terminata come misura di sicurezza, oppure ogni sessione di un account sospeso, eliminato o la cui password è stata modificata o reimpostata), oppure quando il browser non ha potuto completare la consegna, la Request viene invece inviata direttamente da server a server. Le applicazioni raggiungibili solo dalla rete dell'utente vengono quindi disconnesse normalmente quando l'utente è presente e non vengono segnalate come errori solo perché la piattaforma stessa non può raggiungerle. Un'applicazione il cui endpoint di logout *rispondeva* in precedenza e smette di rispondere, oppure che rifiuta la Request, viene invece segnalata in [Problemi](https://dts-identity.com/it/docs/monitoring/issues.md), dove una sola voce copre la condizione anziché una per ogni disconnessione.

#### Firma e crittografia [#signing-and-encryption]

- **Request in entrata**: se l'SP firma le proprie Request di autenticazione e di logout. A tal fine è necessario il suo certificato di firma, e le Request non firmate o firmate in modo errato vengono quindi rifiutate. Finché il certificato manca, le Request di logout dell'SP vengono rifiutate e un [problema](https://dts-identity.com/it/docs/monitoring/issues.md) indica l'applicazione.
- **Firma della Response**: quale parte della Response porta la firma: la SAML Response, l'Assertion o entrambe. Viene sempre applicata almeno una firma. Nelle modalità basate sui metadati, la firma dell'Assertion segue i metadati dell'SP (`WantAssertionsSigned`); solo la firma della Response deriva da questa impostazione.
- **Crittografia dell'Assertion**: cifra l'Assertion per questo SP. La attivi solo quando l'SP richiede Assertion cifrate.
- **Certificato di firma del Service Provider**: il certificato rispetto al quale vengono verificate le Request in entrata.
- **Certificato di crittografia del Service Provider**: necessario solo quando l'SP pubblica un certificato separato per la crittografia, altrimenti viene utilizzato il suo certificato di firma.

#### Dati dell'Identity Provider [#identity-provider-details]

Tutto ciò di cui l'SP ha bisogno per considerare attendibile questo Identity Provider, in sola lettura e con un pulsante di copia: il **Metadata URL** (importandolo si coprono tutti gli altri valori), l'**Entity ID (Issuer)**, l'**URL di accesso**, l'**URL di Single Logout** e il **certificato di firma** con la relativa impronta digitale. Vedere [Certificati di firma e crittografia](#signing-and-encryption-certificates).

### Impostazioni WS-Federation

Per le applicazioni WS-Federation la scheda è suddivisa in tre sezioni (il mapping degli attributi si trova nella scheda **Attributi**, vedere [Attributi e claim](#attributes-and-claims)):

- **Relying Party**: il **Realm** a cui la Request deve corrispondere e l'**elenco consentito dei reply URL** con le destinazioni di ritorno ammesse (la prima voce è quella predefinita).
- **Security Token**: la **durata del token**, ovvero per quanto tempo è valido il token SAML 1.1 emesso.
- **Dati dell'Identity Provider**: valori di sola lettura per la Relying Party, ciascuno con un pulsante di copia: il **Federation Metadata URL**, l'**Entity ID (Issuer)** dei token emessi, l'**URL di accesso** a cui la Relying Party invia le proprie Request e il **certificato di firma** con la relativa impronta digitale.

### Attributi e claim [#attributes-and-claims]

La scheda **Attributi** risponde a una sola domanda per ogni protocollo: cosa viene a sapere questa applicazione sull'utente? Ciò che offre dipende dal protocollo, perché SAML e WS-Federation consentono di denominare liberamente gli attributi, mentre i nomi dei claim OIDC sono fissati dalla specifica.

Le applicazioni machine-to-machine e per dispositivi non dispongono di questa scheda. Non ricevono né un ID token né un'Assertion contenente attributi dell'utente.

#### SAML e WS-Federation

Entrambi i protocolli inseriscono gli attributi dell'utente nell'Assertion ed entrambi consentono di rinominare ciascuno di essi secondo quanto si aspetta l'applicazione ricevente.

- **Name ID source**: selezioni quale campo dell'utente diventa il soggetto dell'Assertion (il Name ID).
- **Emitted attributes**: ogni attributo standard (di base) e ogni attributo personalizzato dispone di una casella di controllo e di un campo per il nome. La casella decide se l'attributo arriva o meno nell'Assertion, il campo contiene il nome esatto con cui viene inviato. Modifichi il campo quando l'SP si aspetta, ad esempio, `mail` anziché `email`; il pulsante di ripristino accanto ripristina il nome iniziale dell'attributo. Un attributo non selezionato non viene inviato e il suo nome non può essere modificato finché non lo seleziona.

Questo mapping modifica solo i **nomi** visti dal destinatario, non trasforma né calcola i valori degli attributi. Il `NameFormat` che l'Assertion dichiara accanto a un attributo segue il nome inserito: un nome in forma di URI viene dichiarato come URI, un nome semplice come basic.

Il **filtro dei gruppi** sotto il mapping decide quali gruppi finiscono nell'Assertion. L'Assertion contiene distinguished name e il filtro confronta sia il distinguished name sia il nome semplice del gruppo, quindi un termine come `APP-JIRA` funziona con entrambe le modalità di corrispondenza.

#### OIDC

- **Claim standard**: una panoramica in sola lettura dei claim rilasciati per ogni scope, così può vedere cosa riceve l'applicazione per gli scope che richiede. Questi nomi sono fissati dalla specifica OpenID Connect e non possono essere rinominati. I claim contrassegnati da un asterisco richiedono inoltre che la directory dell'utente abiliti il campo del profilo sottostante: lo scope da solo non li inserisce nel token. Un claim contrassegnato come deprecato viene ancora emesso, ma sarà rimosso in una versione futura, quindi non basi una nuova integrazione su di esso. Attualmente si tratta del claim `roles` nello scope `groups`: i ruoli vanno nell'access token, emesso tramite un'[API con RBAC attivato](https://dts-identity.com/it/docs/integrations/apis.md#role-based-access-control), oppure nello scope `roles`.
- **Claim personalizzati**: selezioni quali attributi personalizzati riceve in aggiunta l'applicazione. Ogni attributo selezionato viene emesso come claim di primo livello con il proprio nome, accanto ai claim standard, quando l'applicazione richiede lo scope `profile`. Un valore viene emesso solo se l'attributo è assegnato alla directory dell'utente, quindi la selezione di un attributo non rivela mai più di quanto l'utente possieda effettivamente. Per impostazione predefinita non è selezionato nulla: un'applicazione riceve un attributo personalizzato solo dopo che Lei lo ha abilitato qui.
- **Group-name format**: come viene denominato ogni gruppo nel claim `groups`: il suo **distinguished name**, il suo **nome** semplice o il suo **id**. Scelga la forma che l'applicazione si aspetta quando mappa i gruppi sui propri accessi.
- **Filtro dei gruppi**: di quali gruppi l'applicazione viene informata. Senza filtro viene inviato ogni gruppo a cui l'utente appartiene, e un utente sincronizzato da una directory ne ha facilmente qualche centinaio, il che appesantisce il token e consegna a ogni applicazione l'intera struttura interna dei gruppi. Inserisca un termine e scelga se un gruppo deve **contenerlo** o **iniziare con** esso. Il termine viene confrontato con il nome del gruppo e con il suo distinguished name, senza distinzione tra maiuscole e minuscole, e basta una corrispondenza. Volutamente non viene confrontato con il valore presente nel claim stesso: con il formato del nome del gruppo impostato sull'id, tale valore è un identificatore interno e una modifica del formato svuoterebbe altrimenti il claim senza preavviso. Lasci il filtro vuoto per continuare a inviare tutto.

Le espressioni regolari non sono volutamente offerte: il filtro viene eseguito a ogni accesso su ogni gruppo dell'utente, dove un pattern patologico rallenterebbe o bloccherebbe il percorso di login.

## Proprietari dell'applicazione (deprecato) [#application-owners]

> **Deprecato:** I proprietari dell'applicazione non concedono più diritti di amministrazione; l'amministrazione delegata funziona tramite i [Workspace](https://dts-identity.com/it/docs/governance/workspaces.md). I proprietari contano ancora solo per l'impostazione deprecata **I proprietari gestiscono l'accesso**.

**I proprietari gestiscono l'accesso** (deprecato): dove questa impostazione è stata attivata (a partire dalla 26.2), continua a funzionare. Solo i proprietari dell'applicazione (qualunque sia il loro livello di accesso), gli amministratori completi e, all'interno di un workspace, i suoi membri con **Gestire gli accessi** possono quindi concedere o revocare l'accesso, e l'API di gestione non può modificare le assegnazioni dell'applicazione. La scheda **Proprietari** compare solo finché l'impostazione è attiva: elenca i proprietari, consente di rimuoverne uno e di disattivare l'impostazione. La disattivazione rimuove anche i proprietari e l'impostazione non può essere riattivata. Finché un'applicazione la utilizza ancora, l'elenco delle applicazioni mostra un avviso.

Per controllare chi può assegnare o revocare l'accesso a un'applicazione, la aggiunga a un workspace e attivi **I membri del workspace gestiscono l'accesso**. Solo i membri del workspace con l'autorizzazione **Gestire gli accessi** (oltre ai responsabili e agli amministratori completi) possono quindi assegnare l'app o modificare l'appartenenza ai gruppi del workspace. Gli amministratori completi non vengono mai esclusi. La possibilità per gli utenti di richiedere l'accesso tramite un [workflow di approvazione](https://dts-identity.com/it/docs/workflows.md) continua a funzionare in ogni caso.

Per i livelli di accesso coinvolti, vedere [Utenti della console di amministrazione](https://dts-identity.com/it/docs/security/admin-console-users.md).

## Ruotare un client secret [#rotating-a-client-secret]

Per le applicazioni OIDC confidential può ruotare il client secret in qualsiasi momento da **Impostazioni generali → Azioni distruttive** dell'applicazione:

1. Scelga **Ruota Secret** e confermi digitando il nome dell'applicazione.
2. La piattaforma genera immediatamente un nuovo secret; quello precedente smette subito di funzionare.
3. Visualizzi e copi il nuovo secret, quindi lo aggiorni nella configurazione dell'applicazione stessa.

Poiché la rotazione invalida immediatamente il secret precedente, pianifichi una breve finestra di manutenzione oppure la esegua durante un deployment che recepisce il nuovo valore. La rotazione del secret non interrompe l'integrazione in sé: cambia solo il secret memorizzato.

## Credenziali: secret o certificato di firma

Il modo in cui un'applicazione verifica che i suoi token siano stati emessi dalla piattaforma dipende dal protocollo:

- Le **app OIDC confidential** (web, machine-to-machine) dispongono di un **client secret**. Viene mostrato mascherato nella scheda delle impostazioni OIDC: lo visualizzi per copiarlo. Può [ruotarlo](#rotating-a-client-secret) senza registrare di nuovo l'applicazione.
- Le **app SAML e WS-Federation** utilizzano una **chiave / un certificato di firma** anziché un secret. La piattaforma firma con esso Assertion e token, e l'SP verifica la firma rispetto al certificato pubblicato.

Le chiavi di firma alla base di questi certificati sono per impostazione predefinita **asimmetriche (a chiave pubblica)**, quindi gli integratori recuperano la chiave pubblica corrispondente dai metadati o dal JWKS pubblicati dalla piattaforma anziché condividere un secret simmetrico. Le chiavi di firma sono gestite centralmente, vedere [Chiavi di firma](https://dts-identity.com/it/docs/settings/signing-keys.md).

## Sicurezza Financial-grade API [#financial-grade-api-security]

> **Nota:** Disponibile con gli abbonamenti Advanced e Pro.

Per le applicazioni che gestiscono dati di alto valore (open banking, pagamenti, cartelle cliniche), un **profilo di sicurezza** applica il comportamento rafforzato di un profilo Financial-grade API (FAPI) solo a tale applicazione. Le altre applicazioni non sono interessate. Sono offerti due profili: **FAPI 2.0 Security Profile**, descritto di seguito, e **FAPI 1.0 Advanced**, che si basa su di esso e richiede l'abbonamento Pro.

Il profilo si trova in cima alla scheda delle impostazioni OIDC, sopra le impostazioni di protocollo che governa. Utilizzi **Modifica** accanto a **Profilo di sicurezza** per cambiarlo. È offerto per le applicazioni confidential, perché il profilo esclude i client secret condivisi.

### Avvicinarsi gradualmente a un profilo [#working-towards-a-profile]

Non è necessario decidere un profilo fin dall'inizio. Configuri le singole impostazioni una alla volta (autenticazione del client basata su chiave, una chiave client, prova di possesso, pushed authorization request, un request object firmato) e attivi il profilo quando l'applicazione è pronta.

Alcuni requisiti non vanno affatto configurati. PKCE, gli algoritmi di firma PS256 e le risposte di autorizzazione firmate vengono applicati dalla piattaforma quando il profilo viene attivato.

L'attivazione del profilo seleziona anche Private Key JWT se l'applicazione utilizza ancora un client secret. La chiave pubblica può essere registrata prima o dopo (vedere sotto); finché non esiste una chiave l'applicazione non può essere utilizzata, e ogni tentativo di utilizzarla viene elencato in [Problemi](https://dts-identity.com/it/docs/monitoring/issues.md).

La selezione di **FAPI 2.0 Security Profile** impone, per quell'applicazione:

- **Autenticazione del client basata su chiave**: Private Key JWT (oppure Mutual TLS, nei deployment che lo forniscono). Un client secret non viene accettato.
- **Access token vincolati al mittente**: un access token rubato non può essere riutilizzato da nessun altro. La prova di possesso (DPoP) viene attivata e non può essere disattivata; dove sono invece selezionati access token associati al certificato (deployment dedicati), questi ne prendono il posto.
- **Pushed authorization request**: l'applicazione invia prima i propri parametri di autorizzazione alla piattaforma tramite back-channel, quindi reindirizza l'utente con un breve riferimento invece di esporre i parametri nell'URL del browser.
- **PKCE** con il metodo di challenge S256.
- **Solo authorization code flow**: i flussi implicit e hybrid vengono rifiutati.
- **Firme più robuste**: gli ID token e le client assertion dell'applicazione utilizzano PS256 anziché RS256.

**Gli access token non ne fanno parte.** Un access token JWT viene firmato dall'API per cui è emesso, con l'**Algoritmo di firma** impostato su quell'API, il cui valore predefinito è RS256. FAPI si aspetta PS256 o ES256 anche per esso. Se un'applicazione con un profilo può raggiungere un'API che non utilizza nessuno dei due, tali API vengono indicate accanto al profilo nella scheda delle impostazioni OIDC. L'algoritmo deve essere modificato sull'API stessa (vedere [API](https://dts-identity.com/it/docs/integrations/apis.md)) e si applica quindi a ogni applicazione che utilizza quell'API.

Una volta attivo un profilo, le impostazioni che esso fissa mantengono la propria casella di controllo ma sono bloccate, contrassegnate come **Imposto**: la prova di possesso e le pushed authorization request restano selezionate e non possono essere deselezionate, e i metodi di autenticazione del client non consentiti dal profilo sono disabilitati. I request object firmati restano modificabili con FAPI 2.0, che non li richiede. PKCE e PS256 non hanno un'impostazione propria; vengono applicati con il profilo. Il salvataggio di un profilo non riesce, con un messaggio esplicativo, solo se un requisito non può essere soddisfatto affatto, ad esempio su un'applicazione pubblica, che non può mai soddisfare l'autenticazione del client basata su chiave.

Un profilo può essere riportato su **Nessun profilo** in qualsiasi momento. Applicare un profilo a un'applicazione già in uso rappresenta per essa una modifica incompatibile: da quel momento il suo client deve inviare pushed authorization request, una challenge PKCE e la prova di possesso.

### Registrare le chiavi client [#registering-client-keys]

Private Key JWT richiede la chiave **pubblica** dell'applicazione affinché le sue assertion firmate possano essere verificate. Le chiavi si gestiscono nella scheda **Chiavi client** in fondo alla scheda delle impostazioni OIDC, che offre due origini che si escludono a vicenda:

- **Registered keys** (mostrate per prime): selezioni **Aggiungi chiave** e incolli una chiave pubblica o un certificato X.509 in formato PEM; la chiave viene memorizzata immediatamente. Le chiavi RSA devono essere di almeno 2048 bit; le chiavi EC devono utilizzare la curva P-256.
  - Le chiavi registrate sono elencate in una tabella con nome, thumbprint, tipo di chiave, data di aggiunta e, se applicabile, scadenza del certificato.
  - È possibile assegnare un **nome** facoltativo. Conviene impostarlo: quando una chiave viene sostituita, vengono elencate sia la vecchia sia la nuova, ed è il nome a distinguerle a colpo d'occhio. Il thumbprint resta nella propria colonna, perché è il valore che l'applicazione invia con ogni assertion; viene abbreviato per adattarsi alla riga, passandovi sopra con il mouse viene mostrato il valore completo, che può comunque essere selezionato e copiato. La finestra di conferma indica la chiave che sta per essere rimossa.
  - Se è stato caricato un certificato, viene mostrata anche la sua data di scadenza e un certificato scaduto viene contrassegnato. È solo un'informazione. La chiave continua a funzionare, perché è la chiave a verificare le assertion dell'applicazione, non il certificato che la contiene. La sostituisca quando il suo certificato è scaduto.
- **JWKS URI**: punta a un key set pubblicato dall'applicazione stessa. Le chiavi vengono quindi recuperate da lì, il che consente all'applicazione di ruotare le proprie chiavi senza modifiche in questa sede. L'URL deve utilizzare **https**: su una connessione non cifrata le chiavi pubblicate potrebbero essere sostituite durante il transito, e chiunque lo facesse potrebbe autenticarsi come l'applicazione.
  - Al salvataggio, l'URL viene recuperato una volta come verifica. Se non viene restituito alcun key set, l'URL viene comunque salvato e un avviso ne indica il motivo. Questo è intenzionale, così è possibile inserire un URL prima che l'applicazione pubblichi le proprie chiavi. Finché l'URL non fornisce un key set, l'applicazione non può essere utilizzata e il primo tentativo di utilizzarla viene registrato in Monitoring.

Per passare dall'una all'altra, utilizzi il link sotto la sezione: **Utilizza invece un JWKS URI** sotto la tabella delle chiavi e **Inserisci le chiavi manualmente** sotto il campo dell'URI. La registrazione di una chiave rimuove un JWKS URI memorizzato e il salvataggio di un JWKS URI rimuove le chiavi registrate, quindi le due origini non coesistono mai.

Tre impostazioni richiedono una chiave: **Private Key JWT**, **Mutual TLS (certificato autofirmato)** e **Richiedi un request object firmato**. Finché una di esse è attiva e non è registrata né una chiave né un JWKS URI, la scheda delle impostazioni OIDC si apre con un avviso che rimanda alla scheda Chiavi client. Le chiavi possono anche essere aggiunte in anticipo, prima di cambiare metodo. Per Mutual TLS con certificato autofirmato, carichi il **certificato** client stesso anziché una semplice chiave pubblica: la connessione viene autenticata confrontando il certificato presentato con quello registrato.

La chiave privata non lascia mai l'applicazione.

### FAPI 1.0 Advanced

Alcuni ecosistemi (in particolare i sistemi di open banking meno recenti) impongono il precedente profilo **FAPI 1.0 Advanced**. È disponibile con l'abbonamento Pro e aggiunge tre requisiti a tutto quanto elencato sopra:

- **Risposte di autorizzazione firmate (JARM)**: la risposta a una richiesta di autorizzazione viene restituita come JWT firmato anziché come semplici parametri URL, così l'applicazione può verificare che non sia stata manomessa nel browser. Per il profilo non è facoltativo: un'applicazione con FAPI 1.0 Advanced deve richiedere il response mode JWT, altrimenti le sue richieste di autorizzazione vengono rifiutate.
- **Request object firmati (JAR)**: i parametri di autorizzazione vengono accettati solo all'interno di un JWT firmato con la chiave dell'applicazione stessa, e tale JWT non può essere valido per più di un'ora.
- **Access token associati al certificato (mTLS)**: nei deployment dedicati con un edge Mutual TLS, gli access token sono legati al certificato client TLS dell'applicazione, come richiesto dal profilo.

Tutti vengono imposti automaticamente una volta selezionato il profilo e sono elencati come imposti nella scheda delle impostazioni OIDC. Tornando a FAPI 2.0 o a nessun profilo vengono nuovamente rimossi.

> **Nota:** Nei deployment senza edge Mutual TLS, gli access token di questo profilo vengono invece vincolati con DPoP, che il profilo stesso non accetta. Contatti il supporto se un'integrazione deve essere certificata rispetto al profilo completo.

## Certificati di firma e crittografia [#signing-and-encryption-certificates]

Le applicazioni SAML e WS-Federation utilizzano un certificato che la piattaforma genera automaticamente alla creazione dell'applicazione. Non lo si modifica direttamente; il certificato pubblico, l'impronta digitale e un URL dei metadati sono mostrati in sola lettura, così può fornirli all'applicazione.

Se un certificato è prossimo alla scadenza o deve essere sostituito, utilizzi **Rinnova certificato** in **Azioni distruttive**. L'applicazione deve quindi essere aggiornata con il nuovo certificato (oppure reimporti l'URL dei metadati). Le chiavi di firma alla base di questi certificati sono gestite centralmente, vedere [Chiavi di firma](https://dts-identity.com/it/docs/settings/signing-keys.md).

## Durata dei token e logout [#token-lifetimes-and-logout]

- **OIDC**: imposti la **durata dell'ID token** e una **durata massima dell'autenticazione** facoltativa (che impone una nuova autenticazione quando la sessione è più vecchia del limite). Configuri il comportamento di logout tramite i **post-logout redirect URI** e il **back-channel logout URI**.
- **SAML**: la validità delle Assertion è controllata dalla piattaforma; configuri il **Single Logout** tramite l'URL SLO del Service Provider.
- **WS-Federation**: imposti la **durata del token** direttamente sull'applicazione.

La durata dei token machine-to-machine e API è regolata dall'API che protegge, vedere [API](https://dts-identity.com/it/docs/integrations/apis.md).

## Assegnare le applicazioni agli utenti [#assigning-applications-to-users]

La registrazione di un'applicazione non concede a nessuno l'accesso a essa. Decide chi può utilizzarla nella scheda **Assegnazioni** dell'applicazione, dove può assegnarla a:

- singoli **utenti**,
- **gruppi**, vedere [Gruppi](https://dts-identity.com/it/docs/directories/groups.md),
- intere **directory**, vedere [Directory utenti](https://dts-identity.com/it/docs/directories/user-directories.md),
- **organizzazioni** (con l'add-on CIAM): l'app viene aggiunta all'**insieme approvato** dell'organizzazione; i suoi amministratori la ricevono automaticamente, mentre gli altri membri vengono [autorizzati singolarmente](https://dts-identity.com/it/docs/directories/organizations.md#application-access).

Gli utenti assegnati direttamente sono elencati per tipo di pubblico: **Dipendenti** e **Customers** hanno ciascuno una propria sezione e un proprio conteggio nella scheda, e in entrambi i casi l'assegnazione può essere revocata da lì. La concessione da questa scheda è offerta solo per i **dipendenti** e il selettore è limitato a essi.

Agli utenti esterni un'applicazione non viene concessa singolarmente. La raggiungono tramite la propria directory, tramite un gruppo oppure, come membri di un'organizzazione, tramite l'[autorizzazione individuale](https://dts-identity.com/it/docs/directories/organizations.md#application-access) limitata alle applicazioni approvate per tale organizzazione. Volutamente non esiste alcuna concessione per singolo utente al di fuori di tale insieme approvato, sia per i clienti aziendali sia per i consumatori.

La revoca non è mai limitata: un'assegnazione esistente può sempre essere rimossa, anche se non potrebbe essere creata con le regole attuali. È ciò che consente di ripulire le assegnazioni di un tenant aggiornato da una regola precedente.

Ogni assegnazione può facoltativamente avere una **data di inizio** e una **data di scadenza**, così l'accesso inizia o termina automaticamente. Le assegnazioni determinano anche il [provisioning](https://dts-identity.com/it/docs/integrations/application-provisioning.md): il provisioning di un utente in un'applicazione a valle avviene solo finché l'utente dispone di un'assegnazione attiva.

È l'assegnazione a governare l'accesso: **non esiste un interruttore del metodo di accesso per singola app**. I metodi di accesso che un utente vede sono determinati dalla directory o dalla connessione a cui appartiene, non da un interruttore sull'applicazione.

> **Nota:** A seconda del Suo abbonamento, può consentire agli utenti di **richiedere l'accesso** a un'applicazione in autonomia e instradare tali richieste attraverso un [workflow di approvazione](https://dts-identity.com/it/docs/workflows.md) anziché assegnarle direttamente. Vedere [Criteri di autenticazione e di assegnazione per applicazione](#per-application-authentication-and-assignment-policies).

> **Nota:** Quando un'applicazione appartiene a un [workspace](https://dts-identity.com/it/docs/governance/workspaces.md) con **I membri del workspace gestiscono l'accesso** attivo, solo i membri del workspace con l'autorizzazione **Gestire gli accessi** (oltre ai responsabili e agli amministratori completi) possono assegnarne o revocarne l'accesso.

## Criteri di autenticazione e di assegnazione per applicazione [#per-application-authentication-and-assignment-policies]

Nella scheda **Criteri** dell'applicazione si impostano due aspetti indipendenti: con quale livello di sicurezza gli utenti devono autenticarsi per raggiungere l'app e se le assegnazioni richiedono un workflow di approvazione.

**Requisito di autenticazione**: ne scelga uno:

- **Predefinito**: utilizza i requisiti di autenticazione standard della piattaforma.
- **Always require MFA**: ogni accesso a questa applicazione richiede un secondo fattore.
- **Applicare un criterio di autenticazione**: collega un criterio di accesso condizionale che decide *quando* sono richiesti step-up o MFA, in base a segnali come posizione di rete, orario o rischio. Vedere [Criteri di autenticazione](https://dts-identity.com/it/docs/security/conditional-access/authentication-policies.md).

**Criteri di assegnazione** (richiedono l'add-on workflows):

- **Users may request access**: gli utenti richiedono questa app in autonomia tramite un workflow di approvazione self-service anziché attendere che un amministratore la assegni, facendo riferimento a un [workflow di approvazione](https://dts-identity.com/it/docs/workflows/approval-flows.md) da Lei selezionato.

Per limitare *chi* può assegnare questa applicazione, la inserisca in un [workspace](https://dts-identity.com/it/docs/governance/workspaces.md) con accesso gestito. Per i fattori disponibili e il funzionamento dello step-up, vedere [Autenticazione a più fattori](https://dts-identity.com/it/docs/security/multi-factor-authentication.md).

## Aggiungere il provisioning al SSO

Single Sign-On e provisioning in uscita sono **interruttori indipendenti sulla stessa applicazione**. Configuri prima l'SSO affinché gli utenti possano accedere, quindi attivi facoltativamente il [Provisioning delle applicazioni](https://dts-identity.com/it/docs/integrations/application-provisioning.md), così la piattaforma crea e gestisce anche gli account nell'app connessa. Può utilizzarli singolarmente o insieme.

## Riferimento

| Termine | Significato |
|---|---|
| Client ID | L'identificatore pubblico dell'applicazione presso la piattaforma. |
| Client secret | La credenziale riservata che un'applicazione web o machine-to-machine utilizza per autenticarsi. |
| Public client | Un'app (single-page, nativa, per dispositivi) che non può custodire un secret e utilizza invece PKCE. |
| Token exchange | Un grant OIDC che scambia un token con un altro, così un servizio può chiamare un'API a valle come l'utente originale. |
| Redirect URI | Un URL consentito a cui la piattaforma può rimandare l'utente dopo l'accesso; la corrispondenza deve essere esatta. |
| URL ACS | L'endpoint del Service Provider SAML che riceve le Assertion. |
| Realm | L'identificatore della Relying Party WS-Federation. |
| Proprietario | Un utente responsabile di un'applicazione; si abbina all'accesso amministrativo delegato limitato ai propri oggetti. |
| Assegnazione | Una concessione che consente a un utente, gruppo, directory o organizzazione di utilizzare un'applicazione, facoltativamente limitata nel tempo. |

## Risoluzione dei problemi

- **L'applicazione segnala una mancata corrispondenza del redirect URI.** I redirect URI devono corrispondere esattamente, inclusi schema, host, porta, percorso e barra finale. Aggiunga all'elenco dei redirect URI l'URI preciso inviato dall'applicazione (ne controlli la richiesta). Le wildcard non sono accettate.
- **L'accesso non riesce subito dopo la rotazione del client secret.** Il secret precedente smette di funzionare immediatamente al momento della rotazione. Aggiorni il secret nella configurazione dell'applicazione e si assicuri che sia in uso un solo secret alla volta.
- **L'accesso SAML non riesce con un errore di firma o di certificato.** Verifichi che il Service Provider consideri attendibile il certificato di firma attuale e che il suo orologio sia sincronizzato. Una grande differenza di orario tra i due sistemi fa apparire le Assertion scadute o non ancora valide.
- **Un utente non riesce a vedere o ad aprire l'applicazione.** L'accesso viene concesso, non è automatico. Assegni l'applicazione all'utente (direttamente oppure tramite un gruppo, una directory o un'organizzazione). Senza un'assegnazione l'applicazione non compare nel launcher dell'utente e l'accesso interattivo viene rifiutato.

Vedere anche il [glossario](https://dts-identity.com/it/docs/reference/glossary.md).
