Como o Hashing e a Criptografia Protegem Dados de CPF em APIs

Introdução

Hashing e criptografia são técnicas fundamentais para proteger dados de CPF em trânsito e em repouso. Embora frequentemente confundidos, servem a propósitos distintos: o hashing produz uma impressão digital irreversível do dado, enquanto a criptografia permite recuperar o dado original mediante uma chave. Compreender quando e como aplicar cada técnica é essencial para construir integrações seguras com APIs de CPF.

Diferenças fundamentais entre hashing e criptografia

Antes de implementar qualquer proteção, é crucial entender a distinção entre as duas técnicas:

• Use hashing -- quando precisa verificar se um CPF já foi consultado sem armazenar o valor original
• Use criptografia -- quando precisa recuperar o CPF original posteriormente para exibição ou reprocessamento

Hashing de CPF com Salt

O hashing simples de um CPF com SHA-256 produz sempre o mesmo resultado para o mesmo input, o que permite ataques de rainbow table. Para mitigar isso, adicione um salt único por registro:

import hashlib
import os
import requests

def hash_cpf_com_salt(cpf: str) -> dict:
    """Gera hash do CPF com salt aleatório."""
    cpf_limpo = cpf.replace(".", "").replace("-", "")
    salt = os.urandom(32)
    hash_result = hashlib.pbkdf2_hmac(
    'sha256',
    cpf_limpo.encode('utf-8'),
    salt,
    iterations=100000
    )
    return {
    "salt": salt.hex(),
    "hash": hash_result.hex()
    }

def verificar_cpf_hash(cpf: str, salt_hex: str, hash_hex: str) -> bool:
    """Verifica se um CPF corresponde ao hash armazenado."""
    cpf_limpo = cpf.replace(".", "").replace("-", "")
    salt = bytes.fromhex(salt_hex)
    hash_verificacao = hashlib.pbkdf2_hmac(
    'sha256',
    cpf_limpo.encode('utf-8'),
    salt,
    iterations=100000
    )
    return hash_verificacao.hex() == hash_hex

# Exemplo de uso com a API
response = requests.get(
    "https://api.cpfhub.io/cpf/12345678909",
    headers={"x-api-key": "SUA_CHAVE_AQUI"}
)
data = response.json()
if data["success"]:
    resultado = hash_cpf_com_salt(data["data"]["cpf"])
    print(f"Salt: {resultado['salt']}")
    print(f"Hash: {resultado['hash']}")

O PBKDF2 com 100.000 iterações torna ataques de força bruta computacionalmente inviáveis, mesmo considerando o espaço limitado de CPFs válidos (11 dígitos numéricos).

Criptografia de dados de CPF em repouso

Quando você precisa armazenar e posteriormente recuperar dados como nome e data de nascimento retornados pela API, utilize criptografia simétrica AES-256:

from cryptography.fernet import Fernet
import json

# A chave deve ser armazenada em um cofre de segredos
ENCRYPTION_KEY = Fernet.generate_key()
cipher = Fernet(ENCRYPTION_KEY)

def criptografar_dados_cpf(api_response: dict) -> dict:
    """Criptografa dados sensíveis da resposta da API."""
    data = api_response.get("data", {})
    dados_sensiveis = json.dumps({
    "cpf": data.get("cpf"),
    "name": data.get("name"),
    "birthDate": data.get("birthDate"),
    "gender": data.get("gender")
    }).encode()
    encrypted = cipher.encrypt(dados_sensiveis)
    return {
    "encrypted_payload": encrypted.decode(),
    "cpf_hash": hashlib.sha256(
    data.get("cpf", "").encode()
    ).hexdigest()
    }

def descriptografar_dados_cpf(encrypted_payload: str) -> dict:
    """Recupera dados originais a partir do payload criptografado."""
    decrypted = cipher.decrypt(encrypted_payload.encode())
    return json.loads(decrypted.decode())

A chave de criptografia jamais deve residir no mesmo local que os dados criptografados. Utilize serviços como AWS KMS, HashiCorp Vault ou Azure Key Vault para gerenciá-la.

Criptografia em trânsito

A comunicação com a API do CPFHub já utiliza HTTPS (TLS), mas sua aplicação deve garantir que:

• TLS 1.2 ou superior -- rejeite conexões com versões anteriores do protocolo, que possuem vulnerabilidades conhecidas
• Verificação de certificado -- nunca desabilite a verificação SSL em produção, mesmo que simplifique o desenvolvimento
• Certificate pinning -- em aplicações móveis, fixe o certificado esperado para prevenir ataques man-in-the-middle
• HSTS habilitado -- configure HTTP Strict Transport Security para forçar conexões HTTPS em toda a aplicação
• Cifras fortes -- priorize suites como TLS_AES_256_GCM_SHA384 e desabilite cifras fracas

Escolhendo o algoritmo correto

A escolha do algoritmo depende do cenário de uso:

• PBKDF2/bcrypt/Argon2 -- para hashing de CPF quando não é necessário recuperar o valor original, ideal para verificação de duplicidade
• AES-256-GCM -- para criptografia simétrica de dados em repouso, quando os dados precisam ser recuperados pelo mesmo sistema
• RSA-2048/4096 -- para criptografia assimétrica quando sistemas diferentes precisam criptografar e descriptografar dados
• HMAC-SHA256 -- para verificação de integridade de payloads transmitidos entre sistemas
• ChaCha20-Poly1305 -- alternativa ao AES para ambientes sem aceleração de hardware AES

Evite algoritmos obsoletos como MD5, SHA-1, DES e 3DES, que possuem vulnerabilidades conhecidas e não oferecem proteção adequada para dados pessoais.

Perguntas frequentes

O que é necessário para implementar validação de CPF neste contexto?

A validação de CPF exige uma chamada à API com o número do documento e a chave de autenticação. A CPFHub.io retorna o status do CPF, nome do titular e data de nascimento em menos de 200ms, permitindo a verificação em tempo real durante o cadastro ou transação.

A API CPFHub.io funciona para todos os volumes de consulta?

Sim. O plano gratuito oferece 50 consultas por mês sem cartão de crédito — ideal para testes e projetos pequenos. Para volumes maiores, o plano Pro inclui 1.000 consultas mensais por R$149. Se o limite for ultrapassado, a API não bloqueia: cobra R$0,15 por consulta adicional.

Como garantir conformidade com a LGPD ao usar uma API de CPF?

Use o CPF apenas para a finalidade declarada ao titular, armazene apenas o necessário (não guarde o CPF cru se um token bastar), implemente controle de acesso aos logs de consulta e documente a base legal para o tratamento. A ANPD orienta que dados de identificação devem ser tratados com o princípio da necessidade.

Quanto tempo leva para integrar a API CPFHub.io?

A integração básica leva menos de 30 minutos: crie uma conta em cpfhub.io, gere a API key no painel e faça uma chamada GET para https://api.cpfhub.io/cpf/{CPF} com o header x-api-key. A documentação inclui exemplos em Python, Node.js, PHP, Java e outras linguagens.

Conclusão

Hashing e criptografia são complementares na proteção de dados de CPF. O hashing permite verificações e indexações sem expor o dado original, enquanto a criptografia garante confidencialidade quando o armazenamento e a recuperação são necessários. Ao integrar com a API da CPFHub.io, aplique hashing para indexação e verificações de duplicidade, e criptografia AES-256 quando os dados precisam ser recuperados — comece com 50 consultas gratuitas em cpfhub.io.