Segurança e Criptografia Online

Gere senhas fortes, hashes, HMAC, checksums e impressões digitais SHA-256 no seu navegador. Grátis, privado e sem uploads.

100% Privado • Sem Upload de Arquivos para Servidor

Por que usar o Segurança e Criptografia Online gratuito do Utiliome?

Criado do zero para privacidade estrita, execução instantânea e sem atrito. Sem assinaturas, paywalls ou cadastro.

Motor CSPRNG Web Crypto

Obtém entropia criptográfica bruta diretamente de crypto.getRandomValues() do navegador, apoiada pelo CSPRNG do kernel do sistema operacional em vez do estado previsível de Math.random().

Seleção de Palavras Diceware via CSPRNG

Sorteia palavras aleatórias do dicionário uniformemente via Web Crypto crypto.getRandomValues() com amostragem por rejeição imparcial em vez de frases humanas previsíveis.

Matriz Simultânea de Cinco Algoritmos

Calcula MD5 de 128 bits (RFC 1321) junto com SHA-1 de 160 bits, SHA-256 de 256 bits, SHA-384 de 384 bits e SHA-512 de 512 bits (NIST FIPS 180-4) a partir de uma única string UTF-8 ou buffer binário em uma única passagem.

API Nativa Web Crypto

Utiliza a aceleração de hardware do window.crypto.subtle para calcular checksums SHA-256 à velocidade máxima do seu processador.

Utiliome vs Alternativas Tradicionais em Nuvem

Compare nosso motor WebAssembly local contra ferramentas de nuvem legadas.

Recurso Utiliome (Navegador Local) Conversores de Nuvem Legados
Privacidade e Segurança dos Dados Zero carregamentos no servidor (Processamento no navegador) Envia os seus PDF confidenciais para servidores na nuvem
Privacidade e Segurança dos Dados Zero carregamentos no servidor (Processamento no navegador) Envia os seus PDF confidenciais para servidores na nuvem
Tamanho Máximo de Arquivo Sem limites rígidos (limitado apenas pela RAM) Limites estritos de 10MB a 50MB
Privacidade e Segurança dos Dados Zero carregamentos no servidor (Processamento no navegador) Envia os seus PDF confidenciais para servidores na nuvem
Como funciona

Como usar o Segurança e Criptografia Online em 3 passos simples

Nenhuma instalação necessária. Tudo roda diretamente dentro do seu navegador.

1

Defina o Comprimento e as Classes de Caracteres

Selecione um comprimento entre 4 e 128 caracteres e ative letras maiúsculas (A-Z), minúsculas (a-z), dígitos (0-9) e símbolos ASCII imprimíveis conforme as restrições do sistema de destino.

2

Configure Exclusões e Quantidade em Lote

Ative a filtragem de caracteres ambíguos (0/O, 1/l/I) para transcrição humana ou aumente a contagem do lote para gerar múltiplos segredos independentes simultaneamente.

3

Audite os Bits de Entropia e Copie

Verifique a leitura ao vivo da entropia combinatória e de Shannon em bits em relação ao seu limite de segurança (128+ bits para credenciais de produção) e copie localmente.

Geração de Senhas CSPRNG de Alta Entropia: Configuração e Exemplos

Resposta Rápida: Combine conjuntos de caracteres e comprimento (de 4 a 128 caracteres) com a forma como o segredo é armazenado e interpretado. Use 24+ caracteres ASCII completos para entradas em gerenciadores de senhas, 32+ caracteres alfanuméricos para strings de conexão URI e arquivos .env a fim de evitar bugs de escape de delimitadores, e strings sem homóglifos para digitação manual em console.

Diferentes ambientes de execução impõem restrições rigorosas de parsing sobre credenciais. Selecionar o maior conjunto seguro de caracteres N e escalar o comprimento L permite atingir as margens desejadas de entropia em bits sem acionar interpolação de shell ou falhas em parsers de URI.

Perfil 1: Segredo para Cofre de Gerenciador de Senhas (ASCII Imprimível Completo)

Ao armazenar credenciais dentro de um cofre criptografado (1Password, Bitwarden, KeePassXC ou HashiCorp Vault) para preenchimento automático de formulários ou cabeçalhos de API, habilite todas as quatro classes de caracteres (A-Z, a-z, 0-9 e 32 símbolos de pontuação ASCII, N = 94) com L = 24:

Configuration : Length = 24 | Upper + Lower + Digits + Symbols (N = 94) | Exclude Ambiguous = Off
Output        : v9#Km!2pQ@7xR$4nL^8wZ&5j
Pool Entropy  : 24 * log2(94) = 157.31 bits
Search Space  : 94^24 = 2.26e+47 combinations

