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

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 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 ejemplohttps://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.

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