Tema 9: Almacenamiento en Android

1// Guardar un archivo de texto en memoria interna
2fun saveToFile(context: Context, fileName: String, contenido: String) {
3    context.openFileOutput(fileName, Context.MODE_APPEND).use { output ->
4        output.write(contenido.toByteArray())
5    }
6}

1// Leer un archivo de texto desde memoria interna
2fun readFromFile(context: Context, fileName: String): String {
3    return try {
4        context.openFileInput(fileName).bufferedReader().use { it.readText() }
5    } catch (e: Exception) {
6        "Error al leer el archivo: ${e.message}"
7    }
8}

 1// Guardar preferencia
 2fun savePreference(context: Context, key: String, value: String) {
 3    val prefs = context.getSharedPreferences("MisPreferencias", Context.MODE_PRIVATE)
 4    prefs.edit { putString(key, value) }
 5}
 6
 7// Leer preferencia
 8fun readPreference(context: Context, key: String): String? {
 9    val prefs = context.getSharedPreferences("MisPreferencias", Context.MODE_PRIVATE)
10    // Leer preferencia
11    return prefs.getString(key, "Invitado")
12}

1<map>
2    <string name="nombre">Javier</string>
3</map>

1implementation("androidx.datastore:datastore-preferences:1.1.7")

 1val Context.dataStore by preferencesDataStore("ajustes")
 2val TEMA_OSCURO = booleanPreferencesKey("tema_oscuro")
 3
 4suspend fun saveThemeMode(context: Context, oscuro: Boolean) {
 5    context.dataStore.edit { prefs ->
 6        prefs[TEMA_OSCURO] = oscuro
 7    }
 8}
 9
10fun readThemeMode(context: Context): Flow<Boolean> {
11    val temaFlow: Flow<Boolean> = context.dataStore.data.map { prefs ->
12        prefs[TEMA_OSCURO] ?: false
13    }
14    return temaFlow
15}

 1// Guardar el modo tema en DataStore
 2CoroutineScope(Dispatchers.IO).launch {
 3    saveThemeMode(contxt, it)
 4}
 5
 6...
 7// Leer el modo tema desde DataStore
 8LaunchedEffect(checked) {
 9    readThemeMode(contxt).collect { valor ->
10        checked = valor
11    }
12}

 1val contxt = LocalContext.current
 2var uriString by remember { mutableStateOf("") }
 3var content by remember { mutableStateOf("") }
 4
 5val openDocumentLauncher = rememberLauncherForActivityResult(
 6    contract = ActivityResultContracts.OpenDocument(),
 7    onResult = { uri ->
 8        uri?.let {
 9            uriString = it.toString()
10            content = contxt.contentResolver.openInputStream(it)?.bufferedReader().use { reader ->
11                reader?.readText() ?: "Error al leer el archivo"
12            }
13        }
14    }
15)

 1import android.security.keystore.KeyGenParameterSpec
 2import android.security.keystore.KeyProperties
 3import java.security.KeyStore
 4import javax.crypto.Cipher
 5import javax.crypto.KeyGenerator
 6import javax.crypto.SecretKey
 7import javax.crypto.spec.GCMParameterSpec
 8
 9object CryptoManager {
10
11    private const val ANDROID_KEYSTORE = "AndroidKeyStore"
12    private const val KEY_ALIAS = "prefs_aes_key"
13    private const val TRANSFORMATION = "AES/GCM/NoPadding"
14    private const val GCM_TAG_BITS = 128
15
16    // Obtiene o crea una clave simétrica AES en el Keystore (no exportable).
17    fun getOrCreateKey(): SecretKey {
18        val ks = KeyStore.getInstance(ANDROID_KEYSTORE).apply { load(null) }
19        (ks.getEntry(KEY_ALIAS, null) as? KeyStore.SecretKeyEntry)?.secretKey?.let { return it }
20
21        val spec = KeyGenParameterSpec.Builder(
22            KEY_ALIAS,
23            KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
24        )
25            .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
26            .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
27            .setUserAuthenticationRequired(false) // Poner a true si quieres exigir biometría/bloqueo.
28            .build()
29
30        return KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, ANDROID_KEYSTORE)
31            .apply { init(spec) }
32            .generateKey()
33    }
34
35    // Clase para mantener el IV junto a los datos cifrados.
36    data class Ciphertext(val iv: ByteArray, val bytes: ByteArray)
37
38    // Cifra datos con AES-GCM y IV aleatorio generado por el Cipher.
39    fun encrypt(plain: ByteArray, key: SecretKey = getOrCreateKey()): Ciphertext {
40        val cipher = Cipher.getInstance(TRANSFORMATION)
41        cipher.init(Cipher.ENCRYPT_MODE, key)
42        val iv = cipher.iv
43        val enc = cipher.doFinal(plain)
44        return Ciphertext(iv, enc)
45    }
46
47    // Descifra datos con AES-GCM usando el IV asociado.
48    fun decrypt(ct: Ciphertext, key: SecretKey = getOrCreateKey()): ByteArray {
49        val cipher = Cipher.getInstance(TRANSFORMATION)
50        val spec = GCMParameterSpec(GCM_TAG_BITS, ct.iv)
51        cipher.init(Cipher.DECRYPT_MODE, key, spec)
52        return cipher.doFinal(ct.bytes)
53    }
54}

 1import android.content.Context
 2import androidx.datastore.preferences.core.Preferences
 3import androidx.datastore.preferences.core.edit
 4import androidx.datastore.preferences.core.stringPreferencesKey
 5import androidx.datastore.preferences.preferencesDataStore
 6import kotlinx.coroutines.flow.Flow
 7import kotlinx.coroutines.flow.map
 8import android.util.Base64
 9import es.javiercarrasco.documentationt9_1.data.security.CryptoManager
