corregido pequeños bugs del .env vault

Author: MateoGonzalezLourido

Docs/Services/CLAVES_SISTEMA.md

@@ -8,7 +8,7 @@ Ravage maneja varios tipos de claves criptográficas con propósitos distintos.
 
 | Clave | Origen | Formato en memoria | Formato en reposo | Propósito |
 |---|---|---|---|---|
-| `secretKey` (usuario) | `randomBytes(32)` al registrar | `Buffer` | `BinData` en MongoDB | Cifra archivos locales del usuario (ajustes, historial, etc.) |
+| `secretKey` (usuario) | `randomBytes(32)` al registrar | `Buffer` | `EncryptedDataSchema` en MongoDB (cifrado con `INTERNAL_ENCRYPTION_KEY`) | Cifra archivos locales del usuario (ajustes, historial, etc.) |
 | `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.) |
@@ -21,9 +21,11 @@ Ravage maneja varios tipos de claves criptográficas con propósitos distintos.
 
 ### Origen y formato
 
-Generada al registrar el usuario con `randomBytes(32)` (32 bytes, 256 bits). Se almacena directamente como `Buffer` en MongoDB (campo `secretKey` del schema `User`, tipo Mongoose `Buffer` → MongoDB `BinData`).
+Generada al registrar el usuario con `randomBytes(32)` (32 bytes, 256 bits). Se almacena **cifrada** en MongoDB como `EncryptedDataSchema` usando `INTERNAL_ENCRYPTION_KEY` + AES-256-GCM. El hex del buffer es el plaintext cifrado.
 
-Antes se almacenaba como cadena hexadecimal (64 chars). El cambio a `Buffer` elimina la conversión `Buffer.from(key, "hex")` en cada uso y reduce el tamaño en DB a la mitad.
+Al cargar en sesión, `desencriptarDatosSistema(dt.secretKey)` devuelve el hex → `Buffer.from(hex, 'hex')` → Buffer de 32 bytes que se pone en memoria con `setSecretKEY(buffer)`.
+
+Esto significa que comprometer MongoDB sin tener también la `INTERNAL_ENCRYPTION_KEY` (almacenada en el vault del SO) no es suficiente para obtener las claves de cifrado de los usuarios.
 
 ### Ciclo de vida
 
@@ -138,7 +140,7 @@ Para descifrar: receptor hace `ECDH(privKey, ephPub)` → misma wrapping key →
 
 | Clave | Algoritmo de cifrado en reposo | Algoritmo de uso |
 |---|---|---|
-| `secretKey` usuario | — (en MongoDB, protegido por acceso a la DB) | AES-256-GCM (cifra archivos locales) |
+| `secretKey` usuario | AES-256-GCM con `INTERNAL_ENCRYPTION_KEY` (en MongoDB) | AES-256-GCM (cifra archivos locales) |
 | `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) |

backend/models/User.js

