# ECC (Elliptic Curve Cryptography)

### 🎯 Descrição Geral

**ECC (Elliptic Curve Cryptography)** é uma abordagem de criptografia de chave pública baseada na **álgebra de curvas elípticas sobre corpos finitos**. Ela oferece o mesmo nível de segurança que o RSA com **chaves muito menores**, tornando-a ideal para dispositivos com recursos limitados.

```
RSA-3072 (512 bytes)   vs   ECC-256 (32 bytes)
┌─────────────────────┐     ┌─────────────┐
│ Chave muito grande  │     │ Chave pequena│
│ Consome mais energia│     │ Eficiente    │
│ Mais lenta          │     │ Rápida       │
└─────────────────────┘     └─────────────┘
```

#### Analogia

> *"Se RSA é uma porta com uma feitura enorme e complicada, ECC é uma fechadura eletrônica com o mesmo nível de segurança, mas muito menor e mais rápida."*

***

### 📐 Conceitos Matemáticos Fundamentais

#### 1. O que é uma Curva Elíptica?

Uma curva elíptica é definida pela equação:

```
y² = x³ + ax + b
```

Onde `4a³ + 27b² ≠ 0` (para evitar singularidades).

#### 2. Pontos na Curva

```
Exemplo: y² = x³ - x + 1

Pontos: (0,1), (0,-1), (1,1), (1,-1), (2, √7), ...
```

#### 3. Operação de Adição de Pontos

A "mágica" do ECC está na operação de adição de pontos na curva:

```
P + Q = R (onde R é o reflexo do terceiro ponto)
```

#### 4. Multiplicação Escalar

A base da criptografia:

```
Q = k × P (P somado a si mesmo k vezes)
```

**O problema inverso (ECDLP):** Dados P e Q, encontrar k é computacionalmente inviável.

***

### ⚙️ Como Funciona o ECC

#### Geração de Chaves

```python
# 1. Escolher uma curva elíptica (parâmetros públicos)
curva = {
    'p': número_primo_grande,  # corpo finito
    'a': parâmetro,
    'b': parâmetro,
    'G': ponto_base,           # gerador
    'n': ordem_do_gerador
}

# 2. Escolher chave privada (número aleatório)
chave_privada = random.randint(1, n-1)

# 3. Calcular chave pública
chave_publica = chave_privada × G  # multiplicação escalar
```

#### Cifragem ECC (ElGamal sobre curvas)

```python
# Alice quer enviar mensagem M para Bob

# Bob tem chave pública Q_bob = d_bob × G

# Alice:
k = random.randint(1, n-1)
C1 = k × G
C2 = M + k × Q_bob  # M é um ponto na curva

# Envia (C1, C2)

# Bob decifra:
M = C2 - d_bob × C1
```

#### Assinatura ECDSA (mais comum)

```python
# Assinar mensagem com chave privada d
k = random.randint(1, n-1)
R = k × G
r = R.x mod n
s = k⁻¹ × (hash(mensagem) + d × r) mod n
# Assinatura = (r, s)

# Verificar com chave pública Q
w = s⁻¹ mod n
u1 = hash(mensagem) × w mod n
u2 = r × w mod n
P = u1 × G + u2 × Q
# Válido se P.x == r
```

***

### 📊 Comparação: ECC vs RSA

| Nível de Segurança | Tamanho RSA | Tamanho ECC | Proporção |
| ------------------ | ----------- | ----------- | --------- |
| 80 bits (quebrado) | 1024 bits   | 160 bits    | 6.4:1     |
| 112 bits           | 2048 bits   | 224 bits    | 9.1:1     |
| 128 bits           | 3072 bits   | 256 bits    | 12:1      |
| 192 bits           | 7680 bits   | 384 bits    | 20:1      |
| 256 bits           | 15360 bits  | 521 bits    | 29.5:1    |

#### Performance

| Operação                  | RSA-3072  | ECC-256  | Melhoria          |
| ------------------------- | --------- | -------- | ----------------- |
| **Geração de chave**      | \~100 ms  | \~10 ms  | 10x               |
| **Assinatura**            | \~5 ms    | \~1 ms   | 5x                |
| **Verificação**           | \~0.5 ms  | \~2 ms   | RSA é mais rápida |
| **Tamanho chave pública** | 384 bytes | 32 bytes | 12x               |
| **Tamanho assinatura**    | 256 bytes | 64 bytes | 4x                |
| **Consumo energia**       | Alto      | Baixo    | 10-20x            |

