---
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
```