@@ -116,7 +116,8 @@ const UserSchema = new mongoose.Schema({
         index: true
     },
     secretKey: {
-        type: Buffer
+        type: EncryptedDataSchema,
+        default: null
     },
     publicKey: {
         type: String,

backend/repositories/UserRepository.js

@@ -140,7 +140,7 @@ export async function InsertarUsuario({ apodo = "Usuario", contrasena, correo, s
             correo: encriptarDatosSistema(correo),
             correo_hash: correoHash,
             contrasena: contrasena,
-            secretKey: sKey,
+            secretKey: encriptarDatosSistema(sKey.toString('hex')),
             idamigo: encriptarDatosSistema(idAmigo),
             idamigo_hash: idamigoHash,
             publicKey: publicKey
@@ -352,7 +352,7 @@ export async function ActualizarSecretKeyUsuario(actualizar = true) {
     if (!actualizar) return key;
     try {
         const correoHash = hashDatosSistema(getCorreoSesion());
-        const r = await User.updateOne({ correo_hash: correoHash }, { $set: { secretKey: key } });
+        const r = await User.updateOne({ correo_hash: correoHash }, { $set: { secretKey: encriptarDatosSistema(key.toString('hex')) } });
         if (r.matchedCount === 0) return false;
 
         await _syncCache(correoHash);

backend/services/sesionUsuario.js

@@ -28,7 +28,7 @@ import {
 import { generarteToken, validateToken } from './CreadorTokens.js';
 import * as storage from '../STORAGE/Variables_sesion.js';
 import { hash, compare, createHash, machineIdSync, os, si } from '../utils/libs.js';
-import { generarLlavesX25519, hashDatosSistema, getIdentity } from './cryptoService.js';
+import { generarLlavesX25519, hashDatosSistema, getIdentity, desencriptarDatosSistema } from './cryptoService.js';
 
 import { clearCacheUsuarios, setUsuarioEnCache } from '../repositories/UserRepository.js';
 import { clearCacheArchivosDescargados } from '../STORAGE/CACHE/_cache_archivos_descargados.js';
@@ -87,7 +87,7 @@ function ACTUALIZAR_DATOS_LOGIN({ data, limpiar = false, id_maquina = null }) {
     storage.setUsuariosSilence(lp ? dt.users_silence : []);
     storage.setUsuariosBloqueados(lp ? dt.users_bloq : []);
     storage.setIdDispositivo(lp ? (id_maquina ? id_maquina : machineIdSync()) : null)
-    storage.setSecretKEY(lp ? dt.secretKey : null)
+    storage.setSecretKEY(lp ? (dt.secretKey ? Buffer.from(desencriptarDatosSistema(dt.secretKey), 'hex') : null) : null)
     storage.setListaChats(lp ? dt.chats : []);
     storage.setListaContactos(lp ? dt.contactos : []);
     storage.setIDAmigo(lp ? dt.idamigo : false)

backend/utils/env_vault.js

@@ -5,7 +5,6 @@
  *   1. Al arrancar (después de app.whenReady): detecta .env en env/
  *      → los cifra con safeStorage y los borra del disco
  *   2. Carga las variables desde el baúl cifrado a process.env
- *   3. Expone exportarEnvADescargas() para regenerar los .env en Descargas
  *
  * Almacenamiento: <userData>/env_vault/<nombre>.enc  (Buffer cifrado por el SO)
  * Backend safeStorage: libsecret (Linux) · DPAPI (Windows) · Keychain (macOS)
@@ -64,30 +63,37 @@ function listarVault() {
  * @returns {boolean} true si migró al menos un archivo
  */
 function migrarEnvAlBaul() {
-    const archivos = listarEnvSrc();
+    const archivos = listarEnvSrc().filter(({ ruta }) => {
+        try { return fs.statSync(ruta).size > 0; } catch { return false; }
+    });
     if (archivos.length === 0) return false;
 
     if (!safeStorage.isEncryptionAvailable()) {
-        console.warn('[EnvVault] safeStorage no disponible en este sistema, manteniendo .env en disco');
+        console.warn('[EnvVault] safeStorage no disponible — los .env permanecen en disco sin cifrar. Instala gnome-keyring o kwallet para protegerlos.');
         return false;
     }
 
     const vaultDir = getVaultDir();
     fs.mkdirSync(vaultDir, { recursive: true });
 
+    let migrados = 0;
     for (const { nombre, ruta } of archivos) {
         try {
             const contenido = fs.readFileSync(ruta, 'utf-8');
             const cifrado = safeStorage.encryptString(contenido);
-            fs.writeFileSync(path.join(vaultDir, nombre + '.enc'), cifrado);
+            const destino = path.join(vaultDir, nombre + '.enc');
+            fs.writeFileSync(destino, cifrado);
+            // Solo borra el original si el .enc se escribió correctamente
+            fs.accessSync(destino, fs.constants.R_OK);
             fs.unlinkSync(ruta);
-            console.log(`[EnvVault] Migrado al baúl y eliminado: ${nombre}`);
+            migrados++;
+            console.log(`[EnvVault] Migrado y eliminado del disco: ${nombre}`);
         } catch (err) {
-            console.error(`[EnvVault] Error migrando ${nombre}:`, err.message);
+            console.error(`[EnvVault] Fallo migrando ${nombre} — el archivo original se mantiene en disco:`, err.message);
         }
     }
 
-    return true;
+    return migrados > 0;
 }
 
 /**
@@ -100,10 +106,11 @@ function cargarDesdeVaul() {
     if (archivos.length === 0) return false;
 
     if (!safeStorage.isEncryptionAvailable()) {
-        console.warn('[EnvVault] safeStorage no disponible, no se pueden descifrar las variables');
+        console.warn('[EnvVault] safeStorage no disponible — no se pueden leer los .enc del baúl.');
         return false;
     }
 
+    let cargados = 0;
     for (const { nombre, ruta } of archivos) {
         try {
             const cifrado = fs.readFileSync(ruta);
@@ -112,13 +119,14 @@ function cargarDesdeVaul() {
             for (const [key, value] of Object.entries(vars)) {
                 process.env[key] = value;
             }
+            cargados++;
             console.log(`[EnvVault] Cargado desde baúl: ${nombre}`);
         } catch (err) {
             console.error(`[EnvVault] Error descifrando ${nombre}:`, err.message);
         }
     }
 
-    return true;
+    return cargados > 0;
 }
 
 /**
@@ -129,34 +137,3 @@ export async function inicializarVault() {
     migrarEnvAlBaul();
     cargarDesdeVaul();
 }
-
-/**
- * Descifra todos los archivos del baúl y los escribe en <Descargas>/Ravage-env/.
- * @returns {{ ok: boolean, ruta?: string, error?: string }}
- */
-export function exportarEnvADescargas() {
-    const archivos = listarVault();
-    if (archivos.length === 0) return { ok: false, error: 'El baúl está vacío' };
-
-    if (!safeStorage.isEncryptionAvailable()) {
-        return { ok: false, error: 'safeStorage no disponible en este sistema' };
-    }
-
-    const destino = path.join(app.getPath('downloads'), 'Ravage-env');
-
-    try {
-        fs.mkdirSync(destino, { recursive: true });
-
-        for (const { nombre, ruta } of archivos) {
-            const cifrado = fs.readFileSync(ruta);
-            const contenido = safeStorage.decryptString(cifrado);
-            fs.writeFileSync(path.join(destino, nombre), contenido, { encoding: 'utf-8', mode: 0o600 });
-        }
-
-        console.log(`[EnvVault] Archivos exportados a: ${destino}`);
-        return { ok: true, ruta: destino };
-    } catch (err) {
-        console.error('[EnvVault] Error exportando:', err.message);
-        return { ok: false, error: err.message };
-    }
-}

main.js

@@ -354,12 +354,9 @@ if (!gotTheLock) {
 
     app.whenReady().then(async () => {
         // Migrar .env al baúl seguro del SO (si los hay) y cargar vars desde él
-        const { inicializarVault, exportarEnvADescargas } = await import('./backend/utils/env_vault.js');
+        const { inicializarVault } = await import('./backend/utils/env_vault.js');
         await inicializarVault();
 
-        // Handler IPC para exportar los .env desde el baúl a Descargas del usuario
-        ipcMain.handle('vault:exportar-env', async () => exportarEnvADescargas());
-
         const pServer = import('./backend/servidores/serverLocalHost.js');
         const pDb = import("./backend/db/mongo.js");
         const pSesion = import('./backend/services/sesionUsuario.js');