fn_registry/docs/capabilities/e2e-messaging.md

group, description, functions

group	description	functions
e2e-messaging	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.	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

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