Algoritmo de Validação do CPF Explicado: da Teoria ao Código

O que é o CPF e por que ele tem dígitos verificadores?

O Cadastro de Pessoa Física (CPF) é o registro fiscal de pessoas físicas no Brasil, administrado pela Receita Federal. Seu número é composto por 11 dígitos no formato NNN.NNN.NNN-DD, onde os últimos dois dígitos (DD) são os chamados dígitos verificadores.

Os dígitos verificadores existem para detectar erros de digitação e impedir que números aleatórios de 11 dígitos sejam aceitos como CPFs válidos por sistemas. A lógica se baseia no algoritmo de módulo 11, amplamente utilizado em sistemas de identificação ao redor do mundo.

---

Estrutura do número CPF

Antes de entender o cálculo, é fundamental compreender a anatomia do CPF:

Posição	Papel
1º ao 8º dígito	Número base gerado sequencialmente
9º dígito	Dígito regional — indica a Região Fiscal de emissão
10º dígito	1º dígito verificador
11º dígito	2º dígito verificador

O dígito regional e os estados

O nono dígito não é aleatório. Ele segue o seguinte mapeamento de regiões fiscais:

Dígito	Estados
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

Esse mapeamento é relevante para sistemas que precisam vincular um CPF de teste a um estado específico.

---

Calculando o 1º dígito verificador

Dado um CPF base de 9 dígitos (ex.: 123456789), o cálculo do primeiro verificador segue:

1. Multiplique cada dígito pelos pesos 10, 9, 8, 7, 6, 5, 4, 3, 2 da esquerda para a direita.
2. Some todos os produtos.
3. Calcule resto = soma % 11.
4. Se resto < 2, o dígito verificador é 0. Caso contrário, é 11 - resto.

Exemplo com 123456789:

1×10 + 2×9 + 3×8 + 4×7 + 5×6 + 6×5 + 7×4 + 8×3 + 9×2
= 10 + 18 + 24 + 28 + 30 + 30 + 28 + 24 + 18
= 210

resto = 210 % 11 = 1 → dígito verificador = 0

Portanto, o 1º verificador é 0, e o CPF parcial é 123456789-0.

---

Calculando o 2º dígito verificador

Agora use os 10 primeiros dígitos (incluindo o verificador já calculado) com os pesos 11, 10, 9, 8, 7, 6, 5, 4, 3, 2:

1×11 + 2×10 + 3×9 + 4×8 + 5×7 + 6×6 + 7×5 + 8×4 + 9×3 + 0×2
= 11 + 20 + 27 + 32 + 35 + 36 + 35 + 32 + 27 + 0
= 255

resto = 255 % 11 = ??? → 255 / 11 = 23 (quociente), 23 × 11 = 253, 255 - 253 = 2
resto = 2 → dígito verificador = 11 - 2 = 9

O CPF completo é 123.456.789-09 ✓

---

Implementação em JavaScript / TypeScript

function isValidCpf(cpf: string): boolean {
  const digits = cpf.replace(/\D/g, "");

  if (digits.length !== 11) return false;
  // Rejeita sequências como 000.000.000-00, 111.111.111-11 etc.
  if (/^(\d)\1{10}$/.test(digits)) return false;

  function calcVerifier(length: number): number {
    const sum = digits
      .slice(0, length)
      .split("")
      .reduce((acc, d, i) => acc + Number(d) * (length + 1 - i), 0);
    const rem = (sum * 10) % 11;
    return rem >= 10 ? 0 : rem;
  }

  return (
    calcVerifier(9) === Number(digits[9]) &&
    calcVerifier(10) === Number(digits[10])
  );
}

---

Implementação em Python

import re

def is_valid_cpf(cpf: str) -> bool:
    digits = re.sub(r'\D', '', cpf)

    if len(digits) != 11 or len(set(digits)) == 1:
        return False

    def calc_verifier(length: int) -> int:
        total = sum(int(digits[i]) * (length + 1 - i) for i in range(length))
        rem = (total * 10) % 11
        return 0 if rem >= 10 else rem

    return (
        calc_verifier(9) == int(digits[9]) and
        calc_verifier(10) == int(digits[10])
    )

---

Implementação em Java

public static boolean isValidCpf(String cpf) {
    String digits = cpf.replaceAll("[^0-9]", "");

    if (digits.length() != 11) return false;
    if (digits.chars().distinct().count() == 1) return false;

    int[] d = digits.chars().map(c -> c - '0').toArray();

    int sum1 = 0;
    for (int i = 0; i < 9; i++) sum1 += d[i] * (10 - i);
    int v1 = (sum1 * 10) % 11;
    if (v1 >= 10) v1 = 0;

    int sum2 = 0;
    for (int i = 0; i < 10; i++) sum2 += d[i] * (11 - i);
    int v2 = (sum2 * 10) % 11;
    if (v2 >= 10) v2 = 0;

    return d[9] == v1 && d[10] == v2;
}

---

Casos especiais: CPFs que passam no algoritmo mas são inválidos

Existem CPFs que passam matematicamente na validação mas são rejeitados pela Receita Federal:

• Sequências repetidas: 000.000.000-00, 111.111.111-11 etc. São matematicamente coerentes, mas a Receita os bloqueia.
• CPF com todos os dígitos iguais: a verificação deve rejeitar explicitamente esses casos.

Toda implementação séria deve incluir essa checagem.

---

Gerando CPFs de teste com segurança

Após entender o algoritmo, gerar um CPF fictício é trivial: basta criar 9 dígitos aleatórios (respeitando o dígito regional, se necessário) e calcular os dois verificadores.

Use o Gerador de CPF desta ferramenta para gerar CPFs de teste instantaneamente, sem nenhuma instalação ou configuração.

---

Conclusão

O algoritmo do CPF é um exemplo clássico de checksum por módulo 11. Com 30 linhas de código em qualquer linguagem, você pode validar e gerar CPFs corretamente. O ponto mais crítico é tratar os casos especiais (sequências repetidas) e entender que um CPF matematicamente válido não é necessariamente cadastrado na Receita Federal — distinção fundamental para evitar falhas em sistemas de produção.