@tinkerlandai/indiana-react-native 0.9.2 → 0.10.1

package/native-sdk/android/java/ai/tinkerland/indiana/PushInstallation.kt

@@ -0,0 +1,170 @@
+package ai.tinkerland.indiana
+
+import android.content.Context
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyProperties
+import android.util.AtomicFile
+import android.util.Base64
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.security.KeyPairGenerator
+import java.security.KeyStore
+import java.security.MessageDigest
+import java.security.Signature
+import java.security.spec.ECGenParameterSpec
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+import java.util.UUID
+
+enum class IndianaPushPermission(val value: String) { UNKNOWN("unknown"), DENIED("denied"), PROVISIONAL("provisional"), GRANTED("granted") }
+enum class IndianaPushAddressKind(val value: String) { APNS_TOKEN("apns_token"), FCM_TOKEN("fcm_token") }
+data class IndianaPushObservation(val connectionId: UUID?, val kind: IndianaPushAddressKind?, val token: String?, val permission: IndianaPushPermission) {
+    init {
+        require((connectionId == null && kind == null && token == null) || (connectionId != null && kind != null && token != null && token.length in 16..4096 && token.all { it.code in 33..126 }))
+    }
+}
+class IndianaPushObservationTicket internal constructor(internal val client: UUID, internal val identity: UUID, internal val observation: UUID)
+internal const val PUSH_MAX_SEQUENCE = 9_007_199_254_740_991L
+internal fun pushSigningBytes(fields: JSONArray): ByteArray {
+    fun quoted(value: String) = buildString {
+        append('"')
+        for (character in value) when (character) {
+            '"' -> append("\\\"")
+            '\\' -> append("\\\\")
+            else -> { require(character.code in 32..126); append(character) }
+        }
+        append('"')
+    }
+    return (0 until fields.length()).joinToString(",", "[", "]") { index ->
+        when (val value = fields.get(index)) {
+            JSONObject.NULL -> "null"
+            is String -> quoted(value)
+            is Long -> value.toString()
+            is Int -> value.toString()
+            else -> throw IndianaClientException("invalid_configuration")
+        }
+    }.toByteArray(Charsets.UTF_8)
+}
+internal data class IndianaPushJournal(val installationId: UUID, val publicKey: String, val identitySeq: Long = 0, val addressSeq: Long = 0, val detachSeq: Long? = null) {
+    fun validate() {
+        if (identitySeq !in 0..PUSH_MAX_SEQUENCE || addressSeq !in 0..PUSH_MAX_SEQUENCE || (detachSeq != null && detachSeq !in 1..identitySeq) || !publicKey.matches(Regex("[A-Za-z0-9_-]{80,200}"))) throw IndianaClientException("protected_storage_unavailable")
+    }
+}
+internal interface IndianaPushStorage {
+    /** Commits before returning; no Customer credential or provider token is stored. */
+    fun transaction(update: (IndianaPushJournal) -> IndianaPushJournal): IndianaPushJournal
+    fun sign(payload: ByteArray): String
+}
+internal fun pushP1363(der: ByteArray): ByteArray {
+    if (der.size !in 8..72 || der[0].toInt() != 0x30 || (der[1].toInt() and 255) != der.size - 2) throw IndianaClientException("protected_storage_unavailable")
+    var offset = 2
+    val result = ByteArray(64)
+    for (part in 0..1) {
+        if (offset + 2 > der.size || der[offset++].toInt() != 2) throw IndianaClientException("protected_storage_unavailable")
+        val size = der[offset++].toInt() and 255
+        if (size !in 1..33 || offset + size > der.size || der[offset].toInt() < 0) throw IndianaClientException("protected_storage_unavailable")
+        val leading = if (size > 1 && der[offset].toInt() == 0) 1 else 0
+        if (size - leading > 32) throw IndianaClientException("protected_storage_unavailable")
+        der.copyInto(result, part * 32 + 32 - size + leading, offset + leading, offset + size); offset += size
+    }
+    if (offset != der.size) throw IndianaClientException("protected_storage_unavailable")
+    return result
+}
+/** Key stays in Android Keystore; the atomic journal stays in App-private no-backup storage. */
+internal class IndianaPushKeystore(context: Context, scope: IndianaScope): IndianaPushStorage {
+    private val namespace = "${context.packageName}:${scope.projectId}:${scope.environment.value}"
+    private val hash = MessageDigest.getInstance("SHA-256").digest(namespace.toByteArray()).joinToString("") { "%02x".format(it) }
+    private val alias = "indiana.push.v1.$hash"
+    private val file = AtomicFile(File(context.noBackupFilesDir, "indiana-push-$hash.json"))
+    companion object { private val lock = Any() }
+    private fun store(): KeyStore = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
+    private fun base64(bytes: ByteArray) = Base64.encodeToString(bytes, Base64.URL_SAFE or Base64.NO_WRAP or Base64.NO_PADDING)
+    override fun transaction(update: (IndianaPushJournal) -> IndianaPushJournal): IndianaPushJournal = synchronized(lock) {
+        try {
+            val keystore = store()
+            val current = if (!file.baseFile.exists()) {
+                if (keystore.containsAlias(alias)) throw IndianaClientException("protected_storage_unavailable")
+                val spec = KeyGenParameterSpec.Builder(alias, KeyProperties.PURPOSE_SIGN or KeyProperties.PURPOSE_VERIFY).setAlgorithmParameterSpec(ECGenParameterSpec("secp256r1")).setDigests(KeyProperties.DIGEST_SHA256).build()
+                val key = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore").apply { initialize(spec) }.generateKeyPair()
+                IndianaPushJournal(UUID.randomUUID(), base64(key.public.encoded))
+            } else {
+                val bytes = file.openRead().use { input ->
+                    val output = java.io.ByteArrayOutputStream(); val buffer = ByteArray(1024)
+                    while (true) { val count = input.read(buffer); if (count < 0) break; if (output.size() + count > 4096) throw IndianaClientException("protected_storage_unavailable"); output.write(buffer, 0, count) }
+                    output.toByteArray()
+                }
+                if (bytes.size > 4096) throw IndianaClientException("protected_storage_unavailable")
+                val json = JSONObject(bytes.toString(Charsets.UTF_8))
+                if (json.keys().asSequence().toSet() != setOf("installationId", "publicKey", "identitySeq", "addressSeq", "detachSeq")) throw IndianaClientException("protected_storage_unavailable")
+                IndianaPushJournal(UUID.fromString(json.getString("installationId")), json.getString("publicKey"), json.getLong("identitySeq"), json.getLong("addressSeq"), if (json.isNull("detachSeq")) null else json.getLong("detachSeq"))
+            }
+            current.validate()
+            if (base64(keystore.getCertificate(alias)?.publicKey?.encoded ?: throw IndianaClientException("protected_storage_unavailable")) != current.publicKey) throw IndianaClientException("protected_storage_unavailable")
+            val next = update(current); next.validate()
+            if (next.installationId != current.installationId || next.publicKey != current.publicKey || next.identitySeq < current.identitySeq || next.addressSeq < current.addressSeq) throw IndianaClientException("protected_storage_unavailable")
+            if (!file.baseFile.exists() || next != current) {
+                val data = JSONObject().put("installationId", next.installationId.toString()).put("publicKey", next.publicKey).put("identitySeq", next.identitySeq).put("addressSeq", next.addressSeq).put("detachSeq", next.detachSeq ?: JSONObject.NULL).toString().toByteArray()
+                val stream = file.startWrite()
+                try { stream.write(data); file.finishWrite(stream) } catch (error: Exception) { file.failWrite(stream); throw error }
+            }
+            next
+        } catch (_: Exception) { throw IndianaClientException("protected_storage_unavailable") }
+    }
+    override fun sign(payload: ByteArray): String = synchronized(lock) {
+        try {
+            val key = store().getKey(alias, null) as? java.security.PrivateKey ?: throw IndianaClientException("protected_storage_unavailable")
+            val signature = Signature.getInstance("SHA256withECDSA").apply { initSign(key); update(payload) }.sign()
+            base64(pushP1363(signature))
+        } catch (_: Exception) { throw IndianaClientException("protected_storage_unavailable") }
+    }
+}
+internal class IndianaPushIdentity(val storage: IndianaPushStorage) {
+    init { state() }
+    fun state() = storage.transaction { it }
+    fun reserve(detach: Boolean = false): Long = storage.transaction { current ->
+        if (current.identitySeq >= PUSH_MAX_SEQUENCE) throw IndianaClientException("protected_storage_unavailable")
+        val next = current.identitySeq + 1
+        current.copy(identitySeq = next, detachSeq = if (detach) next else current.detachSeq)
+    }.identitySeq
+    fun reserveAddress(): Long = storage.transaction { current ->
+        if (current.addressSeq >= PUSH_MAX_SEQUENCE) throw IndianaClientException("protected_storage_unavailable")
+        current.copy(addressSeq = current.addressSeq + 1)
+    }.addressSeq
+    fun clearDetach(sequence: Long) { storage.transaction { if (it.detachSeq == sequence) it.copy(detachSeq = null) else it } }
+    fun recover(remote: JSONObject, expected: Long): Long = storage.transaction { current ->
+        if (current.identitySeq != expected) throw IndianaClientException("identity_changed")
+        val floor = maxOf(current.identitySeq, remote.getLong("identitySeq"))
+        if (floor >= PUSH_MAX_SEQUENCE) throw IndianaClientException("protected_storage_unavailable")
+        current.copy(identitySeq = floor + 1, addressSeq = maxOf(current.addressSeq, remote.getLong("addressSeq")))
+    }.identitySeq
+    fun command(operation: String, scope: IndianaScope, sequence: Long? = null, credential: String? = null, observation: IndianaPushObservation? = null, challenge: String? = null): JSONObject {
+        val state = state(); val issued = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US).apply { timeZone = TimeZone.getTimeZone("UTC") }.format(Date())
+        val fields = JSONArray().put("indiana_push_v1").put(operation).put(scope.projectId.toString()).put(scope.environment.value).put(state.installationId.toString()).put(state.publicKey).put(issued)
+        val input = JSONObject().put("installationId", state.installationId.toString()).put("publicKey", state.publicKey).put("issuedAt", issued)
+        fun digest(): String = MessageDigest.getInstance("SHA-256").digest((credential ?: throw IndianaClientException("unauthenticated")).toByteArray()).joinToString("") { "%02x".format(it) }
+        when (operation) {
+            "bind", "detach" -> {
+                require(sequence != null); fields.put(sequence).put("android"); input.put("sequence", sequence).put("platform", "android")
+                if (operation == "bind") { val digest = digest(); fields.put(digest); input.put("credentialDigest", digest) }
+            }
+            "read" -> { val digest = digest(); fields.put(digest); input.put("credentialDigest", digest) }
+            "address", "recovery_request", "recovery_confirm" -> {
+                require(sequence != null && observation != null); val digest = digest()
+                val connection = observation.connectionId?.toString() ?: JSONObject.NULL; val kind = observation.kind?.value ?: JSONObject.NULL; val token = observation.token ?: JSONObject.NULL
+                fields.put(sequence).put(digest).put(connection).put(kind).put(token).put(observation.permission.value)
+                input.put("sequence", sequence).put("credentialDigest", digest).put("connectionId", connection).put("kind", kind).put("token", token).put("permission", observation.permission.value)
+                if (operation == "recovery_confirm") {
+                    if (challenge == null || !challenge.matches(Regex("[A-Za-z0-9_-]{100,3500}"))) throw IndianaClientException("invalid_configuration")
+                    fields.put(challenge); input.put("challenge", challenge)
+                }
+            }
+            else -> throw IndianaClientException("invalid_configuration")
+        }
+        input.put("signature", storage.sign(pushSigningBytes(fields)))
+        if (operation == "detach") input.put("projectId", scope.projectId.toString()).put("environment", scope.environment.value)
+        return input
+    }
+}

