> For the complete documentation index, see [llms.txt](https://wiki.datadike.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://wiki.datadike.com/pt/pam/administration/integrations/vulnerability-scanners.md).

# Scanners de vulnerabilidade

Dar ao Tenable, ao Qualys ou a qualquer outro scanner a credencial privilegiada que uma varredura autenticada exige, buscada no cofre na hora da varredura em vez de guardada dentro do scanner.

Um scanner de vulnerabilidade enxerga muito pouco de fora de um host. Sem autenticação, ele só consegue inferir versões pelo que a rede expõe; autenticado, ele entra e lê os pacotes instalados, o nível de correção e a configuração real. Essa é a diferença entre um palpite plausível e um achado sobre o qual se pode agir, e é por isso que toda política séria de varredura pede uma credencial privilegiada.

O problema é onde essa credencial mora. Um scanner configurado do jeito comum guarda uma senha de domínio ou de root no repositório dele, copiada do cofre, rotacionada à mão, e legível por quem administra o scanner.

## O que é isto e quando usar

Em vez de guardar a senha, o scanner **a recebe no momento da varredura**, buscada no cofre por uma identidade de aplicação criada aqui.

O que isso compra:

|                       | Credencial guardada no scanner                      | Credencial buscada no cofre                                                                             |
| --------------------- | --------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| Onde a senha mora     | No scanner e no cofre                               | Só no cofre                                                                                             |
| Depois de uma rotação | A varredura falha até alguém atualizar o scanner    | A próxima busca devolve a senha nova                                                                    |
| Quem consegue ler     | Qualquer um com direitos administrativos no scanner | Ninguém. O valor nunca é exibido                                                                        |
| Evidência de uso      | Os logs do próprio scanner                          | Cada busca está na trilha de auditoria, com a aplicação que chamou, a conta, o IP de origem e o horário |

## Como a credencial chega ao scanner

A solução publica uma API e o scanner a chama. **Não existe conector de encaixe direto** para Tenable ou Qualys, então a busca precisa ser ligada de uma destas duas formas:

| Padrão                       | Como funciona                                                                                                      | Quando escolher                                                     |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------- |
| **Busca antes da varredura** | Um script curto roda antes da varredura, recupera a credencial e a entrega ao scanner ou ao processo que o dispara | A escolha usual. Funciona com qualquer scanner e qualquer agendador |
| **Extensão da plataforma**   | O mecanismo de script ou plugin do próprio scanner chama o endpoint diretamente                                    | Onde a plataforma suporta e você não quer uma etapa externa         |

O script não é trabalho do zero: a solução serve um cliente funcional para seis linguagens na aba **SDKs** da aplicação, e a recuperação é uma única chamada. Veja [Acesso aplicação para aplicação](https://wiki.datadike.com/pt/pam/administration/integrations/application-to-application.md) para o endpoint e a assinatura.

{% hint style="warning" %}
**Planeje trabalho de integração do lado do scanner.** A credencial vem de uma API documentada com clientes de referência, e não de um checkbox no scanner. O esforço é pequeno e pontual, mas não é zero, e pertence ao plano do projeto.
{% endhint %}

## Antes de começar

* Os ativos a varrer já registrados, cada um com a **conta** com que a varredura vai autenticar. Veja [Contas gerenciadas](https://wiki.datadike.com/pt/pam/administration/accounts/managed-accounts.md).
* A solução alcançável a partir do scanner por **HTTPS**, com um certificado em que a máquina que chama confie.
* Os **endereços IP de origem** dos motores do scanner. Não os da sua estação, os das máquinas que efetivamente vão fazer as chamadas.
* Uma decisão de granularidade: **uma aplicação por scanner**, para que cada um tenha segredo, escopo, grupo de IP e trilha de auditoria próprios. Compartilhar uma aplicação entre várias ferramentas destrói a atribuição que você montou isso para ter.

## Passos

1. **Crie a aplicação.** Em **Configurações do Sistema › A2A**, crie uma com o nome do consumidor, por exemplo `tenable-scanner-prod`.
2. **Limite o escopo às contas a varrer.** Conceda as contas da política de varredura daquele scanner e nada além. Um scanner que pode buscar toda credencial do cofre é um risco pior do que o que você removeu.
3. **Restrinja o grupo de IP** aos motores do scanner, como endereços ou faixas CIDR. **Ele permite qualquer endereço por padrão**, o que anula o sentido de um segredo com escopo.
4. **Revele o segredo** e coloque-o no repositório de segredos do próprio host do scanner, ou no do agendador que executa a busca.
5. **Escreva a etapa de busca**, partindo do cliente na sua linguagem, na aba **SDKs**.
6. **Execute a busca à mão uma vez**, a partir do motor que vai fazer a varredura, e confirme que a credencial volta.
7. **Só então agende a varredura.**

{% hint style="danger" %}
Revelar o segredo de novo **substitui o anterior**. Todo motor que ainda esteja com o valor antigo para de autenticar, então trate a rotação como mudança, e não como forma de consultar o valor.
{% endhint %}

{% hint style="warning" %}
Uma aplicação só alcança contas **da própria organização**. Referir-se a um ativo de outro tenant não resolve nada na hora da varredura: a chamada informa que a conta não foi encontrada, e a varredura cai silenciosamente para resultados não autenticados.
{% endhint %}

## Como verificar que funcionou

Uma varredura que termina não é prova. Uma varredura não autenticada também termina, com muito menos achados e sem erro que diga o motivo.

1. **Confirme que a API responde.** A partir do próprio host do scanner:

   ```bash
   curl -s "https://<sua-instancia>/api/health/"
   ```

   Uma instância saudável devolve `"status": true`. Uma falha aqui é rede, nome de host ou certificado, não o segredo.
2. **Execute a etapa de busca à mão** a partir do motor que vai varrer, e não de uma estação em outro endereço.
3. **Varra um ativo e leia a trilha de auditoria.** Confirme que há uma retirada de credencial registrada para aquela conta, a partir do IP do scanner, no horário da varredura. Uma varredura com resultados e sem registro de retirada não está usando o cofre, está usando credencial ainda guardada no scanner.
4. **Compare a contagem de achados** com uma varredura não autenticada anterior do mesmo host. Varredura autenticada reporta bem mais, e a saída da checagem declara que a autenticação funcionou. Se os números parecerem os da varredura antiga, o login falhou e o scanner caiu para o modo anterior.
5. **Prove que a restrição de IP funciona.** Chame de outro endereço e confirme a recusa. Lista de permissão que você nunca testou é lista em que você não pode confiar.
6. **Prove que a rotação é transparente.** [Rotacione](https://wiki.datadike.com/pt/pam/administration/accounts/rotation.md) a senha da conta e varra de novo sem tocar no scanner. Ele precisa continuar autenticando.

## Erros comuns

| Sintoma                                              | Causa                                                                       | Correção                                                                                                   |
| ---------------------------------------------------- | --------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| A busca falha com 401                                | A assinatura, o relógio ou o endereço de origem                             | Confira o formato da data e o relógio do host, depois confirme que o endereço do motor está no grupo de IP |
| Funciona da sua estação, mas não do scanner          | Só o seu endereço está no grupo de IP                                       | Acrescente os endereços dos motores do scanner. É para isso que serve a restrição                          |
| 404 para um ativo que você vê no console             | O ativo pertence a outra organização                                        | Uma aplicação alcança apenas a própria organização                                                         |
| 404 para o ativo certo                               | O nome não bate exatamente com o cadastro                                   | Use o nome do ativo e o nome da conta exatamente como cadastrados                                          |
| Alguns hosts autenticam e outros não                 | Aquelas contas estão fora do escopo da aplicação                            | Acrescente-as, ou varra-as com uma aplicação separada                                                      |
| Tudo funcionava e toda varredura parou de autenticar | O segredo foi revelado de novo, o que o substitui                           | Distribua o segredo novo a todos os motores                                                                |
| A varredura autentica mas acha quase nada            | A conta não tem privilégio suficiente no alvo para uma checagem autenticada | Corrija o privilégio da conta no ativo. O cofre entregou a credencial corretamente                         |

## Referência de campos

O que decidir para cada scanner, antes de criar qualquer coisa:

| Decisão               | Orientação                                                                                                                            |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| **Nome da aplicação** | Uma por scanner, com o nome da ferramenta e do ambiente, `tenable-scanner-prod`                                                       |
| **Escopo de contas**  | As contas da política de varredura daquele scanner, e nenhuma outra                                                                   |
| **Grupo de IP**       | Todo motor do scanner que vai chamar, como endereços `/32` ou a faixa CIDR dos motores                                                |
| **Conta por ativo**   | Uma conta de varredura dedicada, com exatamente o privilégio que as checagens exigem, rotacionada como qualquer credencial gerenciada |

A revogação é imediata: **desative** a aplicação e o scanner para de receber credenciais, sem que nada mude no alvo.

## Páginas relacionadas

* [Acesso aplicação para aplicação](https://wiki.datadike.com/pt/pam/administration/integrations/application-to-application.md), o endpoint, a assinatura e os clientes de referência
* [API](https://wiki.datadike.com/pt/pam/reference/api.md), como assinar uma requisição
* [O cofre de credenciais](https://wiki.datadike.com/pt/pam/administration/accounts/vault.md), onde mora a credencial de varredura
* [Contas gerenciadas](https://wiki.datadike.com/pt/pam/administration/accounts/managed-accounts.md), como cadastrar a conta com que a varredura autentica
* [Rotacionar credenciais](https://wiki.datadike.com/pt/pam/administration/accounts/rotation.md), por que o scanner nunca precisa ser atualizado depois de uma rotação
* [Trilha de auditoria](https://wiki.datadike.com/pt/pam/administration/audit/audit-trail.md), onde cada retirada de credencial fica registrada
