Como implementar data loss prevention (DLP) para dados de 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 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.

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.

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:

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

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

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).

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 — 50 consultas mensais gratuitas, sem cartão de crédito — e comece hoje mesmo.