Como Implementar Anonimização e Pseudonimização de Dados de CPF

Anonimização e pseudonimização são técnicas distintas sob a LGPD: dados anonimizados de forma irreversível deixam de ser dados pessoais (Art. 12) e saem do escopo da lei, enquanto dados pseudonimizados continuam sendo dados pessoais protegidos. Para CPF, a escolha entre as duas depende se você precisará reverter o identificador — para análises estatísticas use anonimização; para processamento com necessidade de reidentificação controlada, use pseudonimização.

Introdução

A LGPD diferencia claramente entre dados anonimizados e pseudonimizados, e essa distinção tem consequências jurídicas significativas. Dados anonimizados de forma irreversível não são mais considerados dados pessoais e, portanto, não estão sujeitos à LGPD. Dados pseudonimizados ainda são dados pessoais, mas oferecem uma camada adicional de proteção. Ao tratar dados de CPF obtidos via APIs, aplicar essas técnicas corretamente permite reduzir riscos, atender ao princípio da minimização e viabilizar usos analíticos sem comprometer a privacidade.

Diferenças entre anonimização e pseudonimização

Entender a distinção é fundamental para aplicar a técnica correta:

Técnicas de anonimização para CPF

Para anonimizar dados de CPF de forma que a reidentificação seja razoavelmente impossível:

import hashlib
import random
import uuid
from datetime import datetime

