CPF Generator

Introduction

The CPF (Cadastro de Pessoas Físicas) is a unique identifier assigned to Brazilian citizens and residents for tax purposes. This generator creates valid, random CPF numbers for testing purposes. It's important to note that these generated CPFs are not associated with real individuals and should only be used in testing environments.

Structure of a CPF

A CPF consists of 11 digits:

• The first 9 digits are the base numbers
• The last 2 digits are check digits

The format is typically represented as: XXX.XXX.XXX-XX

CPF Validation Algorithm

The CPF validation algorithm ensures the integrity of the number. Here's how it works:

1. Multiply the first 9 digits by weights (10 to 2)
2. Sum the results
3. Calculate the remainder of the sum divided by 11
4. If the remainder is less than 2, the first check digit is 0; otherwise, it's 11 minus the remainder
5. Repeat the process for the first 10 digits (including the first check digit) with weights 11 to 2
6. Calculate the second check digit using the same rule as the first

How to Use This Generator

1. Click the "Generate CPF" button
2. A valid, random CPF will be displayed
3. You can copy the generated CPF to use in your testing scenarios

Formula

The formula for generating a valid CPF is as follows:

def generate_cpf():
    # Generate 9 random digits
    base_cpf = [random.randint(0, 9) for _ in range(9)]
    
    # Calculate first check digit
    sum_1 = sum((10 - i) * digit for i, digit in enumerate(base_cpf))
    check_digit_1 = (sum_1 * 10 % 11) % 10
    
    # Calculate second check digit
    sum_2 = sum((11 - i) * digit for i, digit in enumerate(base_cpf + [check_digit_1]))
    check_digit_2 = (sum_2 * 10 % 11) % 10
    
    return base_cpf + [check_digit_1, check_digit_2]

Calculation

The generator performs the following steps:

1. Generate 9 random digits
2. Calculate the first check digit using the algorithm described above
3. Calculate the second check digit
4. Combine all digits to form the complete CPF

Examples

Here are some examples of generated CPFs:

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

Use Cases

The CPF generator is useful in various software development and testing scenarios:

1. Database Testing: Populate test databases with valid CPF numbers
2. Form Validation: Test input validation for Brazilian user registration forms
3. API Testing: Use generated CPFs in API requests that require valid Brazilian identification
4. Performance Testing: Generate large sets of unique, valid CPFs for load testing
5. UI/UX Testing: Ensure proper formatting and display of CPF numbers in user interfaces

Alternatives

While the CPF is the primary individual identifier in Brazil, there are other identifiers that may be used in specific contexts:

1. RG (Registro Geral): A state-issued identity document
2. CNPJ (Cadastro Nacional da Pessoa Jurídica): Used for businesses and legal entities
3. PIS/PASEP: Used for employment-related purposes

History

The CPF was introduced in Brazil in 1965 as part of a broader effort to modernize the country's tax system. Initially, it was used primarily for income tax purposes, but over time, its use expanded to various other areas of Brazilian bureaucracy and commerce.

Key milestones in CPF history:

• 1965: CPF introduced for individuals
• 1972: CPF becomes mandatory for all tax-paying individuals
• 1990s: CPF starts being used more widely in commercial and financial transactions
• 2000s: Digital systems further integrate CPF into daily life in Brazil

Today, the CPF is an essential part of Brazilian citizens' and residents' interactions with government services, financial institutions, and many commercial transactions.

Code Examples

Here are code snippets for generating and validating CPFs in various programming languages:

import random

def generate_cpf():
    cpf = [random.randint(0, 9) for _ in range(9)]
    for _ in range(2):
        value = sum((cpf[num] * ((len(cpf) + 1) - num) for num in range(len(cpf)))) % 11
        cpf.append(11 - value if value > 1 else 0)
    return ''.join(map(str, cpf))

def validate_cpf(cpf):
    numbers = [int(digit) for digit in cpf if digit.isdigit()]
    if len(numbers) != 11 or len(set(numbers)) == 1:
        return False
    for i in range(9, 11):
        value = sum((numbers[num] * ((i + 1) - num) for num in range(i))) % 11
        if numbers[i] != (11 - value if value > 1 else 0):
            return False
    return True

