Générateur de CPF

Introduction

Le CPF (Cadastro de Pessoas Físicas) est un identifiant unique attribué aux citoyens et résidents brésiliens à des fins fiscales. Ce générateur crée des numéros de CPF valides et aléatoires à des fins de test. Il est important de noter que ces CPFs générés ne sont pas associés à de vraies personnes et doivent uniquement être utilisés dans des environnements de test.

Structure d'un CPF

Un CPF se compose de 11 chiffres :

• Les 9 premiers chiffres sont les numéros de base
• Les 2 derniers chiffres sont des chiffres de contrôle

Le format est généralement représenté comme : XXX.XXX.XXX-XX

Algorithme de validation du CPF

L'algorithme de validation du CPF garantit l'intégrité du numéro. Voici comment cela fonctionne :

1. Multiplier les 9 premiers chiffres par des poids (10 à 2)
2. Additionner les résultats
3. Calculer le reste de la somme divisée par 11
4. Si le reste est inférieur à 2, le premier chiffre de contrôle est 0 ; sinon, c'est 11 moins le reste
5. Répéter le processus pour les 10 premiers chiffres (y compris le premier chiffre de contrôle) avec des poids de 11 à 2
6. Calculer le deuxième chiffre de contrôle en utilisant la même règle que pour le premier

Comment utiliser ce générateur

1. Cliquez sur le bouton "Générer CPF"
2. Un CPF valide et aléatoire sera affiché
3. Vous pouvez copier le CPF généré pour l'utiliser dans vos scénarios de test

Formule

La formule pour générer un CPF valide est la suivante :

1def generate_cpf():
2    # Générer 9 chiffres aléatoires
3    base_cpf = [random.randint(0, 9) for _ in range(9)]
4    
5    # Calculer le premier chiffre de contrôle
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    # Calculer le deuxième chiffre de contrôle
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

Calcul

Le générateur effectue les étapes suivantes :

1. Générer 9 chiffres aléatoires
2. Calculer le premier chiffre de contrôle en utilisant l'algorithme décrit ci-dessus
3. Calculer le deuxième chiffre de contrôle
4. Combiner tous les chiffres pour former le CPF complet

Exemples

Voici quelques exemples de CPFs générés :

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

Cas d'utilisation

Le générateur de CPF est utile dans divers scénarios de développement et de test de logiciels :

1. Test de base de données : peupler des bases de données de test avec des numéros de CPF valides
2. Validation de formulaire : tester la validation des entrées pour les formulaires d'inscription d'utilisateurs brésiliens
3. Test d'API : utiliser des CPFs générés dans des requêtes API nécessitant une identification brésilienne valide
4. Test de performance : générer de grands ensembles de CPFs uniques et valides pour des tests de charge
5. Test UI/UX : s'assurer du bon formatage et de l'affichage des numéros de CPF dans les interfaces utilisateur

Alternatives

Bien que le CPF soit l'identifiant principal des individus au Brésil, il existe d'autres identifiants qui peuvent être utilisés dans des contextes spécifiques :

1. RG (Registro Geral) : un document d'identité délivré par l'État
2. CNPJ (Cadastro Nacional da Pessoa Jurídica) : utilisé pour les entreprises et les entités juridiques
3. PIS/PASEP : utilisé à des fins liées à l'emploi

Histoire

Le CPF a été introduit au Brésil en 1965 dans le cadre d'un effort plus large pour moderniser le système fiscal du pays. À l'origine, il était utilisé principalement à des fins d'impôt sur le revenu, mais au fil du temps, son utilisation s'est étendue à divers autres domaines de la bureaucratie et du commerce brésilien.

Principales étapes de l'histoire du CPF :

• 1965 : CPF introduit pour les individus
• 1972 : CPF devient obligatoire pour tous les individus assujettis à l'impôt
• Années 1990 : Le CPF commence à être utilisé plus largement dans les transactions commerciales et financières
• Années 2000 : Les systèmes numériques intègrent davantage le CPF dans la vie quotidienne au Brésil

Aujourd'hui, le CPF est une partie essentielle des interactions des citoyens et résidents brésiliens avec les services gouvernementaux, les institutions financières et de nombreuses transactions commerciales.

Exemples de code

Voici des extraits de code pour générer et valider des CPFs dans divers langages de programmation :

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## Exemple d'utilisation
21cpf = generate_cpf()
22print(f"CPF généré : {cpf}")
23print(f"Est valide : {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// Exemple d'utilisation
23const cpf = generateCPF();
24console.log(`CPF généré : ${cpf}`);
25console.log(`Est valide : ${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 généré : " + cpf);
50        System.out.println("Est valide : " + validateCPF(cpf));
51    }
52}
53

Ces exemples démontrent comment générer et valider des CPFs en Python, JavaScript et Java. Vous pouvez adapter ces fonctions à vos besoins spécifiques ou les intégrer dans des systèmes plus larges nécessitant la gestion des CPF.

Considérations légales et éthiques

Lors de l'utilisation de CPFs générés, il est crucial de garder à l'esprit les points suivants :

1. Les CPFs générés sont uniquement à des fins de test et ne doivent jamais être utilisés pour usurper l'identité de vraies personnes ou pour des activités frauduleuses.
2. Étiquetez clairement toutes les données de test contenant des CPFs générés pour éviter toute confusion avec des données personnelles réelles.
3. Soyez conscient des lois et règlements sur la protection des données dans votre juridiction lorsque vous manipulez même de faux identifiants personnels.
4. Dans les environnements de production, utilisez toujours des CPFs réels et vérifiés fournis par les utilisateurs ou des sources autorisées.
5. Mettez en œuvre des mesures de sécurité appropriées pour protéger à la fois les CPFs réels et générés dans vos systèmes.

Références

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 du CPF." https://www.gov.br/fazenda/pt-br/assuntos/receita-federal
4. Loi nº 4.862, du 29 novembre 1965. "Modifie la législation de l'impôt sur le revenu, adopte diverses mesures d'ordre fiscal et financier, et prend d'autres dispositions."