> For the complete documentation index, see [llms.txt](https://docs.caf.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.caf.io/caf-api/caf-api-pt-br/api-mobile-descontinuado/authentication.md).

# Autenticação (descontinuado)

Autentique a API Mobile com sua chave de acesso para usar os recursos disponíveis.

Para acessar os recursos da CAF usando esta API REST, você primeiro precisará de uma Chave Móvel. Este é um token fornecido pela CAF para autorização e é usado pelo cliente ao fazer cada chamada de API.

As chaves de API são um segredo que apenas o cliente e a CAF conhecem. Assim como a autenticação Basic, a autenticação baseada em chave de API só é considerada segura se usada em conjunto com outros mecanismos de segurança, como HTTPS/SSL.

## **Obtendo suas chaves**

Usuários da conta com as permissões adequadas poderão recuperar ou criar sua chave móvel na Trust Platform seguindo as etapas abaixo:

1. Depois de fazer login na [Plataforma de Confiança CAF](https://trust.caf.io), clique no botão de configurações (ícone de engrenagem) na área de navegação do cliente e depois selecione **"Integração de API"** nas opções.
2. Certifique-se de que a aba ativa seja **"Chaves móveis"**, nesta página você pode ver suas chaves e os produtos vinculados. Clique **"copiar"** para salvar na área de transferência.
3. Para criar uma nova, clique no **"Nova chave"** botão e selecione quais produtos o token poderá executar e um nome para a chave; em seguida, clique em **"Gerar chave"**. A página mostrará `clientId` e `clientSecret`, mantenha-o seguro.

{% hint style="info" %}
Se o ambiente utilizado for o ambiente de homologação (beta), as chaves de acesso devem ser geradas no mesmo ambiente: [Trust Platform BETA](https://beta.trust.caf.io).
{% endhint %}

## **Gerando seu token**

### **Método recomendado**

As etapas a seguir descrevem como você pode gerar tokens que são válidos apenas para um usuário específico. Esta é a forma recomendada de gerar e distribuir os tokens, pois ela limita um possível ataque a uma única conta de usuário.

1. Em algum ponto do fluxo da sua aplicação, crie um JWT com a estrutura do exemplo abaixo;
   * Lembre-se de substituir os campos `{clientId}`, `{peopleId}` e `{expiresAt}`
   * Todos os campos são altamente recomendados; você pode ver qual é obrigatório na parte inferior desta página
2. Assine o token com seu `clientSecret`;
3. Use este token para autenticar chamadas da API ou do SDK.

#### Exemplo:

{% tabs %}
{% tab title="Cabeçalho" %}

```json
{
    "alg": "HS256",
    "typ": "JWT"
}
```

{% endtab %}

{% tab title="Carga útil" %}

```json
{
    "iss": "{clientId}", // string
    "exp": {expiresAt}, // número
    "peopleId": "{peopleId}" // string
}
```

{% endtab %}
{% endtabs %}

### **Método não recomendado (apenas para testes)**

1. Acesse o site [jwt.io](https://jwt.io/);
2. Mantenha o `Cabeçalho` campo, não altere;
3. Edite o payload, apenas o `iss` campo é obrigatório;
4. Substitua `your-256-bit-secret` por seu `clientSecret`;
5. Acesse **Compartilhar JWT** para copiar o token gerado para a área de transferência;
6. Use este token para autenticar chamadas da API ou do SDK.

### **Parâmetros do payload do JWT**

| **Parâmetro** | **Obrigatório** | **Descrição**                                                                     |
| ------------- | --------------- | --------------------------------------------------------------------------------- |
| `iss`         | Sim             | Seu `clientId`                                                                    |
| `exp`         | Não             | Tempo de expiração (segundos [Unix](https://pt.wikipedia.org/wiki/Era_Unix) time) |
| `peopleId`    | Não             | O CPF (Cadastro de Pessoas Físicas) em que o token será válido                    |

## Melhores práticas para autenticação baseada em token

Para garantir uma integração segura e confiável ao usar autenticação baseada em token com nosso serviço, siga estas práticas recomendadas e evite armadilhas comuns.

### ✅ Práticas recomendadas

| Prática                                         | Descrição                                                                                                                     |
| ----------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| **Gere e assine tokens no servidor**            | Emita sempre JWTs do seu sistema de backend confiável para evitar expor chaves de assinatura.                                 |
| **Use HTTPS em todas as comunicações**          | Evite ataques man-in-the-middle e garanta a criptografia em trânsito.                                                         |
| **Use tempos curtos de expiração para JWTs**    | Minimize a janela para uso indevido do token em caso de interceptação. Os tokens normalmente devem expirar em poucos minutos. |
| **Monitore o uso e o comportamento dos tokens** | Implemente logging e monitoramento para detectar atividades anormais ou suspeitas.                                            |

### ❌ Práticas inseguras

| Prática                                                                | Risco                                                                                         |
| ---------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| **Gerar tokens no frontend**                                           | Expõe suas chaves de assinatura e compromete todo o sistema de autenticação.                  |
| **Armazenar chaves de assinatura ou segredos em apps frontend/mobile** | Segredos no código do lado do cliente podem ser extraídos e usados indevidamente.             |
| **Usar tokens de longa duração**                                       | Aumenta a janela de vulnerabilidade em caso de vazamento.                                     |
| **Codificar segredos diretamente em código controlado por versão**     | Segredos em repositórios de código podem vazar ou ser acessados por usuários não autorizados. |

{% hint style="warning" %}
**Aviso importante sobre autenticação e integrações**

Todas as integrações com as APIs da Caf devem ser implementadas exclusivamente no backend/no lado do servidor. Integrações no lado do cliente ou baseadas em frontend podem ser bloqueadas e aumentam significativamente o risco de exposição das chaves de autenticação.

A Caf monitora continuamente o uso e a exposição das chaves de autenticação. Qualquer chave identificada como exposta, comprometida ou usada em implementações fora das conformidades será imediatamente revogada, o que pode resultar na interrupção da operação associada, sem aviso prévio.

É responsabilidade do integrador garantir a conformidade com os padrões de autenticação recomendados e as melhores práticas de segurança descritos nesta documentação.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.caf.io/caf-api/caf-api-pt-br/api-mobile-descontinuado/authentication.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
