Gerador de Dados

Gerador de CNH

Gere números de registro da CNH com 11 dígitos para testes.

A CNH, Carteira Nacional de Habilitação, é o documento relacionado à habilitação de condutores no Brasil. Seu número de registro possui regras de composição e verificação. A ferramenta gera exemplos desse número para testes de software, sem emitir uma habilitação ou comprovar aptidão para dirigir.

Resultado

Dados sintéticos para testes. Dígitos corretos não comprovam emissão, existência ou situação cadastral do documento.

Esta ferramenta foi desenvolvida para apoiar estudantes e programadores em atividades de aprendizagem, desenvolvimento e testes autorizados. Utilize os resultados com responsabilidade, respeitando a privacidade, os direitos de terceiros e as regras do ambiente em que forem aplicados. Sua finalidade é educativa e técnica, sem promover fraude, uso indevido de dados ou qualquer ação que prejudique instituições, pessoas ou grupos.

Como usar

Escolha a quantidade. A ferramenta gera o número de registro com dois dígitos verificadores; esse número é diferente do número do espelho, RENACH e código de segurança da CNH.

Exemplos de código

Implemente no seu projeto

function executar(count = 1) {
    const ELECTORAL_STATES = [
        ['01', 'SP'], ['02', 'MG'], ['03', 'RJ'], ['04', 'RS'], ['05', 'BA'],
        ['06', 'PR'], ['07', 'CE'], ['08', 'PE'], ['09', 'SC'], ['10', 'GO'],
        ['11', 'MA'], ['12', 'PB'], ['13', 'PA'], ['14', 'ES'], ['15', 'PI'],
        ['16', 'RN'], ['17', 'AL'], ['18', 'MT'], ['19', 'MS'], ['20', 'DF'],
        ['21', 'SE'], ['22', 'AM'], ['23', 'RO'], ['24', 'AC'], ['25', 'AP'],
        ['26', 'RR'], ['27', 'TO'], ['28', 'Exterior'],
    ];
    function weightedSum(base, weights, alphanumeric = false) {
        return [...base].reduce((sum, character, index) => sum + (alphanumeric ? character.charCodeAt(0) - 48 : Number(character)) * weights[index], 0);
    }
    function mod11(base, weights, alphanumeric = false) {
        const remainder = weightedSum(base, weights, alphanumeric) % 11;
        return remainder < 2 ? 0 : 11 - remainder;
    }
    function assertBase(base, length, alphanumeric = false) {
        if (base.length !== length || !(alphanumeric ? /^[0-9A-Z]+$/ : /^\d+$/).test(base)) {
            throw new Error(`A base deve ter ${length} ${alphanumeric ? 'caracteres de 0 a 9 ou A a Z' : 'dígitos'}.`);
        }
    }
    function cpfChecksum(base) {
        assertBase(base, 9);
        const first = mod11(base, [10, 9, 8, 7, 6, 5, 4, 3, 2]);
        return `${first}${mod11(base + first, [11, 10, 9, 8, 7, 6, 5, 4, 3, 2])}`;
    }
    function cnpjChecksum(base) {
        assertBase(base, 12, true);
        const first = mod11(base, [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2], true);
        return `${first}${mod11(base + first, [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2], true)}`;
    }
    function rgChecksum(base) {
        assertBase(base, 8);
        const digit = (11 - weightedSum(base, [2, 3, 4, 5, 6, 7, 8, 9]) % 11) % 11;
        return digit === 10 ? 'X' : String(digit);
    }
    function cnhChecksum(base) {
        assertBase(base, 9);
        const remainder = weightedSum(base, [9, 8, 7, 6, 5, 4, 3, 2, 1]) % 11;
        const first = remainder === 10 ? 0 : remainder;
        const secondRemainder = weightedSum(base, [1, 2, 3, 4, 5, 6, 7, 8, 9]) % 11;
        const second = secondRemainder === 10 ? 0 : secondRemainder - (remainder === 10 ? 2 : 0);
        // Evita bases que levam a um resultado negativo nas regras legadas de CNH.
        return second < 0 ? null : `${first}${second}`;
    }
    function electoralChecksum(base) {
        assertBase(base, 10);
        const state = base.slice(8);
        if (!ELECTORAL_STATES.some(([code]) => code === state))
            throw new Error('Selecione uma UF eleitoral válida.');
        const digit = (remainder) => remainder === 10 ? 0 : remainder === 0 && (state === '01' || state === '02') ? 1 : remainder;
        const first = digit(weightedSum(base.slice(0, 8), [2, 3, 4, 5, 6, 7, 8, 9]) % 11);
        return `${first}${digit(weightedSum(state + first, [7, 8, 9]) % 11)}`;
    }
    function pisChecksum(base) {
        assertBase(base, 10);
        return String(mod11(base, [3, 2, 9, 8, 7, 6, 5, 4, 3, 2]));
    }
    function renavamChecksum(base) {
        assertBase(base, 10);
        return String(mod11(base, [3, 2, 9, 8, 7, 6, 5, 4, 3, 2]));
    }
    function completeStateRegistration(base, state) {
        if (state === 'SP') {
            assertBase(base, 10);
            const first = weightedSum(base.slice(0, 8), [1, 3, 4, 5, 6, 7, 8, 10]) % 11 % 10;
            const partial = base.slice(0, 8) + first + base.slice(8);
            return partial + (weightedSum(partial, [3, 2, 10, 9, 8, 7, 6, 5, 4, 3, 2]) % 11 % 10);
        }
        if (state === 'MG') {
            assertBase(base, 11);
            const expanded = base.slice(0, 3) + '0' + base.slice(3);
            const sum = [...expanded].reduce((total, character, index) => {
                const product = Number(character) * (index % 2 + 1);
                return total + Math.floor(product / 10) + product % 10;
            }, 0);
            const first = (10 - sum % 10) % 10;
            return base + first + mod11(base + first, [3, 2, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2]);
        }
        if (state === 'RJ') {
            assertBase(base, 7);
            return base + mod11(base, [2, 7, 6, 5, 4, 3, 2]);
        }
        throw new Error('UF não suportada. Escolha SP, MG ou RJ.');
    }
    function certificateChecksum(base) {
        assertBase(base, 30);
        const firstRemainder = weightedSum(base, Array.from({ length: 30 }, (_, index) => (index + 2) % 11)) % 11;
        const first = firstRemainder === 10 ? 1 : firstRemainder;
        const second = weightedSum(base + first, Array.from({ length: 31 }, (_, index) => (index + 1) % 11)) % 11;
        return `${first}${second === 10 ? 1 : second}`;
    }
    function randomInt(maximum) {
        const values = new Uint32Array(1);
        const limit = Math.floor(0x100000000 / maximum) * maximum;
        do {
            crypto.getRandomValues(values);
        } while (values[0] >= limit);
        return values[0] % maximum;
    }
    function randomCharacters(length, alphabet = '0123456789') {
        return Array.from({ length }, () => alphabet[randomInt(alphabet.length)]).join('');
    }
    function formatDocument(kind, value, state = 'SP') {
        switch (kind) {
            case 'cpf': return value.replace(/^(\d{3})(\d{3})(\d{3})(\d{2})$/, '$1.$2.$3-$4');
            case 'cnpj': return value.replace(/^(.{2})(.{3})(.{3})(.{4})(\d{2})$/, '$1.$2.$3/$4-$5');
            case 'rg': return value.replace(/^(\d{2})(\d{3})(\d{3})([\dX])$/, '$1.$2.$3-$4');
            case 'titulo-eleitor': return value.replace(/^(\d{4})(\d{4})(\d{4})$/, '$1 $2 $3');
            case 'pis-pasep': return value.replace(/^(\d{3})(\d{5})(\d{2})(\d)$/, '$1.$2.$3-$4');
            case 'inscricao-estadual':
                if (state === 'SP')
                    return value.replace(/^(\d{3})(\d{3})(\d{3})(\d{3})$/, '$1.$2.$3.$4');
                if (state === 'MG')
                    return value.replace(/^(\d{3})(\d{3})(\d{3})(\d{4})$/, '$1.$2.$3/$4');
                return value.replace(/^(\d{2})(\d{3})(\d{2})(\d)$/, '$1.$2.$3-$4');
            case 'certidao': return value.replace(/^(\d{6})(\d{2})(\d{2})(\d{4})(\d)(\d{5})(\d{3})(\d{7})(\d{2})$/, '$1 $2 $3 $4 $5 $6 $7 $8-$9');
            default: return value;
        }
    }
    function generateDocument(kind, options = {}) {
        const state = options.state ?? 'SP';
        let value;
        for (;;) {
            switch (kind) {
                case 'cpf': {
                    const base = randomCharacters(9);
                    value = base + cpfChecksum(base);
                    break;
                }
                case 'cnpj': {
                    const alphabet = options.cnpjFormat === 'alphanumeric' ? '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' : '0123456789';
                    let root = randomCharacters(8, alphabet);
                    if (options.cnpjFormat === 'alphanumeric' && !/[A-Z]/.test(root))
                        root = randomCharacters(1, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') + root.slice(1);
                    const base = root + '0001';
                    value = base + cnpjChecksum(base);
                    break;
                }
                case 'rg': {
                    const base = randomCharacters(8);
                    value = base + rgChecksum(base);
                    break;
                }
                case 'cnh': {
                    const base = randomCharacters(9);
                    const checksum = cnhChecksum(base);
                    if (checksum === null)
                        continue;
                    value = base + checksum;
                    break;
                }
                case 'titulo-eleitor': {
                    const base = randomCharacters(8) + (options.electoralState ?? '01');
                    value = base + electoralChecksum(base);
                    break;
                }
                case 'pis-pasep': {
                    const base = '1' + randomCharacters(9);
                    value = base + pisChecksum(base);
                    break;
                }
                case 'inscricao-estadual': {
                    // MG: código municipal 062 e ordem de estabelecimento 00.
                    const base = state === 'MG' ? '062' + randomCharacters(6) + '00' : state === 'RJ' ? randomCharacters(7) : randomCharacters(10);
                    value = completeStateRegistration(base, state);
                    break;
                }
                case 'renavam': {
                    const base = '00' + randomCharacters(8);
                    value = base + renavamChecksum(base);
                    break;
                }
                case 'certidao': {
                    const year = options.year ?? new Date().getFullYear();
                    if (!Number.isInteger(year) || year < 1900 || year > new Date().getFullYear())
                        throw new Error('Informe um ano entre 1900 e o ano atual.');
                    const type = options.certificateType ?? '1';
                    if (!['1', '2', '4'].includes(type))
                        throw new Error('Tipo de certidão inválido.');
                    // CNS aleatório: não há consulta à existência de uma serventia.
                    const base = String(randomInt(999999) + 1).padStart(6, '0') + '0155' + year + type
                        + String(randomInt(99999) + 1).padStart(5, '0')
                        + String(randomInt(300) + 1).padStart(3, '0')
                        + String(randomInt(9999999) + 1).padStart(7, '0');
                    value = base + certificateChecksum(base);
                    break;
                }
                default: throw new Error('Documento não suportado.');
            }
            if (/^(.)\1+$/.test(value))
                continue;
            return options.formatted ? formatDocument(kind, value, state) : value;
        }
    }
    if (!Number.isInteger(count) || count < 1 || count > 100)
        throw new Error('Quantidade: de 1 a 100');
    const values = new Set();
    for (let attempts = 0; values.size < count && attempts < count * 20; attempts++) {
        values.add(generateDocument('cnh', {}));
    }
    if (values.size !== count)
        throw new Error('Não foi possível completar o lote sem repetições');
    return [...values].join('\n');
}

import secrets

def executar(count=1):
    if type(count) is not int or not 1 <= count <= 100:
        raise ValueError('Quantidade: de 1 a 100')

    def generate():
        results = []
    
        def random_chars(n, alphabet='0123456789'):
            return ''.join((secrets.choice(alphabet) for _ in range(n)))
    
        def weighted_sum(base, weights, alpha=False):
            return sum(((ord(c) - 48 if alpha else int(c)) * w for (c, w) in zip(base, weights)))
    
        def dv(base, weights, alpha=False):
            r = weighted_sum(base, weights, alpha) % 11
            return 0 if r < 2 else 11 - r
        while True:
            base = random_chars(9)
            r1 = weighted_sum(base, [9, 8, 7, 6, 5, 4, 3, 2, 1]) % 11
            r2 = weighted_sum(base, [1, 2, 3, 4, 5, 6, 7, 8, 9]) % 11
            d1 = 0 if r1 == 10 else r1
            d2 = 0 if r2 == 10 else r2 - (2 if r1 == 10 else 0)
            if d2 < 0:
                continue
            result = base + str(d1) + str(d2)
            if len(set(result)) > 1:
                break
        results.append(result)
        return results[0] if len(results) == 1 else results

    values = []
    for _ in range(count * 30):
        value = generate()
        if value not in values: values.append(value)
        if len(values) == count: break
    if len(values) != count: raise ValueError('Não foi possível completar o lote sem repetições')
    return '\n'.join(values)

<?php
function executar($count = 1) {
  if (!is_int($count) || $count < 1 || $count > 100) throw new InvalidArgumentException('Quantidade: de 1 a 100');
  $generate = function () {
    $results = [];
      $random_chars = function($n, $alphabet = "0123456789") use (&$random_chars, &$weighted_sum, &$dv) {
          $value = "";
          for ($i = 0; $i < $n; $i++) {
              $value .= $alphabet[random_int(0, strlen($alphabet) - 1)];
          }
          return $value;
      };
      
      $weighted_sum = function($base, $weights, $alpha = false) use (&$random_chars, &$weighted_sum, &$dv) {
          $sum = 0;
          foreach (str_split($base) as $i => $c) {
              $sum += ($alpha ? ord($c) - 48 : (int) $c) * $weights[$i];
          }
          return $sum;
      };
      $dv = function($base, $weights, $alpha = false) use (&$random_chars, &$weighted_sum, &$dv) {
          $r = $weighted_sum($base, $weights, $alpha) % 11;
          return $r < 2 ? 0 : 11 - $r;
      };
      
      // Número de registro da CNH (11 dígitos).
      while (true) {
          $base = $random_chars(9);
          $r1 = $weighted_sum($base, [9,8,7,6,5,4,3,2,1]) % 11;
          $r2 = $weighted_sum($base, [1,2,3,4,5,6,7,8,9]) % 11;
          $d1 = $r1 === 10 ? 0 : $r1;
          $d2 = $r2 === 10 ? 0 : $r2 - ($r1 === 10 ? 2 : 0);
          if ($d2 < 0) continue;
          $result = $base . $d1 . $d2;
          if (!preg_match('/^(\d)\1{10}$/', $result)) break;
      }
      $results[] = $result;
      return count($results) === 1 ? $results[0] : $results;
  };
  $values = [];
  for ($attempts = 0; count($values) < $count && $attempts < $count * 30; $attempts++) {
    $value = $generate();
    if (!in_array($value, $values, true)) $values[] = $value;
  }
  if (count($values) !== $count) throw new RuntimeException('Não foi possível completar o lote sem repetições');
  return implode("\n", $values);
}