Generador de CPF

Introducción

El CPF (Cadastro de Pessoas Físicas) es un identificador único asignado a ciudadanos y residentes brasileños para fines fiscales. Este generador crea números de CPF válidos y aleatorios para fines de prueba. Es importante señalar que estos CPFs generados no están asociados con individuos reales y solo deben usarse en entornos de prueba.

Estructura de un CPF

Un CPF consta de 11 dígitos:

• Los primeros 9 dígitos son los números base
• Los últimos 2 dígitos son dígitos de verificación

El formato se representa típicamente como: XXX.XXX.XXX-XX

Algoritmo de Validación de CPF

El algoritmo de validación de CPF asegura la integridad del número. Así es como funciona:

1. Multiplicar los primeros 9 dígitos por pesos (10 a 2)
2. Sumar los resultados
3. Calcular el resto de la suma dividida por 11
4. Si el resto es menor que 2, el primer dígito de verificación es 0; de lo contrario, es 11 menos el resto
5. Repetir el proceso para los primeros 10 dígitos (incluyendo el primer dígito de verificación) con pesos de 11 a 2
6. Calcular el segundo dígito de verificación utilizando la misma regla que el primero

Cómo Usar Este Generador

1. Haga clic en el botón "Generar CPF"
2. Se mostrará un CPF válido y aleatorio
3. Puede copiar el CPF generado para usarlo en sus escenarios de prueba

Fórmula

La fórmula para generar un CPF válido es la siguiente:

1def generate_cpf():
2    # Generar 9 dígitos aleatorios
3    base_cpf = [random.randint(0, 9) for _ in range(9)]
4    
5    # Calcular el primer dígito de verificación
6    sum_1 = sum((10 - i) * digit for i, digit in enumerate(base_cpf))
7    check_digit_1 = (sum_1 * 10 % 11) % 10
8    
9    # Calcular el segundo dígito de verificación
10    sum_2 = sum((11 - i) * digit for i, digit in enumerate(base_cpf + [check_digit_1]))
11    check_digit_2 = (sum_2 * 10 % 11) % 10
12    
13    return base_cpf + [check_digit_1, check_digit_2]
14

Cálculo

El generador realiza los siguientes pasos:

1. Generar 9 dígitos aleatorios
2. Calcular el primer dígito de verificación utilizando el algoritmo descrito anteriormente
3. Calcular el segundo dígito de verificación
4. Combinar todos los dígitos para formar el CPF completo

Ejemplos

Aquí hay algunos ejemplos de CPFs generados:

1. 123.456.789-09
2. 987.654.321-00
3. 111.222.333-96

Casos de Uso

El generador de CPF es útil en varios escenarios de desarrollo de software y pruebas:

1. Pruebas de Base de Datos: Población de bases de datos de prueba con números de CPF válidos
2. Validación de Formularios: Probar la validación de entrada para formularios de registro de usuarios brasileños
3. Pruebas de API: Usar CPFs generados en solicitudes de API que requieren identificación brasileña válida
4. Pruebas de Rendimiento: Generar grandes conjuntos de CPFs únicos y válidos para pruebas de carga
5. Pruebas de UI/UX: Asegurar el formato y la visualización adecuados de los números de CPF en las interfaces de usuario

Alternativas

Si bien el CPF es el principal identificador individual en Brasil, hay otros identificadores que pueden usarse en contextos específicos:

1. RG (Registro Geral): Un documento de identidad emitido por el estado
2. CNPJ (Cadastro Nacional da Pessoa Jurídica): Usado para negocios y entidades legales
3. PIS/PASEP: Usado para fines relacionados con el empleo

Historia

El CPF fue introducido en Brasil en 1965 como parte de un esfuerzo más amplio para modernizar el sistema fiscal del país. Inicialmente, se utilizó principalmente para fines de impuestos sobre la renta, pero con el tiempo, su uso se expandió a varias otras áreas de la burocracia y el comercio brasileños.

Hitos clave en la historia del CPF:

• 1965: CPF introducido para individuos
• 1972: CPF se vuelve obligatorio para todos los individuos que pagan impuestos
• 1990s: CPF comienza a ser utilizado más ampliamente en transacciones comerciales y financieras
• 2000s: Sistemas digitales integran aún más el CPF en la vida diaria en Brasil

Hoy en día, el CPF es una parte esencial de las interacciones de los ciudadanos y residentes brasileños con los servicios gubernamentales, las instituciones financieras y muchas transacciones comerciales.

Ejemplos de Código

Aquí hay fragmentos de código para generar y validar CPFs en varios lenguajes de programación:

1import random
2
3def generate_cpf():
4    cpf = [random.randint(0, 9) for _ in range(9)]
5    for _ in range(2):
6        value = sum((cpf[num] * ((len(cpf) + 1) - num) for num in range(len(cpf)))) % 11
7        cpf.append(11 - value if value > 1 else 0)
8    return ''.join(map(str, cpf))
9
10def validate_cpf(cpf):
11    numbers = [int(digit) for digit in cpf if digit.isdigit()]
12    if len(numbers) != 11 or len(set(numbers)) == 1:
13        return False
14    for i in range(9, 11):
15        value = sum((numbers[num] * ((i + 1) - num) for num in range(i))) % 11
16        if numbers[i] != (11 - value if value > 1 else 0):
17            return False
18    return True
19
20## Ejemplo de uso
21cpf = generate_cpf()
22print(f"CPF Generado: {cpf}")
23print(f"Es válido: {validate_cpf(cpf)}")
24

