Android で秘匿情報を守る — Keystore, Cipher, DataStore による暗号化と永続化の実装例

dependencies {
    // DataStore
    implementation("androidx.datastore:datastore-preferences:1.1.7")
}

import android.security.keystore.KeyGenParameterSpec
import android.security.keystore.KeyProperties
import java.security.KeyStore
import javax.crypto.KeyGenerator

    ...
    
    fun getOrCreateSecretKey(): SecretKey? {
        try {
            // KeyStoreのインスタンス生成
            val keyStore =
                KeyStore.getInstance(ANDROID_KEY_STORE_PROVIDER).apply {
                    load(null) // KeyStoreを初期化するための必須の呼び出し
                }
            
            // KeyStoreにプロダクトの鍵が存在するか確認し、あれば取得し返す
            if (keyStore.containsAlias(PROJECT_KEY_STORE_ALIAS)) {
                val entry = keyStore.getEntry(PROJECT_KEY_STORE_ALIAS, null)
                if (entry is KeyStore.SecretKeyEntry) {
                    return entry.secretKey
                }
            }
            // KeyStoreにプロダクトの鍵が存在しなければ生成して保存し返す
            val params =
                KeyGenParameterSpec.Builder(
                    PROJECT_KEY_STORE_ALIAS,
                    KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT,
                )
                    .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
                    .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
                    .setKeySize(256)
                    .build()
            val keyGenerator =
                KeyGenerator.getInstance(
                    KeyProperties.KEY_ALGORITHM_AES,
                    ANDROID_KEY_STORE_PROVIDER,
                )
            keyGenerator.init(params)
            return keyGenerator.generateKey()
        } catch (e: Exception) {
            Firebase.crashlytics.recordException(e)
            return null
        }
}

import com.google.firebase.crashlytics.ktx.crashlytics
import com.google.firebase.ktx.Firebase
import java.util.Base64
import javax.crypto.Cipher
import javax.crypto.spec.GCMParameterSpec

interface CryptographyManager {
    fun encrypt(plaintext: String): String

    fun decrypt(encryptedString: String): String
}

private const val TRANSFORMATION = "AES/GCM/NoPadding"
private const val IV_SIZE_BYTES = 12
private const val TAG_SIZE_BITS = 128

class CryptographyManagerImpl : CryptographyManager {
    override fun encrypt(plaintext: String): String {
        return try {
            val cipher = Cipher.getInstance(TRANSFORMATION)
            cipher.init(Cipher.ENCRYPT_MODE, getOrCreateSecretKey())
            val ciphertext = cipher.doFinal(plaintext.toByteArray(Charsets.UTF_8))
            val ivAndCiphertext = cipher.iv + ciphertext // IVと暗号文をバイト配列として結合
            Base64.getEncoder().encodeToString(ivAndCiphertext)
        } catch (e: Exception) {
            try {
                CryptographyException.parse(e)
            } catch (cryptoException: CryptographyException) {
                Firebase.crashlytics.recordException(cryptoException)
                ""
            }
        }
    }

    override fun decrypt(encryptedString: String): String {
        return try {
            val cipher = Cipher.getInstance(TRANSFORMATION)
            val ivAndCiphertext = Base64.getDecoder().decode(encryptedString)
            // 復号化時に保存したIVを使う
            val spec =
                GCMParameterSpec(TAG_SIZE_BITS, ivAndCiphertext, 0, IV_SIZE_BYTES)
            cipher.init(Cipher.DECRYPT_MODE, getOrCreateSecretKey(), spec)
            val plaintext =
                cipher.doFinal(
                    ivAndCiphertext,
                    IV_SIZE_BYTES,
                    ivAndCiphertext.size - IV_SIZE_BYTES,
                )
            String(plaintext, Charsets.UTF_8)
        } catch (e: Exception) {
            try {
                CryptographyException.parse(e)
            } catch (cryptoException: CryptographyException) {
                Firebase.crashlytics.recordException(cryptoException)
                ""
            }
        }
    }
}

import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map

data class SecureDataPreferences(
    val textData: String,
)

object PreferencesKeys {
    private val TEXT_KEY = stringPreferencesKey("encrypted_text")
}

private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "encrypted_prefs")

class SecureDataRepository(
    private val cryptographyManager: CryptographyManager
) {

    suspend fun saveTextData(data: String) {
        val encryptedData = cryptographyManager.encrypt(data)
        dataStore.edit { preferences ->
            preferences[TEXT_KEY] = encryptedData
        }
    }
    
    private val secureDataFlow: Flow<SecureDataPreferences> =
        secureDataStore.data
            .catch { exception ->
                if (exception is IOException) {
                    emit(emptyPreferences())
                } else {
                    throw exception
                }
            }
            .map {
                it.mapSecureDataPreferences()
            }

    private fun Preferences.mapSecureDataPreferences(): SecureDataPreferences {
        return SecureDataPreferences(
            textData = this[PreferencesKeys.TEXT_KEY]?.let { cryptographyManager.decrypt(it) } ?: "",
            // ... Other data
        )
    }

    suspend fun getTextData(): String {
        return try {
            withTimeout(3000L) {
                secureDataFlow.map { it.textData }.first { it.isNotBlank() }
            }
        } catch (_: TimeoutCancellationException) {
            ""
        } catch (_: NoSuchElementException) {
            ""
        }
    }
}

// ViewModelでの使用例
viewModelScope.launch {
    repository.saveTextData(sensitiveData)
}

// Flowの監視
repository.secureDataFlow.map { it.textData }.first { it.isNotBlank() }

val aeadSerializer = AeadSerializer(
    aead = keysetHandle.getPrimitive(
        RegistryConfiguration.get(),
        Aead::class.java,
    ),
    wrappedSerializer = ExistingSerializer,
    associatedData = "settings.json".encodeToByteArray(),
)