Cadastro de Pessoas Físicas

Ficheiro:CPF1.jpg

Frente e verso de um documento de CPF (modelo antigo)

Frente e verso de um documento de CPF (modelo novo)

Cadastro de Pessoas Físicas (CPF) é o registro de um cidadão na Receita Federal brasileira no qual devem estar todos os contribuintes (pessoas físicas brasileiras ou estrangeiras com negócios no Brasil). O CPF armazena informações fornecidas pelo próprio contribuinte e por outros sistemas da Receita Federal.

Cada contribuinte possui um documento, o cartão CPF, que garante este cadastro. É um dos principais documentos para cidadãos brasileiros. Ao ser emitido, um CPF gera um número de onze algarismos, sendo os dois últimos dígitos verificadores para evitar erros de digitação. Este número é único para cada contribuinte e não muda, mesmo no caso de perda do cartão.

Sua posse não é obrigatória, mas é necessária para a maior parte das operações financeiras (como abertura de contas em bancos, por exemplo). Há diversos casos em que o CPF pode ser cancelado. Por exemplo, quando o contribuinte não apresenta a declaração de Imposto de Renda por dois anos consecutivos, quando é apresentada a Declaração Final de Espólio, ou por vício/fraude, em que constará a situação "nulo". A Declaração Anual de Isento - DAI não é mais exigida desde 2008, não sendo mais sua ausência motivo para cancelamento da inscrição.

O porte do cartão também não é obrigatório, embora sua apresentação seja exigida em diversas ocasiões, como instrumento auxiliar na autenticação da identidade do indivíduo. Nesses casos, também podem ser apresentados outros documentos oficiais em que o CPF é mencionado, como o RG ou a carteira de motorista.

Recentemente, o governo lançou o "e-CPF", documento eletrônico em forma de certificado digital, que garante a autenticidade e a integridade na comunicação entre as pessoas físicas e a Secretaria da Receita Federal (SRF). Funciona exatamente como uma versão digital do CPF, sendo vinculado a ele. O e-CPF serve, entre outras aplicações, para entregar declarações de renda e demais documentos eletrônicos com aposição de assinatura digital. Além disso, está sendo difundido seu uso na assinatura digital de contratos de câmbio e, futuramente, em outros contratos bancários.

Instituição do CPF

Frente e verso de um CIC.

O contribuinte que apresentou declaração de rendimentos do exercício de 1969, ano-calendário de 1968, recebeu da Secretaria da Receita Federal, no início de 1970, juntamente com o Manual de Orientação e formulários, duas vias do Cartão de Identificação do Contribuinte (CIC), emitidos eletronicamente e com prazo de validade. Os cartões emitidos até a década de 1970 tinham prazo e eram renovados quando esse expirava. A declaração de rendimentos do imposto de renda das pessoas físicas passou a ter um campo para indicação do número de inscrição no Cadastro das Pessoas Físicas. Assim permaneceu até a reformulação do sistema tributário e a criação, em meados dos anos 80, do Cadastro de Pessoas Físicas, o "CPF".

Com o passar do tempo, o CPF ultrapassou os limites do imposto de renda e tornou-se um documento de suma importância no cotidiano do brasileiro.

Significado dos dígitos

Os dois últimos dígitos do CPF são números de verificação: seguem um algoritmo de módulo 11, baseado no valor dos outros dígitos, para possibilitar a verificação automática e prevenir erros de digitação.

O dígito anterior (isto é, o terceiro dígito da direita para a esquerda) revela a unidade federativa em que a pessoa registrou-se pela primeira vez, dado que é proibido (em condições normais) trocar de número.

Assim, basta observar o dígito final antes do traço para descobrir sua origem.

Exemplo: CPF XXX.XXX.XX"6"-YY

O número destacado (6) indica que a origem deste CPF é Minas Gerais, cujo código é "6". Segue a lista com todos os estados brasileiros:

• 0 Rio Grande do Sul
• 1 Distrito Federal, Goiás, Mato Grosso, Mato Grosso do Sul e Tocantins
• 2 Amazonas, Pará, Roraima, Amapá, Acre e Rondônia
• 3 Ceará, Maranhão e Piauí
• 4 Paraíba, Pernambuco, Alagoas e Rio Grande do Norte
• 5 Bahia e Sergipe
• 6 Minas Gerais
• 7 Rio de Janeiro e Espírito Santo
• 8 São Paulo
• 9 Paraná e Santa Catarina

Algoritmo de validação

Pseudocode

