Guardar los tokens

package com.sebastiannarvaez.pokedex.data
 
// Un sitio donde guardar cadenas pequeñas y privadas. Es pública (no
// `internal`) a propósito: en iOS la implementa Swift, que es otro módulo.
interface SecureStorage {
    // Sin `suspend`: ver la caja de abajo.
    fun leer(clave: String): String?
    fun guardar(clave: String, valor: String)
    fun borrar(clave: String)
}
 
// En memoria. Para los tests y para el destino («target») de JVM, que no tiene dónde guardar.
class InMemorySecureStorage : SecureStorage {
    private val datos = mutableMapOf<String, String>()   // un mapa: pares clave → valor, como un diccionario
    override fun leer(clave: String): String? = datos[clave]
    override fun guardar(clave: String, valor: String) { datos[clave] = valor }
    override fun borrar(clave: String) { datos.remove(clave) }
}

import com.sebastiannarvaez.pokedex.core.AppDispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json

internal class SecureStorageTokenStore(
    private val storage: SecureStorage,        // el sitio de cada plataforma
    private val dispatchers: AppDispatchers,
) : TokenStore {
 
    override suspend fun leer(): Session? = withContext(dispatchers.io) {
        // `return@withContext null` sale solo de este bloque `withContext`, no de más arriba.
        val guardado = storage.leer(CLAVE) ?: return@withContext null
        // Si lo guardado es de una versión anterior y ya no encaja, no se
        // revienta: se trata como «no hay sesión» y el usuario vuelve a entrar.
        runCatching { json.decodeFromString<SessionGuardada>(guardado).aSession() }.getOrNull()
    }
 
    override suspend fun guardar(session: Session) = withContext(dispatchers.io) {
        storage.guardar(CLAVE, json.encodeToString(SessionGuardada.de(session)))
    }
 
    override suspend fun borrar() = withContext(dispatchers.io) { storage.borrar(CLAVE) }
 
    private companion object {
        const val CLAVE = "sesion"
        val json = Json { ignoreUnknownKeys = true }   // si el texto trae campos de más, los ignora
    }
}

// Los nombres de los campos en disco están fijados a propósito y no siguen a
// los de `Session`: renombrar una propiedad del dominio no debe cerrarle la
// sesión a quien ya tenía la app.
@Serializable
private data class SessionGuardada(
    val acceso: String,
    val refresco: String,
    val caducaEn: Long,
    val usuario: String,
    val email: String? = null,
) {
    fun aSession() = Session(acceso, refresco, caducaEn, usuario, email)
 
    companion object {
        fun de(s: Session) = SessionGuardada(
            acceso = s.accessToken,
            refresco = s.refreshToken,
            caducaEn = s.expiresAtEpochSeconds,
            usuario = s.userId,
            email = s.email,
        )
    }
}

val prefs = context.getSharedPreferences("sesion", Context.MODE_PRIVATE)  // el fichero sesion.xml, privado
prefs.getString("token", null)                 // leer: el valor, o null si no hay nada
prefs.edit().putString("token", "abc").commit() // escribir: abrir el editor, cambiar y confirmar
prefs.edit().remove("token").commit()           // borrar, con la misma forma

package com.sebastiannarvaez.pokedex.data
 
import android.content.Context
 
internal class AndroidSecureStorage(context: Context) : SecureStorage {
 
    // `applicationContext`: el de la aplicación, que vive lo que el proceso.
    // `MODE_PRIVATE`: solo esta app puede leer el fichero.
    private val prefs = context.applicationContext
        .getSharedPreferences(FICHERO, Context.MODE_PRIVATE)
 
    override fun leer(clave: String): String? = prefs.getString(clave, null)
 
    // `commit()` y no `apply()`: `apply()` escribe en otro hilo y vuelve al
    // momento. Si la app muere justo después de entrar, la sesión se pierde y
    // el síntoma es «a veces no me guarda la sesión», de los peores. Aquí ya
    // estamos fuera del hilo principal (el adaptador del paso 2 nos movió al
    // dispatcher de entrada y salida).
    override fun guardar(clave: String, valor: String) {
        prefs.edit().putString(clave, valor).commit()
    }
 
