pakstr 0.21.1 → 0.23.0

package/README.md

@@ -49,7 +49,7 @@ build:
 #   apiBase: https://api.example.com  # Optional packaged /api/* proxy target.
 ```
 
-`runtime.apiBase` must be an absolute HTTPS URL. It is public APK metadata, not a secret. When omitted, Pakstr generates an empty runtime config and keeps `/api/*` disabled; when set, `/api/x` forwards to `<apiBase>/api/x`.
+`runtime.apiBase` must be an absolute HTTPS URL. It is the immutable packaged/default proxy target and public APK metadata, not a secret. The effective target precedence is persistent runtime override, then packaged default, then disabled. A web app may call `window.PakstrBridge.setApiBaseUrl(url)` to validate and synchronously persist an HTTPS override, and `window.PakstrBridge.getApiBaseUrl()` to read the effective URL. Developer Tools uses the same setting. Reset removes the override and restores the packaged default; without a packaged default it disables `/api/*`. Changes affect the next proxy request without an app restart, LocalServer restart, or WebView reload.
 
 ### 3. Build, sign, and publish
 ```bash

package/android-template/app/src/androidTest/java/com/pakstr/app/Nip55CallbackTest.kt

@@ -10,7 +10,7 @@ class Nip55CallbackTest {
 
     @Test
     fun accepts_fragment_callback_and_preserves_logical_event() {
-        val event = "{\"kind\":27235,\"content\":\"hello & goodbye / 100%\"}"
+        val event = "{\"id\":\"${"a".repeat(64)}\",\"pubkey\":\"${"b".repeat(64)}\",\"created_at\":1789552517,\"kind\":27235,\"tags\":[],\"content\":\"hello & goodbye / 100%\",\"sig\":\"${"c".repeat(128)}\"}"
         val intent = callbackIntent(
             "${Nip55Callback.PARAM}=${Uri.encode(event)}"
         )

package/android-template/app/src/main/java/com/pakstr/app/LocalServer.kt

@@ -80,6 +80,11 @@ internal fun localRequestUrl(
             if (query.isNullOrEmpty()) "" else "?$query"
 )
 
+internal fun proxyApiUrl(
+    apiBase: String,
+    uri: String
+): URL = URL(apiBase + uri)
+
 internal data class ProxyHttpResponse(
     val code: Int,
     val contentType: String?,
@@ -258,7 +263,8 @@ class LocalServer(
         )
         if (uri.startsWith("/api/")) {
 
-            if (!RuntimeConfig.apiEnabled(context)) {
+            val apiBase = RuntimeConfig.apiBase(context)
+            if (apiBase == null) {
 
                 AppDebugLogger.network(
 
@@ -283,7 +289,7 @@ class LocalServer(
                 )
             }
 
-            return proxyApi(session, uri)
+            return proxyApi(session, uri, apiBase)
 
         }
 
@@ -370,7 +376,7 @@ class LocalServer(
     }
 
     private fun proxyApi(
-        session: IHTTPSession?, uri: String
+        session: IHTTPSession?, uri: String, apiBase: String
     ): Response {
 
         if (AppDebugLogger.isNetworkLoggingEnabled(context)) {
@@ -386,29 +392,7 @@ class LocalServer(
 
         return try {
 
-            val config = RuntimeConfig.load(context)
-
-            val apiBase = config.optString("apiBase")
-
-            if (apiBase.isBlank()) {
-                AppDebugLogger.error(
-
-                    context,
-
-                    "API",
-
-                    "apiBase missing"
-
-                )
-                return newFixedLengthResponse(
-                    Response.Status.INTERNAL_ERROR,
-                    "application/json",
-                    """{"error":"apiBase missing"}"""
-                )
-            }
-
-            val finalUrl = apiBase.removeSuffix("/") + uri
-            val url = URL(finalUrl)
+            val url = proxyApiUrl(apiBase, uri)
             val method = session?.method?.name ?: "GET"
             val requestHeaders = session?.headers ?: emptyMap()
             val localRequestUrl = localRequestUrl(
@@ -438,7 +422,7 @@ class LocalServer(
                 if (AppDebugLogger.isNetworkLoggingEnabled(context)) {
                     AppDebugLogger.network(
                         context,
-                        "Response: ${response.code} $finalUrl"
+                        "Proxy response: ${response.code}"
                     )
                 }
                 return newFixedLengthResponse(
@@ -498,7 +482,7 @@ class LocalServer(
                 AppDebugLogger.network(
 
                     context,
-                    "Response: $code $finalUrl"
+                    "Proxy response: $code"
 
                 )
 

package/android-template/app/src/main/java/com/pakstr/app/Nip55Callback.kt

@@ -10,6 +10,9 @@ internal object Nip55Callback {
     private const val FRAGMENT_PREFIX = "$PARAM="
     private const val MAX_RESULT_LENGTH = 128 * 1024
 
+    val callbackPrefix: String
+        get() = "${BuildConfig.PAKSTR_NIP55_CALLBACK_SCHEME}://$HOST#$FRAGMENT_PREFIX"
+
     fun result(intent: Intent?): String? {
         if (intent?.action != Intent.ACTION_VIEW) {
             return null

package/android-template/app/src/main/java/com/pakstr/app/Nip55SignEventRequest.kt

@@ -0,0 +1,303 @@
+package com.pakstr.app
+
+import com.pakstr.app.crypto.NostrEventHasher
+import com.pakstr.app.signer.SignerType
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+import java.nio.charset.CodingErrorAction
+
+internal sealed interface Nip55SignEventRequest {
+    data object External : Nip55SignEventRequest
+
+    data class Rejected(
+        val reason: String
+    ) : Nip55SignEventRequest
+
+    data class Parsed(
+        val event: JSONObject,
+        val callbackUrl: String
+    ) : Nip55SignEventRequest
+}
+
+internal sealed interface Nip55NormalizedEvent {
+    data class Rejected(
+        val reason: String
+    ) : Nip55NormalizedEvent
+
+    data class Ready(
+        val eventJson: String
+    ) : Nip55NormalizedEvent
+}
+
+internal object Nip55SignEventParser {
+    private const val SCHEME_PREFIX = "nostrsigner:"
+    private const val MAX_REQUEST_BYTES = 128 * 1024
+    private val RELEVANT_PARAMETERS = setOf(
+        "type",
+        "returnType",
+        "compressionType",
+        "callbackUrl"
+    )
+    private val EVENT_FIELDS = setOf(
+        "kind",
+        "created_at",
+        "tags",
+        "content",
+        "pubkey",
+        "id",
+        "sig"
+    )
+
+    fun parse(
+        rawUrl: String,
+        expectedCallbackUrl: String
+    ): Nip55SignEventRequest {
+        if (rawUrl.toByteArray(Charsets.UTF_8).size > MAX_REQUEST_BYTES) {
+            return rejected("request too large")
+        }
+        if (!rawUrl.startsWith(SCHEME_PREFIX, ignoreCase = true)) {
+            return Nip55SignEventRequest.External
+        }
+
+        val schemeSpecificPart = rawUrl.substring(SCHEME_PREFIX.length)
+        if ('#' in schemeSpecificPart) {
+            return rejected("malformed request")
+        }
+        val separator = schemeSpecificPart.indexOf('?')
+        val encodedEvent = if (separator >= 0) {
+            schemeSpecificPart.substring(0, separator)
+        } else {
+            schemeSpecificPart
+        }
+        val rawQuery = if (separator >= 0) {
+            schemeSpecificPart.substring(separator + 1)
+        } else {
+            ""
+        }
+        if (encodedEvent.isEmpty()) {
+            return rejected("missing event")
+        }
+        if (!hasOpaquePayloadEncoding(encodedEvent)) {
+            return rejected("malformed event encoding")
+        }
+
+        val parameters = parseParameters(rawQuery)
+            ?: return rejected("malformed parameters")
+        val type = parameters["type"]
+        if (type != "sign_event") {
+            return Nip55SignEventRequest.External
+        }
+        if (parameters["returnType"] != "event") {
+            return rejected("unsupported return type")
+        }
+        val compressionType = parameters["compressionType"]
+        if (compressionType != null && compressionType != "none") {
+            return rejected("unsupported compression")
+        }
+        val callbackUrl = parameters["callbackUrl"]
+            ?: return rejected("missing callback")
+        if (callbackUrl != expectedCallbackUrl) {
+            return rejected("unexpected callback")
+        }
+
+        val eventText = percentDecode(encodedEvent)
+            ?: return rejected("malformed event encoding")
+        val event = try {
+            JSONObject(eventText)
+        } catch (_: Exception) {
+            return rejected("invalid event")
+        }
+        if (event.keys().asSequence().any { it !in EVENT_FIELDS }) {
+            return rejected("unsupported event field")
+        }
+        if (!hasIntegral(event, "kind") ||
+            event.getLong("kind") !in 0L..65535L ||
+            !hasIntegral(event, "created_at") ||
+            event.optJSONArray("tags") == null ||
+            !hasString(event, "content") ||
+            !hasValidTags(event.getJSONArray("tags"))
+        ) {
+            return rejected("invalid event fields")
+        }
+        if (event.has("sig") &&
+            (!hasString(event, "sig") || event.getString("sig").isNotEmpty())
+        ) {
+            return rejected("event already signed")
+        }
+        if (event.has("pubkey") && !hasString(event, "pubkey")) {
+            return rejected("invalid pubkey")
+        }
+        if (event.has("id") && !hasString(event, "id")) {
+            return rejected("invalid event id")
+        }
+
+        return Nip55SignEventRequest.Parsed(event, callbackUrl)
+    }
+
+    fun normalize(
+        request: Nip55SignEventRequest.Parsed,
+        activePubkey: String
+    ): Nip55NormalizedEvent {
+        if (activePubkey.isBlank()) {
+            return normalizedRejected("signer unavailable")
+        }
+        val event = JSONObject(request.event.toString())
+        if (event.has("pubkey") && event.getString("pubkey") != activePubkey) {
+            return normalizedRejected("pubkey mismatch")
+        }
+
+        if (event.has("id")) {
+            val expectedId = event.getString("id")
+            event.put("pubkey", activePubkey)
+            val actualId = try {
+                NostrEventHasher.hashEvent(event)
+            } catch (_: Exception) {
+                return normalizedRejected("invalid event id")
+            }
+            if (actualId != expectedId) {
+                return normalizedRejected("event id mismatch")
+            }
+        }
+
+        return Nip55NormalizedEvent.Ready(
+            JSONObject()
+                .put("kind", event.getInt("kind"))
+                .put("created_at", event.getLong("created_at"))
+                .put("tags", event.getJSONArray("tags"))
+                .put("content", event.getString("content"))
+                .toString()
+        )
+    }
+
+    private fun hasOpaquePayloadEncoding(value: String): Boolean {
+        var index = 0
+        while (index < value.length) {
+            if (value[index] == '%') {
+                if (index + 2 >= value.length ||
+                    value[index + 1].digitToIntOrNull(16) == null ||
+                    value[index + 2].digitToIntOrNull(16) == null
+                ) {
+                    return false
+                }
+                index += 3
+            } else {
+                val character = value[index]
+                if (!character.isLetterOrDigit() && character !in "-._~") {
+                    return false
+                }
+                index++
+            }
+        }
+        return true
+    }
+
+    private fun parseParameters(rawQuery: String): Map<String, String>? {
+        val parameters = mutableMapOf<String, String>()
+        if (rawQuery.isEmpty()) {
+            return parameters
+        }
+        for (part in rawQuery.split('&')) {
+            val separator = part.indexOf('=')
+            if (separator < 0) {
+                return null
+            }
+            val name = percentDecode(part.substring(0, separator)) ?: return null
+            val value = percentDecode(part.substring(separator + 1)) ?: return null
+            if (name in RELEVANT_PARAMETERS && parameters.containsKey(name)) {
+                return null
+            }
+            parameters[name] = value
+        }
+        return parameters
+    }
+
+    private fun percentDecode(value: String): String? {
+        val bytes = ByteArrayOutputStream(value.length)
+        var index = 0
+        while (index < value.length) {
+            val character = value[index]
+            if (character == '%') {
+                if (index + 2 >= value.length) return null
+                val high = value[index + 1].digitToIntOrNull(16) ?: return null
+                val low = value[index + 2].digitToIntOrNull(16) ?: return null
+                bytes.write((high shl 4) or low)
+                index += 3
+            } else {
+                val codePoint = value.codePointAt(index)
+                bytes.write(String(Character.toChars(codePoint)).toByteArray(Charsets.UTF_8))
+                index += Character.charCount(codePoint)
+            }
+        }
+        return try {
+            Charsets.UTF_8.newDecoder()
+                .onMalformedInput(CodingErrorAction.REPORT)
+                .onUnmappableCharacter(CodingErrorAction.REPORT)
+                .decode(ByteBuffer.wrap(bytes.toByteArray()))
+                .toString()
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    private fun hasIntegral(event: JSONObject, name: String): Boolean {
+        if (!event.has(name) || event.isNull(name)) return false
+        return event.get(name) is Byte ||
+                event.get(name) is Short ||
+                event.get(name) is Int ||
+                event.get(name) is Long
+    }
+
+    private fun hasString(event: JSONObject, name: String): Boolean {
+        return event.has(name) && !event.isNull(name) && event.get(name) is String
+    }
+
+    private fun hasValidTags(tags: JSONArray): Boolean {
+        for (tagIndex in 0 until tags.length()) {
+            val tag = tags.optJSONArray(tagIndex) ?: return false
+            if (tag.length() == 0) return false
+            for (valueIndex in 0 until tag.length()) {
+                if (tag.get(valueIndex) !is String) return false
+            }
+        }
+        return true
+    }
+
+    private fun rejected(reason: String) = Nip55SignEventRequest.Rejected(reason)
+
+    private fun normalizedRejected(reason: String) = Nip55NormalizedEvent.Rejected(reason)
+}
+
+internal fun dispatchNip55SignEvent(
+    rawUrl: String,
+    activeSignerType: SignerType?,
+    expectedCallbackUrl: String,
+    forwardExternally: () -> Unit,
+    launchSigning: (suspend () -> Unit) -> Unit,
+    getActivePubkey: suspend () -> String,
+    signEvent: suspend (String) -> String,
+    deliverSignedEvent: suspend (String) -> Unit,
+    logRejection: (String) -> Unit
+) {
+    if (activeSignerType != SignerType.BUNKER) {
+        forwardExternally()
+        return
+    }
+
+    when (val request = Nip55SignEventParser.parse(rawUrl, expectedCallbackUrl)) {
+        Nip55SignEventRequest.External -> forwardExternally()
+        is Nip55SignEventRequest.Rejected -> logRejection(request.reason)
+        is Nip55SignEventRequest.Parsed -> launchSigning {
+            when (val normalized = Nip55SignEventParser.normalize(
+                request,
+                getActivePubkey()
+            )) {
+                is Nip55NormalizedEvent.Rejected -> logRejection(normalized.reason)
+                is Nip55NormalizedEvent.Ready -> deliverSignedEvent(
+                    signEvent(normalized.eventJson)
+                )
+            }
+        }
+    }
+}

package/android-template/app/src/main/java/com/pakstr/app/PakstrBridge.kt

@@ -2,10 +2,22 @@ package com.pakstr.app
 
 import android.webkit.JavascriptInterface
 
-class PakstrBridge {
+class PakstrBridge(
+    private val runtimeApiBaseSettings: RuntimeApiBaseSettings
+) {
 
     @JavascriptInterface
     fun getNip55CallbackUrl(): String {
-        return "${BuildConfig.PAKSTR_NIP55_CALLBACK_SCHEME}://nip55-callback#nip55_event="
+        return Nip55Callback.callbackPrefix
+    }
+
+    @JavascriptInterface
+    fun setApiBaseUrl(url: String): Boolean {
+        return runtimeApiBaseSettings.setOverride(url)
+    }
+
+    @JavascriptInterface
+    fun getApiBaseUrl(): String? {
+        return runtimeApiBaseSettings.current().url
     }
 }

package/android-template/app/src/main/java/com/pakstr/app/RuntimeApiBaseSettings.kt

@@ -0,0 +1,98 @@
+package com.pakstr.app
+
+import android.content.Context
+import android.content.SharedPreferences
+
+class RuntimeApiBaseSettings private constructor(
+    private val preferences: Preferences,
+    private val packagedValueProvider: () -> String?
+) {
+    enum class Source {
+        RUNTIME_OVERRIDE,
+        PACKAGED_DEFAULT,
+        DISABLED
+    }
+
+    data class Value(
+        val url: String?,
+        val source: Source
+    )
+
+    fun current(): Value = resolveEffectiveValue(
+        persistedOverride = preferences.getString(API_BASE_OVERRIDE_KEY),
+        packagedDefault = packagedValueProvider()
+    )
+
+    fun setOverride(value: String): Boolean {
+        val canonical = RuntimeApiBaseValidator.validateAndCanonicalize(value)
+            ?: return false
+        return preferences.putString(API_BASE_OVERRIDE_KEY, canonical)
+    }
+
+    fun reset(): Boolean = preferences.remove(API_BASE_OVERRIDE_KEY)
+
+    internal interface Preferences {
+        fun getString(key: String): String?
+        fun putString(key: String, value: String): Boolean
+        fun remove(key: String): Boolean
+    }
+
+    private class SharedPreferencesAdapter(
+        private val preferences: SharedPreferences
+    ) : Preferences {
+        override fun getString(key: String): String? = preferences.getString(key, null)
+
+        override fun putString(key: String, value: String): Boolean =
+            preferences.edit().putString(key, value).commit()
+
+        override fun remove(key: String): Boolean =
+            preferences.edit().remove(key).commit()
+    }
+
+    companion object {
+        internal const val PREFERENCES_FILE = "pakstr_runtime_api_base"
+        internal const val API_BASE_OVERRIDE_KEY = "api_base_override"
+
+        fun from(context: Context): RuntimeApiBaseSettings {
+            val applicationContext = context.applicationContext
+            val preferences = applicationContext.getSharedPreferences(
+                PREFERENCES_FILE,
+                Context.MODE_PRIVATE
+            )
+            return RuntimeApiBaseSettings(
+                SharedPreferencesAdapter(preferences)
+            ) {
+                RuntimeConfig.packagedApiBase(applicationContext)
+            }
+        }
+
+        internal fun resolveEffectiveValue(
+            persistedOverride: String?,
+            packagedDefault: String?
+        ): Value {
+            val override = RuntimeApiBaseValidator.validateAndCanonicalize(
+                persistedOverride
+            )
+            if (override != null) {
+                return Value(override, Source.RUNTIME_OVERRIDE)
+            }
+
+            val packaged = RuntimeApiBaseValidator.validateAndCanonicalize(
+                packagedDefault
+            )
+            return if (packaged != null) {
+                Value(packaged, Source.PACKAGED_DEFAULT)
+            } else {
+                Value(null, Source.DISABLED)
+            }
+        }
+
+        internal fun createForTesting(
+            preferences: Preferences,
+            packagedValueProvider: () -> String?
+        ): RuntimeApiBaseSettings = RuntimeApiBaseSettings(
+            preferences,
+            packagedValueProvider
+        )
+    }
+}

package/android-template/app/src/main/java/com/pakstr/app/RuntimeApiBaseValidator.kt

@@ -0,0 +1,30 @@
+package com.pakstr.app
+
+import java.net.URI
+
+object RuntimeApiBaseValidator {
+    const val MAX_LENGTH = 2048
+
+    fun validateAndCanonicalize(value: String?): String? {
+        if (
+            value == null ||
+            value.isEmpty() ||
+            value.length > MAX_LENGTH ||
+            value != value.trim()
+        ) {
+            return null
+        }
+
+        val uri = runCatching { URI(value) }.getOrNull() ?: return null
+        if (!uri.isAbsolute || !uri.scheme.equals("https", ignoreCase = true)) return null
+        if (uri.host.isNullOrBlank()) return null
+        if (uri.rawUserInfo != null || uri.rawQuery != null || uri.rawFragment != null) return null
+
+        val host = uri.host.lowercase().let {
+            if (it.contains(':') && !it.startsWith("[")) "[$it]" else it
+        }
+        val port = if (uri.port == -1) "" else ":${uri.port}"
+        val path = uri.rawPath.orEmpty().trimEnd('/')
+        return "https://$host$port$path"
+    }
+}

package/android-template/app/src/main/java/com/pakstr/app/RuntimeConfig.kt

@@ -58,19 +58,14 @@ object RuntimeConfig {
      */
     fun apiBase(
         context: Context
-    ): String? {
+    ): String? = RuntimeApiBaseSettings.from(context).current().url
 
-        val value = load(context).optString(
-                "apiBase", ""
-            )
-
-
-        debug("apiBase=$value")
-
-
-        return value.takeIf {
-            it.isNotBlank()
-        }
+    internal fun packagedApiBase(
+        context: Context
+    ): String? = load(context).optString(
+        "apiBase", ""
+    ).takeIf {
+        it.isNotBlank()
     }
 
     /**