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 proveedores de OIDC
<a name="oidc-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 tokens de acceso, la `aud` afirmación siempre se asocia a la audiencia.

Los tokens de ID de OIDC tienen una `aud` declaración que contiene el nombre del cliente IDs, por ejemplo. `1example23456789`

Los tokens de acceso de OIDC tienen una `aud` afirmación que contiene la URL de audiencia del token, por ejemplo`https://myapplication.example.com`, y una `client_id` afirmación que contiene el cliente IDs, por ejemplo. `1example23456789`

Al configurar su almacén de políticas, introduzca uno o más valores para la **validación de audiencia** que el almacén de políticas utilice para validar la audiencia de un token.
+ **Tokens de identificación**: Verified Permissions valida el ID del cliente comprobando que al menos un miembro del cliente IDs de la `aud` reclamación coincide con un valor de validación de audiencia.
+ **Tokens de acceso**: los permisos verificados validan la audiencia comprobando que la URL de la notificación coincide con `aud` un valor de validación de audiencia. Si no existe ninguna `aud` reclamación, se puede validar la audiencia mediante las `client_id` afirmaciones `cid` o. Consulta con tu proveedor de identidad cuál es la afirmación y el formato de audiencia correctos.

## Autorización por parte del cliente para JWTs
<a name="oidc-validation-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