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

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 tokens de ID y de acceso, y entre las fuentes de identidad de Amazon Cognito y 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 ejemplohttps://mytoken.example.com. Cuando se utilizan los tokens de acceso, la aud afirmación siempre se asocia a la audiencia.

Los tokens de Amazon Cognito ID tienen una aud declaración que contiene el ID de cliente de la aplicación. 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. Los permisos verificados no validan la URL de una audiencia de una parte de confianza para las fuentes de identidad de Amazon Cognito.

Autorización por parte del cliente para JWTs

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-verifybiblioteca para verificar JWTs si están firmados por un OIDC compatible. IdPs