Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Validación de clientes y audiencias para Amazon Cognito
<a name="cognito-validation"></a>

Al añadir una fuente de identidad a un almacén de políticas, Verified Permissions tiene opciones de configuración que comprueban que los identificadores de identidad y de acceso se utilizan según lo previsto. Esta validación se lleva a cabo durante el procesamiento de las solicitudes de `BatchIsAuthorizedWithToken` API `IsAuthorizedWithToken` y las solicitudes de API. El comportamiento difiere entre los identificadores y los identificadores de acceso Amazon Cognito y entre las fuentes de identidad del OIDC. Con los proveedores de grupos de usuarios de Amazon Cognito, Verified Permissions puede validar el ID de cliente tanto en el identificador como en el token de acceso. Con los proveedores de OIDC, Verified Permissions puede validar el ID del cliente en los tokens de ID y la audiencia en los tokens de acceso.

Un *ID de cliente* es un identificador asociado a la instancia del proveedor de identidad que utiliza tu aplicación, por ejemplo. `1example23456789` Una *audiencia* es una ruta URL asociada a la *parte de confianza* prevista, o al destino, del token de acceso, por ejemplo`https://mytoken.example.com`. Cuando se utilizan los tokens de acceso, la `aud` afirmación siempre se asocia a la audiencia.

Amazon Cognito Los identificadores tienen una `aud` declaración que contiene el ID del [cliente de la aplicación](https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-client-apps.html). Los tokens de acceso tienen una `client_id` declaración que también contiene el ID de cliente de la aplicación.

Cuando ingresas uno o más valores para la **validación de la aplicación cliente** en tu fuente de identidad, Verified Permissions compara esta lista de clientes IDs de aplicaciones con la afirmación del token de ID o la `aud` afirmación del token `client_id` de acceso. Verified Permissions no valida la URL del público de una parte que depende para Amazon Cognito las fuentes de identidad.

## Autorización por parte del cliente para JWTs
<a name="identity-sources-other-idp"></a>

Es posible que desee procesar los tokens web JSON en su aplicación y transferir sus solicitudes a Verified Permissions sin utilizar una fuente de identidad del almacén de políticas. Puedes extraer los atributos de tu entidad de un token web JSON (JWT) y analizarlos para convertirlos en permisos verificados.

En este ejemplo, se muestra cómo se pueden invocar permisos verificados desde una aplicación mediante 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];
}
```

¹ En este ejemplo de código se utiliza la [aws-jwt-verify](https://github.com/awslabs/aws-jwt-verify)biblioteca para verificar JWTs si están firmados por un OIDC compatible. IdPs