10
11private val Context.dataStore by preferencesDataStore(name = "secure_prefs")
12
13class SecurePrefsRepository(private val context: Context) {
14
15    // Claves para el DataStore.
16    private val KEY_IV = stringPreferencesKey("token_iv_b64")
17    private val KEY_CT = stringPreferencesKey("token_ct_b64")
18
19    // Guarda un token cifrado en DataStore (iv + ciphertext, ambos en Base64).
20    suspend fun saveToken(token: String) {
21        val ct = CryptoManager.encrypt(token.encodeToByteArray())
22        val ivB64 = Base64.encodeToString(ct.iv, Base64.NO_WRAP)
23        val dataB64 = Base64.encodeToString(ct.bytes, Base64.NO_WRAP)
24
25        // Almacena ambos en DataStore.
26        context.dataStore.edit { prefs ->
27            prefs[KEY_IV] = ivB64
28            prefs[KEY_CT] = dataB64
29        }
30    }
31
32    // Flujo que expone el token descifrado o null si no existe.
33    val tokenFlow: Flow<String?> = context.dataStore.data.map { prefs: Preferences ->
34        val ivB64 = prefs[KEY_IV]
35        val ctB64 = prefs[KEY_CT]
36        if (ivB64 == null || ctB64 == null) return@map null
37
38        val iv = Base64.decode(ivB64, Base64.NO_WRAP)
39        val data = Base64.decode(ctB64, Base64.NO_WRAP)
40        CryptoManager.decrypt(CryptoManager.Ciphertext(iv, data)).decodeToString()
41    }
42
43    // Flujo que expone el token cifrado en formato "iv|ciphertext" o null si no existe.
44    val encryptedFlow: Flow<String?> = context.dataStore.data.map { prefs ->
45        val iv = prefs[KEY_IV]
46        val ct = prefs[KEY_CT]
47        if (iv != null && ct != null) "$iv|$ct" else null
48    }
49
50    // Elimina el token almacenado.
51    suspend fun clearToken() {
52        context.dataStore.edit { it.remove(KEY_IV); it.remove(KEY_CT) }
53    }
54}

 1import androidx.lifecycle.ViewModel
 2import androidx.lifecycle.viewModelScope
 3import es.javiercarrasco.documentationt9_1.data.repository.SecurePrefsRepository
 4import kotlinx.coroutines.flow.SharingStarted
 5import kotlinx.coroutines.flow.StateFlow
 6import kotlinx.coroutines.flow.stateIn
 7import kotlinx.coroutines.launch
 8
 9class SecurePrefsViewModel(private val repo: SecurePrefsRepository) : ViewModel() {
10
11    // StateFlow para observar el token almacenado de forma segura.
12    val token: StateFlow<String?> = repo.tokenFlow
13        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), null)
14
15    // StateFlow para observar el token cifrado (iv + ciphertext).
16    val encrypted: StateFlow<String?> = repo.encryptedFlow
17        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), null)
18
19    // Función para guardar el token de forma segura.
20    fun saveToken(value: String) = viewModelScope.launch {
21        repo.saveToken(value)
22    }
23
24    // Función para borrar el token almacenado de forma segura.
25    fun clearToken() = viewModelScope.launch {
26        repo.clearToken()
27    }
28}

 1@Composable
 2fun SecurePrefsScreen(vm: SecurePrefsViewModel) {
 3    val token by vm.token.collectAsState()
 4    val encrypted by vm.encrypted.collectAsState()
 5
 6    var input by remember { mutableStateOf("") }
 7    val isValid = input.isNotBlank()
 8
 9    Card {
10        Column(
11            Modifier
12                .fillMaxWidth()
13                .padding(16.dp),
14            verticalArrangement = Arrangement.spacedBy(8.dp)
15        ) {
16            Text(
17                text = "Almacenamiento seguro (Keystore + AES-GCM + DataStore)",
18                style = MaterialTheme.typography.titleSmall
19            )
20            OutlinedTextField(
21                modifier = Modifier.fillMaxWidth(),
22                value = input,
23                onValueChange = { input = it },
24                label = { Text("Token / API key") },
25                singleLine = true
26            )
27            Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
28                Button(
29                    modifier = Modifier.fillMaxWidth(.5f),
30                    enabled = isValid,
31                    onClick = { vm.saveToken(input.trim()) }) { Text("Guardar seguro") }
32                OutlinedButton(
33                    modifier = Modifier.fillMaxWidth(),
34                    onClick = { vm.clearToken() }) { Text("Eliminar") }
35            }
36            HorizontalDivider()
37            Text(
38                "Valor actual (descifrado): ${token ?: "—"}",
39                style = MaterialTheme.typography.bodyMedium
40            )
41            Text(
42                "Valor actual (cifrado, Base64): ${encrypted ?: "—"}",
43                style = MaterialTheme.typography.bodySmall,
44                color = Color.Gray
45            )
46        }
47    }
48}

1val repo = SecurePrefsRepository(this)
2val vm = SecurePrefsViewModel(repo)
3
4SecurePrefsScreen(vm)