function ValidarCPF(cpf: int[11]) -> bool
    var v: int[2]

    //Exemplo CPF para testes: 12345678909
    //Nota: Calcula o primeiro dígito de verificação.
    v[0] := 10×cpf[0] + 9×cpf[1] + 8×cpf[2]
    v[0] +=  7×cpf[3] + 6×cpf[4] + 5×cpf[5]
    v[0] +=  4×cpf[6] + 3×cpf[7] + 2×cpf[8]
    v[0] := 11 - v[0] mod 11
    v[0] := 0 if v[0] = 10

    //Nota: Calcula o segundo dígito de verificação.
    v[1] := 11×cpf[0] + 10×cpf[1] + 9×cpf[2]
    v[1] +=  8×cpf[3] +  7×cpf[4] + 6×cpf[5]
    v[1] +=  5×cpf[6] +  4×cpf[7] + 3×cpf[8]
    v[1] +=  2×v[0]
    v[1] := 11 - v[1] mod 11
    v[1] := 0 if v[1] = 10

    //Nota: Verdadeiro se os dígitos de verificação são os esperados.
    return v[0] = cpf[9] and v[1] = cpf[10]

C#

     public bool seraUmCpf(string CandidatoACpf)
        {
            CandidatoACpf = CandidatoACpf.Replace("-", "").Replace(".", "").Replace(",", "").Replace(" ", "").Replace("_", "");
            if (CandidatoACpf.Length != 11)
                return false;
	    if(1.ToString() == "1")
		{
            int ResultadoTotal = 0;
            int RestoDaDivisao = 0;
            for (int i = 0; i < 9; i++)
            {
                ResultadoTotal += ((((int.Parse(CandidatoACpf[i].ToString()) * (i + 1)))));
            }
            RestoDaDivisao = ResultadoTotal % 11;
            if (RestoDaDivisao.ToString() != CandidatoACpf[9].ToString())
                return false;
            ResultadoTotal = 0;
            for (int i = 0; i < 10; i++)
            {
                char current = CandidatoACpf[i];
                ResultadoTotal += int.Parse(current.ToString()) * (i);
            }
            RestoDaDivisao = ResultadoTotal % 11;
            if (RestoDaDivisao.ToString() != CandidatoACpf[10].ToString())
                return false;
            return true;
		}else return false;

        }

Java

    public static boolean isCpfOK(long cpf) {
        /*
         * cpf = XXX.XXX.XXX-DV
         * dv = d1 * 10 + d2
         */
        long dv = cpf % 100;
        cpf /= 10;
        int d2 = 0;
        for (int i = 1; i <= 10; i++) {
            long x = cpf % (long) Math.pow(10, 11 - i);
            long y = x / (long) Math.pow(10, 10 - i);
            d2 += y * (i - 1);
        }
        d2 = (d2 % 11) % 10;
        cpf /= 10;
        int d1 = 0;
        for (int i = 1; i <= 9; i++) {
            long x = cpf % (long) Math.pow(10, 10 - i);
            long y = x / (long) Math.pow(10, 9 - i);
            d1 += y * i;
        }
        d1 = (d1 % 11) % 10;
        return dv == (d1 * 10 + d2);
    }

JavaScript

    function validarCpf(cpf){
        var digitsString = cpf.replace(/[^0-9]/g, '');
        var digits;
        var a,b,c,d,e,f,g,h,i,j,k;
        var dv1, dv2;
        var soma, resto;
        
        if (digitsString.length == 11){
            digits = digitsString.split('');
            a = parseInt(digits[ 0 ]);
            b = parseInt(digits[ 1 ]);
            c = parseInt(digits[ 2 ]);
            d = parseInt(digits[ 3 ]);
            e = parseInt(digits[ 4 ]);
            f = parseInt(digits[ 5 ]);
            g = parseInt(digits[ 6 ]);
            h = parseInt(digits[ 7 ]);
            i = parseInt(digits[ 8 ]);
            j = parseInt(digits[ 9 ]);
            k = parseInt(digits[ 10 ]);
            soma = a*10 + b*9 + c*8 + d*7 + e*6 + f*5 + g*4 + h*3 + i*2;
            resto = soma % 11;
            dv1 = (11 - resto < 10 ? 11 - resto : 0);
            soma = a*11 + b*10 + c*9 + d*8 + e*7 + f*6 + g*5 + h*4 + i*3 + dv1*2;
            resto = soma % 11;
            dv2 = (11 - resto < 10 ? 11 - resto : 0);
            return dv1 == j && dv2 == k;
        }
        return false;
    }

PHP

/**
 * Verifica se é um número de CPF válido.
 *
 * @param $cpf O número a ser verificado
 * @return boolean
 */
function validarCPF($cpf)
{
    // remove os caracteres não-numéricos
    $cpf = preg_replace('/\D/', '', $cpf);

    // verifica se a sequência tem 11 dígitos
    if (strlen($cpf) != 11)
        return false;

    // calcula o primeiro dígito verificador 
    $sum = 0;
    for ($i = 0; $i < 9; $i++) {
        $sum += $cpf[$i] * (10-$i);
    }
    $mod = $sum % 11;
    $digit = ($mod > 1) ? (11 - $mod) : 0;

    // verifica se o primeiro dígito verificador está correto
    if ($cpf[9] != $digit)
        return false;

    // calcula o segundo dígito verificador
    $sum = 0;
    for ($i = 0; $i < 10; $i++) {
        $sum += $cpf[$i] * (11-$i);
    }
    $mod = $sum % 11;
    $digit = ($mod > 1) ? (11 - $mod) : 0;

    // verifica se o segundo dígito verificador está correto
    if ($cpf[10] != $digit)
        return false;

    // está tudo certo
    return true;
}

