# Como implementar data loss prevention (DLP) para dados de CPF

> Aprenda a implementar uma estratégia de DLP para proteger dados de CPF contra vazamentos, com exemplos de código e políticas práticas.

**Publicado:** 25/08/2025
**Autor:** Redação CPFHub.io
**URL:** https://cpfhub.io/blog/implementar-data-loss-prevention-dlp-cpf

---


DLP (Data Loss Prevention) para dados de CPF é o conjunto de políticas e ferramentas que impede que esse identificador sensível vaze por e-mail, logs, respostas de API ou arquivos não autorizados. A CPFHub.io é projetada com segurança desde a concepção — autenticação via `x-api-key`, sem armazenamento de dados além do necessário — e serve como caminho controlado e auditável para qualquer consulta de CPF na sua organização.

## Introdução

Data Loss Prevention -- ou DLP -- é um conjunto de estratégias e ferramentas que impede que dados sensíveis deixem o perímetro de segurança da organização de forma não autorizada. Quando se trata de dados de CPF, a implementação de DLP é particularmente relevante, pois esse identificador é frequentemente alvo de fraudes e seu vazamento pode causar danos significativos aos titulares. A [ANPD](https://www.gov.br/anpd) considera o CPF dado pessoal e exige que organizações adotem medidas técnicas e administrativas para prevenir acessos não autorizados e vazamentos.

---

## Tipos de DLP

### DLP em rede (Network DLP)

Monitora o tráfego de rede para detectar dados de CPF sendo transmitidos por canais não autorizados -- e-mails, uploads, transferências de arquivos.

### DLP em endpoint (Endpoint DLP)

Controla o que os usuários podem fazer com dados de CPF em suas estações de trabalho -- copiar para USB, imprimir, capturar tela.

### DLP em nuvem (Cloud DLP)

Monitora e protege dados de CPF armazenados em serviços de cloud -- buckets S3, bancos de dados, aplicações SaaS.

### DLP em aplicação (Application DLP)

Implementa controles diretamente na aplicação para impedir a exposição de dados de CPF em logs, respostas de API e interfaces.

---

## Detector de CPF em texto

O primeiro componente de um sistema DLP é a capacidade de identificar padrões de CPF em qualquer texto.

```python
import re
from typing import List, Dict
from dataclasses import dataclass

@dataclass
class DeteccaoCPF:
 posicao_inicio: int
 posicao_fim: int
 valor_detectado: str
 contexto: str
 formato: str

class DetectorCPF:
 """Detecta padrões de CPF em texto para DLP."""

 PADROES = [
 # CPF formatado: 123.456.789-01
 (r"\b(\d{3})\.(\d{3})\.(\d{3})-(\d{2})\b", "formatado"),
 # CPF sem formatação: 12345678901
 (r"\b(\d{11})\b", "numerico"),
 # CPF com espaços: 123 456 789 01
 (r"\b(\d{3})\s(\d{3})\s(\d{3})\s(\d{2})\b", "espacado"),
 ]

 @staticmethod
 def validar_digitos_cpf(cpf_numerico: str) -> bool:
 """Valida os dígitos verificadores do CPF."""
 if len(cpf_numerico) != 11:
 return False
 if cpf_numerico == cpf_numerico[0] * 11:
 return False

 # Primeiro dígito verificador
 soma = sum(int(cpf_numerico[i]) * (10 - i) for i in range(9))
 resto = soma % 11
 d1 = 0 if resto < 2 else 11 - resto
 if int(cpf_numerico[9]) != d1:
 return False

 # Segundo dígito verificador
 soma = sum(int(cpf_numerico[i]) * (11 - i) for i in range(10))
 resto = soma % 11
 d2 = 0 if resto < 2 else 11 - resto
 return int(cpf_numerico[10]) == d2

 def detectar(self, texto: str) -> List[DeteccaoCPF]:
 """Detecta todos os padrões de CPF no texto."""

 deteccoes = []

 for padrao, formato in self.PADROES:
 for match in re.finditer(padrao, texto):
 cpf_numerico = re.sub(r"\D", "", match.group())

 if self.validar_digitos_cpf(cpf_numerico):
 inicio = max(0, match.start() - 30)
 fim = min(len(texto), match.end() + 30)

 deteccoes.append(DeteccaoCPF(
 posicao_inicio=match.start(),
 posicao_fim=match.end(),
 valor_detectado=match.group(),
 contexto=texto[inicio:fim],
 formato=formato
 ))

 return deteccoes

 def sanitizar(self, texto: str) -> str:
 """Remove ou mascara todos os CPFs encontrados no texto."""

 deteccoes = self.detectar(texto)
 texto_limpo = texto

 for det in sorted(deteccoes, key=lambda d: d.posicao_inicio, reverse=True):
 cpf_num = re.sub(r"\D", "", det.valor_detectado)
 mascara = f"***.{cpf_num[3:6]}.***-{cpf_num[-2:]}"
 texto_limpo = (
 texto_limpo[:det.posicao_inicio]
 + mascara
 + texto_limpo[det.posicao_fim:]
 )

 return texto_limpo

# Exemplo de uso
detector = DetectorCPF()

texto = "O cliente João, CPF 123.456.789-09, solicitou acesso."
deteccoes = detector.detectar(texto)
for d in deteccoes:
 print(f"Detectado: {d.valor_detectado} ({d.formato}) - contexto: {d.contexto}")

texto_seguro = detector.sanitizar(texto)
print(f"Texto sanitizado: {texto_seguro}")
```

---

## DLP em respostas de API

Implemente um middleware que intercepte todas as respostas de API para garantir que dados de CPF não sejam expostos inadvertidamente.

```python
import requests
from flask import Flask, jsonify, request
from functools import wraps

app = Flask(__name__)
detector = DetectorCPF()

def dlp_response_filter(func):
 """Middleware DLP que filtra CPFs em respostas de API."""
 @wraps(func)
 def wrapper(*args, **kwargs):
 response_data = func(*args, **kwargs)

 # Converter resposta para string e verificar
 response_str = str(response_data)
 deteccoes = detector.detectar(response_str)

 if deteccoes:
 # Registrar alerta
 for det in deteccoes:
 app.logger.warning(
 f"[DLP] CPF detectado em resposta de API: "
 f"endpoint={request.path} formato={det.formato}"
 )

 # Sanitizar resposta se estiver em modo de bloqueio
 if isinstance(response_data, dict):
 response_str = detector.sanitizar(
 str(response_data)
 )

 return response_data

 return wrapper

@app.route("/api/consulta/<cpf>")
@dlp_response_filter
def consultar(cpf: str):
 """Endpoint protegido por DLP."""

 try:
 response = requests.get(
 f"https://api.cpfhub.io/cpf/{cpf}",
 headers={
 "x-api-key": "SUA_API_KEY",
 "Accept": "application/json"
 },
 timeout=30
 )

 if response.status_code == 200:
 return response.json()

 except requests.exceptions.Timeout:
 return {"error": "Timeout"}

 return {"error": "Não encontrado"}
```

Teste via cURL:

```bash
curl -X GET "https://api.cpfhub.io/cpf/12345678901" \
 -H "x-api-key: SUA_API_KEY" \
 -H "Accept: application/json" \
 --max-time 30
```

---

## DLP em logs e arquivos

### Scanner de arquivos

```python
import os
import json
from datetime import datetime, timezone

def escanear_diretorio(caminho: str, detector: DetectorCPF) -> List[Dict]:
 """Escaneia diretório em busca de arquivos contendo CPFs."""

 resultados = []
 extensoes_texto = {".txt", ".csv", ".json", ".log", ".xml", ".sql", ".py", ".js"}

 for raiz, dirs, arquivos in os.walk(caminho):
 for arquivo in arquivos:
 _, ext = os.path.splitext(arquivo)
 if ext.lower() in extensoes_texto:
 caminho_completo = os.path.join(raiz, arquivo)
 try:
 with open(caminho_completo, "r", encoding="utf-8", errors="ignore") as f:
 conteudo = f.read()

 deteccoes = detector.detectar(conteudo)
 if deteccoes:
 resultados.append({
 "arquivo": caminho_completo,
 "cpfs_encontrados": len(deteccoes),
 "formatos": list(set(d.formato for d in deteccoes)),
 "timestamp": datetime.now(timezone.utc).isoformat()
 })
 except (PermissionError, IOError):
 continue

 return resultados
```

---

## Políticas de DLP recomendadas

### Política de bloqueio

| Canal | Ação | Condição |
|-------|------|----------|
| E-mail | Bloquear envio | CPF detectado no corpo ou anexo |
| Upload cloud | Bloquear | Arquivo contém CPF em texto claro |
| API response | Mascarar | CPF presente na resposta |
| Logs | Sanitizar | CPF detectado em qualquer nível de log |
| Clipboard | Alertar | Cópia de CPF para área de transferência |

### Política de monitoramento

Em ambientes onde o bloqueio não é viável imediatamente, implemente monitoramento com alertas para identificar padrões de risco.

---

## Métricas de eficácia do DLP

Monitore as seguintes métricas para avaliar a eficácia do sistema:

- **Taxa de detecção**: percentual de CPFs identificados corretamente.
- **Falsos positivos**: quantos alertas foram gerados para dados que não eram CPF.
- **Tempo de resposta**: quanto tempo entre a detecção e a ação corretiva.
- **Tentativas bloqueadas**: número de vazamentos evitados pelo DLP.
- **Cobertura**: percentual de canais de saída monitorados.

---

## Integração com SIEM

Envie os alertas do DLP para o sistema de SIEM (Security Information and Event Management) da organização para correlação com outros eventos de segurança. Isso permite identificar padrões mais complexos -- como um funcionário que consulta CPFs via API e depois tenta exportá-los por e-mail.

---

## Perguntas frequentes

### Qual é a diferença entre DLP e criptografia de dados de CPF?

DLP previne que dados de CPF saiam do perímetro autorizado — monitorando e bloqueando canais de exfiltração como e-mail, upload e logs. Criptografia protege os dados em repouso e em trânsito, mas não impede que um usuário autorizado os exporte indevidamente. As duas abordagens são complementares: criptografe o armazenamento e implemente DLP nos canais de saída.

### A API CPFHub.io pode ser usada de forma compatível com uma política de DLP?

Sim. A CPFHub.io retorna dados de CPF apenas mediante autenticação via `x-api-key`, o que facilita a implementação de controles de acesso granulares. Integre a chamada à API dentro de um serviço interno isolado — não exponha a API key no frontend — e aplique o middleware DLP descrito neste artigo para sanitizar qualquer CPF que apareça em logs ou respostas.

### Como evitar que CPFs apareçam em logs de aplicação?

Use o `DetectorCPF` como filtro de log: antes de qualquer escrita em arquivo de log, passe o texto pelo método `sanitizar()` para substituir CPFs por versão mascarada. Em frameworks como Django ou Flask, implemente isso como handler de logging customizado para aplicar o filtro automaticamente em toda a aplicação.

### Quantas consultas de CPF são necessárias em um fluxo de DLP?

Em DLP, a consulta à API de CPF serve para confirmar se um número detectado é realmente um CPF válido antes de acionar um alerta — evitando falsos positivos com sequências numéricas de 11 dígitos que não são CPFs. O plano gratuito da CPFHub.io com 50 consultas mensais é suficiente para ambientes de desenvolvimento; produção com alto volume de alertas pode exigir o plano Pro (1.000 consultas/mês por R$149).

### Leia também

- [Vazamento de CPF: responsabilidades da empresa e como prevenir](https://cpfhub.io/blog/vazamento-de-cpf-responsabilidades-da-empresa-e-como-prevenir)
- [LGPD: CPF é dado pessoal sensível ou não? Entenda a classificação correta](https://cpfhub.io/blog/lgpd-cpf-e-dado-pessoal-sensivel-ou-nao-entenda-a-classificacao-correta)
- [KYC no Brasil: quais setores são obrigados a validar CPF por lei](https://cpfhub.io/blog/kyc-no-brasil-quais-setores-sao-obrigados-a-validar-cpf-por-lei)
- [IA generativa e fraudes de identidade: por que validação de CPF é mais importante que nunca](https://cpfhub.io/blog/ia-generativa-e-fraudes-de-identidade-por-que-validacao-de-cpf-e-mais-importante-que-nunca)

---

## Conclusão

Data Loss Prevention é uma camada essencial de proteção para dados de CPF. Ao combinar detecção inteligente de padrões, políticas de bloqueio em múltiplos canais e monitoramento contínuo, você cria uma barreira robusta contra vazamentos acidentais ou intencionais. A implementação deve ser gradual -- comece pelo monitoramento, refine as políticas e depois ative o bloqueio.

Para consultas de CPF seguras e controladas, utilize uma API projetada com segurança desde a concepção. Cadastre-se em [cpfhub.io](https://www.cpfhub.io/) — 50 consultas mensais gratuitas, sem cartão de crédito — e comece hoje mesmo.