JavaScript Python PHP
async function executar(values = { "payload": "{\"sub\":\"test-user\"}", "secret": "segredo-ficticio-para-exemplo-com-64-bytes-00000000000000000000000000", "algorithm": "HS256" }) {
const encoder = new TextEncoder();
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 required(values, key) {
if (!values[key])
throw new Error(`Preencha o campo ${key}.`);
return values[key];
}
async function generateJwt(payloadText, secret, algorithm = 'HS256') {
const hashes = { HS256: 'SHA-256', HS384: 'SHA-384', HS512: 'SHA-512' };
if (!hashes[algorithm])
throw new Error('Algoritmo JWT não suportado.');
const minimum = { HS256: 32, HS384: 48, HS512: 64 };
if (encoder.encode(secret).length < minimum[algorithm])
throw new Error(`Use um segredo com pelo menos ${minimum[algorithm]} bytes UTF-8 para ${algorithm}.`);
const payload = JSON.parse(payloadText);
if (!payload || typeof payload !== 'object' || Array.isArray(payload))
throw new Error('O payload deve ser um objeto JSON.');
for (const claim of ['exp', 'iat', 'nbf'])
if (claim in payload && (!Number.isFinite(payload[claim]) || typeof payload[claim] !== 'number'))
throw new Error(`${claim} deve ser um NumericDate em segundos.`);
const header = toBase64Url(encoder.encode(JSON.stringify({ alg: algorithm, typ: 'JWT' })));
const body = toBase64Url(encoder.encode(JSON.stringify(payload)));
const key = await crypto.subtle.importKey('raw', encoder.encode(secret), { name: 'HMAC', hash: hashes[algorithm] }, false, ['sign']);
const signature = new Uint8Array(await crypto.subtle.sign('HMAC', key, encoder.encode(`${header}.${body}`)));
return `${header}.${body}.${toBase64Url(signature)}`;
}
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.');
{
return { text: await generateJwt(required(values, 'payload'), required(values, 'secret'), option(values, 'algorithm', ['HS256', 'HS384', 'HS512'], 'HS256')) };
}
}
return await runSecurityTool("jwt", values);
}
import base64
import hashlib
import hmac
import json
import re
def executar(values=None):
values = {'payload': '{"sub":"test-user"}', 'secret': 'segredo-ficticio-para-exemplo-com-64-bytes-00000000000000000000000000', 'algorithm': 'HS256'} 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(payload_text='{"sub":"test-user"}', secret='segredo-ficticio-de-exemplo', algorithm='HS256'):
algorithms = {'HS256': hashlib.sha256, 'HS384': hashlib.sha384, 'HS512': hashlib.sha512}
if algorithm not in algorithms or not secret:
raise ValueError('Algoritmo ou segredo inválido')
payload = json.loads(payload_text)
if not isinstance(payload, dict):
raise ValueError('Payload deve ser objeto')
def encode(value):
raw = json.dumps(value, separators=(',', ':'), ensure_ascii=False).encode('utf-8')
return base64.urlsafe_b64encode(raw).rstrip(b'=').decode('ascii')
input_value = encode({'alg': algorithm, 'typ': 'JWT'}) + '.' + encode(payload)
signature = hmac.new(secret.encode('utf-8'), input_value.encode('ascii'), algorithms[algorithm]).digest()
return input_value + '.' + base64.urlsafe_b64encode(signature).rstrip(b'=').decode('ascii')
size = {'HS256':32,'HS384':48,'HS512':64}.get(values.get('algorithm'))
if size is None or len(values.get('secret','').encode()) < size: raise ValueError('Segredo JWT curto ou algoritmo inválido')
result = process(payload_text=values.get('payload', ''), secret=values.get('secret', ''), algorithm=values.get('algorithm', ''))
return {'text':result}
<?php
function executar($values = ['payload'=>'{"sub":"test-user"}','secret'=>'segredo-ficticio-para-exemplo-com-64-bytes-00000000000000000000000000','algorithm'=>'HS256']) {
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 ($payloadText = '{"sub":"test-user"}', $secret = 'segredo-ficticio-de-exemplo', $algorithm = 'HS256') {
$algorithms = ['HS256'=>'sha256','HS384'=>'sha384','HS512'=>'sha512'];
if (!isset($algorithms[$algorithm]) || $secret === '') throw new InvalidArgumentException('Algoritmo ou segredo inválido');
$payload = json_decode($payloadText,false,512,JSON_THROW_ON_ERROR);
if (!is_object($payload)) throw new InvalidArgumentException('Payload deve ser objeto');
$encode = fn($value) => rtrim(strtr(base64_encode($value), '+/', '-_'), '=');
$input = $encode(json_encode(['alg'=>$algorithm,'typ'=>'JWT'],JSON_THROW_ON_ERROR)) . '.' . $encode(json_encode($payload,JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR));
return $input . '.' . $encode(hash_hmac($algorithms[$algorithm],$input,$secret,true));
};
$size = ['HS256'=>32,'HS384'=>48,'HS512'=>64][$values['algorithm'] ?? ''] ?? null;
if ($size === null || strlen($values['secret'] ?? '') < $size) throw new InvalidArgumentException('Segredo JWT curto ou algoritmo inválido');
$result = $process($values['payload'] ?? '', $values['secret'] ?? '', $values['algorithm'] ?? '');
return ['text'=>$result];
}