## Example usage
cpf = generate_cpf()
print(f"Generated CPF: {cpf}")
print(f"Is valid: {validate_cpf(cpf)}")

function generateCPF() {
    const cpf = Array.from({length: 9}, () => Math.floor(Math.random() * 10));
    for (let i = 0; i < 2; i++) {
        let sum = cpf.reduce((acc, cur, idx) => acc + cur * (cpf.length + 1 - idx), 0);
        let digit = 11 - (sum % 11);
        cpf.push(digit > 9 ? 0 : digit);
    }
    return cpf.join('');
}

function validateCPF(cpf) {
    const numbers = cpf.match(/\d/g).map(Number);
    if (numbers.length !== 11 || new Set(numbers).size === 1) return false;
    for (let i = 9; i < 11; i++) {
        let sum = numbers.slice(0, i).reduce((acc, cur, idx) => acc + cur * (i + 1 - idx), 0);
        let digit = 11 - (sum % 11);
        if (numbers[i] !== (digit > 9 ? 0 : digit)) return false;
    }
    return true;
}

// Example usage
const cpf = generateCPF();
console.log(`Generated CPF: ${cpf}`);
console.log(`Is valid: ${validateCPF(cpf)}`);

import java.util.Random;

public class CPFGenerator {
    private static final Random random = new Random();

    public static String generateCPF() {
        int[] cpf = new int[11];
        for (int i = 0; i < 9; i++) {
            cpf[i] = random.nextInt(10);
        }
        cpf[9] = calculateCheckDigit(cpf, 10);
        cpf[10] = calculateCheckDigit(cpf, 11);
        return formatCPF(cpf);
    }

    private static int calculateCheckDigit(int[] cpf, int factor) {
        int sum = 0;
        for (int i = 0; i < factor - 1; i++) {
            sum += cpf[i] * (factor - i);
        }
        int result = 11 - (sum % 11);
        return result > 9 ? 0 : result;
    }

    private static String formatCPF(int[] cpf) {
        return String.format("%d%d%d.%d%d%d.%d%d%d-%d%d",
                cpf[0], cpf[1], cpf[2], cpf[3], cpf[4], cpf[5], cpf[6], cpf[7], cpf[8], cpf[9], cpf[10]);
    }

    public static boolean validateCPF(String cpf) {
        cpf = cpf.replaceAll("[^0-9]", "");
        if (cpf.length() != 11) return false;
        int[] numbers = cpf.chars().map(Character::getNumericValue).toArray();
        if (allEqual(numbers)) return false;
        int digit10 = calculateCheckDigit(numbers, 10);
        int digit11 = calculateCheckDigit(numbers, 11);
        return numbers[9] == digit10 && numbers[10] == digit11;
    }

    private static boolean allEqual(int[] array) {
        for (int i = 1; i < array.length; i++) {
            if (array[i] != array[0]) return false;
        }
        return true;
    }

    public static void main(String[] args) {
        String cpf = generateCPF();
        System.out.println("Generated CPF: " + cpf);
        System.out.println("Is valid: " + validateCPF(cpf));
    }
}

These examples demonstrate how to generate and validate CPFs in Python, JavaScript, and Java. You can adapt these functions to your specific needs or integrate them into larger systems that require CPF handling.

Legal and Ethical Considerations

When using generated CPFs, it's crucial to keep the following points in mind:

1. Generated CPFs are for testing purposes only and should never be used to impersonate real individuals or for any fraudulent activities.
2. Clearly label any test data containing generated CPFs to prevent confusion with real personal data.
3. Be aware of data protection laws and regulations in your jurisdiction when handling even fake personal identifiers.
4. In production environments, always use real, verified CPFs provided by users or authorized sources.
5. Implement proper security measures to protect both real and generated CPFs in your systems.

References

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. "História do CPF." https://www.gov.br/fazenda/pt-br/assuntos/receita-federal
4. Lei nº 4.862, de 29 de novembro de 1965. "Altera a legislação do impôsto de renda, adota diversas medidas de ordem fiscal e fazendária, e dá outras providências."