    override fun borrar(clave: String) {
        prefs.edit().remove(clave).commit()
    }
 
    private companion object {
        // Un fichero propio, `sesion.xml`, y no el de los ajustes: así se puede
        // excluir de la copia de seguridad (paso 5) sin excluir los demás datos.
        const val FICHERO = "sesion"
    }
}

import com.sebastiannarvaez.pokedex.data.AndroidSecureStorage
import com.sebastiannarvaez.pokedex.data.SecureStorage

    // Una sola instancia. El Context lo da Koin (`androidContext`): es el que
    // se le pasó en `PokedexApplication` al arrancar.
    single<SecureStorage> { AndroidSecureStorage(androidContext()) }

import com.sebastiannarvaez.pokedex.data.InMemorySecureStorage
import com.sebastiannarvaez.pokedex.data.SecureStorage

    // El destino de JVM solo existe para tests: no hay llavero que valga.
    single<SecureStorage> { InMemorySecureStorage() }

InstanceCreationException: Could not create instance for '[Singleton: 'com.sebastiannarvaez.pokedex.data.TokenStore']'
Caused by: NoDefinitionFoundException: No definition found for type 'com.sebastiannarvaez.pokedex.data.SecureStorage' on scope '['_root_']'.

import com.sebastiannarvaez.pokedex.data.SecureStorageTokenStore   // antes: InMemoryTokenStore

    // El almacén lo pone cada plataforma (get()); lo que se guarda y en qué
    // formato lo decide este adaptador, que es común. El segundo get() es AppDispatchers.
    single<TokenStore> { SecureStorageTokenStore(get(), get()) }

package com.sebastiannarvaez.pokedex.di
 
import com.sebastiannarvaez.pokedex.core.AppConfig
import com.sebastiannarvaez.pokedex.data.SecureStorage
import org.koin.dsl.module
 
// El arranque de Koin para iOS: la única llamada que hace Swift. Se llama
// `startKoinIos` y no `initKoin` porque `init` + mayúscula es un prefijo
// reservado de Objective-C (llegaría a Swift como `doInitKoin`).
fun startKoinIos(config: AppConfig, secureStorage: SecureStorage) {
    initKoin {
        // La configuración y ahora también el Llavero, que es de iOS y se
        // escribe en Swift: el grafo recibe una implementación que no está en Kotlin.
        modules(module {
            single { config }
            single { secureStorage }
        })
    }
}

import Foundation
import Security      // la API del Llavero (SecItemAdd, SecItemCopyMatching…)
import Shared        // el framework de Kotlin: de ahí sale `SecureStorage`
 
// El Llavero de iOS, implementando una interfaz escrita en Kotlin. Es de las
// pocas veces que la dependencia va al revés: normalmente Swift llama a Kotlin.
// `SecureStorage` llega a Swift como un protocolo, y esta clase lo cumple.
final class AlmacenDelLlavero: SecureStorage {
 
    // Todo lo que guarde la app comparte este «servicio», que es lo que permite
    // borrarlo junto y no pisar lo de otras apps. `bundleIdentifier` es el
    // nombre único de tu app (el que ves en Xcode); si no lo hubiera, se usa el de después de `??`.
    private let servicio = Bundle.main.bundleIdentifier ?? "com.sebastiannarvaez.pokedex"
 
    func leer(clave: String) -> String? {
        var consulta = base(clave)
        consulta[kSecReturnData as String] = true          // devuélveme los datos…
        consulta[kSecMatchLimit as String] = kSecMatchLimitOne   // …de un solo elemento
 
        // `resultado` empieza vacío y `&` deja que el sistema lo rellene.
        var resultado: CFTypeRef?
        let estado = SecItemCopyMatching(consulta as CFDictionary, &resultado)
        guard estado == errSecSuccess, let datos = resultado as? Data else { return nil }
        return String(data: datos, encoding: .utf8)   // de bytes (Data) a texto
    }
 
