# Funções de Hash

Uma **função de hash criptográfica** transforma qualquer volume de dados (um arquivo, uma senha, um texto) em uma **sequência de tamanho fixo** chamada **hash**, **digest** ou **resumo**.

```
"qualquer texto" → Função de Hash → "a1b2c3d4e5f6..."
(entrada de qualquer tamanho)      (saída de tamanho fixo)
```

### Propriedades Essenciais

| Propriedade               | Significado                                         |
| ------------------------- | --------------------------------------------------- |
| **Determinística**        | Mesma entrada → mesmo hash (sempre)                 |
| **Irreversível**          | Não é possível obter a entrada a partir do hash     |
| **Resistência a colisão** | Dois dados diferentes não podem gerar o mesmo hash  |
| **Avalanche**             | Mudar 1 bit na entrada muda \~50% dos bits da saída |
| **Tamanho fixo**          | SHA-256 sempre gera 256 bits (32 bytes)             |

### Para que serve

* ✅ Senhas (armazenar hashes, não senhas)
* ✅ Integridade de arquivos (checksums)
* ✅ Assinaturas digitais (hash + chave privada)
* ✅ Blockchain (mineração, conexão de blocos)
* ✅ Identificação de dados (deduplicação, forense)

{% hint style="warning" %}
**Importante:** Hash não é criptografia (não se "decifra" um hash).
{% endhint %}

***

### 📋 Principais Funções de Hash

| Algoritmo           | Criado    | Tamanho da Saída | Status                    |
| ------------------- | --------- | ---------------- | ------------------------- |
| **SHA-2 (256/512)** | 2001      | 256/512 bits     | ✅ **Padrão atual**        |
| **SHA-3 (Keccak)**  | 2015      | 224-512 bits     | ✅ Padrão mais recente     |
| **BLAKE2/BLAKE3**   | 2012/2020 | 256/512 bits     | ✅ Extremamente rápido     |
| **RIPEMD-160**      | 1996      | 160 bits         | 🔸 Usado em Bitcoin       |
| **MD5**             | 1992      | 128 bits         | ❌ **Inseguro**            |
| **SHA-1**           | 1995      | 160 bits         | ❌ **Obsoleto** (colisões) |
| **Whirlpool**       | 2003      | 512 bits         | 🔸 Padrão ISO/IEC         |

***

### 🏆 SHA-2 – O Padrão Atual

**SHA-2 (Secure Hash Algorithm 2)** é a família mais utilizada no mundo hoje.

#### Principais variantes

| Algoritmo   | Tamanho  | Saída (hex)    | Uso                    |
| ----------- | -------- | -------------- | ---------------------- |
| **SHA-224** | 224 bits | 56 caracteres  | Aplicações específicas |
| **SHA-256** | 256 bits | 64 caracteres  | ✅ **Padrão geral**     |
| **SHA-384** | 384 bits | 96 caracteres  | Alto nível             |
| **SHA-512** | 512 bits | 128 caracteres | Sistemas 64-bit        |

#### Onde é usado

* ✅ SSL/TLS (certificados digitais)
* ✅ Blockchain (Bitcoin, Ethereum)
* ✅ Assinaturas digitais
* ✅ Senhas (com salt, ex: bcrypt usa SHA-2)
* ✅ Verificação de integridade

#### Exemplo (SHA-256)

```bash
# Linux/macOS
echo -n "mensagem secreta" | sha256sum

# Output: 6d7e1e7f4d9e9c8b7a6f5e4d3c2b1a0f9e8d7c6b5a4f3e2d1c0b9a8f7e6d5c4b
```

```python
# Python
import hashlib

hash_obj = hashlib.sha256(b"mensagem secreta")
print(hash_obj.hexdigest())
# 6d7e1e7f4d9e9c8b7a6f5e4d3c2b1a0f9e8d7c6b5a4f3e2d1c0b9a8f7e6d5c4b
```

***

### 🔄 SHA-3 (Keccak) – O Novo Padrão

**SHA-3** foi lançado pela NIST em 2015. É baseado no algoritmo **Keccak** (vencedor do concurso).

#### Diferenças do SHA-2