> **Nota:** RSA é mais rápida para verificação, ECC é mais rápida para assinatura e geração de chave.

***

### 🔐 Curvas Elípticas Padrão

#### Curvas NIST (Recomendadas pelo governo americano)

| Curva     | Tamanho  | Segurança | Uso                   |
| --------- | -------- | --------- | --------------------- |
| **P-192** | 192 bits | 96 bits   | ❌ Obsoleta            |
| **P-224** | 224 bits | 112 bits  | ⚠️ Legado             |
| **P-256** | 256 bits | 128 bits  | ✅ Padrão (governo US) |
| **P-384** | 384 bits | 192 bits  | ✅ Alto nível          |
| **P-521** | 521 bits | 256 bits  | ✅ Máxima segurança    |

#### Curvas de domínio público (Recomendadas)

| Curva          | Criador          | Tamanho  | Segurança | Característica                      |
| -------------- | ---------------- | -------- | --------- | ----------------------------------- |
| **Curve25519** | Daniel Bernstein | 256 bits | 128 bits  | ✅ Mais rápida, sem ataques laterais |
| **Ed25519**    | Daniel Bernstein | 256 bits | 128 bits  | ✅ Versão para assinaturas           |
| **Curve448**   | Daniel Bernstein | 448 bits | 224 bits  | ✅ Alta segurança                    |
| **secp256k1**  | Certicom         | 256 bits | 128 bits  | 🔸 Bitcoin                          |

#### Por que Curve25519/Ed25519 é recomendada?

```python
# Vantagens da Curve25519:
# 1. Design "safe" - evita vulnerabilidades comuns
# 2. Implementação constante - resistente a timing attacks
# 3. Sem patentes - domínio público
# 4. Extremamente rápida
# 5. Sem pontos fracos conhecidos

# Curva: y² = x³ + 486662x² + x (mod 2²⁵⁵ - 19)
```

***

### 💻 Exemplos Práticos

#### Exemplo 1 – Gerar chaves Ed25519 (OpenSSL)

```bash
# Gerar chave privada Ed25519
openssl genpkey -algorithm ED25519 -out private_key_ed25519.pem

# Extrair chave pública
openssl pkey -in private_key_ed25519.pem -pubout -out public_key_ed25519.pem

# Verificar chaves
openssl pkey -in private_key_ed25519.pem -text -noout
openssl pkey -pubin -in public_key_ed25519.pem -text -noout
```

#### Exemplo 2 – Assinatura com Ed25519 (OpenSSL)

```bash
# Criar arquivo
echo "Mensagem importante" > msg.txt

# Assinar
openssl pkeyutl -sign -inkey private_key_ed25519.pem -rawin -in msg.txt -out signature.bin

# Verificar
openssl pkeyutl -verify -pubin -inkey public_key_ed25519.pem -rawin -in msg.txt -sigfile signature.bin
```

#### Exemplo 3 – ECDSA com P-256 (OpenSSL)

```bash
# Gerar chave ECDSA P-256
openssl ecparam -name prime256v1 -genkey -out private_key_ecdsa.pem

# Extrair chave pública
openssl ec -in private_key_ecdsa.pem -pubout -out public_key_ecdsa.pem

# Assinar
openssl dgst -sha256 -sign private_key_ecdsa.pem -out signature.bin msg.txt

# Verificar
openssl dgst -sha256 -verify public_key_ecdsa.pem -signature signature.bin msg.txt
```

#### Exemplo 4 – ECC em Python (Cryptography)

```python
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric.utils import (
    decode_dss_signature, encode_dss_signature
)

# Gerar chave privada (Curve25519 não está no cryptography, usar Ed25519)
private_key = ec.generate_private_key(ec.SECP256R1())  # P-256
public_key = private_key.public_key()

# Assinar mensagem
message = b"Mensagem super secreta"
signature = private_key.sign(
    message,
    ec.ECDSA(hashes.SHA256())
)

# Verificar assinatura
try:
    public_key.verify(signature, message, ec.ECDSA(hashes.SHA256()))
    print("✅ Assinatura válida!")
except:
    print("❌ Assinatura inválida!")

# Serializar chaves
pem_private = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.NoEncryption()
)

pem_public = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)
```

