pakstr 0.19.3 → 0.21.0

package/android-template/app/src/test/java/com/pakstr/app/signer/bunker/Nip46ProtocolTest.kt

@@ -0,0 +1,578 @@
+package com.pakstr.app.signer.bunker
+
+import com.pakstr.app.crypto.Bip340Hash
+import com.pakstr.app.crypto.Nip44Crypto
+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 org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+class Nip46ProtocolTest {
+    private lateinit var clientKey: Nip46ClientKey
+    private lateinit var signerKey: Nip46ClientKey
+    private lateinit var config: BunkerConfig
+    private lateinit var protocol: Nip46Protocol
+
+    @Before
+    fun setup() {
+        clientKey = Nip46ClientKey.fromPrivateKey(privateKey(1))
+        signerKey = Nip46ClientKey.fromPrivateKey(privateKey(2))
+        config =
+            BunkerConfig.parse(
+                "bunker://${signerKey.publicKeyHex}" +
+                        "?relay=wss://relay.example" +
+                        "&secret=$PAIRING_SECRET"
+            )
+        protocol =
+            Nip46Protocol(
+                clientKey,
+                config,
+                Nip46RequestIdGenerator { REQUEST_ID },
+                clockSeconds = { CREATED_AT }
+            )
+    }
+
+    @After
+    fun teardown() {
+        clientKey.close()
+        signerKey.close()
+    }
+
+    @Test
+    fun connect_request_builds_signed_encrypted_kind_24133_event() {
+        val outbound =
+            protocol.prepareConnect(
+                clientMetadataJson =
+                    JSONObject()
+                        .put("name", "Pakstr")
+                        .toString()
+            )
+        val event = JSONObject(outbound.eventJson)
+
+        assertEquals(24133, event.getInt("kind"))
+        assertEquals(clientKey.publicKeyHex, event.getString("pubkey"))
+        assertEquals(CREATED_AT, event.getLong("created_at"))
+        assertEquals(
+            signerKey.publicKeyHex,
+            event.getJSONArray("tags")
+                .getJSONArray(0)
+                .getString(1)
+        )
+        assertTrue(NostrEventVerifier.verify(event))
+        assertFalse(outbound.eventJson.contains(PAIRING_SECRET))
+
+        val request =
+            decryptRequest(
+                event.getString("content")
+            )
+        assertEquals(Nip46Method.CONNECT, request.method)
+        assertEquals(signerKey.publicKeyHex, request.params[0])
+        assertEquals(PAIRING_SECRET, request.params[1])
+        assertEquals("", request.params[2])
+        assertEquals(4, request.params.size)
+    }
+
+    @Test
+    fun disconnect_request_builds_signed_encrypted_event() {
+        val outbound = protocol.prepareDisconnect()
+        val event = JSONObject(outbound.eventJson)
+        val request = decryptRequest(event.getString("content"))
+
+        assertEquals(24133, event.getInt("kind"))
+        assertTrue(NostrEventVerifier.verify(event))
+        assertEquals(Nip46Method.DISCONNECT, request.method)
+        assertTrue(request.params.isEmpty())
+    }
+
+    @Test
+    fun connect_accepts_ack_or_matching_pairing_secret() {
+        listOf("ack", PAIRING_SECRET).forEach { result ->
+            val outbound = protocol.prepareConnect()
+            val outcome =
+                protocol.correlateResponse(
+                    protocol.decodeResponseEvent(
+                        createResponseEvent(
+                            REQUEST_ID,
+                            result = result
+                        )
+                    ),
+                    outbound.context
+                )
+            assertEquals(
+                result,
+                (outcome as Nip46ResponseOutcome.Success).result
+            )
+        }
+    }
+
+    @Test
+    fun connect_rejects_wrong_pairing_secret() {
+        val outbound = protocol.prepareConnect()
+        assertThrows(Nip46ProtocolException::class.java) {
+            protocol.correlateResponse(
+                protocol.decodeResponseEvent(
+                    createResponseEvent(
+                        REQUEST_ID,
+                        result = "wrong-pairing-secret"
+                    )
+                ),
+                outbound.context
+            )
+        }
+    }
+
+    @Test
+    fun sign_event_uses_exact_unsigned_fields_and_rejects_signer_fields() {
+        val unsigned =
+            JSONObject()
+                .put("kind", 1)
+                .put("created_at", CREATED_AT)
+                .put("tags", JSONArray().put(JSONArray().put("t").put("test")))
+                .put("content", "private event content")
+        val outbound = protocol.prepareSignEvent(
+            unsigned.toString(),
+            signerKey.publicKeyHex
+        )
+        val request =
+            decryptRequest(
+                JSONObject(outbound.eventJson)
+                    .getString("content")
+            )
+        val parameter = JSONObject(request.params.single())
+
+        assertEquals(4, parameter.length())
+        assertFalse(parameter.has("id"))
+        assertFalse(parameter.has("pubkey"))
+        assertFalse(parameter.has("sig"))
+
+        assertThrows(Nip46ProtocolException::class.java) {
+            protocol.prepareSignEvent(
+                JSONObject(unsigned.toString())
+                    .put("pubkey", signerKey.publicKeyHex)
+                    .toString(),
+                signerKey.publicKeyHex
+            )
+        }
+    }
+
+    @Test
+    fun verified_response_is_decrypted_and_correlated() {
+        val outbound = protocol.prepareGetPublicKey()
+        val responseEvent =
+            createResponseEvent(
+                REQUEST_ID,
+                result = signerKey.publicKeyHex
+            )
+
+        val verified =
+            protocol.decodeResponseEvent(responseEvent)
+        val outcome =
+            protocol.correlateResponse(
+                verified,
+                outbound.context
+            )
+
+        assertEquals(
+            signerKey.publicKeyHex,
+            (outcome as Nip46ResponseOutcome.Success).result
+        )
+        assertThrows(Nip46ProtocolException::class.java) {
+            protocol.correlateResponse(
+                verified,
+                outbound.context
+            )
+        }
+    }
+
+    @Test
+    fun auth_url_requires_absolute_https_and_allows_followup_response() {
+        val outbound = protocol.prepareGetPublicKey()
+        val authUrl = "https://signer.example/approve/request"
+        val verified =
+            protocol.decodeResponseEvent(
+                createResponseEvent(
+                    REQUEST_ID,
+                    result = "auth_url",
+                    error = authUrl
+                )
+            )
+
+        val outcome =
+            protocol.correlateResponse(
+                verified,
+                outbound.context
+            )
+
+        assertEquals(
+            authUrl,
+            (outcome as Nip46ResponseOutcome.AuthChallenge).url
+        )
+
+        val success =
+            protocol.correlateResponse(
+                protocol.decodeResponseEvent(
+                    createResponseEvent(
+                        REQUEST_ID,
+                        result = signerKey.publicKeyHex
+                    )
+                ),
+                outbound.context
+            )
+        assertTrue(success is Nip46ResponseOutcome.Success)
+    }
+
+    @Test
+    fun non_https_auth_urls_are_rejected() {
+        listOf(
+            "http://signer.example/approve",
+            "nostr-auth://approve/request",
+            "javascript:alert(1)",
+            "/relative/approve",
+            "https://user@signer.example/approve",
+            "https://signer.example/approve#fragment"
+        ).forEach { authUrl ->
+            val outbound = protocol.prepareGetPublicKey()
+            val verified =
+                protocol.decodeResponseEvent(
+                    createResponseEvent(
+                        REQUEST_ID,
+                        result = "auth_url",
+                        error = authUrl
+                    )
+                )
+            assertThrows(Nip46ProtocolException::class.java) {
+                protocol.correlateResponse(
+                    verified,
+                    outbound.context
+                )
+            }
+        }
+    }
+
+    @Test
+    fun invalid_author_recipient_signature_payload_and_id_are_rejected() {
+        val outbound = protocol.prepareGetPublicKey()
+        val valid = JSONObject(
+            createResponseEvent(
+                REQUEST_ID,
+                result = signerKey.publicKeyHex
+            )
+        )
+
+        val wrongAuthor = JSONObject(valid.toString())
+            .put("pubkey", clientKey.publicKeyHex)
+        assertProtocolFailureDoesNotExpose(
+            wrongAuthor.toString(),
+            signerKey.publicKeyHex
+        )
+
+        val wrongRecipient =
+            resignResponse(
+                JSONObject(valid.toString())
+                    .put(
+                        "tags",
+                        JSONArray()
+                            .put(
+                                JSONArray()
+                                    .put("p")
+                                    .put(signerKey.publicKeyHex)
+                            )
+                    )
+            )
+        assertProtocolFailureDoesNotExpose(
+            wrongRecipient,
+            signerKey.publicKeyHex
+        )
+
+        val badSignature = JSONObject(valid.toString())
+            .put("sig", "0".repeat(128))
+        assertProtocolFailureDoesNotExpose(
+            badSignature.toString(),
+            PAIRING_SECRET
+        )
+
+        val tamperedPayload = JSONObject(valid.toString())
+            .put("content", valid.getString("content") + "A")
+        assertProtocolFailureDoesNotExpose(
+            tamperedPayload.toString(),
+            PAIRING_SECRET
+        )
+
+        val mismatched =
+            protocol.decodeResponseEvent(
+                createResponseEvent(
+                    "b".repeat(64),
+                    result = signerKey.publicKeyHex
+                )
+            )
+        val error =
+            assertThrows(Nip46ProtocolException::class.java) {
+                protocol.correlateResponse(
+                    mismatched,
+                    outbound.context
+                )
+            }
+        assertFalse(error.message.orEmpty().contains(REQUEST_ID))
+    }
+
+    @Test
+    fun response_requires_kind_and_exactly_one_client_recipient_tag() {
+        val valid = JSONObject(
+            createResponseEvent(
+                REQUEST_ID,
+                result = signerKey.publicKeyHex
+            )
+        )
+        val invalidEvents =
+            listOf(
+                JSONObject(valid.toString()).put("kind", 24132),
+                JSONObject(valid.toString()).put("tags", JSONArray()),
+                JSONObject(valid.toString())
+                    .put(
+                        "tags",
+                        JSONArray()
+                            .put(JSONArray().put("p").put(clientKey.publicKeyHex))
+                            .put(JSONArray().put("p").put(clientKey.publicKeyHex))
+                    )
+            )
+
+        invalidEvents.forEach { event ->
+            assertThrows(Nip46ProtocolException::class.java) {
+                protocol.decodeResponseEvent(resignResponse(event))
+            }
+        }
+    }
+
+    @Test
+    fun nip44_authenticated_payload_and_result_boundaries_are_enforced() {
+        val outbound = protocol.prepareNip44Encrypt(
+            signerKey.publicKeyHex,
+            "message"
+        )
+        val tampered = JSONObject(
+            createResponseEvent(
+                REQUEST_ID,
+                result = "ciphertext"
+            )
+        )
+        val content = tampered.getString("content")
+        tampered.put(
+            "content",
+            content.dropLast(1) + if (content.last() == 'A') "B" else "A"
+        )
+
+        assertThrows(Nip46ProtocolException::class.java) {
+            protocol.decodeResponseEvent(resignResponse(tampered))
+        }
+
+        assertThrows(Nip46ProtocolException::class.java) {
+            protocol.correlateResponse(
+                protocol.decodeResponseEvent(
+                    createResponseEvent(REQUEST_ID, result = "")
+                ),
+                outbound.context
+            )
+        }
+
+        val decryptOutbound = protocol.prepareNip44Decrypt(
+            signerKey.publicKeyHex,
+            "ciphertext"
+        )
+        val emptyPlaintext = protocol.correlateResponse(
+            protocol.decodeResponseEvent(
+                createResponseEvent(REQUEST_ID, result = "")
+            ),
+            decryptOutbound.context
+        )
+        assertEquals(
+            "",
+            (emptyPlaintext as Nip46ResponseOutcome.Success).result
+        )
+    }
+
+    @Test
+    fun sign_event_rejects_out_of_range_kinds_and_wrong_user_key() {
+        listOf(-1L, 65536L, 4_294_967_297L).forEach { kind ->
+            assertThrows(Nip46ProtocolException::class.java) {
+                protocol.prepareSignEvent(
+                    JSONObject()
+                        .put("kind", kind)
+                        .put("created_at", CREATED_AT)
+                        .put("tags", JSONArray())
+                        .put("content", "content")
+                        .toString(),
+                    signerKey.publicKeyHex
+                )
+            }
+        }
+
+        val unsigned =
+            JSONObject()
+                .put("kind", 1)
+                .put("created_at", CREATED_AT)
+                .put("tags", JSONArray())
+                .put("content", "expected")
+        val outbound = protocol.prepareSignEvent(
+            unsigned.toString(),
+            clientKey.publicKeyHex
+        )
+        val signedByWrongKey = signUserEvent(unsigned)
+
+        assertThrows(Nip46ProtocolException::class.java) {
+            protocol.correlateResponse(
+                protocol.decodeResponseEvent(
+                    createResponseEvent(
+                        REQUEST_ID,
+                        result = signedByWrongKey
+                    )
+                ),
+                outbound.context
+            )
+        }
+    }
+
+    @Test
+    fun signed_event_response_must_match_requested_unsigned_fields() {
+        val unsigned =
+            JSONObject()
+                .put("kind", 1)
+                .put("created_at", CREATED_AT)
+                .put("tags", JSONArray())
+                .put("content", "expected")
+        val outbound = protocol.prepareSignEvent(
+            unsigned.toString(),
+            signerKey.publicKeyHex
+        )
+        val signed = signUserEvent(unsigned)
+
+        val success =
+            protocol.correlateResponse(
+                protocol.decodeResponseEvent(
+                    createResponseEvent(
+                        REQUEST_ID,
+                        result = signed
+                    )
+                ),
+                outbound.context
+            )
+        assertTrue(success is Nip46ResponseOutcome.Success)
+
+        val changed =
+            signUserEvent(
+                JSONObject(unsigned.toString())
+                    .put("content", "changed")
+            )
+        assertThrows(Nip46ProtocolException::class.java) {
+            protocol.correlateResponse(
+                protocol.decodeResponseEvent(
+                    createResponseEvent(
+                        REQUEST_ID,
+                        result = changed
+                    )
+                ),
+                outbound.context
+            )
+        }
+    }
+
+    private fun decryptRequest(payload: String): Nip46Request {
+        return Nip46Request.parse(
+            signerKey.decryptNip44(
+                payload,
+                clientKey.publicKeyHex
+            )
+        )
+    }
+
+    private fun createResponseEvent(
+        id: String,
+        result: String? = null,
+        error: String? = null
+    ): String {
+        val response =
+            JSONObject()
+                .put("id", id)
+        result?.let { response.put("result", it) }
+        error?.let { response.put("error", it) }
+
+        val encrypted =
+            signerKey.encryptNip44(
+                response.toString(),
+                clientKey.publicKeyHex
+            )
+        val event =
+            JSONObject()
+                .put("pubkey", signerKey.publicKeyHex)
+                .put("created_at", CREATED_AT)
+                .put("kind", 24133)
+                .put(
+                    "tags",
+                    JSONArray()
+                        .put(
+                            JSONArray()
+                                .put("p")
+                                .put(clientKey.publicKeyHex)
+                        )
+                )
+                .put("content", encrypted)
+
+        return resignResponse(event)
+    }
+
+    private fun resignResponse(event: JSONObject): String {
+        NostrEventBuilder.addId(event)
+        val id = Bip340Hash.hexToBytes(event.getString("id"))
+        val signature = signerKey.sign(id)
+        event.put("sig", Bip340Hash.bytesToHex(signature))
+        return event.toString()
+    }
+
+    private fun signUserEvent(unsigned: JSONObject): String {
+        val event =
+            JSONObject(unsigned.toString())
+                .put("pubkey", signerKey.publicKeyHex)
+        NostrEventBuilder.addId(event)
+        val signature =
+            signerKey.sign(
+                Bip340Hash.hexToBytes(
+                    event.getString("id")
+                )
+            )
+        event.put("sig", Bip340Hash.bytesToHex(signature))
+        return event.toString()
+    }
+
+    private fun assertProtocolFailureDoesNotExpose(
+        event: String,
+        sensitiveValue: String
+    ) {
+        val error =
+            assertThrows(Nip46ProtocolException::class.java) {
+                protocol.decodeResponseEvent(event)
+            }
+        assertFalse(
+            error.message.orEmpty().contains(sensitiveValue)
+        )
+    }
+
+    private fun privateKey(value: Int): ByteArray {
+        return ByteArray(32).also {
+            it[31] = value.toByte()
+        }
+    }
+
+    companion object {
+        private const val REQUEST_ID =
+            "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+        private const val CREATED_AT = 1_700_000_000L
+        private const val PAIRING_SECRET = "temporary-pairing-secret"
+    }
+}