* SHA-2 usa estrutura **Merkle-Damgård**
* SHA-3 usa estrutura **Sponge Function**
* Mais resistente a certos tipos de ataque

#### Variantes SHA-3

| Algoritmo | Tamanho  |
| --------- | -------- |
| SHA3-224  | 224 bits |
| SHA3-256  | 256 bits |
| SHA3-384  | 384 bits |
| SHA3-512  | 512 bits |

#### SHAKE (Extensible Output)

SHA-3 também oferece **SHAKE128** e **SHAKE256** – funções que geram saída de **tamanho variável**.

#### Exemplo Python

```python
import hashlib

# SHA3-256
hash_obj = hashlib.sha3_256(b"mensagem secreta")
print(hash_obj.hexdigest())

# SHAKE128 (tamanho variável)
shake = hashlib.shake_128(b"mensagem secreta")
print(shake.hexdigest(32))  # 64 caracteres (32 bytes)
```

***

### 🚀 BLAKE2 / BLAKE3 – Velocidade Extrema

**BLAKE2** é mais rápido que MD5 (!!) e tão seguro quanto SHA-3.

#### Comparação de velocidade

| Algoritmo   | MB/s (aprox) |
| ----------- | ------------ |
| **BLAKE2**  | 1000-1500    |
| **SHA-256** | 300-500      |
| **SHA-3**   | 200-400      |
| **MD5**     | 600-800      |

#### Características

* ✅ Mais rápido que MD5, mas seguro
* ✅ Suporte a chave (HMAC nativo)
* ✅ Suporte a salt
* ✅ Sem patentes

#### BLAKE3 (2020)

* Ainda mais rápido (paralelismo)
* Suporte a streaming e árvores de hash
* Disponível em Rust, C, Python

#### Exemplo Python

```python
import hashlib

# BLAKE2b (64-bit plataforma)
hash_obj = hashlib.blake2b(b"mensagem secreta")
print(hash_obj.hexdigest())

# BLAKE2s (32-bit plataforma)
hash_obj = hashlib.blake2s(b"mensagem secreta")
print(hash_obj.hexdigest())
```

***

### 💀 MD5 – Morto e Enterrado

**MD5 (Message Digest 5)** foi amplamente usado nos anos 90 e 2000. Hoje é **totalmente inseguro**.

#### Problemas

* Colisões encontráveis em segundos (2012 – Flame malware)
* Ataque de extensão de comprimento (length extension)

#### Onde foi usado (e ainda se encontra em lugares errados)

* Checksums de arquivos (ainda comum em sites legados)
* Senhas (não use! use bcrypt/Argon2)
* Certificados digitais antigos

#### Exemplo de colisão

```bash
# Dois PDFs diferentes com mesmo MD5
echo "Arquivo A" | md5sum
echo "Arquivo B" | md5sum
# Podem gerar o mesmo hash!
```

{% hint style="danger" %}
**Recomendação:** **NUNCA** use MD5 para segurança. Apenas para checksums não críticos.
{% endhint %}

***

### 💀 SHA-1 – Obsoleto

**SHA-1** foi o padrão dos anos 2000. Colisões foram demonstradas em 2017 (SHAttered).

#### Ataque SHAttered (2017)

* Google e CWI Amsterdam criaram dois PDFs diferentes com o mesmo SHA-1
* Custo: \~110 mil dólares em CPU/GPU

#### Status atual

* ❌ Proibido em certificados TLS (2017)
* ❌ Proibido em Git (Git 2.13+ usa SHA-256)
* ❌ Descontinuado pela NIST

***

### ₿ RIPEMD-160 – Bitcoin

**RIPEMD-160** é usado principalmente em **criptomoedas**.

#### Onde é usado

* 🔸 **Bitcoin** (endereços: SHA-256 + RIPEMD-160)
* 🔸 Blockchain em geral

#### Por que RIPEMD-160

* 160 bits (20 bytes) → endereços mais curtos que SHA-256
* Menos vulnerável a certos ataques que SHA-1

#### Exemplo Bitcoin