#### Exemplo 5 – Ed25519 em Python (cryptography)

```python
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey

# Gerar chave
private_key = Ed25519PrivateKey.generate()
public_key = private_key.public_key()

# Assinar
message = b"Mensagem para assinar"
signature = private_key.sign(message)

# Verificar
try:
    public_key.verify(signature, message)
    print("✅ Assinatura Ed25519 válida!")
except:
    print("❌ Assinatura inválida!")
```

#### Exemplo 6 – secp256k1 (Bitcoin) em Python

```python
# pip install coincurve
import coincurve

# Gerar chave privada (para Bitcoin)
private_key = coincurve.PrivateKey()
public_key = private_key.public_key

print(f"Chave privada: {private_key.secret.hex()}")
print(f"Chave pública (compressed): {public_key.format().hex()}")
print(f"Endereço Bitcoin: {public_key.address()}")

# Assinar mensagem
message = b"Transferir 1 BTC"
signature = private_key.sign(message)

# Verificar
verified = public_key.verify(signature, message)
print(f"Assinatura válida: {verified}")
```

***

### 🔐 Aplicações do ECC

| Aplicação          | Curva Usada         | Finalidade                        |
| ------------------ | ------------------- | --------------------------------- |
| **Bitcoin**        | secp256k1           | Assinatura de transações          |
| **Ethereum**       | secp256k1           | Assinatura de transações          |
| **WhatsApp**       | Curve25519          | Troca de chaves (Signal Protocol) |
| **Signal**         | Curve25519, Ed25519 | Criptografia fim-a-fim            |
| **WireGuard**      | Curve25519          | Troca de chaves da VPN            |
| **SSH**            | Ed25519             | Autenticação de usuários          |
| **TLS 1.3**        | X25519, P-256       | Troca de chaves (ECDHE)           |
| **Apple iMessage** | Curve25519          | Criptografia de mensagens         |
| **Android**        | P-256, Curve25519   | Keystore, autenticação            |
| **JWT**            | ES256 (P-256)       | Tokens de autenticação            |

***

### ⚠️ Vulnerabilidades e Ataques

#### 1. Ataques Clássicos

| Ataque             | Descrição                    | Mitigação                        |
| ------------------ | ---------------------------- | -------------------------------- |
| **ECDLP**          | Resolver logaritmo discreto  | Curvas grandes (>256 bits)       |
| **Pollard's Rho**  | Algoritmo de fatoração       | Ordem da curva com fator grande  |
| **Pohlig-Hellman** | Reduzir para subgrupos       | Ordem com fator primo grande     |
| **Smart's Attack** | Curvas anômalas              | Evitar curvas com traço = 1      |
| **MOV Attack**     | Reduzir para corpo estendido | Curvas com embedding degree alto |

#### 2. Ataques de Implementação

| Ataque                   | Descrição                    | Mitigação                 |
| ------------------------ | ---------------------------- | ------------------------- |
| **Timing Attack**        | Medir tempo de operações     | Implementação constante   |
| **Power Analysis**       | Medir consumo energia        | Contramedidas (blinding)  |
| **Fault Attack**         | Induzir erro computacional   | Verificação de resultados |
| **Invalid Curve Attack** | Fornecer ponto fora da curva | Validar pontos            |
| **Side-channel**         | Cache, eletromagnético       | Implementação segura      |

#### 3. Ameaça Quântica

Assim como RSA, ECC é vulnerável ao **algoritmo de Shor** em computadores quânticos.

| Curva      | Quântico Seguro? |
| ---------- | ---------------- |
| P-256      | ❌ Não            |
| P-384      | ❌ Não            |
| Curve25519 | ❌ Não            |
| secp256k1  | ❌ Não            |

**Alternativa pós-quântica:** CRYSTALS-Kyber, CRYSTALS-Dilithium, FALCON

***

### 🔒 Recomendações de Segurança

#### Curvas para cada cenário

