Cadastro de Pessoas Físicas
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.
Índice |
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.
[editar] Instituição do CPF
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.
[editar] 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
[editar] Algoritmo de validação
[editar] 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]
[editar] 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;
}
[editar] 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);
}
[editar] 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;
}
[editar] 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; }
[editar] 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;
[editar] 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
[editar] Ver também
- Cédula de identidade
- Cadastro Nacional de Pessoa Jurídica - (Cadastro nacional de pessoas jurídicas)
