As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Validação de clientes e públicos para fornecedores de OIDC
<a name="oidc-validation"></a>

Quando você adiciona uma fonte de identidade a um repositório de políticas, as Permissões Verificadas têm opções de configuração que verificam se os tokens de ID e acesso estão sendo usados conforme o esperado. Essa validação acontece no processamento `IsAuthorizedWithToken` e nas solicitações de `BatchIsAuthorizedWithToken` API. O comportamento difere entre tokens de ID e acesso Amazon Cognito e entre fontes de identidade do OIDC. Com os provedores de grupos de usuários do Amazon Cognito, as Permissões Verificadas podem validar a ID do cliente em tokens de ID e de acesso. Com os provedores do OIDC, as Permissões Verificadas podem validar o ID do cliente em tokens de ID e o público em tokens de acesso.

Um *ID de cliente* é um identificador associado à instância do provedor de identidade que seu aplicativo usa, por exemplo`1example23456789`. Um *público* é um caminho de URL associado à *parte confiável ou* ao destino pretendido do token de acesso, por exemplo`https://mytoken.example.com`. Ao usar tokens de acesso, a `aud` reivindicação está sempre associada ao público.

Os tokens de ID do OIDC têm uma `aud` reivindicação que contém o cliente IDs, como. `1example23456789`

Os tokens de acesso do OIDC têm uma `aud` declaração que contém a URL do público do token, como`https://myapplication.example.com`, e uma `client_id` afirmação que contém o cliente IDs, como. `1example23456789`

Ao configurar seu repositório de políticas, insira um ou mais valores para **validação de público** que seu armazenamento de políticas usa para validar o público de um token.
+ **Tokens de ID** — As permissões verificadas validam o ID do cliente verificando se pelo menos um membro do cliente IDs na `aud` reivindicação corresponde a um valor de validação de público.
+ **Tokens de acesso** — as permissões verificadas validam o público verificando se o URL na `aud` declaração corresponde a um valor de validação do público. Se nenhuma `aud` reivindicação existir, o público poderá ser validado usando as `client_id` reivindicações `cid` ou. Verifique com seu provedor de identidade a afirmação e o formato corretos do público.

## Autorização do lado do cliente para JWTs
<a name="oidc-validation-other-idp"></a>

Talvez você queira processar tokens web JSON em seu aplicativo e passar suas reivindicações para Permissões Verificadas sem usar uma fonte de identidade do repositório de políticas. Você pode extrair seus atributos de entidade de um JSON Web Token (JWT) e analisá-los em Permissões verificadas.

Este exemplo mostra como você pode chamar Permissões Verificadas de um aplicativo usando um 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];
}
```

¹ Este exemplo de código usa a [aws-jwt-verify](https://github.com/awslabs/aws-jwt-verify)biblioteca para verificar se a JWTs assinatura é compatível com IdPs OIDC.