> ## Documentation Index
> Fetch the complete documentation index at: https://zeropath.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Regras Personalizadas

> Crie e gerencie regras SAST personalizadas usando linguagem natural para aplicar políticas de segurança específicas da sua organização

<h2 id="overview">
  Visão Geral
</h2>

As regras personalizadas permitem definir políticas de segurança em linguagem natural que a ZeroPath avalia durante scans completos nos repositórios selecionados. Em vez de escrever regras complexas de correspondência de padrões, descreva o que você quer verificar e a IA da ZeroPath a aplica em toda a sua base de código.

<h2 id="creating-rules">
  Criando Regras
</h2>

<h3 id="from-the-dashboard">
  Pelo Dashboard
</h3>

1. Navegue até [**Rules**](https://zeropath.com/app/rules) no dashboard da ZeroPath e selecione a aba **Custom Rules**.
2. Clique em **"Add Rule"**.
3. Dê à regra um **nome** descritivo.
4. Escreva sua regra em linguagem natural. Por exemplo:

   * *"Sinalize qualquer endpoint de API que retorne endereços de e-mail de usuários sem que o chamador tenha escopo de admin"*
   * *"Encontre instruções de log que incluam corpos de requisição que possam conter senhas ou tokens"*
   * *"Verifique se todas as consultas ao banco de dados usam consultas parametrizadas em vez de concatenação de strings"*

   O editor de regras inclui exemplos clicáveis de regras que você pode usar como ponto de partida.
5. Opcionalmente, defina um **escopo de arquivos** usando um padrão glob (por exemplo, `src/api/**`, `*.py`) para limitar a regra a arquivos específicos. O padrão é todos os arquivos.
6. Escolha o **escopo de repositórios**: aplique a regra a **todos os repositórios** (incluindo quaisquer adicionados no futuro) ou selecione **repositórios específicos**. Você também pode atribuir **tags** para organizar suas regras.
7. Salve a regra.

<h3 id="from-the-api">
  Pela API
</h3>

As regras podem ser gerenciadas por meio da API v2:

```bash theme={null}
# Create a rule scoped to specific repositories
curl -X POST https://zeropath.com/api/v2/rules/create \
  -H "Content-Type: application/json" \
  -H "X-ZeroPath-API-Token-Id: your-token-id" \
  -H "X-ZeroPath-API-Token-Secret: your-token-secret" \
  -d '{
    "organizationId": "your-org-id",
    "name": "Require Auth on API Endpoints",
    "description": "All API endpoints must require authentication",
    "rule": "All API endpoints must require authentication before processing requests",
    "repositoryIds": ["repo-id-1", "repo-id-2"]
  }'
```

Para aplicar uma regra a todos os repositórios da organização, passe `allRepositories: true` em vez de `repositoryIds`:

```bash theme={null}
# Create a rule that applies to all repositories
curl -X POST https://zeropath.com/api/v2/rules/create \
  -H "Content-Type: application/json" \
  -H "X-ZeroPath-API-Token-Id: your-token-id" \
  -H "X-ZeroPath-API-Token-Secret: your-token-secret" \
  -d '{
    "organizationId": "your-org-id",
    "name": "No Hardcoded Secrets",
    "rule": "No hardcoded credentials or API keys in source code",
    "allRepositories": true
  }'
```

Para limitar o escopo de uma regra a todos os repositórios com tags específicas, use `scope: "tags"` com `tagIds`:

```bash theme={null}
# Create a rule scoped to repositories with specific tags
curl -X POST https://zeropath.com/api/v2/rules/create \
  -H "Content-Type: application/json" \
  -H "X-ZeroPath-API-Token-Id: your-token-id" \
  -H "X-ZeroPath-API-Token-Secret: your-token-secret" \
  -d '{
    "organizationId": "your-org-id",
    "name": "Require Auth on Internal APIs",
    "rule": "All internal API endpoints must require authentication",
    "scope": "tags",
    "tagIds": ["tag-id-1", "tag-id-2"]
  }'
```

Você também pode usar o parâmetro explícito `scope` (`"allRepositories"`, `"repositories"` ou `"tags"`) em qualquer requisição de criação ou atualização para tornar o escopo pretendido inequívoco:

```bash theme={null}
# Explicitly set scope to all repositories
curl -X POST https://zeropath.com/api/v2/rules/create \
  -d '{ "scope": "allRepositories", ... }'

# Explicitly set scope to specific repositories
curl -X POST https://zeropath.com/api/v2/rules/create \
  -d '{ "scope": "repositories", "repositoryIds": ["repo-id-1"], ... }'
```

<Info>
  Você não pode combinar `allRepositories` e `repositoryIds` na mesma requisição. Use um ou outro ao criar ou atualizar uma regra. Ao usar `scope: "tags"`, não passe `repositoryIds` nem `allRepositories`.
</Info>

<h2 id="how-rules-are-evaluated">
  Como as Regras São Avaliadas
</h2>

Durante cada scan, a ZeroPath:

1. **Identifica as aplicações** no seu repositório (serviços, módulos, pontos de entrada).
2. **Avalia cada regra personalizada** contra cada aplicação em contexto.
3. **Reporta violações** como achados, junto aos resultados de SAST, SCA e outros.

As violações de regras personalizadas aparecem no mesmo fluxo de achados que os demais resultados de scan — com severidade, confiança, arquivo afetado e orientação de remediação.

<h2 id="rule-scope">
  Escopo das Regras
</h2>

As regras podem ter escopo em diferentes níveis:

| Escopo          | Aplica-se A                                  |
| --------------- | -------------------------------------------- |
| **Organização** | Todos os repositórios da organização         |
| **Tag**         | Todos os repositórios com uma tag específica |
| **Repositório** | Um único repositório                         |

Regras com escopo de organização se aplicam automaticamente a repositórios recém-adicionados, sem nenhuma atualização manual. Regras com escopo de tag se aplicam automaticamente a todos os repositórios que pertencem às tags selecionadas, e o acesso é atualizado dinamicamente conforme repositórios entram ou saem de uma tag. Ao listar regras pela API, cada regra inclui um campo `scope` (`"allRepositories"`, `"repositories"` ou `"tags"`) indicando como seu escopo está definido.

As regras seguem a mesma cascata de herança **org → tag → repo** das configurações do scanner. Regras no nível de repositório complementam (e não substituem) as regras nos níveis de organização e tag.

<h2 id="managing-rules">
  Gerenciando Regras
</h2>

Pelo dashboard ou pela API, você pode:

* **Listar** todas as regras da sua organização — regras que se aplicam a todos os repositórios exibem **"All Repositories"**, e regras com escopo de tag exibem o número de tags atribuídas (por exemplo, **"2 Tags"**) em vez de uma contagem numérica de repositórios
* **Visualizar** a definição, o escopo e os metadados de uma regra
* **Atualizar** o nome, a descrição, a definição em linguagem natural ou o escopo de uma regra (passe `allRepositories: true` para aplicar a todos os repositórios, ou `repositoryIds` para limitar a repositórios específicos)
* **Excluir** regras que não são mais necessárias

<h2 id="custom-rules-only-mode">
  Modo Somente Regras Personalizadas
</h2>

Para organizações ou repositórios que desejam executar **apenas** suas regras personalizadas, habilite a opção **Custom rules only** nas configurações do scanner. Quando habilitada, a ZeroPath desativa todos os módulos de scan integrados — incluindo SAST, SCA, IaC, Secrets e EOL — e avalia apenas suas regras personalizadas em linguagem natural contra as fontes identificadas. Essa configuração pode ser definida no nível da organização, da tag ou de um repositório individual, seguindo a cascata padrão de herança de configurações.

<h2 id="rule-packs">
  Pacotes de Regras
</h2>

Além das regras personalizadas, a ZeroPath oferece **Rule Packs** — coleções curadas de regras pré-construídas publicadas pela ZeroPath que cobrem padrões de segurança comuns e requisitos de conformidade. Você pode navegar pelos pacotes de regras disponíveis na aba **Rule Packs** da página [Rules](https://zeropath.com/app/rules?tab=packs) e habilitar os que forem relevantes para a sua organização.

Os pacotes de regras complementam suas regras personalizadas. Quando um pacote de regras está habilitado, suas regras são avaliadas durante os scans junto com quaisquer regras personalizadas que você tenha definido.

<h2 id="best-practices">
  Boas Práticas
</h2>

1. **Seja específico** — "Todos os endpoints de API devem validar o token de sessão do usuário antes de processar" é melhor que "As APIs devem ser seguras".
2. **Uma política por regra** — crie regras separadas para preocupações separadas, para que as violações sejam acionáveis.
3. **Comece amplo e depois refine** — comece com políticas de alto nível e adicione detalhes com base nas violações que você observar.
4. **Use tags para regras específicas de cada equipe** — equipes diferentes podem ter requisitos de segurança diferentes; delimite o escopo das regras usando tags.