Fraude de novo cadastro: como detectar CPFs que já foram banidos

const express = require("express");
const axios = require("axios");
const crypto = require("crypto");

const app = express();
app.use(express.json());

const CPFHUB_API_URL = "https://api.cpfhub.io/cpf";
const CPFHUB_API_KEY = "SUA_CHAVE_DE_API";
const REQUEST_TIMEOUT = 10000; // 10 segundos

// Simulação de banco de dados
const usuarios = new Map();
const cpfsAtivos = new Set();

// Lista de bloqueio com metadados
const listaBloqueio = new Map();
// cpf -> { motivo, data, severidade, nomeOriginal, dataNascimento, enderecosUsados }

function limparCpf(cpf) {
    return cpf.replace(/\D/g, "");
}

async function consultarCpf(cpf) {
    const cpfLimpo = limparCpf(cpf);

    try {
    const response = await axios.get(`${CPFHUB_API_URL}/${cpfLimpo}`, {
    headers: {
    "x-api-key": CPFHUB_API_KEY,
    Accept: "application/json",
    },
    timeout: REQUEST_TIMEOUT,
    });

    if (response.data.success) {
    return response.data.data;
    }
    return null;
    } catch (error) {
    if (error.code === "ECONNABORTED") {
    throw new Error("Timeout na consulta de CPF");
    }
    if (error.response) {
    const { status } = error.response;
    if (status === 401) throw new Error("API key inválida");
    if (status === 404) return null;
    }
    throw new Error("Erro na consulta de CPF");
    }
}

function normalizarNome(nome) {
    return nome
    .normalize("NFD")
    .replace(/[\u0300-\u036f]/g, "")
    .toUpperCase()
    .trim();
}

function extrairSobrenome(nome) {
    const partes = normalizarNome(nome).split(" ");
    return partes.length > 1 ? partes[partes.length - 1] : "";
}

// Banir CPF
app.post("/api/admin/banir", (req, res) => {
    const { cpf, motivo, severidade } = req.body;
    // severidade: "LEVE", "GRAVE", "PERMANENTE"

    const cpfLimpo = limparCpf(cpf);

    const usuario = [...usuarios.values()].find((u) => u.cpf === cpfLimpo);

    const registro = {
    cpf: cpfLimpo,
    motivo,
    severidade: severidade || "GRAVE",
    dataBanimento: new Date().toISOString(),
    nomeOriginal: usuario ? usuario.nome : null,
    nomeUpperOriginal: usuario ? usuario.nomeUpper : null,
    dataNascimento: usuario ? usuario.dataNascimento : null,
    sobrenome: usuario ? extrairSobrenome(usuario.nome) : null,
    enderecosUsados: usuario ? usuario.enderecosUsados || [] : [],
    emailsUsados: usuario ? [usuario.email] : [],
    };

    listaBloqueio.set(cpfLimpo, registro);

    // Desativa a conta
    if (usuario) {
    usuario.status = "BANIDO";
    }

    cpfsAtivos.delete(cpfLimpo);

    res.json({
    sucesso: true,
    mensagem: `CPF ${cpfLimpo} adicionado à lista de bloqueio`,
    severidade: registro.severidade,
    });
});

