Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Validation du client et du public pour les fournisseurs OIDC
<a name="oidc-validation"></a>

Lorsque vous ajoutez une source d'identité à un magasin de politiques, Verified Permissions propose des options de configuration qui vérifient que les jetons d'identification et d'accès sont utilisés comme prévu. Cette validation intervient lors du traitement `IsAuthorizedWithToken` des demandes `BatchIsAuthorizedWithToken` d'API. Le comportement diffère entre les jetons d'identification et d'accès, Amazon Cognito et entre les sources d'identité OIDC. Avec les fournisseurs de groupes d'utilisateurs Amazon Cognito, Verified Permissions peut valider l'ID client à la fois sous forme d'ID et de jetons d'accès. Avec les fournisseurs OIDC, Verified Permissions peut valider l'identifiant du client sous forme de jetons d'identification et l'audience sous forme de jetons d'accès.

Un *ID client* est un identifiant associé à l'instance du fournisseur d'identité utilisée par votre application, par exemple`1example23456789`. Une *audience* est un chemin d'URL associé à la *partie utilisatrice* prévue, ou à la destination, du jeton d'accès, par exemple`https://mytoken.example.com`. Lorsque vous utilisez des jetons d'accès, la `aud` réclamation est toujours associée au public.

Les jetons d'identification OIDC ont une `aud` réclamation qui contient un client IDs, telle que`1example23456789`.

Les jetons d'accès OIDC ont une `aud` réclamation qui contient l'URL d'audience du jeton, telle que`https://myapplication.example.com`, et une `client_id` réclamation qui contient le client IDs, telle que`1example23456789`.

Lorsque vous configurez votre magasin de politiques, entrez une ou plusieurs valeurs pour la **validation d'audience** que votre magasin de politiques utilisera pour valider l'audience d'un jeton.
+ **Jetons d'identification** — Verified Permissions valide l'identifiant du client en vérifiant qu'au moins un membre du client indiqué IDs dans la `aud` réclamation correspond à une valeur de validation d'audience.
+ **Jetons d'accès** : les autorisations vérifiées valident l'audience en vérifiant que l'URL figurant dans la `aud` réclamation correspond à une valeur de validation de l'audience. Si aucune `aud` réclamation n'existe, l'audience peut être validée à l'aide des `client_id` revendications `cid` or. Vérifiez auprès de votre fournisseur d'identité la bonne déclaration d'audience et le bon format.

## Autorisation côté client pour JWTs
<a name="oidc-validation-other-idp"></a>

Vous souhaiterez peut-être traiter les jetons Web JSON dans votre application et transmettre leurs demandes à Verified Permissions sans utiliser de source d'identité de magasin de politiques. Vous pouvez extraire les attributs de votre entité d'un jeton Web JSON (JWT) et les analyser en autorisations vérifiées.

Cet exemple montre comment vous pouvez appeler Verified Permissions depuis une application utilisant 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];
}
```

¹ Cet exemple de code utilise la [aws-jwt-verify](https://github.com/awslabs/aws-jwt-verify)bibliothèque pour vérifier la JWTs signature par OIDC compatible IdPs.