Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Convalida di clienti e destinatari per i provider OIDC
<a name="oidc-validation"></a>

Quando si aggiunge una fonte di identità a un policy store, Verified Permissions dispone di opzioni di configurazione che verificano che l'ID e i token di accesso vengano utilizzati come previsto. Questa convalida avviene durante l'elaborazione delle richieste API`IsAuthorizedWithToken`. `BatchIsAuthorizedWithToken` Il comportamento differisce tra ID e token di accesso Amazon Cognito e tra fonti di identità OIDC. Con i provider di pool di utenti di Amazon Cognito, Verified Permissions può convalidare l'ID client sia nell'ID che nei token di accesso. Con i provider OIDC, Verified Permissions può convalidare l'ID client nei token ID e il pubblico nei token di accesso.

Un *ID client* è un identificatore associato all'istanza del provider di identità utilizzata dall'applicazione, ad esempio. `1example23456789` Un *pubblico* è un percorso URL associato al *relying party*, o destinazione, previsto per il token di accesso, ad esempio. `https://mytoken.example.com` Quando si utilizzano i token di accesso, l'`aud`affermazione è sempre associata al pubblico.

I token ID OIDC hanno un `aud` claim che contiene client IDs, ad esempio. `1example23456789`

I token di accesso OIDC hanno un'`aud`attestazione che contiene l'URL del pubblico per il token, ad esempio, e un'`client_id`attestazione che contiene client`https://myapplication.example.com`, ad esempio. IDs `1example23456789`

Quando configuri il tuo policy store, inserisci uno o più valori per la **convalida dell'audience** che il tuo policy store utilizzerà per convalidare il pubblico di un token.
+ **Token ID**: Verified Permissions convalida l'ID client verificando che almeno un membro del client IDs nell'`aud`attestazione corrisponda a un valore di convalida del pubblico.
+ **Token di accesso**: le autorizzazioni verificate convalidano il pubblico verificando che l'URL nell'attestazione corrisponda a un valore di convalida del `aud` pubblico. Se non esiste alcuna `aud` affermazione, il pubblico può essere convalidato utilizzando le attestazioni o. `cid` `client_id` Rivolgiti al tuo provider di identità per conoscere la dichiarazione e il formato corretti relativi al pubblico.

## Autorizzazione lato client per JWTs
<a name="oidc-validation-other-idp"></a>

Potresti voler elaborare i token web JSON nella tua applicazione e passare le relative dichiarazioni a Verified Permissions senza utilizzare una fonte di identità del Policy Store. Puoi estrarre gli attributi della tua entità da un token Web JSON (JWT) e analizzarli in autorizzazioni verificate.

Questo esempio mostra come è possibile chiamare le autorizzazioni verificate da un'applicazione che utilizza un JWT.¹

```
async function authorizeUsingJwtToken(jwtToken) {
  
    const payload = await verifier.verify(jwtToken);
   
    let principalEntity = {
        entityType: "PhotoFlash::User", // the application needs to fill in the relevant user type
        entityId: payload["sub"], // the application need to use the claim that represents the user-id
    };
    let resourceEntity = {
        entityType: "PhotoFlash::Photo", //the application needs to fill in the relevant resource type
        entityId: "jane_photo_123.jpg", // the application needs to fill in the relevant resource id
    };
    let action = {
        actionType: "PhotoFlash::Action", //the application needs to fill in the relevant action id
        actionId: "GetPhoto", //the application needs to fill in the relevant action type
    };
    let entities = {
        entityList: [],
    };
    entities.entityList.push(...getUserEntitiesFromToken(payload));
    let policyStoreId = "PSEXAMPLEabcdefg111111"; // set your own policy store id
    
    const authResult = await client
        .isAuthorized({
        policyStoreId: policyStoreId,
        principal: principalEntity,
        resource: resourceEntity,
        action: action,
        entities,
        })
        .promise();
        
    return authResult; 
  
}

function getUserEntitiesFromToken(payload) {
  let attributes = {};
  let claimsNotPassedInEntities = ['aud', 'sub', 'exp', 'jti', 'iss'];
  Object.entries(payload).forEach(([key, value]) => {
    if (claimsNotPassedInEntities.includes(key)) {
        return;
    }
    if (Array.isArray(value)) {
      var attibuteItem = [];
      value.forEach((item) => {
        attibuteItem.push({
          string: item,
        });
      });
      attributes[key] = {
        set: attibuteItem,
      };
    } else if (typeof value === 'string') {
      attributes[key] = {
        string: value,
      } 
    } else if (typeof value === 'bigint' || typeof value ==='number') {
        attributes[key] = {
            long: value,
          } 
    } else if (typeof value === 'boolean') {
        attributes[key] = {
            boolean: value,
       } 
    }

  });

  let entityItem = {
    attributes: attributes,
    identifier: {
      entityType: "PhotoFlash::User",
      entityId: payload["sub"], // the application needs to use the claim that represents the user-id
    }
  };
  return [entityItem];
}
```

¹ Questo esempio di codice utilizza la [aws-jwt-verify](https://github.com/awslabs/aws-jwt-verify)libreria per la verifica JWTs della compatibilità con OIDC. IdPs