---
title: "Criptografia SHA1"
url: "https://lucasferrazseo.com/ferramentas/criptografia-sha1/"
datePublished: "2026-06-20T15:19:56-03:00"
dateModified: "2026-10-08T20:35:07-03:00"
image: "https://lucasferrazseo.com/wp-content/uploads/2026/06/criptografia-sha1-online.webp"
description: "Criptografia SHA1 online e grátis: gere o hash SHA-1 de 40 caracteres no navegador, sem enviar o texto, e veja quando ele ainda serve."
content_signal: ai-train=yes, search=yes, ai-input=yes
---

# Criptografia SHA1

Criptografia SHA1 online e grátis: gere o hash SHA-1 de 40 caracteres no navegador, sem enviar o texto, e veja quando ele ainda serve.

![Página de ferramenta da Lucas Ferraz SEO com o título Criptografia SHA1, passos de uso, destaques grátis e no navegador, e janela da criptografia sha1 online com o texto abc e o hash SHA1 dele.](https://lucasferrazseo.com/wp-content/uploads/2026/06/criptografia-sha1-online.webp)

## Resumo

A ferramenta de SHA-1 calcula no navegador o hash de 40 caracteres de um texto e mostra junto o MD5 e o SHA-256, sem enviar nada a servidor. O SHA-1 segue útil para identificar e conferir em sistemas que já o usam e saiu da segurança: a primeira colisão pública veio em 2017 e o NIST marcou o fim do uso para 31 de dezembro de 2030.

## Principais pontos

- A ferramenta de SHA-1 gera os hashes SHA-1, MD5 e SHA-256 do mesmo texto de uma vez, com cálculo feito no navegador pela Web Crypto API e sem envio do texto a servidor;
- Na medição da agência de 2 de outubro de 2026, o cálculo da ferramenta de SHA-1 devolveu os dois hashes de exemplo da RFC 3174 idênticos aos publicados na especificação, e texto com acento ou emoji bateu com o cálculo em UTF-8;
- O texto abc precisa gerar a9993e364706816aba3e25717850c26c9cd0d89d; um espaço no fim ou uma letra maiúscula na entrada muda o hash inteiro;
- O SHA-1 de um arquivo se confere pelo comando do próprio sistema: Get-FileHash no Windows, sha1sum no Linux e shasum -a 1 no macOS;
- A primeira colisão pública de SHA-1, anunciada pelo Google e pelo CWI Amsterdam em 2017, exigiu cerca de 9 quintilhões de operações;
- O NIST definiu 31 de dezembro de 2030 como prazo para abandonar o SHA-1, e o Git escolheu o SHA-256 como sucessor em 2018.

## Passo a passo

1. Digite ou cole no campo o texto que quer transformar em hash, em uma linha;
2. Clique em Criptografar e leia os 40 caracteres do SHA-1, com o MD5 e o SHA-256 ao lado;
3. Teste a conferência digitando abc: o SHA-1 precisa ser a9993e364706816aba3e25717850c26c9cd0d89d;
4. Copie o hash e compare com o valor de referência, caractere por caractere, sem espaço sobrando no fim do texto;
5. Para um arquivo, rode o comando do sistema (Get-FileHash no Windows, sha1sum no Linux, shasum -a 1 no macOS) e compare com o valor publicado;
6. Se o site da empresa guarda senha em SHA-1, a correção é de estrutura e entra no projeto de criação de sites, não em uma ferramenta de hash.

A ferramenta de SHA-1 gera, de graça e no seu navegador, o hash SHA-1 de qualquer texto que você digitar, junto com o MD5 e o SHA-256 do mesmo texto. O SHA-1 transforma o texto em 40 caracteres hexadecimais, sempre os mesmos para o mesmo texto. Ele ainda aparece em sistemas legados e no controle de versão, mas é obsoleto para segurança, como explicado abaixo.

*Vale um aviso de quem cuida de sistema: encontrar SHA-1 em um projeto não é, sozinho, sinal de erro. O problema é usá-lo para assinatura ou senha novas, onde já se demonstrou como forjar uma colisão.*

## O que é o SHA-1 e onde ele ainda aparece?

O SHA-1 é uma função de hash que resume qualquer entrada em um valor fixo de **160 bits, escrito como 40 caracteres hexadecimais**. A mesma entrada gera sempre o mesmo hash, o que permite comparar dados sem olhar o conteúdo. Ele foi o padrão por anos e ainda vive em sistemas antigos e em ferramentas de controle de versão, onde identifica cada mudança de código.

O uso que sobra é a identificação e a conferência dentro de sistemas que já o adotaram, não a proteção de dado novo. Em um repositório de código, por exemplo, o SHA-1 nomeia cada versão como identificador, uma função que não depende de resistência a fraude e continua servindo bem.

Até o Git, o exemplo mais conhecido desse uso, já planeja a saída. O documento de [transição de hash do Git](https://git-scm.com/docs/hash-function-transition) registra que a versão 2.13.0 passou a usar por padrão um SHA-1 reforçado contra o ataque de colisão de 2017 e que, no fim de 2018, o projeto escolheu o **SHA-256 como sucessor**. Para quem mantém um sistema, o recado é o mesmo: o SHA-1 que já existe pode ficar enquanto identifica, e o que nasce agora começa no SHA-256.

## Como usar a ferramenta de SHA-1?

A ferramenta de SHA-1 calcula o hash do texto no próprio navegador, sem enviar nada para servidor. O uso pede três ações, digitar ou colar o texto, clicar em Criptografar e copiar o resultado. Você recebe **o SHA-1 com 40 caracteres hexadecimais** e, no mesmo clique, o MD5 e o SHA-256, úteis para comparar com um hash de referência e identificar registros.

1. Digite ou cole o texto que você quer transformar em hash;
2. Gere o resultado e veja os 40 caracteres do SHA-1;
3. Copie o hash para comparar ou registrar;
4. Para conferir integridade, compare o hash gerado com o de referência.

Para saber se o cálculo está certo, use os textos de exemplo da própria especificação do SHA-1, a [RFC 3174](https://www.rfc-editor.org/rfc/rfc3174.txt), publicada em 2001. Digite **abc** no campo: o hash precisa ser **a9993e364706816aba3e25717850c26c9cd0d89d**, caractere por caractere.

> Na medição da agência de 2 de outubro de 2026, testamos o cálculo da ferramenta de SHA-1 com os dois exemplos da RFC 3174: os hashes saíram idênticos aos publicados na especificação, e texto com acento ou emoji bateu com o cálculo em UTF-8.
>
>
> [Lucas Ferraz](https://lucasferrazseo.com/autor-lucas-ferraz/), especialista em SEO

A conferência que não bate quase sempre tem uma de duas causas. A primeira é um **espaço sobrando no fim do texto**: “abc” com um espaço depois gera eeca658f56ce50a4f36605aaf93e29e87c12009a, um valor sem nenhuma relação com o anterior. A segunda é maiúscula e minúscula na entrada, porque “Abc” e “abc” são textos diferentes para o SHA-1. Já o hash de referência escrito em letras maiúsculas, como a RFC 3174 imprime, é o mesmo valor da ferramenta, que mostra o resultado em minúsculas.

### Como conferir o SHA-1 de um arquivo sem ferramenta online?

O SHA-1 de um arquivo se confere com um comando que o próprio sistema operacional já traz, sem enviar o arquivo a site nenhum. A ferramenta desta página calcula o hash de **uma linha de texto digitado**, então instalador, backup e arquivo baixado passam pelo comando do computador.

- No Windows, pelo PowerShell: Get-FileHash arquivo.zip -Algorithm SHA1;
- No Linux, pelo terminal: sha1sum arquivo.zip;
- No macOS, pelo terminal: shasum -a 1 arquivo.zip.

Compare o resultado com o valor publicado por quem distribui o arquivo. Se os dois são iguais do primeiro ao último caractere, **o arquivo chegou inteiro**. Quando quem distribui publica o SHA-1 e também o SHA-256, confira pelo SHA-256, porque só ele também resiste a quem tente trocar o arquivo de propósito.

## O que a ferramenta de SHA-1 entrega?

A ferramenta calcula o hash e devolve pronto. Cada recurso serve a uma decisão sobre conferir ou identificar um dado.

- Hash SHA-1 com os 40 caracteres hexadecimais do padrão, mais o MD5 e o SHA-256 do mesmo texto, calculados de uma vez;
- Cálculo 100% no navegador, com Web Crypto API, sem enviar o texto para servidor;
- Resultado inline pronto para copiar, para levar direto à comparação;
- Mesmo hash sempre para o mesmo texto, para comparar e identificar registros.

## Por que o SHA-1 não deve mais assinar dados novos?

O SHA-1 não deve assinar dado novo porque já se provou como criar duas entradas diferentes com o mesmo hash, o que abre espaço para forjar um documento com a mesma assinatura. Por isso navegadores e sistemas modernos abandonaram o SHA-1 em certificados e assinaturas. Para dado novo que precisa de segurança, o padrão é o SHA-256, da família SHA-2.

Vale saber onde o texto vai. O cálculo roda **inteiro no seu navegador**, com a Web Crypto API, e o texto não é enviado a servidor nenhum, então nada do que você digita sai da sua tela. Ainda assim, para guardar senha em um sistema, o método é o do servidor com sal e custo alto, não um hash SHA-1 gerado aqui.

Quando quem mantém o site confirma que as senhas dos clientes estão guardadas em SHA-1, com ou sem sal, a correção não cabe em uma ferramenta de hash. A troca por um algoritmo feito para senha, como bcrypt ou Argon2, mexe no login e na plataforma, e entra na [criação de um site profissional](https://lucasferrazseo.com/servicos/criacao-de-sites/), quando o sistema é refeito.

### Quando o SHA-1 foi quebrado e até quando ele pode ser usado?

A prova pública veio em 23 de fevereiro de 2017, quando pesquisadores do CWI Amsterdam e do Google anunciaram no [blog de segurança do Google](https://security.googleblog.com/2017/02/announcing-first-sha1-collision.html) a primeira colisão de SHA-1, dois PDFs diferentes com o mesmo hash. O cálculo exigiu cerca de **9 quintilhões de operações de SHA-1**, o equivalente a 6.500 anos de processamento em CPU e 110 anos em GPU. Esse custo afasta o curioso, mas não quem ganharia dinheiro forjando um contrato ou um certificado, e é por isso que assinatura nova não fica no SHA-1.

O prazo final também já tem data. Em dezembro de 2022, o [NIST](https://www.nist.gov/news-events/news/2022/12/nist-retires-sha-1-cryptographic-algorithm), o instituto de padrões dos Estados Unidos que oficializou o SHA-1 em 1995, anunciou que ele deve ser **abandonado até 31 de dezembro de 2030**, em favor das famílias SHA-2 e SHA-3. Se um sistema da empresa ainda assina ou valida algo com SHA-1, a troca já cabe no planejamento, sem esperar o prazo apertar.

## Como a ferramenta calcula o SHA-1 por dentro?

A ferramenta calcula o hash **no seu navegador**, sem enviar o texto a servidor. O SHA-1 é gerado pela Web Crypto API do próprio navegador, e ao mesmo tempo ela calcula o MD5 (por código próprio do site) e o SHA-256 do mesmo texto, mostrando os três de uma vez. Cada função lê a entrada byte a byte e devolve um resumo de tamanho fixo, sempre igual para o mesmo texto, o que permite comparar e identificar dados sem olhar o conteúdo.

O SHA-1 produz **160 bits, escritos como 40 caracteres hexadecimais**. É uma função de mão única, então não há como voltar ao texto a partir do hash; a conferência se faz gerando o valor de novo e comparando. A tabela abaixo situa o SHA-1 ao lado dos outros dois algoritmos que a ferramenta calcula, para você escolher o certo por tarefa.

| Algoritmo | Tamanho do hash | Uso recomendado hoje |
| --- | --- | --- |
| MD5 | 32 caracteres (128 bits) | Conferência rápida de integridade, sem resistência a fraude |
| SHA-1 | 40 caracteres (160 bits) | Identificação em sistemas legados, obsoleto para segurança |
| SHA-256 | 64 caracteres (256 bits) | Integridade, assinatura e verificação com resistência a fraude |

O resultado é determinístico, então um caractere trocado muda o hash inteiro. É o que faz o SHA-1 servir como identificador único em sistemas de controle de versão, e é também por que ele saiu de assinaturas e certificados, onde a resistência a colisão passou a ser exigida. Quando a tarefa pede essa resistência, o passo seguinte é a [ferramenta de hash SHA-256](https://lucasferrazseo.com/ferramentas/criptografia-sha256/), que calcula o valor do mesmo jeito, no navegador.

*O que confiro primeiro em um site antigo é onde o SHA-1 aparece. No nome de arquivo, no cache ou no commit, ele fica onde está. Na tabela de senhas ou na assinatura de um token, vai para a lista de correções.*

## Perguntas frequentes sobre o SHA-1

Estas são as dúvidas mais comuns de quem vai gerar um hash SHA-1.

### O que a ferramenta de SHA-1 entrega?

A ferramenta de SHA-1 entrega o hash do texto informado, uma sequência fixa de 40 caracteres hexadecimais, e mostra ainda o MD5 e o SHA-256 do mesmo texto. Tudo é calculado no seu navegador e o resultado sai pronto para copiar. O mesmo texto gera sempre o mesmo hash, o que permite comparar valores e identificar registros.

### Dá para reverter um hash SHA-1 no texto original?

Não. O SHA-1 é uma função de mão única, sem operação que devolva o texto a partir do hash. Para entradas comuns, existem bancos de hashes já calculados que revelam a origem, o que reforça por que o SHA-1 não protege senha. Para um texto longo e aleatório, achar a entrada segue inviável.

### O SHA-1 ainda é seguro?

Para segurança, não. Desde a demonstração pública de uma colisão, o SHA-1 deixou de ser aceito em assinaturas e certificados. Para identificação e conferência dentro de sistemas legados, onde não há atacante tentando forjar, ele ainda cumpre a função. Dado novo com exigência de segurança usa SHA-256.

### Qual a diferença entre SHA-1 e SHA-256?

O SHA-1 gera 40 caracteres e é obsoleto para segurança, enquanto o SHA-256 gera 64 e é o padrão atual, da família SHA-2. Os dois resumem dados de forma parecida, mas o SHA-256 resiste às colisões que quebraram o SHA-1. Para qualquer uso novo com segurança, o SHA-256 é a escolha.

### Por que o Git usa SHA-1?

O Git usa o SHA-1 para identificar cada versão de código, uma função de nomeação, não de segurança. Como o objetivo ali é dar um identificador único a cada mudança, e não impedir fraude, o risco de colisão tem impacto pequeno. Projetos mais novos já caminham para versões com hash mais forte, mas o SHA-1 segue no papel de identificar.

### O hash SHA-1 em maiúsculas é diferente do hash em minúsculas?

Não, é o mesmo valor escrito de outro jeito. Os 40 caracteres são números em hexadecimal, e A9993E36 e a9993e36 representam os mesmos bytes, então uma referência em maiúsculas confere com o resultado da ferramenta. O que muda o hash é a caixa do texto de entrada, porque “Abc” e “abc” geram valores sem relação entre si.

## Quando o SHA-1 basta e quando exige o SHA-256

O SHA-1 basta para identificar e conferir dentro de um sistema que já o usa, e exige troca pelo SHA-256 sempre que houver assinatura, certificado ou senha em jogo. Um desenvolvedor, por exemplo, convive com o SHA-1 como identificador de commit no controle de versão, e nunca o escolhe para assinar um novo token de autenticação, onde usa o SHA-256.