O cálculo do dígito verificador do CPF e do CNPJ

Artigos - 12/Fev/2020 - por Henrique Morato

Existem diversos códigos para validar CNPJ e CPF que podem ser encontrados nas interwebs, mas é bastante importante entender os algoritmos por trás desses códigos. Então vamos dar uma olhada em como funciona a validação desses documentos?

A maioria dos documentos oficiais (CPF, CNPJ, Título de Eleitor, CNH) possuem, mesmo que de forma não explícita, alguns dígitos que verificam a validade dos demais. Eles são conhecidos como dígitos verificadores (DV). No CPF e CNPJ eles vem após o - e servem para validar a autenticidade do número de documento evitando assim erros de digitação, fraudes, etc.

CPF

Vamos começar trabalhando com um CPF, usando de exemplo o número: 145.382.206-20

Validando o primeiro dígito verificador

O cálculo de validação do CPF é bem direto. Ele funciona através de pesos associados a cada número e uma divisão pelo número primo 11 ao final. Vamos vê-lo em etapas.

Começamos utilizando os 9 primeiros dígitos multiplicando-os pela sequência decrescente de 10 à 2 e somamos esse resultado.

1 4 5 3 8 2 2 0 6
X X X X X X X X X
10 9 8 7 6 5 4 3 2
10 36 40 21 48 10 8 0 12
10 + 36 + 40 + 21 + 48 + 10 + 8 + 0 + 12 = 185

Com esse resultado em mãos, vamos dividí-lo por 11, mas o importante para nós não é resultado, mas sim o módulo (resto) da divisão.

185 % 11 = 9

O resto da divisão é 9. Agora para calcular o dígito verificador vamos subtrair este resto do número 11:

11 - 9 = 2
```
Como o resultado da da subtração foi 2, o primeiro dígito verificador é igual a 2. Caso o resultado dessa divisão for `10` ou maior, o penúltimo dígito verificador será o `0`.

Pronto! Confirmamos que nosso primeiro dígito verificador é válido.

### Validando o segundo dígito verificador

A validação do segundo dígito é semelhante a primeira, porém vamos considerar o primeiro dígito verificador calculado anteriormente. Por isso a multiplicação é feita de 11 à 2.

| 1 | 4 | 5 | 3 | 8 | 2 | 2 | 0 | 6 | 2 |
|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
| X | X | X | X | X | X | X | X | X | X |
|11 |10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 |
|11 |40 |45 |24 |56 |12 |10 | 0 |18 | 4 |

```ruby
11 + 40 + 45 + 24 + 56 + 12 + 10 + 0 + 18 + 4 = 220
```

Novamente vamos efetuar a divisão por 11 usando o módulo:

```ruby
220 % 11 = 0
```

E vamos fazer a subtração:

```ruby
11 - 0 = 11
```

Como o valor é igual ou maior que `10`, o último dígito é `0`.

Assim, confirmamos os dois dígitos verificadores do nosso CPF 145.382.206-**20** e sabemos que esse CPF é válido. Outra regra muito importante é que CPFs com números iguais como: `111.111.111-11`, `222.222.222-22`, entre outros, são CPFs válidos pelo algoritmo mas não existem no registro oficial. Assim esse tipo de CPF não pode ser usado.

## CNPJ

O Cadastro Nacional de Pessoa Jurídica (CNPJ) segue uma regra muito parecida com a que usamos acima, mas é um número maior e pode ser dividido em blocos.

Vamos levar em consideração o CNPJ de número 59.541.264/0001-03:

- O primeiro bloco representa a inscrição do CNPJ: **59.541.264**/0001-03
- O segundo bloco representa um código para matriz ou filial: 59.541.264/**0001**-03
- O terceiro bloco são os dígitos verificadores: 59.541.264/0001-**03**

Os dígitos verificadores são criados usando como base os os 12 primeiros números.

### Validando o primeiro dígito verificador

Para validar o primeiro dígito a forma mais simples é inverter o nosso número de CNPJ e adicionar pesos de 2 até 9:

| 1 | 0 | 0 | 0 | 4 | 6 | 2 | 1 | 4 | 5 | 9 | 5 |
|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
| X | X | X | X | X | X | X | X | X | X | X | X |
| 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 3 | 4 | 5 |
| 2 | 0 | 0 | 0 |24 |42 |16 | 9 | 8 |15 |36 |25 |

Da mesma forma como na validação de CPF, nós somamos os resultados e usamos o módulo 11 para calcular o dígito:

```ruby
2 + 0 + 0 + 0 + 24 + 42 + 16 + 9 + 8 + 15 + 36 + 25 = 177

177 % 11 = 1

11 - 1 = 10
```

Como o resultado foi `10`, usamos a mesma regra e o primeiro dígito verificador é `0`.

### Validando o segundo dígito verificador

Utilizando a mesma regra do primeiro dígito, mas agora a partir do 13º número, vamos lá:

| 0 | 1 | 0 | 0 | 0 | 4 | 6 | 2 | 1 | 4 | 5 | 9 | 5 |
|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
| X | X | X | X | X | X | X | X | X | X | X | X | X |
| 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 2 | 3 | 4 | 5 | 6 |
| 0 | 3 | 0 | 0 | 0 |28 |48 |18 | 2 |12 |20 |45 |30 |

```ruby
0 + 3 + 0 + 0 + 0 + 28 + 48 + 18 + 2 + 12 + 20 + 45 + 30 = 206

206 % 11 = 8

11 - 8 = 3
```

Com nosso segundo dígito calculado, verificamos que esse CNPJ é válido! 

Lembrando que a mesma regra de CPF com dígitos iguais se aplica aqui também, CNPJs como 11.111.111/1111-11 não são válidos.

## Conclusão

Agora que sabemos as regras de validação de dígitos podemos fazer a engenharia reversa e criar CPF ou CNPJ validos para nossos programas. Uma dica é sempre consultar os atos declaratórios da Receita Federal para verificar se houve atualização nas regras e os detalhes de validação.


Dependendo da sua aplicação você poderia optar por utilizar ferramentas prontas que você poderia contratar para realizar essa validação, além de verificar a quem esses documentos pertencem, entre outras funções. 

Foto de perfil do autor
Henrique Morato

Dev