// Verificação completa no cadastro
app.post("/api/usuario/cadastro", async (req, res) => {
    const { nome, email, cpf, endereco } = req.body;

    if (!cpf || !nome || !email) {
    return res.status(400).json({
    erro: "Nome, email e CPF são obrigatórios",
    });
    }

    const cpfLimpo = limparCpf(cpf);
    const alertas = [];
    let bloqueado = false;
    let motivoBloqueio = null;

    // Verificação 1: CPF exato na lista de bloqueio
    if (listaBloqueio.has(cpfLimpo)) {
    const registro = listaBloqueio.get(cpfLimpo);
    bloqueado = true;
    motivoBloqueio = `CPF banido: ${registro.motivo} (${registro.severidade})`;

    // Log para análise (não expor ao usuário)
    console.log(
    `[ALERTA] Tentativa de recadastro de CPF banido: ${cpfLimpo}`
    );

    return res.status(403).json({
    erro: "Não foi possível completar o cadastro. Entre em contato com o suporte.",
    codigo: "CADASTRO_NEGADO",
    });
    }

    // Verificação 2: CPF já ativo
    if (cpfsAtivos.has(cpfLimpo)) {
    return res.status(409).json({
    erro: "Este CPF já possui uma conta ativa",
    });
    }

    // Verificação 3: Validação via API CPFHub.io
    let dadosCpf;
    try {
    dadosCpf = await consultarCpf(cpfLimpo);
    } catch (error) {
    return res.status(503).json({ erro: error.message });
    }

    if (!dadosCpf) {
    return res.status(422).json({
    erro: "CPF não encontrado na base de dados",
    });
    }

    // Verificação 4: Análise de proximidade com CPFs banidos
    const nomeCpf = normalizarNome(dadosCpf.name || "");
    const sobrenomeCpf = extrairSobrenome(dadosCpf.name || "");
    const dataNascCpf = dadosCpf.birthDate;

    for (const [cpfBanido, registro] of listaBloqueio) {
    // Mesmo sobrenome
    if (registro.sobrenome && sobrenomeCpf === registro.sobrenome) {
    alertas.push({
    tipo: "MESMO_SOBRENOME",
    detalhe: `Sobrenome "${sobrenomeCpf}" coincide com CPF banido`,
    cpfRelacionado: cpfBanido.substring(0, 3) + "***",
    severidade: "MEDIA",
    });
    }

    // Mesma data de nascimento e mesmo sobrenome (forte indicativo)
    if (
    registro.dataNascimento &&
    dataNascCpf === registro.dataNascimento &&
    registro.sobrenome === sobrenomeCpf
    ) {
    alertas.push({
    tipo: "FAMILIAR_PROVAVEL",
    detalhe: "Mesma data de nascimento e sobrenome de CPF banido",
    severidade: "ALTA",
    });
    }

    // Mesmo endereço
    if (endereco && registro.enderecosUsados) {
    const enderecoNorm = JSON.stringify(endereco).toUpperCase();
    for (const endBanido of registro.enderecosUsados) {
    if (JSON.stringify(endBanido).toUpperCase() === enderecoNorm) {
    alertas.push({
    tipo: "MESMO_ENDERECO",
    detalhe: "Endereço coincide com CPF banido",
    severidade: "ALTA",
    });
    break;
    }
    }
    }

    // Mesmo e-mail (variações)
    if (registro.emailsUsados) {
    const emailBase = email.split("@")[0].replace(/\./g, "").toLowerCase();
    for (const emailBanido of registro.emailsUsados) {
    const emailBanidoBase = emailBanido
    .split("@")[0]
    .replace(/\./g, "")
    .toLowerCase();
    if (emailBase === emailBanidoBase) {
    alertas.push({
    tipo: "EMAIL_SIMILAR",
    detalhe: "Email similar ao de CPF banido",
    severidade: "ALTA",
    });
    break;
    }
    }
    }
    }

    // Decisão baseada em alertas
    const alertasAltos = alertas.filter((a) => a.severidade === "ALTA");
    const status =
    alertasAltos.length >= 2
    ? "BLOQUEADO"
    : alertasAltos.length === 1
    ? "REVISAO_MANUAL"
    : alertas.length > 0
    ? "APROVADO_COM_RESSALVAS"
    : "APROVADO";

    if (status === "BLOQUEADO") {
    return res.status(403).json({
    erro: "Não foi possível completar o cadastro. Entre em contato com o suporte.",
    codigo: "CADASTRO_NEGADO",
    });
    }

    // Cria conta
    const id = crypto.randomUUID();

    usuarios.set(id, {
    id,
    nome: dadosCpf.name,
    nomeUpper: dadosCpf.nameUpper,
    email,
    cpf: cpfLimpo,
    dataNascimento: dadosCpf.birthDate,
    genero: dadosCpf.gender,
    enderecosUsados: endereco ? [endereco] : [],
    status,
    alertas:
    alertas.length > 0
    ? alertas.map((a) => `${a.tipo}: ${a.detalhe}`)
    : [],
    criadoEm: new Date().toISOString(),
    });

    cpfsAtivos.add(cpfLimpo);

    const resposta = {
    sucesso: true,
    usuarioId: id,
    nome: dadosCpf.name,
    status,
    };

    if (status === "REVISAO_MANUAL") {
    resposta.mensagem =
    "Cadastro em análise. Você será notificado em até 24 horas.";
    } else {
    resposta.mensagem = "Cadastro realizado com sucesso";
    }

    // Log interno de alertas (não expor ao usuário)
    if (alertas.length > 0) {
    console.log(
    `[ALERTA] Novo cadastro ${id} com ${alertas.length} alertas:`,
    alertas.map((a) => a.tipo).join(", ")
    );
    }

    res.json(resposta);
});

// Consultar lista de bloqueio (admin)
app.get("/api/admin/lista-bloqueio", (req, res) => {
    const lista = [];

    for (const [cpf, registro] of listaBloqueio) {
    lista.push({
    cpfMascarado: cpf.substring(0, 3) + ".***.***-" + cpf.substring(9),
    nome: registro.nomeOriginal,
    motivo: registro.motivo,
    severidade: registro.severidade,
    dataBanimento: registro.dataBanimento,
    });
    }

    res.json({
    total: lista.length,
    registros: lista,
    });
});

app.listen(3000, () => {
    console.log("Servidor rodando na porta 3000");
});