Secure Token Storage and API Authentication

dependencies {
    implementation("androidx.datastore:datastore:<version>")
    implementation("com.google.crypto.tink:tink-android:<version>")
}

/** AEAD backed by a Tink keyset that is itself encrypted with an Android Keystore master key. */
object TokenCrypto {
    private const val KEYSET_NAME = "token_keyset"
    private const val PREF_FILE = "token_keyset_prefs"
    private const val MASTER_KEY_URI = "android-keystore://token_master_key"

    fun aead(context: Context): Aead {
        AeadConfig.register()
        return AndroidKeysetManager.Builder()
            .withSharedPref(context, KEYSET_NAME, PREF_FILE)       // stores the ENCRYPTED keyset
            .withKeyTemplate(KeyTemplates.get("AES256_GCM"))
            .withMasterKeyUri(MASTER_KEY_URI)                      // Keystore key wraps the keyset
            .build()
            .keysetHandle
            .getPrimitive(RegistryConfiguration.get(), Aead::class.java)
    }
}

@Serializable
data class AuthTokens(val accessToken: String, val refreshToken: String, val expiresAtEpochSec: Long)

class EncryptedTokensSerializer(private val aead: Aead) : Serializer<AuthTokens?> {
    override val defaultValue: AuthTokens? = null
    private val associatedData = "auth_tokens".toByteArray()

    override suspend fun readFrom(input: InputStream): AuthTokens? {
        val bytes = input.readBytes()
        if (bytes.isEmpty()) return null
        return runCatching {
            Json.decodeFromString<AuthTokens>(aead.decrypt(bytes, associatedData).decodeToString())
        }.getOrNull()                                       // undecryptable (key lost) → treat as signed out
    }

    override suspend fun writeTo(t: AuthTokens?, output: OutputStream) {
        if (t == null) return                               // empty file = no tokens
        output.write(aead.encrypt(Json.encodeToString(t).encodeToByteArray(), associatedData))
    }
}

class TokenStore(context: Context) {
    private val store = DataStoreFactory.create(
        serializer = EncryptedTokensSerializer(TokenCrypto.aead(context)),
        produceFile = { File(context.filesDir, "datastore/auth_tokens.enc") },
    )
    @Volatile private var cached: AuthTokens? = null       // fast synchronous reads for interceptors

    val tokens: Flow<AuthTokens?> = store.data.onEach { cached = it }

    fun accessTokenBlocking(): String? = cached?.accessToken
    suspend fun save(tokens: AuthTokens) { store.updateData { tokens } }
    suspend fun clear() { store.updateData { null } }
}

<data-extraction-rules>
    <cloud-backup>
        <exclude domain="file" path="datastore/auth_tokens.enc" />
        <exclude domain="sharedpref" path="token_keyset_prefs.xml" />
    </cloud-backup>
    <device-transfer>
        <exclude domain="file" path="datastore/auth_tokens.enc" />
        <exclude domain="sharedpref" path="token_keyset_prefs.xml" />
    </device-transfer>
</data-extraction-rules>