98 lines
4.2 KiB
Markdown
98 lines
4.2 KiB
Markdown
---
|
|
group: e2e-messaging
|
|
description: "Criptografía extremo a extremo para bus de mensajería: identidades duales Ed25519/X25519, distribución de claves de sala con sealed box anónimo, cifrado simétrico AEAD por mensaje, y firma/verificación de mensajes."
|
|
functions:
|
|
- generate_identity_go_cybersecurity
|
|
- seal_aead_go_cybersecurity
|
|
- open_aead_go_cybersecurity
|
|
- seal_key_box_go_cybersecurity
|
|
- open_key_box_go_cybersecurity
|
|
- sign_ed25519_go_cybersecurity
|
|
- verify_ed25519_go_cybersecurity
|
|
---
|
|
|
|
## Funciones del grupo
|
|
|
|
| ID | Firma corta | Qué hace |
|
|
|---|---|---|
|
|
| `generate_identity_go_cybersecurity` | `GenerateIdentity() (Identity, error)` | Genera par Ed25519 (firma) + par X25519 (kex) para un participante |
|
|
| `seal_aead_go_cybersecurity` | `SealAEAD(key, plaintext, aad []byte) (nonce, ct []byte, err error)` | Cifra mensaje con ChaCha20-Poly1305, nonce aleatorio por llamada |
|
|
| `open_aead_go_cybersecurity` | `OpenAEAD(key, nonce, ct, aad []byte) ([]byte, error)` | Descifra y autentica; error explícito si el tag falla |
|
|
| `seal_key_box_go_cybersecurity` | `SealKeyBox(recipientKexPub, secret []byte) ([]byte, error)` | Cifra room key para un destinatario con su X25519 pubkey (sealed box anónimo) |
|
|
| `open_key_box_go_cybersecurity` | `OpenKeyBox(kexPub, kexPriv, sealedMsg []byte) ([]byte, error)` | Abre sealed box con el par X25519 propio para recuperar la room key |
|
|
| `sign_ed25519_go_cybersecurity` | `SignEd25519(priv, msg []byte) []byte` | Firma determinista Ed25519 (pura, sin I/O) |
|
|
| `verify_ed25519_go_cybersecurity` | `VerifyEd25519(pub, msg, sig []byte) bool` | Verifica firma Ed25519 (pura, sin I/O) |
|
|
|
|
## Ejemplo canónico end-to-end
|
|
|
|
```go
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
cs "fn-registry/functions/cybersecurity"
|
|
)
|
|
|
|
func main() {
|
|
// 1. Cada participante genera su identidad una sola vez
|
|
server, err := cs.GenerateIdentity()
|
|
if err != nil { log.Fatal(err) }
|
|
user, err := cs.GenerateIdentity()
|
|
if err != nil { log.Fatal(err) }
|
|
|
|
// 2. Servidor genera room key y la distribuye al usuario cifrada
|
|
roomKey := make([]byte, 32)
|
|
// ... llenar roomKey con crypto/rand en producción ...
|
|
sealed, err := cs.SealKeyBox(user.KexPub, roomKey)
|
|
if err != nil { log.Fatal(err) }
|
|
|
|
// 3. Usuario recupera la room key
|
|
gotKey, err := cs.OpenKeyBox(user.KexPub, user.KexPriv, sealed)
|
|
if err != nil { log.Fatal(err) }
|
|
|
|
// 4. Usuario cifra un mensaje con la room key
|
|
aad := []byte("room:sala-general:seq:1")
|
|
nonce, ct, err := cs.SealAEAD(gotKey, []byte("hola sala"), aad)
|
|
if err != nil { log.Fatal(err) }
|
|
|
|
// 5. Usuario firma el ciphertext para autenticar autoría
|
|
sig := cs.SignEd25519(user.SignPriv, ct)
|
|
|
|
// 6. Receptor verifica firma y descifra
|
|
if !cs.VerifyEd25519(user.SignPub, ct, sig) {
|
|
log.Fatal("firma inválida")
|
|
}
|
|
plain, err := cs.OpenAEAD(gotKey, nonce, ct, aad)
|
|
if err != nil { log.Fatal(err) }
|
|
fmt.Printf("recibido: %s\n", plain)
|
|
_ = server // server.SignPub publicado en directorio de participantes
|
|
}
|
|
```
|
|
|
|
## Fronteras
|
|
|
|
Este grupo cubre las primitivas criptográficas del bus, no el protocolo completo:
|
|
|
|
- **No cubre**: transporte (WebSocket, gRPC), gestión de sesiones, ratchet de claves (doble ratchet), persistencia de identidades, revocación de claves.
|
|
- **No cubre**: cifrado de archivos adjuntos (usar SealAEAD directamente con una key derivada).
|
|
- **No reemplaza**: libsodium ni libolm para implementaciones de producción de Signal/Matrix — estas funciones son el sustrato criptográfico, no el protocolo completo.
|
|
|
|
## Prerequisitos
|
|
|
|
- `golang.org/x/crypto` ya en `go.mod` (presente en fn-registry).
|
|
- `crypto/ed25519` de stdlib (Go 1.13+).
|
|
- Identidades persistidas de forma segura (keyring, HSM, archivo cifrado): este grupo no gestiona almacenamiento.
|
|
|
|
## Patrón de uso recomendado
|
|
|
|
```
|
|
GenerateIdentity() → persiste Identity por participante
|
|
SealKeyBox(kexPub, roomKey) → distribuye room key al unirse a sala
|
|
OpenKeyBox(kexPub, kexPriv) → recupera room key
|
|
SealAEAD(roomKey, msg, aad) → cifra cada mensaje
|
|
SignEd25519(signPriv, ct) → autentica autoría sobre ciphertext
|
|
VerifyEd25519(signPub, ct) → verifica antes de descifrar
|
|
OpenAEAD(roomKey, nonce, ct)→ descifra mensaje verificado
|
|
```
|