PL/SQL

Nota: esta função replica o cálculo, mas para retornar os validadores. Fazer a validação será comparar o retorno desta função com os 2 últimos dígitos do número),

create or replace function ObterValidadores
(
  i_Numero in nvarchar2
)
return nvarchar2
is
  v_Digito1 number;
  v_Digito2 number;
begin

  -----------------------------------------------------------------------------
  -- Validacoes
  -----------------------------------------------------------------------------
  if ( i_Numero is null ) then
    return null;
  end if;

  if ( length( i_Numero ) not in ( 9, 11 ) ) then
    return null;
  end if;

  declare
    v_Numero number;
  begin
    v_Numero := to_number( i_Numero );
  exception
    when OTHERS then
      return null;
  end;

  -----------------------------------------------------------------------------
  -- Se o Numero tiver tamanho 11, entao os 2 ultimos sao os
  -- digitos verificadores. Retorna-los logo.
  -----------------------------------------------------------------------------
  if ( length( i_Numero ) = 11 ) then
    return substr( i_Numero, 10, 2 );
  end if;

  -----------------------------------------------------------------------------
  -- Foi dado numero com tamanho 9. Calcular o primeiro digito verificador.
  -----------------------------------------------------------------------------
  v_Digito1 :=
    10 * to_number( substr( i_Numero, 1, 1 ) ) +
     9 * to_number( substr( i_Numero, 2, 1 ) ) +
     8 * to_number( substr( i_Numero, 3, 1 ) ) +
     7 * to_number( substr( i_Numero, 4, 1 ) ) +
     6 * to_number( substr( i_Numero, 5, 1 ) ) +
     5 * to_number( substr( i_Numero, 6, 1 ) ) +
     4 * to_number( substr( i_Numero, 7, 1 ) ) +
     3 * to_number( substr( i_Numero, 8, 1 ) ) +
     2 * to_number( substr( i_Numero, 9, 1 ) );

  v_Digito1 := 11 - ( v_Digito1 mod 11 );

  v_Digito1 := case when v_Digito1 >= 10 then 0 else v_Digito1 end;

  -----------------------------------------------------------------------------
  -- Foi dado numero com tamanho 9. Calcular o segundo digito verificador.
  -----------------------------------------------------------------------------
  v_Digito2 :=
    11 * to_number( substr( i_Numero, 1, 1 ) ) +
    10 * to_number( substr( i_Numero, 2, 1 ) ) +
     9 * to_number( substr( i_Numero, 3, 1 ) ) +
     8 * to_number( substr( i_Numero, 4, 1 ) ) +
     7 * to_number( substr( i_Numero, 5, 1 ) ) +
     6 * to_number( substr( i_Numero, 6, 1 ) ) +
     5 * to_number( substr( i_Numero, 7, 1 ) ) +
     4 * to_number( substr( i_Numero, 8, 1 ) ) +
     3 * to_number( substr( i_Numero, 9, 1 ) );

  v_Digito2 := v_Digito2 + 2 * v_Digito1;

  v_Digito2 := 11 - ( v_Digito2 mod 11 );

  v_Digito2 := case when v_Digito2 >= 10 then 0 else v_Digito2 end;

  -----------------------------------------------------------------------------
  -- Retornar os dois digitos, concatenados.
  -----------------------------------------------------------------------------
  return to_char( v_Digito1 ) || to_char( v_Digito2 );

end ObterValidadores;

Python

def validar_cpf(cpf):
    digitos = [int(c) for c in cpf if c.isdigit()]
    if len(digitos) == 11:
        a,b,c,d,e,f,g,h,i,j,k = digitos
        numeros = [a,b,c,d,e,f,g,h,i]
        r = range(10, 1, -1)
        soma = sum([x * y for x, y in zip(numeros, r)])
        resto = soma % 11
        dv1 = (11 - resto if 11 - resto < 10 else 0)
        numeros = [a,b,c,d,e,f,g,h,i,dv1]
        r = range(11, 1, -1)
        soma = sum([x*y for x, y in zip(numeros, r)])
        resto = soma % 11
        dv2 = (11 - resto if 11 - resto < 10 else 0)
        return dv1 == j and dv2 == k
    return False

Ver também

• Cédula de identidade
• Cadastro Nacional de Pessoa Jurídica - (Cadastro nacional de pessoas jurídicas)

Ligações externas

• Receita Federal - Cadastro de Pessoas Físicas - CPF
• Memória da Receita Federal