Dígito verificador

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, de matrícula, cartões de crédito e quaisquer outros códigos numéricos que necessitem de maior segurança utilizam dígitos verificadores.

Utilização

É 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 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 dividido por 11. O resto desta divisão (módulo 11) é o primeiro 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 261533:

  +---+---+---+---+---+---+   +---+
  | 2 | 6 | 1 | 5 | 3 | 3 | - | 9 |<---
  +---+---+---+---+---+---+   +---+
    |   |   |   |   |   |
    x7  x6  x5  x4  x3  x2
    |   |   |   |   |   |
    =14 =36 =5  =20 =9  =6
    +---+---+---+---+---+-> = (90 x 10) / 11 = 81, resto 9 => Dígito = 9

  +---+---+---+---+---+---+   +---+---+
  | 2 | 6 | 1 | 5 | 3 | 3 | - | 9 | 4 |<---
  +---+---+---+---+---+---+   +---+---+
    |   |   |   |   |   |       |
    x8  x7  x6  x5  x4  x3      x2
    |   |   |   |   |   |       |
    =16 =42 =6  =25 =12 =9      =18
    +---+---+---+---+---+-> = (128 x 10) / 11 = 116, resto 4 => Dígito = 4

Considerando o número 2615337, onde o 7 é o dígito verificador e a validação é através do "módulo 11". Não seria considerado um número válido, pois o número correto é 2615339, onde 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ção: 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 do Bradesco, que quando o cálculo resulta em 10, o digito verificador utilizado é o 0 (ou 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
    +---+---+---+---+---+-> = (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 (se uma multiplicação der 12, por exemplo, será somado 1 + 2 = 3).

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.

Algoritmos

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)

Ver também

• Algoritmo
• Códigos corretores de erros
• Segurança da informação
• Soma de verificação

Ligações externas

• Teste de Luhn para números de cartões de crédito no Rosetta Code
• SEDOL no Rosetta Code, com implementações em diversas linguagens de programação