🔐 Auditoría de Seguridad

El JWT nunca se escribe en settings.json. El campo está marcado con [JsonIgnore] para impedir serialización accidental. El token se persiste exclusivamente en el Android Keystore a través de SecureStorage, protegido por el hardware del dispositivo. La carga al arranque es asíncrona y falla de forma segura (el usuario vuelve a hacer login) si el Keystore no puede desproteger el token.

// settings.json — JwtToken nunca aparece
[JsonIgnore]
public string? JwtToken { get; set; }

// Persistencia en Android Keystore
await SecureStorage.Default.SetAsync("kavynox_jwt",        token);
await SecureStorage.Default.SetAsync("kavynox_jwt_expira", expira.ToString("O"));

La db_key de sesión v2/v3 se almacena en _sessionKeyBytes (byte[]?). Al hacer logout, VaultKeyService.Clear() aplica CryptographicOperations.ZeroMemory sobre el array antes de nullearlo, sobreescribiendo los bytes en el heap. El hex string para la cadena de conexión SQLCipher se genera al vuelo en el getter de CurrentKey, minimizando su vida útil en memoria. La ruta v1 (PBKDF2) mantiene el string por compatibilidad.

⚠️ Limitación conocida de plataforma: Convert.ToHexString(_sessionKeyBytes) genera un string inmutable en el heap gestionado de .NET que no puede zerearse explícitamente. No es evitable: el wrapper .NET de SQLCipher requiere un string para la contraseña de conexión. La mitigación aplicada consiste en no cachear el valor — el getter lo genera en cada llamada y se descarta inmediatamente después. Esto minimiza la ventana de exposición, pero la liberación efectiva de memoria depende del GC. Es una limitación estructural de .NET + SQLCipher compartida por todos los password managers .NET con la misma arquitectura, no un error de diseño de la aplicación.

private static byte[]? _sessionKeyBytes = null;

public static string CurrentKey
{
    get
    {
        // v2/v3 — hex al vuelo, los bytes son zereables
        if (_sessionKeyBytes != null)
            return Convert.ToHexString(_sessionKeyBytes).ToLowerInvariant();
        // ...
    }
}

public static void Clear()
{
    if (_sessionKeyBytes != null)
    {
        CryptographicOperations.ZeroMemory(_sessionKeyBytes);
        _sessionKeyBytes = null;
    }
    // ...
}

CifrarClaveParaRecuperacion usa AES-256-GCM con nonce aleatorio de 12 bytes y tag de 16 bytes. El formato de salida incluye el prefijo "R:" que permite distinguirlo del formato CBC legacy. RestaurarClaveDesdeRecuperacion detecta automáticamente el formato: si empieza por "R:" descifra con GCM (autenticado, detecta manipulación del ciphertext); en caso contrario usa la ruta CBC para los códigos de emergencia ya emitidos, garantizando compatibilidad total hacia atrás.

// Nuevo formato GCM — nonce[12] ∥ tag[16] ∥ ciphertext
RandomNumberGenerator.Fill(nonce);
using var gcm = new AesGcm(claveRecuperacion, tagSizeInBytes: 16);
gcm.Encrypt(nonce, _claveMaestra, cifrado, tag);
return "R:" + Convert.ToBase64String(resultado);

// Restauración — detecta formato automáticamente
if (claveCifradaBase64.StartsWith("R:", StringComparison.Ordinal))
    // → ruta GCM autenticada (detecta cualquier manipulación)
else
    // → ruta CBC legacy para códigos anteriores a esta versión

DbPathService.RekeyVault(oldKey, newKey) usa el mecanismo sqlcipher_export (la misma técnica de las migraciones KDF): crea un vault temporal cifrado con la nueva clave, sustituye atómicamente el fichero original y limpia los pools de conexión. CambioContrasenaViewModel lo llama al final del cambio de contraseña para ambas rutas v1 y v2/v3, eliminando la ventana temporal en la que el fichero .db permanecía cifrado con la clave anterior.

// Flujo v2/v3 — al finalizar el cambio de contraseña
var newDbKeyBytes = KdfService.DerivarDbKey(masterKeyNew);
DbPathService.RekeyVault(oldKeyHex, newKeyHex);   // sqlcipher_export atómico
VaultKeyService.SetDerivedKey(newDbKeyBytes);
CryptographicOperations.ZeroMemory(newDbKeyBytes);