class AnonimizadorCPF:
    """Técnicas de anonimização para dados de CPF."""

    def suprimir(self, registro: dict) -> dict:
    """Remove completamente o CPF e dados identificadores."""
    return {
    "id_anonimo": str(uuid.uuid4()),
    "genero": registro.get("gender"),
    "faixa_etaria": self._calcular_faixa(
    registro.get("birthDate")
    ),
    "regiao_cpf": self._regiao_por_digito(
    registro.get("cpf", "")
    ),
    "anonimizado_em": datetime.utcnow().isoformat()
    }

    def generalizar(self, registro: dict) -> dict:
    """Generaliza dados para reduzir identificabilidade."""
    return {
    "id_anonimo": str(uuid.uuid4()),
    "genero": registro.get("gender"),
    "faixa_etaria": self._calcular_faixa(
    registro.get("birthDate")
    ),
    "decada_nascimento": self._decada(
    registro.get("year", "")
    ),
    "regiao_cpf": self._regiao_por_digito(
    registro.get("cpf", "")
    )
    }

    def adicionar_ruido(self, registros: list) -> list:
    """Adiciona registros fictícios para dificultar
    a reidentificação por cruzamento."""
    resultado = list(registros)
    qtd_ruido = max(1, len(registros) // 10)
    for _ in range(qtd_ruido):
    resultado.append({
    "id_anonimo": str(uuid.uuid4()),
    "genero": random.choice(["M", "F"]),
    "faixa_etaria": random.choice([
    "18-25", "26-35", "36-45", "46-55", "56+"
    ]),
    "sintetico": True
    })
    random.shuffle(resultado)
    return resultado

    def _calcular_faixa(self, birth_date: str) -> str:
    if not birth_date:
    return "desconhecida"
    try:
    ano = int(birth_date.split("-")[0])
    idade = datetime.now().year - ano
    if idade < 18: return "menor_18"
    elif idade < 26: return "18-25"
    elif idade < 36: return "26-35"
    elif idade < 46: return "36-45"
    elif idade < 56: return "46-55"
    else: return "56+"
    except (ValueError, IndexError):
    return "desconhecida"

    def _decada(self, year: str) -> str:
    if not year:
    return "desconhecida"
    try:
    return f"{int(year) // 10 * 10}s"
    except ValueError:
    return "desconhecida"

    def _regiao_por_digito(self, cpf: str) -> str:
    """O 9o dígito do CPF indica a região fiscal."""
    regioes = {
    "0": "RS", "1": "DF/GO/MS/MT/TO",
    "2": "AC/AM/AP/PA/RO/RR",
    "3": "CE/MA/PI", "4": "AL/PB/PE/RN",
    "5": "BA/SE", "6": "MG",
    "7": "ES/RJ", "8": "SP", "9": "PR/SC"
    }
    if len(cpf) >= 9:
    return regioes.get(cpf[8], "desconhecida")
    return "desconhecida"

Técnicas de pseudonimização para CPF

A pseudonimização substitui o CPF por um identificador artificial, mantendo a possibilidade de reversão:

const crypto = require("crypto");

class PseudonimizadorCPF {
    constructor(chaveSecreta) {
    // A chave deve ser armazenada em cofre de segredos
    this.chave = chaveSecreta;
    this.algoritmo = "aes-256-gcm";
    }

    // Pseudonimizar: substituir CPF por token reversível
    pseudonimizar(cpf) {
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv(
    this.algoritmo, Buffer.from(this.chave, "hex"), iv
    );
    let encrypted = cipher.update(cpf, "utf8", "hex");
    encrypted += cipher.final("hex");
    const authTag = cipher.getAuthTag().toString("hex");

    return {
    token: `PSE_${encrypted}`,
    iv: iv.toString("hex"),
    tag: authTag
    };
    }

    // Reverter: recuperar CPF original a partir do token
    reverter(token, ivHex, tagHex) {
    const encrypted = token.replace("PSE_", "");
    const decipher = crypto.createDecipheriv(
    this.algoritmo,
    Buffer.from(this.chave, "hex"),
    Buffer.from(ivHex, "hex")
    );
    decipher.setAuthTag(Buffer.from(tagHex, "hex"));
    let decrypted = decipher.update(encrypted, "hex", "utf8");
    decrypted += decipher.final("utf8");
    return decrypted;
    }
}

// Uso prático
const pseudo = new PseudonimizadorCPF(
    crypto.randomBytes(32).toString("hex")
);

const resultado = pseudo.pseudonimizar("12345678909");
console.log("Token:", resultado.token);

const cpfOriginal = pseudo.reverter(
    resultado.token, resultado.iv, resultado.tag
);
console.log("CPF original:", cpfOriginal);

Quando usar cada técnica

A escolha entre anonimização e pseudonimização depende da finalidade:

• Relatórios estatísticos -- anonimização completa, pois não há necessidade de reidentificar os titulares
• Ambiente de testes -- anonimização, para que dados de produção possam ser usados sem risco
• Data warehouse analítico -- pseudonimização, permitindo cruzamento controlado quando necessário
• Compartilhamento com terceiros -- anonimização, eliminando qualquer possibilidade de reidentificação
• Processamento interno -- pseudonimização, mantendo a capacidade de reverter quando houver necessidade legítima
• Backup de longo prazo -- pseudonimização com chave separada do backup, protegendo mesmo em caso de comprometimento do backup

Riscos de reidentificação

A anonimização não é infalível. Considere os riscos de reidentificação:

Perguntas frequentes

Dados pseudonimizados de CPF ainda precisam de base legal para tratamento?

Sim. A pseudonimização reduz o risco mas não remove o CPF do escopo da LGPD — o dado continua sendo pessoal porque pode ser revertido. Você ainda precisa de base legal (consentimento, execução de contrato, obrigação legal, etc.) e deve registrar a finalidade do tratamento. Apenas a anonimização irreversível libera os dados das obrigações da lei.

Qual a diferença entre hash de CPF e pseudonimização?

Um hash simples (SHA-256 do CPF) é reversível por força bruta, pois CPFs são previsíveis — existem apenas 10^9 combinações válidas. Por isso não é considerado pseudonimização adequada pela ANPD. Use HMAC com chave secreta ou criptografia simétrica (AES-256-GCM como no exemplo) para garantir que a reversão exija a chave.

Posso usar CPF anonimizado para cruzar dados com outra base interna?

Depende. Se a outra base contiver o mesmo CPF original ou um campo que permita reidentificação indireta, o cruzamento pode anular a anonimização. Avalie o risco de reidentificação por linkagem antes de qualquer cruzamento e considere técnicas de k-anonimidade para garantir que cada registro se confunda com pelo menos k-1 outros.

Onde armazenar a chave de reversão da pseudonimização?

Nunca no mesmo sistema que armazena os dados pseudonimizados. Use um cofre de segredos separado (AWS Secrets Manager, HashiCorp Vault, Azure Key Vault) com controle de acesso independente, rotação periódica de chaves e registro de auditoria de cada acesso. Em caso de comprometimento do banco de dados, os tokens pseudonimizados são inúteis sem a chave.

Conclusão

Anonimização e pseudonimização são ferramentas complementares na proteção de dados de CPF. A anonimização irreversível libera os dados das exigências da LGPD, enquanto a pseudonimização oferece proteção adicional sem perder a capacidade de reversão. Ao tratar dados obtidos da API do cpfhub.io, aplique a técnica adequada à finalidade: anonimize o que não precisa ser reidentificado e pseudonimize o que pode precisar de reversão controlada.

Cadastre-se em cpfhub.io — 50 consultas mensais gratuitas, sem cartão de crédito — e implemente o tratamento de dados de CPF em conformidade com a LGPD hoje mesmo.