Dígito verificador – Wikipédia, a enciclopédia livre

Dígito verificador ou algarismo de controle é um mecanismo de autenticação utilizado para verificar a validade e a autenticidade de um valor numérico, evitando dessa forma fraudes ou erros de transmissão ou digitação.

Consiste em um ou mais algarismos acrescentados ao valor original e calculados a partir deste através de um determinado algoritmo.

Números de documentos de identificação (tais como RG e CPF), cartões de crédito, boletos bancários e quaisquer outros códigos numéricos que necessitem de maior segurança utilizam dígitos verificadores.

Utilização

O dígito de verificação algoritmos é geralmente projetado para capturar erros de transcrição humano. Em ordem de complexidade, estes incluem o seguinte:^[1]

erros de dígito único, como 1 → 2
erros de transposição, como 12 → 21
erros gêmeos, como 11 → 22
Pular erros de transposição, como 132 → 231
Ir erros gêmeos, como 131 → 232
erros fonéticos, como 3 → 6 ("três" a "seis")

Código de identidade do Deutsche Post / DHL

É usado normalmente em representações numéricas que exijam integridade, como por exemplo:

Documentos de identificação
- brasileiros como CPF, CNPJ, RG etc.
- portugueses como NIF, BI, etc.
Códigos de Barras como EAN, UPC e ITF.
Códigos de pagamentos: Número de boleto de cobrança, código de concessionária pública etc.
Códigos em geral: Agência bancária, conta corrente, número de matrícula etc.

Exemplos

O método de cálculo desses dígitos varia conforme o caso, porém muitos deles se baseiam em duas rotinas tradicionais: Módulo 11 e Módulo 10.

Abaixo temos uma explicação do cálculo dessas duas rotinas:

Módulo 11

Conforme o esquema abaixo, para calcular o primeiro dígito verificador, cada dígito do número, começando da direita para a esquerda (do dígito menos significativo para o dígito mais significativo) é multiplicado, na ordem, por 2, depois 3, depois 4 e assim sucessivamente, até o primeiro dígito do número. O somatório dessas multiplicações é multiplicado por 10 e depois dividido por 11. O resto desta divisão (módulo 11) é o dígito verificador. Para calcular o próximo dígito, considera-se o dígito anterior como parte do número e efetua-se o mesmo processo. No exemplo, foi considerado o número 1201611227:

  +---+---+---+---+---+---+---+---+---+---+   +---+   | 1 | 2 | 0 | 1 | 6 | 1 | 1 | 2 | 2 | 7 | - | 3 |   +---+---+---+---+---+---+---+---+---+---+   +---+     |   |   |   |   |   |   |   |   |   |       x3  x2  x9  x8  x7  x6  x5  x4  x3  x2     |   |   |   |   |   |   |   |   |   |     =3	=4  =0	=8  =42	=6  =5  =8  =6	=14 soma = 96     +---+---+---+---+---+-> = (96 * 10 / 11) = 87, resto 3 => DV = 11 - 3 = 8

Considerando o número 2615336, onde o 6 é o dígito verificador e a validação é através do "módulo 11", este não seria considerado um número válido, pois o número correto é 2615339, onde 9 (resto 2 -> DV = 11 - 2 = 9) é o dígito verificador gerado pelo módulo 11.

O CPF utiliza o módulo 11 duas vezes seguidas (conforme o exemplo), obtendo dois dígitos verificadores.

Observações:

Para calculo de CPF, CNPJ e similares, sempre que o resto da divisão for 0 ou 1, o dígito será 0.
Para o código de barras, sempre que o resto for 0, 1 ou 10, deverá ser utilizado o dígito 1.

Cálculos variantes poderiam ocorrer, tal como substituir por uma letra, quando o cálculo do dígito final der 10 ou outro número escolhido. Exemplos são os casos da utilização do dígito verificador pelo Banco do Brasil, quando o cálculo resulta em 10, o dígito verificador utilizado é o X, e quando resulta em 11, o dígito verificador utilizado é 0, e da Caixa Econômica Federal e Bradesco, que quando o cálculo resulta em 10, o digito verificador utilizado é o 0 (no caso do Bradesco também pode ser P para poupanças).

Módulo 10

Conforme o esquema abaixo, cada dígito do número, começando da direita para a esquerda (menos significativo para o mais significativo) é multiplicado, na ordem, por 2, depois 1, depois 2, depois 1 e assim sucessivamente.

Número exemplo: 261533-4

  +---+---+---+---+---+---+   +---+   | 2 | 6 | 1 | 5 | 3 | 3 | - | 4 |   +---+---+---+---+---+---+   +---+     |   |   |   |   |   |    x1  x2  x1  x2  x1  x2     |   |   |   |   |   |    =2 =12  =1 =10  =3  =6     |   |   |   |   |   |    =2  =3  =1  =1   =3  6 (Soma de cada dígito = 16)     +---+---+---+---+---+-> = (16 / 10) = 1, resto 6 => DV = (10 - 6) = 4

Em vez de ser feito o somatório das multiplicações, será feito o somatório dos dígitos das multiplicações (para o exemplo proposto, o resultado da multiplicação 6x2 = 12, resultará na soma dos seus dígitos 1 + 2 = 3; para 5x2 = 10, será 1 + 0 = 1).