package/native-sdk/android/java/ai/tinkerland/indiana/RendererNavigation.kt

@@ -0,0 +1,13 @@
+package ai.tinkerland.indiana
+
+import java.net.URI
+
+private object BundledRenderer {
+    val url: String by lazy {
+        checkNotNull(BundledRenderer::class.java.getResourceAsStream("/renderer-data-url.txt"))
+            .bufferedReader(Charsets.UTF_8).use { it.readText() }
+    }
+}
+/** Subframes can execute only the renderer bytes shipped with this SDK. */
+internal fun allowsFunnelRendererNavigation(offered: URI, base: URI): Boolean =
+    base.toString() == "https://indiana-sdk.invalid/" && offered.toString().substringBefore('#') == BundledRenderer.url

package/native-sdk/android/java/ai/tinkerland/indiana/SDKVersion.kt

@@ -0,0 +1,6 @@
+// Generated by scripts/sdk/generate-native-protocol.mjs. Do not edit.
+package ai.tinkerland.indiana
+
+object IndianaSDK {
+    const val version = "0.10.1"
+}

package/native-sdk/android/java/ai/tinkerland/indiana/StoreSubscriptionManagement.kt

@@ -0,0 +1,19 @@
+package ai.tinkerland.indiana
+
+import android.app.Activity
+import android.content.Intent
+import android.net.Uri
+
+/** Opens Play's renewal management. Returning to the App never proves an entitlement change. */
+object IndianaStoreSubscriptions {
+    fun manage(activity: Activity, productId: String) {
+        val url = managementURL(activity.packageName, productId)
+        activity.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url)))
+    }
+
+    internal fun managementURL(packageName: String, productId: String): String {
+        require(packageName.matches(Regex("[A-Za-z][A-Za-z0-9_]*(\\.[A-Za-z][A-Za-z0-9_]*)+"))) { "invalid_app_package" }
+        require(productId.length in 1..255 && productId.matches(Regex("[a-z0-9][a-z0-9._]*"))) { "invalid_store_product" }
+        return "https://play.google.com/store/account/subscriptions?sku=$productId&package=$packageName"
+    }
+}

