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

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, et entre les sources d'identité Amazon Cognito et 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 exemple1example23456789. Une audience est un chemin d'URL associé à la partie utilisatrice prévue, ou à la destination, du jeton d'accès, par exemplehttps://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 que1example23456789.

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

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.

Autorisation côté client pour JWTs

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-verifybibliothèque pour vérifier la JWTs signature par OIDC compatible IdPs.