O somatório será dividido por 10 e se o resto (módulo 10) for diferente de zero, o dígito será 10 menos este valor. Se o resto (módulo 10) for zero (0) o DV também será zero (0).

O Banco Itaú utiliza módulo 10 para a definição do digito verificador nas contas em suas agências no Brasil, sendo utilizado o número da agência com 4 dígitos e o número da conta com 5 digitos pra efeitos de definição do dígito verificador da conta, como demonstrado abaixo:

Exemplo: Agência 7681 Conta 93542-0

 +---+---+---+---+---+---+---+---+---+   +---+  | 7 | 6 | 8 | 1 | 9 | 3 | 5 | 4 | 2 | - | 0 |  +---+---+---+---+---+---+---+---+---+   +---+     |   |   |   |   |   |   |   |   |    x2  x1  x2  x1  x2  x1  x2  x1  x2     |   |   |   |   |   |   |   |   |   =14  =6 =16  =1 =18  =3 =10  =4  =4      |   |   |   |   |   |   |   |   |    =5  =6  =7  =1  =9  =3  =1  =4  =4 (Soma de cada dígito = 40)     +---+---+---+---+---+---+---+---+-> = (40 / 10) = 4, resto 0 => DV = (0 - 0) = 0

Entre os algoritmos notáveis para o cálculo de dígitos verificadores estão os seguintes:

Algoritmo de Luhn (1954)
Algoritmo de Verhoeff (1969)

Realização dos cálculos em C++

O código é bastante simples, consiste em receber uma string representando os números do CPF sem os dígitos verificadores, e um array do tipo short, que será preenchido com os valores da string mais os dígitos verificadores, sendo devolvida tanto a string como o array contendo os dígitos já calculados.

Há também um função que identifica os estados com base no antepenúltimo dígito (quando contado com os verificadores).

#include <iostream> #include <string.h>  using namespace std;  char* check_cpf(char cpf[], short* nums) { 	short nums_multiplicados[11]; 	short nums_originais[11]; 	int numeros = 0; 	int multiplicador = 10; 	int soma = 0; 	int resto = 0; 	int digito = 0; 	for(int i = 0; i < 9; i++) 	{ 		numeros = 0; 		if(cpf[i] >= '0' && cpf[i] <= '9') 		{ 			nums_originais[i] = cpf[i] - '0'; 			nums_multiplicados[i] = nums_originais[i]; 			nums_multiplicados[i] = nums_multiplicados[i] * multiplicador--; 		} 		soma += nums_multiplicados[i]; 	} 	resto = soma % 11; 	if(resto != 0 && resto != 1) 	{ 		digito = 11 - resto; 	}  	nums_originais[9] = digito; 	cpf[9] = '0' + digito; 	multiplicador = 11; 	soma = 0; 	resto = 0; 	digito = 0; 	for(int i = 0; i < 10; i++) 	{  		nums_multiplicados[i] = nums_originais[i]; 		nums_multiplicados[i] = nums_multiplicados[i] * multiplicador--; 		soma += nums_multiplicados[i]; 	} 	resto = soma % 11; 	if(resto != 0 && resto != 1) 	{ 		digito = 11 - resto; 	} 	nums_originais[10] = digito; 	cpf[10] = '0' + digito; 	for(int i = 0; i < 11; i++) 	{ 		nums[i] = nums_originais[i]; 	} 	return cpf; }  void cpf_lugar(char cpf[]) { 	switch(cpf[8]) 	{ 	case '0': 		cout << "Rio Grande do Sul" << endl; 		break; 	case '1': 		cout << "Distrito Federal, Goiás, Mato Grosso, Mato Grosso do Sul e Tocantins" << endl; 		break; 	case '2': 		cout << "Amazonas, Pará, Roraima, Amapá, Acre e Rondônia" << endl; 		break; 	case '3': 		cout << "Ceará, Maranhão e Piauí" << endl; 		break; 	case '4': 		cout << "Paraíba, Pernambuco, Alagoas e Rio Grande do Norte" << endl; 		break; 	case '5': 		cout << "Bahia e Sergipe" << endl; 		break; 	case '6': 		cout << "Minas Gerais" << endl; 		break; 	case '7': 		cout << "Rio de Janeiro e Espírito Santo" << endl; 		break; 	case '8': 		cout << "São Paulo" << endl; 		break; 	case '9': 		cout << "Paraná e Santa Catarina" << endl; 		break; 	} }  //078539806-63 cpf falso para testes  int main(int argc, char *argv[]) { 	short num_cpf[11]; 	char cpf[11]; 	strcpy(cpf, "078539806"); 	cout << check_cpf(cpf, num_cpf) << endl; 	return 0; }

Ver também

Referências

↑ Kirtland, Joseph (2001). Identification Numbers and Check Digit Schemes. Col: Classroom Resource Materials. [S.l.]: Mathematical Association of America. pp. 4–6. ISBN 978-0-88385-720-5

[Kirtland2001_p4-6-1] Kirtland, Joseph (2001). Identification Numbers and Check Digit Schemes. Col: Classroom Resource Materials. [S.l.]: Mathematical Association of America. pp. 4–6. ISBN 978-0-88385-720-5

[1]