package/native-sdk/android/java/ai/tinkerland/indiana/WireSchema.kt

@@ -0,0 +1,76 @@
+package ai.tinkerland.indiana
+import org.json.JSONObject
+import org.json.JSONArray
+import java.net.URI
+import java.util.UUID
+/** Generated contract interpreter for the native wire boundary; no business policy is evaluated here. */
+internal object IndianaSchema {
+    private val schemas: JSONObject by lazy { IndianaSchema::class.java.getResourceAsStream("/funnel-wire-schemas.json")?.bufferedReader(Charsets.UTF_8)?.use { JSONObject(it.readText()) } ?: throw IndianaClientException("invalid_response") }
+    fun validate(name: String, value: JSONObject) { val root = schemas.getJSONObject(name);if (!valid(value, root, root, 0)) throw IndianaClientException("invalid_response") }
+    fun customerResponse(name: String, value: JSONObject): JSONObject { val root = schemas.getJSONObject(name); return adapt(value, root, root, listOf(name), 0) as JSONObject }
+    private fun adapt(original: Any?, schema: JSONObject, root: JSONObject, path: List<String>, depth: Int): Any? {
+        if (depth > 100) throw IndianaClientException("invalid_response")
+        if (schema.has("\$ref")) { var target: Any = root; for (part in schema.getString("\$ref").substring(2).split('/')) target = (target as JSONObject).get(part.replace("~1", "/").replace("~0", "~")); return adapt(original, target as JSONObject, root, path, depth + 1) }
+        (schema.optJSONArray("anyOf") ?: schema.optJSONArray("oneOf"))?.let { branches -> val branch = (0 until branches.length()).map { branches.getJSONObject(it) }.firstOrNull { valid(original, it, root, 0) } ?: throw IndianaClientException("invalid_response"); return adapt(original, branch, root, path, depth + 1) }
+        var value = IndianaCustomerResponseSemantics.rules(original, schema)
+        schema.optJSONArray("allOf")?.let { branches -> for (n in 0 until branches.length()) value = adapt(value, branches.getJSONObject(n), root, path, depth + 1) }
+        if (value is JSONObject) {
+            val objectValue = value as JSONObject; val properties = schema.optJSONObject("properties") ?: JSONObject()
+            for (key in properties.keys()) if (objectValue.has(key)) objectValue.put(key, adapt(objectValue.get(key), properties.getJSONObject(key), root, path + key, depth + 1))
+            schema.optJSONObject("additionalProperties")?.let { additional -> for (key in objectValue.keys()) if (!properties.has(key)) objectValue.put(key, adapt(objectValue.get(key), additional, root, path + "{}", depth + 1)) }
+            IndianaCustomerResponseSemantics.objectValue(objectValue, properties.keys().asSequence().toSet(), path); return objectValue
+        }
+        if (value is JSONArray) { val array = value as JSONArray; schema.optJSONObject("items")?.let { child -> for (n in 0 until array.length()) array.put(n, adapt(array.opt(n), child, root, path + "[]", depth + 1)) }; return array }
+        if (value is String && schema.optString("pattern") in listOf("^(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$", "^-?(0|[1-9]\\d{0,11})(\\.\\d{1,6})?$")) return (value as String).toBigDecimal().stripTrailingZeros().toPlainString()
+        return value
+    }
+    internal fun equal(a: Any?, b: Any?): Boolean = when {
+        a is JSONObject && b is JSONObject -> a.keys().asSequence().toSet() == b.keys().asSequence().toSet() && a.keys().asSequence().all { equal(a.opt(it), b.opt(it)) }
+        a is JSONArray && b is JSONArray -> a.length() == b.length() && (0 until a.length()).all { equal(a.opt(it), b.opt(it)) }
+        a is Number && b is Number -> a.toDouble() == b.toDouble()
+        else -> a == b
+    }
+    private fun valid(value: Any?, schema: JSONObject, root: JSONObject, depth: Int): Boolean {
+        if (depth > 100) return false
+        val value = try { IndianaCustomerResponseSemantics.rules(value, schema) } catch (_: Exception) { return false }
+        if (schema.has("\$ref")) { val ref = schema.getString("\$ref");if (!ref.startsWith("#/")) return false;var target: Any = root;for (part in ref.substring(2).split('/')) target = (target as? JSONObject)?.opt(part.replace("~1", "/").replace("~0", "~")) ?: return false;return target is JSONObject && valid(value, target, root, depth + 1) }
+        for (name in listOf("allOf", "anyOf", "oneOf")) schema.optJSONArray(name)?.let { choices -> val matches = (0 until choices.length()).count { valid(value, choices.getJSONObject(it), root, depth + 1) };if (name == "allOf" && matches != choices.length() || name == "anyOf" && matches == 0 || name == "oneOf" && matches != 1) return false }
+        if (schema.has("const") && !equal(value, schema.opt("const"))) return false
+        schema.optJSONArray("enum")?.let { choices -> if ((0 until choices.length()).none { equal(value, choices.opt(it)) }) return false }
+        when (schema.optString("type")) {
+            "null" -> if (value != null && value != JSONObject.NULL) return false
+            "boolean" -> if (value !is Boolean) return false
+            "string" -> if (value !is String) return false
+            "number", "integer" -> if (value !is Number || !value.toDouble().isFinite() || schema.getString("type") == "integer" && value.toDouble() != kotlin.math.floor(value.toDouble())) return false
+            "object" -> if (value !is JSONObject) return false
+            "array" -> if (value !is JSONArray) return false
+        }
+        if (value is String) {
+            if (schema.has("minLength") && value.length < schema.getInt("minLength") || schema.has("maxLength") && value.length > schema.getInt("maxLength")) return false
+            if (schema.has("pattern") && !Regex(schema.getString("pattern")).containsMatchIn(value)) return false
+            try { when (schema.optString("format")) { "uuid" -> UUID.fromString(value);"date-time" -> utcMillis(value);"uri" -> if (URI(value).scheme == null) return false } } catch (_: Exception) { return false }
+        }
+        if (value is Number) {
+            val n = value.toDouble()
+            if (schema.has("minimum") && n < schema.getDouble("minimum") || schema.has("maximum") && n > schema.getDouble("maximum") || schema.has("exclusiveMinimum") && n <= schema.getDouble("exclusiveMinimum") || schema.has("exclusiveMaximum") && n >= schema.getDouble("exclusiveMaximum")) return false
+        }
+        if (value is JSONArray) {
+            if (schema.has("minItems") && value.length() < schema.getInt("minItems") || schema.has("maxItems") && value.length() > schema.getInt("maxItems")) return false
+            if (schema.optBoolean("uniqueItems")) for (index in 0 until value.length()) if ((0 until index).any { equal(value.opt(it), value.opt(index)) }) return false
+            schema.optJSONObject("items")?.let { items -> if ((0 until value.length()).any { !valid(value.opt(it), items, root, depth + 1) }) return false }
+            schema.optJSONArray("items")?.let { tuple -> for (index in 0 until value.length()) if (index < tuple.length() && !valid(value.opt(index), tuple.getJSONObject(index), root, depth + 1)) return false;if (schema.opt("additionalItems") == false && value.length() > tuple.length()) return false }
+        }
+        if (value is JSONObject) {
+            if (schema.has("maxProperties") && value.length() > schema.getInt("maxProperties") || schema.has("minProperties") && value.length() < schema.getInt("minProperties")) return false
+            val properties = schema.optJSONObject("properties") ?: JSONObject()
+            schema.optJSONArray("required")?.let { required -> if ((0 until required.length()).any { !value.has(required.getString(it)) }) return false }
+            for (key in value.keys()) {
+                if (properties.has(key)) { if (!valid(value.opt(key), properties.getJSONObject(key), root, depth + 1)) return false }
+                else if (schema.opt("additionalProperties") == false) return false
+                else schema.optJSONObject("additionalProperties")?.let { if (!valid(value.opt(key), it, root, depth + 1)) return false }
+                schema.optJSONObject("propertyNames")?.let { if (!valid(key, it, root, depth + 1)) return false }
+            }
+        }
+        return true
+    }
+}