Perfil 2: Credencial de Serviço Segura para URI e Shell (Apenas Alfanumérica)

DSNs de banco de dados (postgres://user:password@db.internal:5432/app) e arquivos .env do Docker frequentemente quebram quando as senhas contêm delimitadores URI reservados pela RFC 3986 (:, /, ?, #, [, ], @) ou tokens de expansão de shell ($, `, ", ', \). Desativar os símbolos (N = 62) e expandir o comprimento para L = 32 entrega maior entropia do que uma senha de 24 caracteres com símbolos, sem nenhum risco de escape:

Configuration : Length = 32 | Upper + Lower + Digits (N = 62) | Symbols = Off
Output        : 8fKp3mQv9xRt2nLw7zJc4bYh6dGs5aPe
Pool Entropy  : 32 * log2(62) = 190.53 bits
Search Space  : 62^32 = 2.27e+57 combinations

Perfil 3: Códigos Break-Glass em Lote (Caracteres Ambíguos Excluídos)

Para consoles fora de banda IPMI/iLO ou planilhas de recuperação de desastres onde um engenheiro precisa ler caracteres na tela em fontes monoespaçadas ou proporcionais, ative a exclusão de ambíguos (0, O, 1, l, I removidos de N = 62, restando N = 57) e gere um lote:

Configuration : Length = 20 | Upper + Lower + Digits | Exclude Ambiguous (0/O, 1/l/I) = On (N = 57) | Bulk = 3
Outputs       :
  1. 7mKp4xQv9nRw3zJc8bYh
  2. 5dGs2fPe6tMa9kVu4wNx
  3. 3hBz8qJr7cLy2pWt6gKm
Pool Entropy  : 20 * log2(57) = 116.66 bits per credential
Recurso ISO 32000 / WebAssembly / Web Crypto Utiliome (Navegador Local)
Gerador de Senhas Seguras Web Crypto CSPRNG (getRandomValues) Gere senhas aleatórias altamente complexas e criptograficamente seguras no dispositivo.
Senhas Memoráveis Cryptographic Diceware Passphrases Crie senhas seguras e muito fáceis de lembrar com Diceware e mnemônicos.
Gerador de Hash SHA-256 / SHA-512 / SHA-1 (FIPS 180-4) Gere hashes criptográficos seguros (SHA-256, SHA-512, etc.) a partir de textos.
Gerador HMAC Keyed-Hash HMAC (RFC 2104 / FIPS 198-1) Gere e verifique autenticações de mensagem HMAC (HMAC-SHA256, HMAC-SHA512, HMAC-MD5) no navegador.
Calculadora de Checksum Multi-Hash Binary File Fingerprinting Calcule hashes SHA-1, SHA-256, SHA-384 e SHA-512 de qualquer arquivo no navegador.
SHA-256 de Arquivo Local Multi-GB SHA-256 Verification Calcule e verifique o hash criptográfico SHA-256 de qualquer arquivo localmente sem upload.

Construindo Passphrases Diceware: Contagem de Palavras, Delimitadores e Exemplos de Saída

Resposta Rápida: Uma passphrase de 6 palavras sorteada uniformemente de um dicionário Diceware de 7.776 palavras fornece 77,55 bits de entropia criptográfica, mantendo-se fácil de memorizar e digitar sem olhar. Anexar um dígito e um símbolo aleatórios eleva a força total para além de 85 bits e passa nos rigorosos validadores corporativos de classes de caracteres.

A memória humana tem dificuldade para reter 16 glifos ASCII aleatórios (v9#Km!2pQ@7xR$4n), mas retém facilmente de 5 a 7 palavras concretas organizadas como imagens mentais. O uso de um CSPRNG para escolher palavras de forma independente preserva a segurança matemática estrita enquanto otimiza a ergonomia de digitação.

Perfil 1: Chave Mestra de Gerenciador de Senhas e Criptografia de Disco Completo (LUKS2 / FileVault)

Durante os prompts de criptografia de disco completo pré-inicialização (LUKS2, VeraCrypt, FileVault), a colagem da área de transferência não está disponível e layouts de teclado diferentes do padrão americano podem trocar a posição de pontuações que usam a tecla Shift. Seis palavras em minúsculas separadas por hifens sobre um dicionário Diceware padrão de 7.776 palavras eliminam erros de digitação com a tecla Shift e oferecem resistência massiva contra ataques KDF offline:

Configuração       : 6 Palavras | Separador = Hífen (-) | Capitalização = minúsculas | Extras = Desativado
Saída              : lantern-cobalt-harvest-velvet-orbit-spruce
Entropia Palavras  : 6 * log2(7776) = 77.55 bits
Espaço de Busca    : 7776^6 = 2.21e+23 combinações

Perfil 2: Conformidade com Políticas Corporativas de SSO e Active Directory

Muitas políticas corporativas de IAM e Active Directory impõem verificações de regex exigindo letras maiúsculas, minúsculas, um dígito [0-9] e um símbolo. Aplicar Title Case com delimitadores de sublinhado ou ponto mais um dígito sorteado via CSPRNG (+3,32 bits) e um símbolo CSPRNG (por exemplo, de um conjunto de 32 símbolos, +5,00 bits) satisfaz os validadores legados de forma limpa:

Configuração   : 5 Palavras | Separador = Ponto (.) | Capitalização = Title Case | Anexar Dígito + Símbolo = Ativado
Saída          : Glacier.Badger.Summit.Quartz.Anchor.7#
Entropia Total : (5 * 12.925) + log2(10) + log2(32) = 72.95 bits

Perfil 3: Chave Mestra GPG Isolada (Air-Gapped) ou Passphrase de CA Raiz

Para raízes de confiança criptográficas offline de longa duração (chaves de certificação OpenPGP, chaves frias age/SSH ou extensões de passphrase BIP-39 em carteiras de hardware), escale para 7 ou 8 palavras separadas por espaços:

Configuração       : 8 Palavras | Separador = Espaço ( ) | Capitalização = minúsculas | Extras = Desativado
Saída              : canyon timber falcon magnet fossil harbor meadow quartz
Entropia Palavras  : 8 * log2(7776) = 103.40 bits
Espaço de Busca    : 7776^8 = 1.34e+31 combinações

O que é um Checksum de Arquivo SHA-256?

Resposta Rápida: Um checksum SHA-256 é um digest hexadecimal único de 64 caracteres que representa o conteúdo binário exato de um arquivo. Funciona como uma impressão digital para garantir que o arquivo não esteja corrompido ou adulterado.

O SHA-256 (Secure Hash Algorithm 256-bit) é um membro da família SHA-2 definida pelo NIST. Ele gera um valor de hash fixo de 256 bits (32 bytes), geralmente exibido como uma string hexadecimal de 64 caracteres.

  Devido ao *Efeito Avalanche* criptográfico, alterar um único byte ou bit em um arquivo de vários gigabytes produzirá um resultado SHA-256 totalmente diferente. Isso torna o SHA-256 o padrão para verificar downloads de software, imagens ISO e backups de bancos de dados.

Calculando e Verificando Assinaturas HMAC de Webhooks e APIs: Guia Prático

Resposta Rápida: Assinar a mensagem what do ya want for nothing? com o segredo de 4 bytes Jefe (Caso de Teste 2 da IETF RFC 4231) sob HMAC-SHA256 produz 5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843 em Hex e W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM= em Base64 nos modos de chave UTF-8, Hex (4a656665) e Base64 (SmVmZQ==).

Um Código de Autenticação de Mensagem Baseado em Hash com Chave (HMAC) comprova tanto a integridade dos dados (o payload não foi alterado em trânsito) quanto a autenticidade (o remetente detém a chave secreta compartilhada). Reproduzir a assinatura de um provedor exige corresponder a três parâmetros exatos: a primitiva de hash subjacente, a decodificação em bytes brutos da chave secreta e a sequência exata de bytes do payload assinado.

Exemplo 1: Caso de Teste 2 da IETF RFC 2104 / RFC 2202 / RFC 4231

Quer você insira a chave secreta de 4 bytes como texto UTF-8 Jefe, hexadecimal bruto 4a656665 ou Base64 SmVmZQ==, ela é decodificada para o mesmo buffer de chave [0x4a, 0x65, 0x66, 0x65]. Assinar a mensagem UTF-8 de 28 bytes what do ya want for nothing? resulta em:

{
  "keyUtf8": "Jefe",
  "keyHex": "4a656665",
  "keyBase64": "SmVmZQ==",
  "message": "what do ya want for nothing?",
  "signatures": {
    "hmac_md5_hex": "750c783e6ab0b503eaa86e310a5db738",
    "hmac_sha1_hex": "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
    "hmac_sha256_hex": "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
    "hmac_sha256_base64": "W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM=",
    "hmac_sha256_base64url": "W9zBRr9gdU5qBCQmCJV1x1oAPwidJzmDnexYuWTsOEM",
    "hmac_sha384_hex": "af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649",
    "hmac_sha512_hex": "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737"
  }
}

Exemplo 2: Base64 vs Base64URL e Payloads Canônicos de Webhooks

O Base64 padrão (RFC 4648 Seção 4) emite +, / e padding final =, enquanto o Base64URL seguro para URLs (RFC 4648 Seção 5, usado em assinaturas JWS/JWT e URLs assinadas) substitui + por -, / por _ e remove o padding =. Assinar The quick brown fox jumps over the lazy dog com a chave UTF-8 key sob HMAC-SHA256 ilustra diretamente a diferença de codificação:

Key (UTF-8):     key
Message (UTF-8): The quick brown fox jumps over the lazy dog

HMAC-SHA256 Hex:       f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8
HMAC-SHA256 Base64:    97yD9DBThCSxMpjmqm+xQ+9NWaFJRhdZl0edvC0aPNg=
HMAC-SHA256 Base64URL: 97yD9DBThCSxMpjmqm-xQ-9NWaFJRhdZl0edvC0aPNg

Ao verificar cabeçalhos de webhooks reais, construa o payload exato de pré-assinatura definido por cada provedor antes de remover os prefixos do cabeçalho:

GitHub (X-Hub-Signature-256: sha256=<hex>):
  Signed input = <raw_http_body>

Stripe (Stripe-Signature: t=1730419200,v1=<hex>):
  Signed input = 1730419200.<raw_http_body>

Slack (X-Slack-Signature: v0=<hex>):
  Signed input = v0:1730419200:<raw_http_body>

Shopify (X-Shopify-Hmac-Sha256: <base64>):
  Signed input = <raw_http_body>
Perguntas frequentes

FAQ e Guia Técnico do Segurança e Criptografia Online

Tudo o que você precisa saber sobre o gerador de senhas e hashes sha256 online e gratuito do Utiliome.

Por que devo desativar símbolos para strings de conexão de banco de dados e arquivos .env?

A RFC 3986 reserva caracteres como :, /, ?, #, [, ], @ e % como delimitadores estruturais de URI, enquanto shells POSIX e carregadores de .env interpretam $, crases (backticks), aspas, # e \ como expansões de variáveis, comentários ou escapes. Gerar uma senha alfanumérica de 32 caracteres (A-Z, a-z, 0-9, N = 62) produz 190.53 bits de entropia — mais forte que uma senha de 24 caracteres com símbolos (157.31 bits) — enquanto elimina falhas de parsing e de URL-encoding em Kubernetes Secrets, Terraform e drivers JDBC/libpq.

Se a lista de palavras é pública, um invasor não pode quebrar minha passphrase com um ataque de dicionário?

Mesmo quando um invasor carrega o dicionário exato de 7.776 palavras no Hashcat em modo combinador, a seleção uniforme via CSPRNG o força a pesquisar cada combinação W^k. Para uma passphrase de 6 palavras, 7.776^6 equivale a 2,21 x 10^23 candidatos equiprováveis (77,55 bits) — exatamente a mesma barreira computacional que uma chave binária pura de 77,5 bits, com zero padrões gramaticais para servir de atalho.

Por que o comando echo "text" | sha256sum no meu terminal retorna um hash diferente de quando colo text aqui?

Por padrão, o comando echo adiciona um caractere de quebra de linha no final (<LF>, byte 0x0a) à sua string, de modo que echo "abc" na verdade calcula o hash da sequência de 4 bytes 61 62 63 0a em vez da string de 3 bytes 61 62 63. Execute printf '%s' 'abc' | sha256sum (ou echo -n 'abc' | sha256sum) no seu terminal para omitir a quebra de linha final e obter exatamente os mesmos hashes de strings UTF-8.

Por que a verificação HMAC do meu webhook falha mesmo quando minha chave secreta e os campos JSON parecem idênticos?

Dois problemas causam mais de 90% das falhas de correspondência de HMAC em webhooks. Primeiro, middlewares como o express.json() do Express analisam e re-serializam o JSON, alterando espaços em branco, escape Unicode ou a ordenação de chaves em relação ao fluxo bruto de bytes TCP que o remetente assinou — assine sempre o buffer bruto não analisado da requisição e inclua os prefixos de timestamp do provedor (como <timestamp>.<body> do Stripe ou v0:<timestamp>:<body> do Slack). Segundo, verifique se o segredo do provedor deve ser decodificado de Base64 ou Hex para bytes brutos em vez de lido como uma string UTF-8.

O que é um checksum e por que ele é importante?

Um checksum é um código alfanumérico único gerado ao aplicar um algoritmo criptográfico ao conteúdo de um arquivo. Ele funciona como uma assinatura digital. Se apenas um byte do arquivo for alterado, o checksum muda totalmente. É importante porque permite confirmar que o arquivo baixado é idêntico ao original, garantindo que não foi corrompido ou infectado por malware.

Meus arquivos são enviados para algum servidor?

Não. Todo o cálculo é feito localmente na memória do seu navegador utilizando a API Web Crypto nativa.