Segurança e Criptografia

Gerador de chave RSA

Gere um par de chaves RSA em PEM, pronto para download.

RSA utiliza um par de chaves, pública e privada, em operações como assinatura e criptografia, conforme o esquema adotado. A ferramenta gera pares para testes e estudo de formatos de chave. A chave privada deve permanecer restrita a quem está autorizado a utilizá-la.

Chave pública em SPKI e privada em PKCS#8 sem senha. Web Crypto usa SHA-256 para o uso selecionado.

Resultado

Entradas e resultados permanecem nesta página e não são enviados a um serviço externo. Nenhum segredo é salvo pelo utilitário.

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

Configure os campos e execute a ferramenta. O processamento acontece localmente no navegador. Copie o resultado ou baixe os arquivos quando disponíveis. Os exemplos ao lado usam os parâmetros padrão.

Exemplos de código

Implemente no seu projeto

async function executar(values = { "bits": "2048", "usage": "RSA-OAEP" }) {
    function toBase64(bytes) {
        let binary = '';
        for (let i = 0; i < bytes.length; i += 8192)
            binary += String.fromCharCode(...bytes.subarray(i, i + 8192));
        return btoa(binary);
    }
    function pem(bytes, label) { return `-----BEGIN ${label}-----\n${toBase64(bytes).match(/.{1,64}/g).join('\n')}\n-----END ${label}-----\n`; }
    function option(values, key, options, fallback) {
        const value = values[key] ?? fallback;
        if (!options.includes(value))
            throw new Error(`Opção inválida: ${key}.`);
        return value;
    }
    async function runSecurityTool(kind, values) {
        if (!crypto.subtle)
            throw new Error('Esta ferramenta requer Web Crypto em HTTPS ou localhost.');
        if (Object.values(values).some(value => value.length > 1000000))
            throw new Error('Limite de entrada: 1 milhão de caracteres por campo.');
        {
            {
                const name = option(values, 'usage', ['RSA-OAEP', 'RSA-PSS', 'RSASSA-PKCS1-v1_5'], 'RSA-OAEP');
                const bits = Number(option(values, 'bits', ['2048', '3072', '4096'], '2048'));
                const keys = await crypto.subtle.generateKey({ name, modulusLength: bits, publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' }, true, name === 'RSA-OAEP' ? ['encrypt', 'decrypt'] : ['sign', 'verify']);
                const publicKey = pem(new Uint8Array(await crypto.subtle.exportKey('spki', keys.publicKey)), 'PUBLIC KEY');
                const privateKey = pem(new Uint8Array(await crypto.subtle.exportKey('pkcs8', keys.privateKey)), 'PRIVATE KEY');
                return { text: publicKey + '\n' + privateKey, files: [{ name: 'public-key.pem', content: publicKey }, { name: 'private-key.pem', content: privateKey }] };
            }
        }
    }
    return await runSecurityTool("rsa", values);
}

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization as s
import re

def executar(values=None):
    values = {'bits': '2048', 'usage': 'RSA-OAEP'} if values is None else values
    if not isinstance(values, dict) or any(not isinstance(v,str) or len(v.encode('utf-16-le',errors='surrogatepass')) // 2 > 1000000 for v in values.values()): raise ValueError('Informe campos textuais de até 1 milhão de caracteres')
    def integer(key):
        raw = values.get(key,'')
        if not re.fullmatch(r'[0-9]+',raw): raise ValueError('Informe inteiro válido: ' + key)
        return int(raw)
    def process(bits=2048):
        if type(bits) is not int or bits not in (2048, 3072, 4096):
            raise ValueError('Tamanho RSA inválido')
        results = []
        key = rsa.generate_private_key(public_exponent=65537, key_size=bits)
        results.append(key.public_key().public_bytes(s.Encoding.PEM, s.PublicFormat.SubjectPublicKeyInfo).decode())
        results.append(key.private_bytes(s.Encoding.PEM, s.PrivateFormat.PKCS8, s.NoEncryption()).decode())
        return results[0] if len(results) == 1 else results
    if values.get('usage') not in ('RSA-OAEP','RSA-PSS','RSASSA-PKCS1-v1_5'): raise ValueError('Finalidade RSA inválida')
    result = process(bits=integer('bits'))
    return {'text':result[0]+'\n'+result[1], 'files':[{'name':'public-key.pem','content':result[0]},{'name':'private-key.pem','content':result[1]}]}

<?php

function executar($values = ['bits'=>'2048','usage'=>'RSA-OAEP']) {
  foreach ($values as $value) if (!is_string($value) || strlen($value)>1000000) throw new InvalidArgumentException("Informe campos textuais de até 1 milhão de bytes");
  $integer = function ($key) use ($values) { $raw = $values[$key] ?? ""; if (!preg_match("/^[0-9]+$/D",$raw)) throw new InvalidArgumentException("Inteiro inválido: " . $key); return (int)$raw; };
  $process = function ($bits = 2048) {
    if (!in_array($bits,[2048,3072,4096],true)) throw new InvalidArgumentException('Tamanho RSA inválido');
    $results = [];
    $key = openssl_pkey_new(['private_key_bits' => $bits, 'private_key_type' => OPENSSL_KEYTYPE_RSA]);
    if ($key === false) throw new RuntimeException('Falha ao gerar RSA');
    if (!openssl_pkey_export($key, $private)) throw new RuntimeException('Falha ao exportar');
    $details = openssl_pkey_get_details($key);
    if ($details === false) throw new RuntimeException('Falha ao exportar a chave pública');
    $results[] = $details['key'] . "\n" . $private;
    // O par RSA pode ser importado com a finalidade e o padding apropriados.
    return count($results) === 1 ? $results[0] : $results;
  };
  if (!in_array($values['usage'] ?? '', ['RSA-OAEP','RSA-PSS','RSASSA-PKCS1-v1_5'],true)) throw new InvalidArgumentException('Finalidade RSA inválida');
  $result = $process($integer('bits'));
  return ['text'=>$result[0] . "\n" . $result[1], 'files'=>[['name'=>'public-key.pem','content'=>$result[0]],['name'=>'private-key.pem','content'=>$result[1]]]];
}