pakstr 0.20.0 → 0.21.0

package/android-template/app/src/main/java/com/pakstr/app/signer/bunker/Nip46Protocol.kt

@@ -0,0 +1,695 @@
+package com.pakstr.app.signer.bunker
+
+import com.pakstr.app.crypto.Bip340Verifier
+import com.pakstr.app.crypto.Nip46ClientKey
+import com.pakstr.app.crypto.NostrEventVerifier
+import com.pakstr.app.signer.NostrEventBuilder
+import org.json.JSONArray
+import org.json.JSONObject
+import java.net.URI
+import java.security.MessageDigest
+
+internal class Nip46Protocol(
+    private val clientKey: Nip46ClientKey,
+    private val config: BunkerConfig,
+    private val requestIdGenerator: Nip46RequestIdGenerator =
+        SecureNip46RequestIdGenerator,
+    private val clockSeconds: () -> Long = {
+        System.currentTimeMillis() / 1000L
+    },
+    private val limits: Nip46ProtocolLimits =
+        Nip46ProtocolLimits()
+) {
+    fun prepareConnect(
+        requestedPermissions: String? = null,
+        clientMetadataJson: String? = null
+    ): Nip46OutboundRequest {
+        clientMetadataJson?.let(::validateMetadata)
+
+        val pairingSecret = config.pairingSecret
+        val params = mutableListOf(config.remoteSignerPubkey)
+        if (
+            pairingSecret != null ||
+            requestedPermissions != null ||
+            clientMetadataJson != null
+        ) {
+            params += pairingSecret.orEmpty()
+        }
+        if (
+            requestedPermissions != null ||
+            clientMetadataJson != null
+        ) {
+            params += requestedPermissions.orEmpty()
+        }
+        if (clientMetadataJson != null) {
+            params += clientMetadataJson
+        }
+
+        return prepare(
+            Nip46Method.CONNECT,
+            params,
+            expectedConnectResult = pairingSecret
+        )
+    }
+
+    fun clearPairingSecret() {
+        config.clearPairingSecret()
+    }
+
+    fun prepareDisconnect(): Nip46OutboundRequest {
+        return prepare(
+            Nip46Method.DISCONNECT,
+            emptyList()
+        )
+    }
+
+    fun prepareGetPublicKey(): Nip46OutboundRequest {
+        return prepare(
+            Nip46Method.GET_PUBLIC_KEY,
+            emptyList()
+        )
+    }
+
+    fun prepareSignEvent(
+        unsignedEventJson: String,
+        expectedUserPubkey: String
+    ): Nip46OutboundRequest {
+        validatePublicKey(expectedUserPubkey)
+        val normalized =
+            normalizeUnsignedEvent(unsignedEventJson)
+        val fingerprint =
+            MessageDigest.getInstance("SHA-256")
+                .digest(
+                    normalized.toByteArray(Charsets.UTF_8)
+                )
+
+        return prepare(
+            Nip46Method.SIGN_EVENT,
+            listOf(normalized),
+            fingerprint,
+            expectedUserPubkey
+        )
+    }
+
+    fun prepareNip04Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): Nip46OutboundRequest {
+        validatePublicKey(pubkey)
+        return prepare(
+            Nip46Method.NIP04_ENCRYPT,
+            listOf(pubkey, plaintext)
+        )
+    }
+
+    fun prepareNip04Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): Nip46OutboundRequest {
+        validatePublicKey(pubkey)
+        return prepare(
+            Nip46Method.NIP04_DECRYPT,
+            listOf(pubkey, ciphertext)
+        )
+    }
+
+    fun prepareNip44Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): Nip46OutboundRequest {
+        validatePublicKey(pubkey)
+        return prepare(
+            Nip46Method.NIP44_ENCRYPT,
+            listOf(pubkey, plaintext)
+        )
+    }
+
+    fun prepareNip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): Nip46OutboundRequest {
+        validatePublicKey(pubkey)
+        return prepare(
+            Nip46Method.NIP44_DECRYPT,
+            listOf(pubkey, ciphertext)
+        )
+    }
+
+    fun decodeResponseEvent(
+        eventJson: String
+    ): Nip46VerifiedResponse {
+        requireSize(
+            eventJson,
+            limits.maximumEventBytes,
+            "NIP-46 response event is too large"
+        )
+
+        val event = parseObject(
+            eventJson,
+            "Invalid NIP-46 response event"
+        )
+        validateEventShape(event)
+
+        if (event.getInt("kind") != EVENT_KIND) {
+            throw Nip46ProtocolException(
+                "Invalid NIP-46 response event"
+            )
+        }
+        if (
+            event.getString("pubkey") !=
+            config.remoteSignerPubkey
+        ) {
+            throw Nip46ProtocolException(
+                "Unexpected NIP-46 response author"
+            )
+        }
+        validateRecipientTags(
+            event.getJSONArray("tags")
+        )
+
+        val verified =
+            try {
+                NostrEventVerifier.verify(event)
+            } catch (_: Exception) {
+                false
+            }
+        if (!verified) {
+            throw Nip46ProtocolException(
+                "NIP-46 response verification failed"
+            )
+        }
+
+        val encryptedContent = event.getString("content")
+        if (
+            encryptedContent.length >
+            limits.maximumEncryptedContentLength
+        ) {
+            throw Nip46ProtocolException(
+                "NIP-46 response payload is too large"
+            )
+        }
+
+        val decrypted =
+            try {
+                clientKey.decryptNip44(
+                    encryptedContent,
+                    config.remoteSignerPubkey
+                )
+            } catch (_: Exception) {
+                throw Nip46ProtocolException(
+                    "Invalid NIP-46 response payload"
+                )
+            }
+        requireSize(
+            decrypted,
+            limits.maximumPayloadBytes,
+            "NIP-46 response payload is too large"
+        )
+
+        val response =
+            try {
+                Nip46Response.parse(decrypted)
+            } catch (_: Exception) {
+                throw Nip46ProtocolException(
+                    "Invalid NIP-46 response payload"
+                )
+            }
+
+        return Nip46VerifiedResponse(response)
+    }
+
+    fun correlateResponse(
+        verified: Nip46VerifiedResponse,
+        context: Nip46RequestContext
+    ): Nip46ResponseOutcome {
+        val response = verified.response
+        if (response.id != context.id) {
+            throw Nip46ProtocolException(
+                "NIP-46 response does not match request"
+            )
+        }
+
+        if (
+            response.result == AUTH_URL_RESULT &&
+            response.error != null
+        ) {
+            validateAuthUrl(response.error)
+            context.beginResponse(authChallenge = true)
+            return Nip46ResponseOutcome.AuthChallenge(
+                response.error
+            )
+        }
+
+        if (response.error != null) {
+            context.beginResponse(authChallenge = false)
+            return Nip46ResponseOutcome.RemoteError()
+        }
+
+        val result =
+            response.result
+                ?: throw Nip46ProtocolException(
+                    "Invalid NIP-46 response"
+                )
+        validateResult(
+            context,
+            result
+        )
+        context.beginResponse(authChallenge = false)
+
+        return Nip46ResponseOutcome.Success(result)
+    }
+
+    private fun validateAuthUrl(value: String) {
+        if (value.length > limits.maximumAuthUrlLength) {
+            throw Nip46ProtocolException(
+                "Invalid NIP-46 auth URL"
+            )
+        }
+        val uri =
+            try {
+                URI(value)
+            } catch (_: Exception) {
+                throw Nip46ProtocolException(
+                    "Invalid NIP-46 auth URL"
+                )
+            }
+        if (
+            uri.scheme != "https" ||
+            uri.host.isNullOrBlank() ||
+            uri.rawUserInfo != null ||
+            uri.rawFragment != null
+        ) {
+            throw Nip46ProtocolException(
+                "Invalid NIP-46 auth URL"
+            )
+        }
+    }
+
+    private fun prepare(
+        method: Nip46Method,
+        params: List<String>,
+        fingerprint: ByteArray? = null,
+        expectedUserPubkey: String? = null,
+        expectedConnectResult: String? = null
+    ): Nip46OutboundRequest {
+        val id = requestIdGenerator.nextId()
+        validateNip46RequestId(id)
+        val request = Nip46Request(id, method, params)
+        val requestJson = request.toJson()
+        requireSize(
+            requestJson,
+            limits.maximumPayloadBytes,
+            "NIP-46 request payload is too large"
+        )
+
+        val encrypted =
+            try {
+                clientKey.encryptNip44(
+                    requestJson,
+                    config.remoteSignerPubkey
+                )
+            } catch (_: Exception) {
+                throw Nip46ProtocolException(
+                    "Unable to encrypt NIP-46 request"
+                )
+            }
+        if (
+            encrypted.length >
+            limits.maximumEncryptedContentLength
+        ) {
+            throw Nip46ProtocolException(
+                "NIP-46 request payload is too large"
+            )
+        }
+
+        val event =
+            JSONObject()
+                .put("pubkey", clientKey.publicKeyHex)
+                .put("created_at", clockSeconds())
+                .put("kind", EVENT_KIND)
+                .put(
+                    "tags",
+                    JSONArray()
+                        .put(
+                            JSONArray()
+                                .put("p")
+                                .put(config.remoteSignerPubkey)
+                        )
+                )
+                .put("content", encrypted)
+        NostrEventBuilder.addId(event)
+
+        val eventId = hexToBytes(event.getString("id"))
+        val signature =
+            try {
+                clientKey.sign(eventId)
+            } finally {
+                eventId.fill(0)
+            }
+        event.put("sig", bytesToHex(signature))
+        signature.fill(0)
+
+        if (!NostrEventVerifier.verify(event)) {
+            throw Nip46ProtocolException(
+                "Unable to verify NIP-46 request event"
+            )
+        }
+
+        val eventJson = event.toString()
+        requireSize(
+            eventJson,
+            limits.maximumEventBytes,
+            "NIP-46 request event is too large"
+        )
+
+        return Nip46OutboundRequest(
+            eventJson,
+            Nip46RequestContext(
+                id = id,
+                method = method,
+                expectedUserPubkey = expectedUserPubkey,
+                expectedConnectResult = expectedConnectResult,
+                unsignedEventFingerprint = fingerprint
+            )
+        )
+    }
+
+    private fun validateResult(
+        context: Nip46RequestContext,
+        result: String
+    ) {
+        when (context.method) {
+            Nip46Method.CONNECT -> {
+                if (
+                    result != "ack" &&
+                    result != context.expectedConnectResult
+                ) {
+                    throw Nip46ProtocolException(
+                        "Invalid NIP-46 connect response"
+                    )
+                }
+            }
+            Nip46Method.DISCONNECT -> Unit
+            Nip46Method.GET_PUBLIC_KEY ->
+                validatePublicKey(result)
+            Nip46Method.SIGN_EVENT ->
+                validateSignedEvent(result, context)
+            Nip46Method.NIP04_ENCRYPT,
+            Nip46Method.NIP44_ENCRYPT -> {
+                if (result.isEmpty()) {
+                    throw Nip46ProtocolException(
+                        "Invalid NIP-46 encryption response"
+                    )
+                }
+            }
+            Nip46Method.NIP04_DECRYPT,
+            Nip46Method.NIP44_DECRYPT -> Unit
+        }
+    }
+
+    private fun validateSignedEvent(
+        value: String,
+        context: Nip46RequestContext
+    ) {
+        val event = parseObject(
+            value,
+            "Invalid signed event response"
+        )
+        validateEventShape(event)
+        val verified =
+            try {
+                NostrEventVerifier.verify(event)
+            } catch (_: Exception) {
+                false
+            }
+        if (!verified) {
+            throw Nip46ProtocolException(
+                "Invalid signed event response"
+            )
+        }
+        if (
+            event.getString("pubkey") !=
+            context.expectedUserPubkey
+        ) {
+            throw Nip46ProtocolException(
+                "Unexpected signed event author"
+            )
+        }
+
+        val normalized = normalizeSignedEvent(event)
+        val fingerprint =
+            MessageDigest.getInstance("SHA-256")
+                .digest(
+                    normalized.toByteArray(Charsets.UTF_8)
+                )
+        try {
+            if (!context.matchesUnsignedEvent(fingerprint)) {
+                throw Nip46ProtocolException(
+                    "Signed event does not match request"
+                )
+            }
+        } finally {
+            fingerprint.fill(0)
+        }
+    }
+
+    private fun normalizeUnsignedEvent(value: String): String {
+        val json = parseObject(
+            value,
+            "Invalid unsigned event"
+        )
+        val forbidden = listOf("id", "pubkey", "sig")
+        if (forbidden.any(json::has)) {
+            throw Nip46ProtocolException(
+                "Unsigned event contains signer-owned fields"
+            )
+        }
+        val allowed = setOf(
+            "kind",
+            "created_at",
+            "tags",
+            "content"
+        )
+        if (json.keys().asSequence().any { it !in allowed }) {
+            throw Nip46ProtocolException(
+                "Unsigned event contains unsupported fields"
+            )
+        }
+
+        return normalizedUnsignedFields(json).toString()
+    }
+
+    private fun normalizeSignedEvent(
+        event: JSONObject
+    ): String {
+        return normalizedUnsignedFields(event).toString()
+    }
+
+    private fun normalizedUnsignedFields(
+        json: JSONObject
+    ): JSONObject {
+        val kind = requireKind(json)
+        requireIntegral(json, "created_at")
+        val tags = requireTags(json)
+        requireString(json, "content")
+
+        return JSONObject()
+            .put("kind", kind)
+            .put("created_at", json.getLong("created_at"))
+            .put("tags", tags)
+            .put("content", json.getString("content"))
+    }
+
+    private fun validateEventShape(event: JSONObject) {
+        requireString(event, "id")
+        requireString(event, "pubkey")
+        requireIntegral(event, "created_at")
+        requireKind(event)
+        requireTags(event)
+        requireString(event, "content")
+        requireString(event, "sig")
+        validatePublicKey(event.getString("pubkey"))
+        if (!event.getString("id").matches(Regex("[0-9a-f]{64}"))) {
+            throw Nip46ProtocolException(
+                "Invalid NIP-46 event ID"
+            )
+        }
+        if (!event.getString("sig").matches(Regex("[0-9a-f]{128}"))) {
+            throw Nip46ProtocolException(
+                "Invalid NIP-46 event signature"
+            )
+        }
+    }
+
+    private fun validateRecipientTags(tags: JSONArray) {
+        var recipients = 0
+        for (index in 0 until tags.length()) {
+            val tag = tags.getJSONArray(index)
+            if (
+                tag.length() > 0 &&
+                tag.getString(0) == "p"
+            ) {
+                recipients++
+                if (
+                    tag.length() < 2 ||
+                    tag.getString(1) != clientKey.publicKeyHex
+                ) {
+                    throw Nip46ProtocolException(
+                        "Unexpected NIP-46 response recipient"
+                    )
+                }
+            }
+        }
+        if (recipients != 1) {
+            throw Nip46ProtocolException(
+                "Invalid NIP-46 response recipient"
+            )
+        }
+    }
+
+    private fun validateMetadata(value: String) {
+        requireSize(
+            value,
+            limits.maximumPayloadBytes,
+            "NIP-46 client metadata is too large"
+        )
+        parseObject(
+            value,
+            "Invalid NIP-46 client metadata"
+        )
+    }
+
+    private fun validatePublicKey(value: String) {
+        if (
+            !value.matches(Regex("[0-9a-f]{64}")) ||
+            !Bip340Verifier.isValidXOnlyPubkey(value)
+        ) {
+            throw Nip46ProtocolException(
+                "Invalid Nostr public key"
+            )
+        }
+    }
+
+    private fun requireTags(json: JSONObject): JSONArray {
+        val tags = json.optJSONArray("tags")
+            ?: throw Nip46ProtocolException(
+                "Invalid Nostr event"
+            )
+        for (index in 0 until tags.length()) {
+            val tag = tags.optJSONArray(index)
+                ?: throw Nip46ProtocolException(
+                    "Invalid Nostr event"
+                )
+            if (tag.length() == 0) {
+                throw Nip46ProtocolException(
+                    "Invalid Nostr event"
+                )
+            }
+            for (valueIndex in 0 until tag.length()) {
+                if (tag.get(valueIndex) !is String) {
+                    throw Nip46ProtocolException(
+                        "Invalid Nostr event"
+                    )
+                }
+            }
+        }
+        return tags
+    }
+
+    private fun requireString(
+        json: JSONObject,
+        key: String
+    ) {
+        if (
+            !json.has(key) ||
+            json.isNull(key) ||
+            json.get(key) !is String
+        ) {
+            throw Nip46ProtocolException(
+                "Invalid Nostr event"
+            )
+        }
+    }
+
+    private fun requireKind(json: JSONObject): Int {
+        requireIntegral(json, "kind")
+        val kind = json.getLong("kind")
+        if (kind !in 0L..65535L) {
+            throw Nip46ProtocolException(
+                "Invalid Nostr event kind"
+            )
+        }
+        return kind.toInt()
+    }
+
+    private fun requireIntegral(
+        json: JSONObject,
+        key: String
+    ) {
+        if (!json.has(key) || json.isNull(key)) {
+            throw Nip46ProtocolException(
+                "Invalid Nostr event"
+            )
+        }
+        val value = json.get(key)
+        if (
+            value !is Byte &&
+            value !is Short &&
+            value !is Int &&
+            value !is Long
+        ) {
+            throw Nip46ProtocolException(
+                "Invalid Nostr event"
+            )
+        }
+    }
+
+    private fun parseObject(
+        value: String,
+        message: String
+    ): JSONObject {
+        return try {
+            JSONObject(value)
+        } catch (_: Exception) {
+            throw Nip46ProtocolException(message)
+        }
+    }
+
+    private fun requireSize(
+        value: String,
+        maximumBytes: Int,
+        message: String
+    ) {
+        if (
+            value.toByteArray(Charsets.UTF_8).size >
+            maximumBytes
+        ) {
+            throw Nip46ProtocolException(message)
+        }
+    }
+
+    private fun hexToBytes(value: String): ByteArray {
+        if (!value.matches(Regex("[0-9a-f]{64}"))) {
+            throw Nip46ProtocolException(
+                "Invalid NIP-46 event ID"
+            )
+        }
+        return ByteArray(32) { index ->
+            value.substring(
+                index * 2,
+                index * 2 + 2
+            ).toInt(16).toByte()
+        }
+    }
+
+    private fun bytesToHex(value: ByteArray): String {
+        return value.joinToString("") { byte ->
+            "%02x".format(byte.toInt() and 0xff)
+        }
+    }
+
+    companion object {
+        private const val EVENT_KIND = 24133
+        private const val AUTH_URL_RESULT = "auth_url"
+    }
+}