    func guardar(clave: String, valor: String) {
        // El Llavero no tiene «guardar o actualizar»: hay que borrar y añadir, o
        // `SecItemAdd` devuelve -25299 (errSecDuplicateItem) la segunda vez, que
        // es lo que convierte «entré dos veces» en «no me guarda».
        borrar(clave: clave)
 
        var item = base(clave)
        item[kSecValueData as String] = Data(valor.utf8)   // de texto a bytes, que es lo que guarda el Llavero
        // Sin esta línea, el elemento viajaría en las copias de seguridad de
        // iCloud a otros dispositivos. Un token de sesión no debe viajar:
        // `ThisDeviceOnly` lo ata a este teléfono.
        item[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
 
        SecItemAdd(item as CFDictionary, nil)
    }
 
    func borrar(clave: String) {
        SecItemDelete(base(clave) as CFDictionary)
    }
 
    // La «dirección» de un elemento: es una contraseña genérica de este servicio
    // y de esta cuenta (la clave).
    private func base(_ clave: String) -> [String: Any] {
        [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrService as String: servicio,
            kSecAttrAccount as String: clave,
        ]
    }
}

        KoinIosKt.startKoinIos(config: IosAppConfig())

        // El Llavero se pasa aquí porque es de iOS: el núcleo declara la
        // interfaz y la app la cumple.
        KoinIosKt.startKoinIos(config: IosAppConfig(), secureStorage: AlmacenDelLlavero())

src/main/res/xml/backup_rules.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- Android 11 y anteriores: qué entra en la copia automática. -->
<full-backup-content>
    <!-- `sharedpref` = la carpeta de SharedPreferences; `path` = el fichero. -->
    <exclude domain="sharedpref" path="sesion.xml" />
</full-backup-content>

<?xml version="1.0" encoding="utf-8"?>
<!-- Android 12 y posteriores, que separa dos casos. -->
<data-extraction-rules>
    <!-- La copia que sube a Google: la sesión no sube. -->
    <cloud-backup>
        <exclude domain="sharedpref" path="sesion.xml" />
    </cloud-backup>
    <!-- El paso directo de un móvil al siguiente: tampoco. El usuario vuelve a
         entrar una vez y a cambio el token no se duplica. -->
    <device-transfer>
        <exclude domain="sharedpref" path="sesion.xml" />
    </device-transfer>
</data-extraction-rules>

    <application
        android:name=".PokedexApplication"
        android:allowBackup="true"
        android:fullBackupContent="@xml/backup_rules"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:icon="@mipmap/ic_launcher"
        …

    @Test
    fun `un contenido ilegible se trata como si no hubiera sesion`() = runTest {
        val almacen = InMemorySecureStorage()
        almacen.guardar("sesion", "{esto no es json}")   // algo que ya no encaja
 
        assertNull(store(almacen).leer())                // sin sesión, y sin excepción
    }

    @Test
    fun `el formato en disco no arrastra los nombres del dominio`() = runTest {
        val almacen = InMemorySecureStorage()
        store(almacen).guardar(sesion)
 
        val guardado = almacen.leer("sesion")!!
 
        assertTrue(guardado.contains("\"acceso\""), guardado)
        assertTrue(guardado.contains("\"caducaEn\""), guardado)
        assertTrue(!guardado.contains("accessToken"), guardado)   // este nombre NO debe aparecer
    }

// `dispatchers` y `sesion` serían los del fichero de tests: los hilos de prueba y una sesión de ejemplo.
val almacen = InMemorySecureStorage()                              // el sitio donde de verdad se guarda
SecureStorageTokenStore(almacen, dispatchers).guardar(sesion)      // «antes de cerrar la app»
val tras = SecureStorageTokenStore(almacen, dispatchers).leer()    // «al volver a abrirla»: otro store, el mismo almacén
// tras == sesion: lo que sobrevive a un reinicio es lo que hay en el almacén, no el TokenStore

./gradlew :shared:jvmTest :shared:testAndroidHostTest :shared:iosSimulatorArm64Test
open shared/build/reports/tests/jvmTest/index.html