| Cenário                              | Curva Recomendada | Por que                      |
| ------------------------------------ | ----------------- | ---------------------------- |
| **Novos projetos (assinaturas)**     | Ed25519           | Rápida, segura, sem patentes |
| **Novos projetos (troca de chaves)** | X25519            | Eficiente, segura            |
| **Compatibilidade máxima**           | P-256 (secp256r1) | Suportada por todos          |
| **Bitcoin/Blockchain**               | secp256k1         | Padrão da indústria          |
| **Alta segurança**                   | P-521 ou Ed448    | Margem extra                 |
| **Sistemas legados**                 | P-256             | Compatibilidade              |

#### Configurações seguras

```bash
# SSH - Use Ed25519
ssh-keygen -t ed25519 -a 100

# OpenSSL - ECDSA com P-256
openssl ecparam -name prime256v1 -genkey -out key.pem

# OpenSSL - Troca de chaves X25519
openssl s_client -cipher ECDHE-X25519

# TLS 1.3 (prioriza X25519)
# Configure: SignatureAlgorithms = ed25519
```

#### Práticas recomendadas

```python
# ✅ Correto - Usar curvas seguras
from cryptography.hazmat.primitives.asymmetric import ec
key = ec.generate_private_key(ec.SECP256R1())  # P-256
key = ec.generate_private_key(ec.Ed25519())    # Ed25519 (cryptography 37+)

# ❌ Errado - Curvas pequenas ou inseguras
key = ec.generate_private_key(ec.SECP192R1())  # 192 bits (obsoleta)
key = ec.generate_private_key(ec.SECT163K2())  # Curva Koblitz (não recomendada)
```

***

### 📜 História do ECC

| Ano      | Evento                                           |
| -------- | ------------------------------------------------ |
| **1985** | Koblitz e Miller propõem ECC independentemente   |
| **1991** | Certicom é fundada (detém muitas patentes ECC)   |
| **1999** | NIST padroniza curvas P-192, P-256, P-384, P-521 |
| **2000** | RSA começa a ser ameaçado por ECC                |
| **2005** | Daniel Bernstein publica Curve25519              |
| **2011** | NSA recomenda ECC para sistemas classificados    |
| **2015** | Ed25519 adotado pelo OpenSSH                     |
| **2017** | Patentes ECC começam a expirar                   |
| **2018** | TLS 1.3 exige suporte a ECC                      |
| **2020** | WireGuard (usa Curve25519) entra no kernel Linux |

***

### 🔄 ECC vs RSA vs Pós-Quântico

| Característica             | RSA-3072  | ECC-256  | Pós-Quântico (Kyber) |
| -------------------------- | --------- | -------- | -------------------- |
| **Tamanho chave**          | 384 bytes | 32 bytes | 800-1500 bytes       |
| **Tamanho cifrado**        | 256 bytes | 64 bytes | 500-1000 bytes       |
| **Velocidade (assinar)**   | Lenta     | Rápida   | Média                |
| **Velocidade (verificar)** | Rápida    | Média    | Média                |
| **Resistência quântica**   | ❌         | ❌        | ✅                    |
| **Maturação**              | 40+ anos  | 30+ anos | 5-10 anos            |
| **Adoção**                 | Universal | Alta     | Baixa (emergente)    |

***

### 🎯 Resumo Rápido

| Ponto                   | Resumo                                             |
| ----------------------- | -------------------------------------------------- |
| **Base**                | Logaritmo discreto em curvas elípticas             |
| **Vantagem**            | Mesma segurança com chaves muito menores           |
| **Tamanho recomendado** | 256 bits (128 bits de segurança)                   |
| **Curva recomendada**   | Ed25519 (assinatura), X25519 (troca de chaves)     |
| **Principal uso**       | Assinaturas, troca de chaves (não cifragem direta) |
| **Bitcoin**             | secp256k1                                          |
| **TLS 1.3**             | X25519, P-256                                      |
| **SSH**                 | Ed25519                                            |

***

### 🔗 Links Úteis

* [RFC 8032 - Ed25519](https://datatracker.ietf.org/doc/html/rfc8032)
* [Curve25519 - Official Site](https://cr.yp.to/ecdh.html)
* [NIST SP 800-56A - ECC](https://csrc.nist.gov/publications/detail/sp/800-56a/rev-3/final)
* [SafeCurves - Curvas seguras](https://safecurves.cr.yp.to/)
* [SECG - Standards for Efficient Cryptography](https://www.secg.org/)


---

# 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/assimetrica/ecc-elliptic-curve-cryptography.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.