1function generateCPF() {
2    const cpf = Array.from({length: 9}, () => Math.floor(Math.random() * 10));
3    for (let i = 0; i < 2; i++) {
4        let sum = cpf.reduce((acc, cur, idx) => acc + cur * (cpf.length + 1 - idx), 0);
5        let digit = 11 - (sum % 11);
6        cpf.push(digit > 9 ? 0 : digit);
7    }
8    return cpf.join('');
9}
10
11function validateCPF(cpf) {
12    const numbers = cpf.match(/\d/g).map(Number);
13    if (numbers.length !== 11 || new Set(numbers).size === 1) return false;
14    for (let i = 9; i < 11; i++) {
15        let sum = numbers.slice(0, i).reduce((acc, cur, idx) => acc + cur * (i + 1 - idx), 0);
16        let digit = 11 - (sum % 11);
17        if (numbers[i] !== (digit > 9 ? 0 : digit)) return false;
18    }
19    return true;
20}
21
22// Ejemplo de uso
23const cpf = generateCPF();
24console.log(`CPF Generado: ${cpf}`);
25console.log(`Es válido: ${validateCPF(cpf)}`);
26

1import java.util.Random;
2
3public class CPFGenerator {
4    private static final Random random = new Random();
5
6    public static String generateCPF() {
7        int[] cpf = new int[11];
8        for (int i = 0; i < 9; i++) {
9            cpf[i] = random.nextInt(10);
10        }
11        cpf[9] = calculateCheckDigit(cpf, 10);
12        cpf[10] = calculateCheckDigit(cpf, 11);
13        return formatCPF(cpf);
14    }
15
16    private static int calculateCheckDigit(int[] cpf, int factor) {
17        int sum = 0;
18        for (int i = 0; i < factor - 1; i++) {
19            sum += cpf[i] * (factor - i);
20        }
21        int result = 11 - (sum % 11);
22        return result > 9 ? 0 : result;
23    }
24
25    private static String formatCPF(int[] cpf) {
26        return String.format("%d%d%d.%d%d%d.%d%d%d-%d%d",
27                cpf[0], cpf[1], cpf[2], cpf[3], cpf[4], cpf[5], cpf[6], cpf[7], cpf[8], cpf[9], cpf[10]);
28    }
29
30    public static boolean validateCPF(String cpf) {
31        cpf = cpf.replaceAll("[^0-9]", "");
32        if (cpf.length() != 11) return false;
33        int[] numbers = cpf.chars().map(Character::getNumericValue).toArray();
34        if (allEqual(numbers)) return false;
35        int digit10 = calculateCheckDigit(numbers, 10);
36        int digit11 = calculateCheckDigit(numbers, 11);
37        return numbers[9] == digit10 && numbers[10] == digit11;
38    }
39
40    private static boolean allEqual(int[] array) {
41        for (int i = 1; i < array.length; i++) {
42            if (array[i] != array[0]) return false;
43        }
44        return true;
45    }
46
47    public static void main(String[] args) {
48        String cpf = generateCPF();
49        System.out.println("CPF Generado: " + cpf);
50        System.out.println("Es válido: " + validateCPF(cpf));
51    }
52}
53

Estos ejemplos demuestran cómo generar y validar CPFs en Python, JavaScript y Java. Puede adaptar estas funciones a sus necesidades específicas o integrarlas en sistemas más grandes que requieran manejo de CPF.

Consideraciones Legales y Éticas

Al usar CPFs generados, es crucial tener en cuenta los siguientes puntos:

1. Los CPFs generados son solo para fines de prueba y nunca deben usarse para impersonar a individuos reales o para actividades fraudulentas.
2. Etiquete claramente cualquier dato de prueba que contenga CPFs generados para evitar confusiones con datos personales reales.
3. Sea consciente de las leyes y regulaciones de protección de datos en su jurisdicción al manejar incluso identificadores personales falsos.
4. En entornos de producción, siempre use CPFs reales y verificados proporcionados por los usuarios o fuentes autorizadas.
5. Implemente medidas de seguridad adecuadas para proteger tanto los CPFs reales como los generados en sus sistemas.

Referencias

1. Receita Federal do Brasil. "CPF - Cadastro de Pessoas Físicas." https://www.gov.br/receitafederal/pt-br/assuntos/orientacao-tributaria/cadastros/cpf
2. Serpro. "Validador de CPF." https://www.serpro.gov.br/links-fixos-superiores/validador-cpf
3. Ministério da Fazenda. "Historia del CPF." https://www.gov.br/fazenda/pt-br/assuntos/receita-federal
4. Ley nº 4.862, de 29 de noviembre de 1965. "Modifica la legislación del impuesto sobre la renta, adopta diversas medidas de orden fiscal y financiero, y da otras providencias."