Segurança e Criptografia

Gerador de chave AES

Gere uma chave AES de 128, 192 ou 256 bits.

AES é um algoritmo de criptografia simétrica, no qual uma chave secreta participa da proteção e recuperação dos dados. Esta ferramenta gera uma chave do tamanho escolhido para testes. O resultado é somente a chave: criptografar também exige uma implementação adequada do modo de operação e seus parâmetros.

A saída contém a chave bruta codificada. Não inclui IV, ciphertext ou operação de criptografia.

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": "256", "format": "base64" }) {
    function toHex(bytes) { return [...bytes].map(byte => byte.toString(16).padStart(2, '0')).join(''); }
    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 toBase64Url(bytes) { return toBase64(bytes).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_'); }
    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;
    }
    function encoded(bytes, format) { return format === 'hex' ? toHex(bytes) : format === 'base64' ? toBase64(bytes) : toBase64Url(bytes); }
    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 bits = Number(option(values, 'bits', ['128', '192', '256'], '256'));
                const key = await crypto.subtle.generateKey({ name: 'AES-GCM', length: bits }, true, ['encrypt', 'decrypt']);
                return { text: encoded(new Uint8Array(await crypto.subtle.exportKey('raw', key)), option(values, 'format', ['hex', 'base64', 'base64url'], 'base64')) };
            }
        }
    }
    return await runSecurityTool("aes", values);
}

import secrets
import base64
import re

def executar(values=None):
    values = {'bits': '256', 'format': 'base64'} 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=256, format='base64'):
        if type(bits) is not int or bits not in (128, 192, 256):
            raise ValueError('Tamanho AES inválido')

        def encode(raw):
            if format == 'hex':
                return raw.hex()
            if format == 'base64':
                return base64.b64encode(raw).decode('ascii')
            if format == 'base64url':
                return base64.urlsafe_b64encode(raw).rstrip(b'=').decode('ascii')
            raise ValueError('Formato inválido')
        return encode(secrets.token_bytes(bits // 8))
    result = process(bits=integer('bits'), format=values.get('format', ''))
    return {'text':result}

<?php

function executar($values = ['bits'=>'256','format'=>'base64']) {
  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 = 256, $format = 'base64') {
    if (!in_array($bits,[128,192,256],true)) throw new InvalidArgumentException('Tamanho AES inválido');
    $encode = function ($raw) use ($format) {
      return match ($format) {
        'hex' => bin2hex($raw),
        'base64' => base64_encode($raw),
        'base64url' => rtrim(strtr(base64_encode($raw), '+/', '-_'), '='),
        default => throw new InvalidArgumentException('Formato inválido'),
      };
    };
    return $encode(random_bytes(intdiv($bits,8)));
  };
  $result = $process($integer('bits'), $values['format'] ?? '');
  return ['text'=>$result];
}