```python
import hashlib

# Endereço Bitcoin (simplificado)
public_key = b"..."
sha = hashlib.sha256(public_key).digest()
ripemd = hashlib.new('ripemd160', sha).hexdigest()
print(ripemd)  # Endereço parcial
```

***

### 🌪️ Whirlpool

**Whirlpool** é uma função de hash de 512 bits adotada como padrão **ISO/IEC 10118-3**.

#### Características

* Baseada em cifra de bloco (W, derivada do AES)
* Saída de 512 bits
* Auditada e adotada por órgãos governamentais

#### Uso atual

* 🔸 Aplicações governamentais europeias
* 🔸 Alguns sistemas forenses
* 🔸 Raramente usado em novos projetos (prefira SHA-2/SHA-3)

***

### ⚔️ Comparativo de Segurança

| Algoritmo      | Tamanho  | Resistência a Colisão | Status        |
| -------------- | -------- | --------------------- | ------------- |
| **BLAKE3**     | variável | ✅ Excelente           | ✅ Recomendado |
| **SHA-512**    | 512 bits | ✅ Excelente           | ✅ Padrão      |
| **SHA-256**    | 256 bits | ✅ Excelente           | ✅ Padrão      |
| **SHA-3-256**  | 256 bits | ✅ Excelente           | ✅ Padrão      |
| **BLAKE2**     | variável | ✅ Excelente           | ✅ Recomendado |
| **Whirlpool**  | 512 bits | ✅ Bom                 | 🔸 Específico |
| **RIPEMD-160** | 160 bits | 🔸 Moderada           | 🔸 Bitcoin    |
| **SHA-1**      | 160 bits | ❌ Colisões (2017)     | ❌ Obsoleto    |
| **MD5**        | 128 bits | ❌ Colisões (2012)     | ❌ Morto       |

***

### 🔐 Hash para Senhas: Cuidado Especial

**Hash puro NÃO é adequado para senhas!**

| Problema                    | Solução                               |
| --------------------------- | ------------------------------------- |
| Mesma senha → mesmo hash    | **Salt** (valor aleatório)            |
| Rápido demais (força bruta) | **Função lenta** (iterações, memória) |

#### Funções específicas para senhas

| Algoritmo  | Base             | Status                             |
| ---------- | ---------------- | ---------------------------------- |
| **bcrypt** | Blowfish         | ✅ Recomendado                      |
| **Argon2** | Hash + memória   | ✅ **Melhor atual**                 |
| **PBKDF2** | HMAC + iterações | 🔸 Ainda usado (menos recomendado) |
| **scrypt** | Hash + memória   | ✅ Recomendado                      |

#### Exemplo correto (bcrypt)

```python
import bcrypt

senha = b"senha_do_usuario"
salt = bcrypt.gensalt()
hash_senha = bcrypt.hashpw(senha, salt)

# Verificar
if bcrypt.checkpw(senha, hash_senha):
    print("Senha correta")
```

***

### 🎯 Recomendação Final

| Cenário                          | Escolha                               |
| -------------------------------- | ------------------------------------- |
| **Hash geral (integridade)**     | ✅ **SHA-256** ou **BLAKE2**           |
| **Alta segurança (assinaturas)** | ✅ SHA-512 ou SHA-3-512                |
| **Velocidade extrema**           | ✅ **BLAKE3**                          |
| **Blockchain/Bitcoin**           | SHA-256 + RIPEMD-160                  |
| **Senhas**                       | ✅ **Argon2** ou **bcrypt**            |
| **Certificados digitais**        | SHA-256 (mínimo)                      |
| **MD5 / SHA-1**                  | ❌ **Nunca** (só checksum não crítico) |

***

### 🔗 Links Úteis

* [NIST – SHA-3 Standard](https://csrc.nist.gov/projects/hash-functions/sha-3-project)
* [BLAKE2 – Official Site](https://www.blake2.net/)
* [BLAKE3 – GitHub](https://github.com/BLAKE3-team/BLAKE3)
* [SHAttered – SHA-1 Collision](https://shattered.io/)
* [Argon2 – Password Hashing Competition](https://www.password-hashing.net/)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/conceitos/criptografia/funcoes-de-hash.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.