Segurança e Criptografia

Gerador de HMAC

Autentique um texto usando uma chave compartilhada.

HMAC combina uma função de hash com uma chave compartilhada para verificar a integridade e a autenticidade de uma mensagem. Esta ferramenta calcula o código de autenticação de um texto, ajudando a testar assinaturas de requisições e integrações. Quem verifica precisa conhecer a mesma chave.

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 = { "text": "Olá", "secret": "segredo de exemplo", "algorithm": "SHA-256", "format": "hex" }) {
    const encoder = new TextEncoder();
    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 required(values, key) {
        if (!values[key])
            throw new Error(`Preencha o campo ${key}.`);
        return values[key];
    }
    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 hash = option(values, 'algorithm', ['SHA-256', 'SHA-384', 'SHA-512'], 'SHA-256');
                const key = await crypto.subtle.importKey('raw', encoder.encode(required(values, 'secret')), { name: 'HMAC', hash }, false, ['sign']);
                const signature = new Uint8Array(await crypto.subtle.sign('HMAC', key, encoder.encode(values.text ?? '')));
                return { text: encoded(signature, option(values, 'format', ['hex', 'base64', 'base64url'], 'hex')) };
            }
        }
    }
    return await runSecurityTool("hmac", values);
}

import hashlib
import hmac
import base64
import re

def executar(values=None):
    values = {'text': 'Olá', 'secret': 'segredo de exemplo', 'algorithm': 'SHA-256', 'format': 'hex'} 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(text='Olá, Bennu!', secret='segredo-ficticio-de-exemplo', algorithm='sha256', format='hex'):
        if algorithm not in ('sha256', 'sha384', 'sha512') or not secret:
            raise ValueError('Algoritmo ou segredo 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(hmac.new(secret.encode('utf-8'), text.encode('utf-8'), getattr(hashlib, algorithm)).digest())
    result = process(text=values.get('text', ''), secret=values.get('secret', ''), algorithm=values.get('algorithm', 'SHA-256').lower().replace('-', ''), format=values.get('format', ''))
    return {'text':result}

<?php

function executar($values = ['text'=>'Olá','secret'=>'segredo de exemplo','algorithm'=>'SHA-256','format'=>'hex']) {
  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 ($text = 'Olá, Bennu!', $secret = 'segredo-ficticio-de-exemplo', $algorithm = 'sha256', $format = 'hex') {
    if (!in_array($algorithm,['sha256','sha384','sha512'],true) || $secret === '') throw new InvalidArgumentException('Algoritmo ou segredo 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(hash_hmac($algorithm,$text,$secret,true));
  };
  $result = $process($values['text'] ?? '', $values['secret'] ?? '', strtolower(str_replace('-', '', $values['algorithm'] ?? 'SHA-256')), $values['format'] ?? '');
  return ['text'=>$result];
}