mejorado cifrado de claves rachet de los mensajes

Author: MateoGonzalezLourido

Docs/Services/CLAVES_SISTEMA.md

@@ -12,8 +12,8 @@ Ravage maneja varios tipos de claves criptográficas con propósitos distintos.
 | `SECRET_KEY_COKKIE` | Variable de entorno (hex) | `Buffer` | `.env.secret` | Cifra archivos locales de sesión y configuración de la app |
 | `SECRET_KEY_PRIVATE` | Variable de entorno (hex) | `Buffer` | `.env.secret` | Cifra el archivo de identidad E2EE (clave privada RSA) en disco |
 | `INTERNAL_ENCRYPTION_KEY` | Variable de entorno (hex) | `Buffer` | `.env.secret` | Cifra datos sensibles almacenados en MongoDB (buzón, etc.) |
-| Chain key (ratchet E2EE) | `randomBytes(32)` al crear chat | Hex string | Hex string (RSA-wrapped en `ratchet_keys`) | Clave raíz del ratchet de mensajes por chat |
-| Clave privada RSA | Generada con `generateKeyPairSync` | PEM string | Cifrada con `SECRET_KEY_PRIVATE` en `identityFile` | Descifra chain keys y mensajes E2EE |
+| Chain key (ratchet E2EE) | `randomBytes(32)` al crear chat | Hex string | Hex string (X25519-wrapped en `ratchet_keys`) | Clave raíz del ratchet de mensajes por chat |
+| Clave privada X25519 | Generada con `generateKeyPairSync('x25519')` | PEM string | Cifrada con `SECRET_KEY_PRIVATE` en `identityFile` | Descifra chain keys E2EE (ECDH) |
 
 ---
 
@@ -83,10 +83,7 @@ Las chain keys implementan un ratchet de tipo Sender Key, similar al protocolo S
 
 ### Formato y convención
 
-Las chain keys se almacenan y transportan siempre como **cadenas hexadecimales de 64 caracteres** (representación de 32 bytes). Este convenio es intencional:
-
-- `descifrarConPrivada()` en `cryptoService.js` devuelve `.toString('utf8')`. Una cadena hex sobrevive sin corrupción a este round-trip (todos sus caracteres son ASCII imprimibles).
-- Si se almacenaran como bytes binarios, el `.toString('utf8')` los corrompería al encontrar secuencias de bytes no válidas UTF-8.
+Las chain keys se almacenan y transportan siempre como **cadenas hexadecimales de 64 caracteres** (representación de 32 bytes, todos caracteres ASCII). Esta convención es segura frente al round-trip de AES-GCM porque UTF-8 no corrompe ASCII.
 
 ### Flujo de la chain key
 
@@ -95,31 +92,45 @@ Las chain keys se almacenan y transportan siempre como **cadenas hexadecimales d
 randomBytes(32).toString('hex')       ← chain key inicial (hex, 64 chars)
       │
       ▼
-cifrarConPublica(chainKey, publicKey) ← RSA-OAEP cifra los 64 bytes UTF-8
-      │
+cifrarConX25519(chainKey, publicKey)  ← ECDH efímero + HKDF + AES-256-GCM
+      │                                 genera: { ephPub, iv, data, tag }
       ▼
-ratchet_keys[].clave_envuelta         ← almacenada cifrada en MongoDB por par emisor→receptor
+ratchet_keys[].clave_envuelta         ← subdocumento { ephPub, iv, data, tag } en MongoDB
 
 [Enviar / recibir mensaje]