VaultKeyService.CurrentKey detecta el estado inconsistente mediante el flag _claveModernaEstablecida: si SetDerivedKey fue llamado en esta sesión pero los bytes ya no están disponibles (Clear invocado antes de tiempo), lanza una InvalidOperationException con mensaje diagnóstico claro en lugar de devolver la LegacyKey. El fallback a LegacyKey solo ocurre cuando nunca se estableció ninguna clave derivada, lo que corresponde a vaults V1 pre-migración.

public static string CurrentKey
{
    get
    {
        if (_sessionKeyBytes != null) return Convert.ToHexString(...);
        if (!string.IsNullOrEmpty(_sessionKey)) return _sessionKey;

        // Error descriptivo — solo si hubo SetDerivedKey previo
        if (_claveModernaEstablecida)
            throw new InvalidOperationException(
                "VaultKeyService: la clave derivada v2/v3 fue establecida en esta " +
                "sesión pero ya no está disponible...");

        return LegacyKey; // solo para vaults V1 pre-v1.3
    }
}

Los campos mac y usuarioSO se envían como null en ambas plataformas. El deviceId ya no usa el MachineGuid del registro de Windows (identificador hardware permanente cross-app) ni el ANDROID_ID directamente: WPF genera un UUID pseudónimo en el primer arranque y lo persiste en settings.json; MAUI usa el ANDROID_ID con scope por app+usuario (no hardware real). El campo dispositivo se conserva porque es el identificador usado por la función de bloqueo de dispositivos en el servidor.

// WPF — SyncService.InfoDispositivo() (ahora no-estático)
deviceId  = _settingsService.Settings.DeviceId,  // UUID app-específico
usuarioSO = (string?)null,   // eliminado
mac       = (string?)null    // eliminado

// WPF — SettingsService: genera UUID en primer arranque
if (string.IsNullOrWhiteSpace(_settings.DeviceId))
{
    _settings.DeviceId = Guid.NewGuid().ToString("N");
    Guardar();
}

Defensa en dos capas independientes:

• Capa SO (Android): network_security_config.xml referenciado en AndroidManifest.xml. El SO Android rechaza cualquier conexión TLS a passwords.kavynox.com cuya cadena no incluya alguno de los dos pins SPKI SHA-256 (leaf + CA intermedia Let's Encrypt R12). Tráfico HTTP en claro bloqueado globalmente. Expiración configurada al 2027-04-15.
• Capa código (no-Android): CertificatePinningHandler valida los mismos pins SPKI SHA-256 mediante ServerCertificateCustomValidationCallback. En Android no se usa (el SO ya lo garantiza y SocketsHttpHandler ignoraría el XML).

// SyncService.cs — handler según plataforma
HttpMessageHandler certHandler =
#if ANDROID
    new Xamarin.Android.Net.AndroidMessageHandler();  // SO aplica network_security_config.xml
#else
    new CertificatePinningHandler();                   // validación SPKI en código
#endif

// network_security_config.xml — pins SPKI SHA-256
// Leaf:  PAynogswE2afoIRddjwbZ7kYruOCM8kWysq902M1q4A=  (renovar antes 2026-08-01)
// R12:   kZwN96eHtZftBWrOZUsd6cA4es80n3NzSk/XtYz2EqQ=  (cubre renovaciones hasta 2027-03-12)

El fichero sync_error.log se trunca a cero cuando supera 100 KB. Solo se registra el tipo de excepción y el código HTTP (nunca el cuerpo de la respuesta, rutas de archivo ni mensajes internos del vault). Ante un escenario de conectividad intermitente, el fichero no puede crecer indefinidamente ni filtrar datos internos.

if (_fi.Exists && _fi.Length > 100 * 1024)
    File.WriteAllText(logPath, string.Empty);  // rotación por truncado

var _tipo   = ex.GetType().Name;               // solo el tipo
var _codigo = ex is HttpRequestException hre
    ? ((int?)hre.StatusCode)?.ToString() ?? "net"
    : "-";
File.AppendAllText(logPath,
    $"[{DateTime.Now:yyyy-MM-dd HH:mm:ss}] {_tipo} HTTP={_codigo}{Environment.NewLine}");