From 7ce1e1c7fedc90a35182aabd4c43f79057f2d280 Mon Sep 17 00:00:00 2001 From: Jordan Nelson Date: Mon, 16 Nov 2026 11:13:29 -0500 Subject: [PATCH 1/3] Add a per-environment fraud key override to the example app MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Testing verified tracking against staging or a local server needed a rebuilt fraud SDK, because fraud payloads are always encrypted to the production key. Settings → Environment now takes an optional fraud public key and key version for Staging and Local, saved in the example app's preferences. At launch, if the current environment has a saved key, the app sets it with the fraud SDK's internal FraudKeyOverride API. Otherwise the API isn't called. Production can't be overridden. Bumps sdk-fraud to the branch that adds FraudKeyOverride. Co-Authored-By: Claude Opus 5.5 --- example/build.gradle | 7 ++++ .../java/io/radar/example/MainActivity.kt | 15 ++++++++ .../radar/example/store/RadarEnvironment.kt | 3 ++ .../io/radar/example/store/SettingsStore.kt | 29 +++++++++++++-- .../tests/settings/EnvironmentSection.kt | 35 +++++++++++++++++-- .../radar/example/FraudKeyOverrideBridge.kt | 17 +++++++++ .../radar/example/FraudKeyOverrideBridge.kt | 13 +++++++ sdk-fraud | 2 +- 8 files changed, 115 insertions(+), 6 deletions(-) create mode 100644 example/src/withFraud/java/io/radar/example/FraudKeyOverrideBridge.kt create mode 100644 example/src/withoutFraud/java/io/radar/example/FraudKeyOverrideBridge.kt diff --git a/example/build.gradle b/example/build.gradle index 9769d1021..4302affbb 100644 --- a/example/build.gradle +++ b/example/build.gradle @@ -37,6 +37,13 @@ android { jvmTarget = "17" } namespace 'io.radar.example' + + sourceSets { + main { + // FraudKeyOverrideBridge calls the fraud SDK's internal key override only when sdk-fraud is included. + java.srcDirs += findProject(':sdk-fraud') != null ? 'src/withFraud/java' : 'src/withoutFraud/java' + } + } } dependencies { diff --git a/example/src/main/java/io/radar/example/MainActivity.kt b/example/src/main/java/io/radar/example/MainActivity.kt index c269f3dca..ad85dfa97 100644 --- a/example/src/main/java/io/radar/example/MainActivity.kt +++ b/example/src/main/java/io/radar/example/MainActivity.kt @@ -115,6 +115,7 @@ class MainActivity : AppCompatActivity() { activity = this, ) settingsStore.environment.applyTo(this, settingsStore.host, settingsStore.verifiedHost) + applyFraudKeyOverride(settingsStore, logStore) Log.i("radar-env", settingsStore.environmentSummary()) logStore.writeResult("radar-env: ${settingsStore.environmentSummary()}") val authToken = settingsStore.resolvedAuthToken @@ -202,6 +203,20 @@ class MainActivity : AppCompatActivity() { private fun isGranted(permission: String): Boolean = ContextCompat.checkSelfPermission(this, permission) == PackageManager.PERMISSION_GRANTED + /** + * Sets the saved fraud key override for this environment, if any, before the first verified + * request. Without one, the internal API isn't called and the SDK uses its built-in key. The + * environment is fixed for the life of the process, so the override never needs clearing. + */ + private fun applyFraudKeyOverride(settingsStore: SettingsStore, logStore: LogStore) { + val setting = settingsStore.resolvedFraudKeyOverride ?: return + try { + FraudKeyOverrideBridge.set(setting) + } catch (e: Exception) { + logStore.writeError("Fraud key override not applied", e.message) + } + } + @RequiresApi(Build.VERSION_CODES.O) private fun createCustomNotification(): Notification { val channelId = "radar_custom_channel" diff --git a/example/src/main/java/io/radar/example/store/RadarEnvironment.kt b/example/src/main/java/io/radar/example/store/RadarEnvironment.kt index cd742eac1..ad2ada892 100644 --- a/example/src/main/java/io/radar/example/store/RadarEnvironment.kt +++ b/example/src/main/java/io/radar/example/store/RadarEnvironment.kt @@ -23,6 +23,9 @@ enum class RadarEnvironment( fun verifiedHost(localUrl: String): String = fixedVerifiedHost ?: localUrl + /** Whether a fraud key override can be saved for this environment. Production always uses the SDK's key. */ + val allowsFraudKeyOverride: Boolean get() = this != PRODUCTION + /** Writes the SDK's host overrides. */ fun applyTo(context: Context, host: String, verifiedHost: String) { context.getSharedPreferences(SDK_PREFS, Context.MODE_PRIVATE).edit { diff --git a/example/src/main/java/io/radar/example/store/SettingsStore.kt b/example/src/main/java/io/radar/example/store/SettingsStore.kt index 9a48230a3..9226e36f1 100644 --- a/example/src/main/java/io/radar/example/store/SettingsStore.kt +++ b/example/src/main/java/io/radar/example/store/SettingsStore.kt @@ -9,9 +9,13 @@ import io.radar.example.MainActivity import io.radar.sdk.Radar import org.json.JSONObject +/** A saved fraud public key (base64) and key version that replace the SDK's built-in key. */ +data class FraudKeyOverrideSetting(val publicKeyBase64: String, val keyVersion: Int) + /** * SDK-backed identity + tracking snapshot, plus the persisted environment: which - * [RadarEnvironment] to use, a publishable key and host overrides per environment, and the Local server URL. + * [RadarEnvironment] to use, a publishable key, host overrides, and a fraud key override per environment, and the + * Local server URL. * * The environment applied at launch is fixed for the life of the process. Changing it goes * through [saveEnvironment] followed by a restart (see `MainActivity.restart`). @@ -39,6 +43,9 @@ class SettingsStore(context: Context) { val host: String = apiHost(environment) val verifiedHost: String = verifiedHostOverride(environment).ifBlank { environment.verifiedHost(localUrl) } + /** The fraud key override for [environment], or null to use the SDK's built-in production key. */ + val resolvedFraudKeyOverride: FraudKeyOverrideSetting? = fraudKeyOverride(environment) + /** Which environments [resolvedPublishableKey] is valid on. */ var keyCheck by mutableStateOf(KeyCheck.NotChecked) private set @@ -60,6 +67,17 @@ class SettingsStore(context: Context) { fun apiHost(env: RadarEnvironment): String = hostOverride(env).ifBlank { env.host(localUrl) } + /** The saved fraud public key (base64) for [env], or "" if none is set. Production is never overridden. */ + fun fraudPublicKey(env: RadarEnvironment): String = + if (env.allowsFraudKeyOverride) prefs.getString("fraudPublicKey.${env.name}", null) ?: "" else "" + + /** The saved fraud key version for [env], defaulting to 1. */ + fun fraudKeyVersion(env: RadarEnvironment): Int = prefs.getInt("fraudKeyVersion.${env.name}", 1) + + /** The fraud key override for [env], or null if none is saved. */ + fun fraudKeyOverride(env: RadarEnvironment): FraudKeyOverrideSetting? = + fraudPublicKey(env).ifBlank { null }?.let { FraudKeyOverrideSetting(it, fraudKeyVersion(env)) } + /** Persists the environment settings. Takes effect on the next launch. */ fun saveEnvironment( env: RadarEnvironment, @@ -68,9 +86,15 @@ class SettingsStore(context: Context) { verifiedHostOverride: String, useAuthToken: Boolean, authToken: String, + fraudPublicKey: String, + fraudKeyVersion: Int, ) { prefs.edit(commit = true) { putString(KEY_ENVIRONMENT, env.name) + if (env.allowsFraudKeyOverride) { + putString("fraudPublicKey.${env.name}", fraudPublicKey.filterNot { it.isWhitespace() }) + putInt("fraudKeyVersion.${env.name}", fraudKeyVersion) + } putString(keyPrefsKey(env), publishableKey.trim()) putBoolean("useAuthToken.${env.name}", useAuthToken) putString("authToken.${env.name}", authToken.trim()) @@ -106,7 +130,8 @@ class SettingsStore(context: Context) { /** Where requests go, e.g. `env = Staging; host = https://…; key = prj_test_pk_ab12…; key check = …`. */ fun environmentSummary(): String = - "env = ${environment.label}; host = $host; verified host = $verifiedHost; ${credentialSummary()}; key check = ${keyCheck.summary()}" + "env = ${environment.label}; host = $host; verified host = $verifiedHost; ${credentialSummary()}; " + + "fraud key = ${resolvedFraudKeyOverride?.let { "override v${it.keyVersion}" } ?: "built-in"}; key check = ${keyCheck.summary()}" /** `key = prj_…` or `auth token = kid …, expires …`. */ private fun credentialSummary(): String = when { diff --git a/example/src/main/java/io/radar/example/tests/settings/EnvironmentSection.kt b/example/src/main/java/io/radar/example/tests/settings/EnvironmentSection.kt index 3f289730a..aea811a7d 100644 --- a/example/src/main/java/io/radar/example/tests/settings/EnvironmentSection.kt +++ b/example/src/main/java/io/radar/example/tests/settings/EnvironmentSection.kt @@ -29,7 +29,7 @@ import io.radar.example.store.LocalSettingsStore import io.radar.example.store.RadarEnvironment /** - * Picks the Radar environment, publishable key, and host overrides. Changes apply on relaunch. + * Picks the Radar environment, publishable key, host overrides, and fraud key override. Changes apply on relaunch. */ @Composable fun EnvironmentSection() { @@ -42,6 +42,9 @@ fun EnvironmentSection() { var verifiedHost by remember(selected) { mutableStateOf(settings.verifiedHostOverride(selected)) } var useAuthToken by remember(selected) { mutableStateOf(settings.useAuthToken(selected)) } var authToken by remember(selected) { mutableStateOf(settings.authToken(selected)) } + var fraudPublicKey by remember(selected) { mutableStateOf(settings.fraudPublicKey(selected)) } + var fraudKeyVersion by remember(selected) { mutableStateOf(settings.fraudKeyVersion(selected).toString()) } + val parsedFraudKeyVersion = fraudKeyVersion.trim().toIntOrNull()?.takeIf { it > 0 } Column(modifier = Modifier.fillMaxWidth()) { Text("Environment", style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.SemiBold) @@ -110,13 +113,39 @@ fun EnvironmentSection() { color = MaterialTheme.colorScheme.onSurfaceVariant, ) + if (selected.allowsFraudKeyOverride) { + FieldEditor( + "${selected.label} fraud public key override", + fraudPublicKey, + { fraudPublicKey = it }, + placeholder = "Base64 P-256 public key (optional)", + ) + FieldEditor("${selected.label} fraud key version", fraudKeyVersion, { fraudKeyVersion = it }, placeholder = "1") + Text( + "Encrypts fraud payloads to this key instead of the SDK's built-in production key. " + + "Leave empty to use the built-in key. Saved on this device.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + Button( onClick = { - settings.saveEnvironment(selected, key, host, verifiedHost, useAuthToken, authToken) + settings.saveEnvironment( + selected, + key, + host, + verifiedHost, + useAuthToken, + authToken, + fraudPublicKey, + parsedFraudKeyVersion ?: 1, + ) MainActivity.restart(context) }, enabled = (selected != RadarEnvironment.LOCAL || settings.localUrl.isNotBlank() || (host.isNotBlank() && verifiedHost.isNotBlank())) && - (!useAuthToken || authToken.isNotBlank()), + (!useAuthToken || authToken.isNotBlank()) && + (fraudPublicKey.isBlank() || parsedFraudKeyVersion != null), modifier = Modifier.fillMaxWidth().padding(top = 8.dp), ) { Text("Apply & restart") } } diff --git a/example/src/withFraud/java/io/radar/example/FraudKeyOverrideBridge.kt b/example/src/withFraud/java/io/radar/example/FraudKeyOverrideBridge.kt new file mode 100644 index 000000000..ec7f667d9 --- /dev/null +++ b/example/src/withFraud/java/io/radar/example/FraudKeyOverrideBridge.kt @@ -0,0 +1,17 @@ +package io.radar.example + +import io.radar.example.store.FraudKeyOverrideSetting +import io.radar.sdk.fraud.internal.FraudKeyOverride +import io.radar.sdk.fraud.internal.RadarInternalApi + +/** + * Sets the fraud SDK's internal key override. Compiled only when the sdk-fraud module is included + * (see build.gradle); `src/withoutFraud` has the stand-in. + */ +object FraudKeyOverrideBridge { + /** Sets [setting] as the fraud key override. Throws IllegalArgumentException if the key or version is invalid. */ + @OptIn(RadarInternalApi::class) + fun set(setting: FraudKeyOverrideSetting) { + FraudKeyOverride.set(setting.publicKeyBase64, setting.keyVersion) + } +} diff --git a/example/src/withoutFraud/java/io/radar/example/FraudKeyOverrideBridge.kt b/example/src/withoutFraud/java/io/radar/example/FraudKeyOverrideBridge.kt new file mode 100644 index 000000000..037dd623f --- /dev/null +++ b/example/src/withoutFraud/java/io/radar/example/FraudKeyOverrideBridge.kt @@ -0,0 +1,13 @@ +package io.radar.example + +import io.radar.example.store.FraudKeyOverrideSetting + +/** + * Stand-in used when the sdk-fraud module isn't included (see build.gradle). Without the fraud + * module there are no fraud payloads to encrypt. + */ +object FraudKeyOverrideBridge { + fun set(setting: FraudKeyOverrideSetting) { + throw IllegalStateException("The sdk-fraud module isn't included in this build") + } +} diff --git a/sdk-fraud b/sdk-fraud index 92a092ed6..82e790dd1 160000 --- a/sdk-fraud +++ b/sdk-fraud @@ -1 +1 @@ -Subproject commit 92a092ed6a4446ddea51b30b4b571c30b58fa4a2 +Subproject commit 82e790dd1b073ead2f188191191d306965cd5361 From 2316c79f9e67b8031f32766aa4ca44271064f936 Mon Sep 17 00:00:00 2001 From: Jordan Nelson Date: Mon, 16 Nov 2026 11:54:01 -0500 Subject: [PATCH 2/3] Bump sdk-fraud to the simplified key override validation Co-Authored-By: Claude Opus 5.5 --- sdk-fraud | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sdk-fraud b/sdk-fraud index 82e790dd1..f4d7e077f 160000 --- a/sdk-fraud +++ b/sdk-fraud @@ -1 +1 @@ -Subproject commit 82e790dd1b073ead2f188191191d306965cd5361 +Subproject commit f4d7e077f5910dc68e216ee5de98e495c35c56b0 From 032f82a282cdc5e48086debd86929fe2e74fd571 Mon Sep 17 00:00:00 2001 From: Jordan Nelson Date: Tue, 17 Nov 2026 17:14:40 -0500 Subject: [PATCH 3/3] Point sdk-fraud at main after the key override merge Co-Authored-By: Claude Opus 5.5 --- sdk-fraud | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sdk-fraud b/sdk-fraud index f4d7e077f..6728f889e 160000 --- a/sdk-fraud +++ b/sdk-fraud @@ -1 +1 @@ -Subproject commit f4d7e077f5910dc68e216ee5de98e495c35c56b0 +Subproject commit 6728f889e4b0feead509e1418b02299f78bacfdd