-descifrarConPrivada(clave_envuelta)   ← devuelve la chain key como hex string
+descifrarConX25519(clave_envuelta, privateKey)   ← devuelve la chain key como hex string
       │
       ▼
 ratchetChainKey(chainKeyHex)
   ├─ messageKey   = HMAC-SHA256(Buffer.from(hex, 'hex'), 0x01)  → Buffer (clave AES para este mensaje)
   └─ nextChainKey = HMAC-SHA256(Buffer.from(hex, 'hex'), 0x02)  → hex string (siguiente estado del ratchet)
 ```
 
-El `nextChainKey` vuelve a ser hex para mantener el contrato y poder pasarse a la siguiente iteración de `ratchetChainKey`.
+### Por qué X25519 en lugar de RSA-OAEP
+
+Con RSA-OAEP, comprometer una clave privada permite descifrar **todos** los `clave_envuelta` pasados almacenados en la DB. Con X25519 efímero, cada `clave_envuelta` se cifró con una clave efímera de un solo uso: comprometer la clave privada de identidad no permite descifrar mensajes anteriores (**forward secrecy** en la distribución de chain keys).
+
+### Cómo funciona el cifrado X25519
+
+Para cada par (emisor, receptor) al crear o rotar claves de chat:
+
+1. Se genera un par X25519 **efímero** (vive solo durante la operación).
+2. `ECDH(ephPriv, recipientPub)` → 32 bytes de secreto compartido.
+3. `HKDF-SHA256(sharedSecret, info='ravage-ck-wrap')` → 32 bytes de wrapping key.
+4. `AES-256-GCM(chainKeyHex, wrappingKey)` → `{ iv, data, tag }`.
+5. Se almacena `{ ephPub (raw hex 32B), iv, data, tag }` en `ratchet_keys[].clave_envuelta`.
+
+Para descifrar: receptor hace `ECDH(privKey, ephPub)` → misma wrapping key → descifra con AES-GCM.
 
 ### Archivos relevantes
 
 | Archivo | Rol |
 |---|---|
-| `ChatRepository.js` | Genera la chain key inicial y la cifra con RSA pública de cada miembro |
-| `cryptoService.js` | `ratchetChainKey`, `cifrarConPublica`, `descifrarConPrivada` |
-| `cryptoWorker.js` | Worker pool: réplica de `_ratchetChainKey` y `_descifrarConPrivada` para operaciones paralelas |
+| `ChatRepository.js` | Genera la chain key inicial y la cifra con X25519 para cada miembro |
+| `cryptoService.js` | `ratchetChainKey`, `cifrarConX25519`, `descifrarConX25519`, `descifrarConX25519Multi` |
+| `cryptoWorker.js` | Worker pool: `_cifrarConX25519`, `_descifrarConX25519`, `_ratchetChainKey` |
 | `messageCryptoService.js` | Orquesta el descifrado de mensajes usando el ratchet |
-| `Chat.js` (modelo) | `clave_envuelta: String` — la chain key cifrada con RSA |
+| `Chat.js` (modelo) | `clave_envuelta: { ephPub, iv, data, tag }` — subdocumento en MongoDB |
 
 ---
 
@@ -131,5 +142,5 @@ El `nextChainKey` vuelve a ser hex para mantener el contrato y poder pasarse a l
 | `SECRET_KEY_COKKIE` | En `.env.secret` (protegido por vault del SO) | AES-256-GCM |
 | `SECRET_KEY_PRIVATE` | En `.env.secret` (protegido por vault del SO) | AES-256-GCM |
 | `INTERNAL_ENCRYPTION_KEY` | En `.env.secret` | AES-256-GCM (cifra datos en MongoDB) |
-| Chain key | RSA-OAEP (SHA-256) con clave pública del receptor | HMAC-SHA256 (ratchet) → AES-256-GCM (mensajes) |
-| Clave privada RSA | AES-256-GCM con `SECRET_KEY_PRIVATE` | RSA-OAEP (descifrar chain keys) |
+| Chain key | X25519+HKDF+AES-256-GCM (efímero por operación) | HMAC-SHA256 (ratchet) → AES-256-GCM (mensajes) |
+| Clave privada X25519 | AES-256-GCM con `SECRET_KEY_PRIVATE` | ECDH (descifrar chain keys envueltas) |

Docs/Services/seguridad/LOGIN_SESION.md

@@ -13,7 +13,7 @@ Este documento describe el flujo completo de autenticación en Ravage: registro,
 3. Se comprueba en DB que el correo no esté ya registrado (`correo_hash`).
 4. Si pasa, en background se ejecutan en paralelo:
    - **Hash de contraseña** con Argon2id (ver `Docs/Services/seguridad/HASHING_CONTRASENAS.md`).
-   - **Generación de par de claves RSA** para cifrado E2EE.
+   - **Generación de par de claves X25519** para cifrado E2EE.
 5. Se genera un código de verificación numérico aleatorio y se guarda en la colección `validationcodes` cifrado, vinculado al correo y al dispositivo.
 6. Se envía el código por correo. El usuario tiene **10 minutos** y **5 intentos** para introducirlo.
 
@@ -154,7 +154,7 @@ autoLoginUsuario()
 Tras cualquier login exitoso (manual o autologin) se verifica que existe la clave privada RSA local.
 
 - Si existe → sin acción.
-- Si no existe (p.ej. primer login en un dispositivo nuevo, o archivo corrupto) → se regeneran las claves RSA automáticamente, se actualiza la clave pública en DB y se guarda la privada en el archivo local.
+- Si no existe (p.ej. primer login en un dispositivo nuevo, o archivo corrupto) → se regeneran las claves X25519 automáticamente, se actualiza la clave pública en DB y se guarda la privada en el archivo local.
 
 > **Atención**: regenerar la identidad rompe el descifrado de mensajes anteriores en todos los chats, ya que fueron cifrados con la clave pública antigua. Es un escenario de último recurso.
 
@@ -197,5 +197,5 @@ Todos los archivos se guardan cifrados en el directorio de datos de la app (fuer
 | `sessionFile` | `{ username, token }` | Login con `mantenerSesion` | Cierre de sesión / token inválido |
 | `omitirVerificacionCuentaFile` | `{ username, token }` | Tras validar código de login | Token expirado / inválido |
 | `dispositivoConfianza` | `{ username, token }` | Al marcar como de confianza | Al revocar confianza |
-| `identityFile` | Claves RSA privada + pública | Registro / regeneración | Nunca (persiste entre sesiones) |
+| `identityFile` | Claves X25519 privada + pública | Registro / regeneración | Nunca (persiste entre sesiones) |
 | `securityPin` | `{ correo, pinHash }` | Al configurar el PIN | Al borrar el PIN |

backend/models/Chat.js

@@ -23,8 +23,14 @@ const ChatSchema = new mongoose.Schema({
     },
     ratchet_keys: [{
         emisor_id: mongoose.Schema.Types.ObjectId,
-        receptor_id: mongoose.Schema.Types.ObjectId, // A quien va dirigida esta copia de la clave
-        clave_envuelta: String, // ChainKey del emisor cifrada con RSA pública del receptor
+        receptor_id: mongoose.Schema.Types.ObjectId,
+        clave_envuelta: {
+            ephPub: { type: String, required: true },
+            iv:     { type: String, required: true },
+            data:   { type: String, required: true },
+            tag:    { type: String, required: true },
+            _id: false
+        },
         counter: { type: Number, default: 0 }
     }],
     escaneres_seguridad: {

backend/repositories/ChatRepository.js

@@ -7,7 +7,7 @@ import { convertirObjectId } from '../utils/conversores.js';
 import { getIDMongodbUsuario, getInvisibleUsuario, setUsuariosSilence, setUsuariosBloqueados, getUsuariosSilence, getUsuariosBloqueados } from '../STORAGE/Variables_sesion.js';
 import { Añadir_Entrada_Buzon_Usuario } from './BuzonRepository.js';
 import { descifrarListaMensajes } from '../services/messageCryptoService.js';
-import { cifrarConPublica, desencriptarDatosSistema, encriptarDatosSistema } from '../services/cryptoService.js';
+import { cifrarConX25519, desencriptarDatosSistema, encriptarDatosSistema } from '../services/cryptoService.js';
 
 
 const log = createLogger('chat-repo');
@@ -360,7 +360,7 @@ export async function CREAR_CHAT_NUEVO(ids = null, nombre = "", id_chat = null,
             ratchet_keys.push({
                 emisor_id: emisor._id,
                 receptor_id: receptor._id,
-                clave_envuelta: cifrarConPublica(chainKey, receptor.publicKey),
+                clave_envuelta: cifrarConX25519(chainKey, receptor.publicKey),
                 counter: 0
             });
         }
@@ -731,7 +731,7 @@ export async function rotarClavesChat(id_chat, id_emisor) {
             updates.push({
                 emisor_id: id_emisor_str,
                 receptor_id: receptor._id,
-                clave_envuelta: cifrarConPublica(newChainKey, receptor.publicKey),
+                clave_envuelta: cifrarConX25519(newChainKey, receptor.publicKey),
                 counter: 0
             });
         }

backend/repositories/MessageRepository.js

@@ -14,8 +14,8 @@ import { setUsuarioEnCache } from './UserRepository.js';
 import { descifrarListaMensajes, getMessageKey } from '../services/messageCryptoService.js';
 import {
     cifrarContenido,
-    descifrarConPrivada,
-    cifrarConPublica,
+    descifrarConX25519,
+    cifrarConX25519,
     crearCipherStream,
     crearDecipherStream,
     encriptarDatosSistema,
@@ -66,7 +66,7 @@ export async function ENVIAR_MENSAJE({ asunto = "", archivos = [], id_chat, id_e
         // Recibe identity_data como parámetro para no volver a pedirla
         async function intentarDescifrado(ent, id_data) {
             if (!id_data || !id_data.primary?.privateKey) throw new Error("No Identity keys found locally.");
-            return descifrarConPrivada(ent.clave_envuelta, id_data.primary.privateKey);
+            return descifrarConX25519(ent.clave_envuelta, id_data.primary.privateKey);
         }
 
         try {
@@ -181,7 +181,7 @@ export async function ENVIAR_MENSAJE({ asunto = "", archivos = [], id_chat, id_e
         };
 
         // Crear mensaje y actualizar ratchet en paralelo
-        const nuevaClave = cifrarConPublica(nextChainKey, usuario.publicKey);
+        const nuevaClave = cifrarConX25519(nextChainKey, usuario.publicKey);
         const [nuevoMensaje] = await Promise.all([
             MessagesRavage.create(mensaje),
             ChatsRavage.updateOne(

backend/services/controladorArchivos.js

@@ -162,16 +162,15 @@ async function _leerIdentidadLocal() {
 async function importarClavePrivada(pemContent, label = '') {
     try {
         const pem = pemContent.trim();
-        // Validar que sea una clave privada válida usando Node crypto
-        const { createPrivateKey } = await import('node:crypto');
-        createPrivateKey(pem);
+        const { createPrivateKey, createPublicKey } = await import('node:crypto');
+        const privKeyObj = createPrivateKey(pem);
+        const publicKey = createPublicKey(privKeyObj).export({ type: 'spki', format: 'pem' });
 
         const id = _fingerprint(pem);
         const current = await _leerIdentidadLocal();
 
         if (!current) {
-            // Sin identidad previa → esta clave se convierte en la principal
-            const nuevo = { primary: { id, privateKey: pem, publicKey: '', createdAt: Date.now() }, supportKeys: [] };
+            const nuevo = { primary: { id, privateKey: pem, publicKey, createdAt: Date.now() }, supportKeys: [] };
             await saveIdentityFile(nuevo);
             return { ok: true, id, tipo: 'primary' };
         }
@@ -180,7 +179,7 @@ async function importarClavePrivada(pemContent, label = '') {
         if ((current.supportKeys || []).some(k => k.id === id)) return { ok: false, error: 'Esa clave ya está en la lista de soporte' };
 
         current.supportKeys = current.supportKeys || [];
-        current.supportKeys.push({ id, privateKey: pem, addedAt: Date.now(), label });
+        current.supportKeys.push({ id, privateKey: pem, publicKey, addedAt: Date.now(), label });
         await saveIdentityFile(current);
         return { ok: true, id, tipo: 'support' };
     } catch (err) {
@@ -211,6 +210,7 @@ async function cambiarClavePrincipal(keyId) {
             current.supportKeys.unshift({
                 id: oldPrimary.id,
                 privateKey: oldPrimary.privateKey,
+                publicKey: oldPrimary.publicKey || '',
                 addedAt: oldPrimary.createdAt || Date.now(),
                 label: 'Antigua principal'
             });