pakstr 0.20.0 → 0.21.0

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

@@ -0,0 +1,144 @@
+package com.pakstr.app.signer.bunker
+
+import android.content.Context
+import android.util.Base64
+import androidx.security.crypto.EncryptedSharedPreferences
+import androidx.security.crypto.MasterKey
+import com.pakstr.app.crypto.Bip340Verifier
+import com.pakstr.app.crypto.Nip46ClientKey
+
+internal data class BunkerConnection(
+    val config: BunkerConfig,
+    val clientKey: Nip46ClientKey,
+    val userPubkey: String?,
+    val connected: Boolean
+)
+
+internal class BunkerConnectionStore(
+    context: Context
+) {
+    private val preferences =
+        EncryptedSharedPreferences.create(
+            context.applicationContext,
+            PREFERENCES_NAME,
+            MasterKey.Builder(context.applicationContext)
+                .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+                .build(),
+            EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+            EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+        )
+
+    fun savePending(
+        config: BunkerConfig,
+        clientKey: Nip46ClientKey
+    ) {
+        saveConnection(config, clientKey, null, false)
+    }
+
+    fun save(
+        config: BunkerConfig,
+        clientKey: Nip46ClientKey,
+        userPubkey: String?,
+        connected: Boolean = true
+    ) {
+        saveConnection(
+            config.withoutPairingSecret(),
+            clientKey,
+            userPubkey,
+            connected
+        )
+    }
+
+    private fun saveConnection(
+        config: BunkerConfig,
+        clientKey: Nip46ClientKey,
+        userPubkey: String?,
+        connected: Boolean
+    ) {
+        userPubkey?.let(::validateUserPubkey)
+        clientKey.withPrivateKey { privateKey ->
+            val encodedKey =
+                Base64.encodeToString(
+                    privateKey,
+                    Base64.NO_WRAP
+                )
+            val saved =
+                preferences.edit()
+                    .putString(KEY_CONFIG, config.encode())
+                    .putString(KEY_CLIENT_KEY, encodedKey)
+                    .putBoolean(KEY_CONNECTED, connected)
+                    .apply {
+                        if (userPubkey == null) {
+                            remove(KEY_USER_PUBKEY)
+                        } else {
+                            putString(KEY_USER_PUBKEY, userPubkey)
+                        }
+                    }
+                    .commit()
+            check(saved) {
+                "Unable to store bunker connection"
+            }
+        }
+    }
+
+    fun restore(): BunkerConnection? {
+        val encodedConfig = preferences.getString(KEY_CONFIG, null)
+        val encodedKey = preferences.getString(KEY_CLIENT_KEY, null)
+        if (encodedConfig == null && encodedKey == null) {
+            return null
+        }
+        if (encodedConfig == null || encodedKey == null) {
+            clear()
+            return null
+        }
+
+        val privateKey =
+            try {
+                Base64.decode(encodedKey, Base64.NO_WRAP)
+            } catch (_: Exception) {
+                clear()
+                return null
+            }
+        return try {
+            val config = BunkerConfig.parse(encodedConfig)
+            val userPubkey = preferences.getString(KEY_USER_PUBKEY, null)
+            userPubkey?.let(::validateUserPubkey)
+            BunkerConnection(
+                config,
+                Nip46ClientKey.fromPrivateKey(privateKey),
+                userPubkey,
+                preferences.getBoolean(KEY_CONNECTED, false)
+            )
+        } catch (_: Exception) {
+            clear()
+            null
+        } finally {
+            privateKey.fill(0)
+        }
+    }
+
+    fun clear() {
+        if (!preferences.edit().clear().commit()) {
+            throw IllegalStateException(
+                "Unable to clear bunker connection"
+            )
+        }
+    }
+
+    private fun validateUserPubkey(value: String) {
+        require(
+            value.matches(Regex("[0-9a-f]{64}")) &&
+                    Bip340Verifier.isValidXOnlyPubkey(value)
+        ) {
+            "Invalid user public key"
+        }
+    }
+
+    private companion object {
+        const val PREFERENCES_NAME = "bunker_connection"
+        const val KEY_CONFIG = "config"
+        const val KEY_CLIENT_KEY = "client_key"
+        const val KEY_USER_PUBKEY = "user_pubkey"
+        const val KEY_CONNECTED = "connected"
+    }
+}

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

@@ -0,0 +1,79 @@
+package com.pakstr.app.signer.bunker
+
+import com.pakstr.app.signer.exceptions.SignerUnavailableException
+
+interface Nip46Client {
+    suspend fun getPublicKey(): String
+
+    suspend fun signEvent(eventJson: String): String
+
+    suspend fun nip04Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String
+
+    suspend fun nip04Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String
+
+    suspend fun nip44Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String
+
+    suspend fun nip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String
+
+    fun disconnect() = Unit
+
+    fun close()
+}
+
+internal object UnavailableNip46Client : Nip46Client {
+    override suspend fun getPublicKey(): String {
+        throw unavailable()
+    }
+
+    override suspend fun signEvent(eventJson: String): String {
+        throw unavailable()
+    }
+
+    override suspend fun nip04Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        throw unavailable()
+    }
+
+    override suspend fun nip04Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        throw unavailable()
+    }
+
+    override suspend fun nip44Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        throw unavailable()
+    }
+
+    override suspend fun nip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        throw unavailable()
+    }
+
+    override fun close() = Unit
+
+    private fun unavailable(): SignerUnavailableException {
+        return SignerUnavailableException(
+            "Bunker signer is not connected"
+        )
+    }
+}

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

@@ -0,0 +1,319 @@
+package com.pakstr.app.signer.bunker
+
+import org.json.JSONArray
+import org.json.JSONObject
+import java.security.SecureRandom
+import java.util.Arrays
+
+internal enum class Nip46Method(
+    val wireName: String
+) {
+    CONNECT("connect"),
+    DISCONNECT("disconnect"),
+    GET_PUBLIC_KEY("get_public_key"),
+    SIGN_EVENT("sign_event"),
+    NIP04_ENCRYPT("nip04_encrypt"),
+    NIP04_DECRYPT("nip04_decrypt"),
+    NIP44_ENCRYPT("nip44_encrypt"),
+    NIP44_DECRYPT("nip44_decrypt");
+
+    companion object {
+        fun fromWireName(value: String): Nip46Method {
+            return entries.firstOrNull { it.wireName == value }
+                ?: throw Nip46ProtocolException(
+                    "Unknown NIP-46 method"
+                )
+        }
+    }
+}
+
+internal class Nip46Request(
+    val id: String,
+    val method: Nip46Method,
+    params: List<String>
+) {
+    val params: List<String> = params.toList()
+
+    fun toJson(): String {
+        validateNip46RequestId(id)
+
+        return JSONObject()
+            .put("id", id)
+            .put("method", method.wireName)
+            .put("params", JSONArray(params))
+            .toString()
+    }
+
+    override fun toString(): String {
+        return "Nip46Request(" +
+                "id=${id.take(12)}..., " +
+                "method=${method.wireName}, " +
+                "paramCount=${params.size}" +
+                ")"
+    }
+
+    companion object {
+        fun parse(value: String): Nip46Request {
+            val json = parseJsonObject(value)
+            requireExactString(json, "id")
+            requireExactString(json, "method")
+            val params = requireArray(json, "params")
+            val parsedParams =
+                (0 until params.length()).map { index ->
+                    val parameter = params.get(index)
+                    if (parameter !is String) {
+                        throw Nip46ProtocolException(
+                            "Invalid NIP-46 request"
+                        )
+                    }
+                    parameter
+                }
+
+            return Nip46Request(
+                id = json.getString("id")
+                    .also(::validateNip46RequestId),
+                method = Nip46Method.fromWireName(
+                    json.getString("method")
+                ),
+                params = parsedParams
+            )
+        }
+    }
+}
+
+internal class Nip46Response(
+    val id: String,
+    val result: String?,
+    val error: String?
+) {
+    override fun toString(): String {
+        return "Nip46Response(" +
+                "id=${id.take(12)}..., " +
+                "hasResult=${result != null}, " +
+                "hasError=${error != null}" +
+                ")"
+    }
+
+    companion object {
+        fun parse(value: String): Nip46Response {
+            val json = parseJsonObject(value)
+            val id = requireExactString(json, "id")
+                .also(::validateNip46RequestId)
+            val result = optionalString(json, "result")
+            val error = optionalString(json, "error")
+
+            if (error == null && result == null) {
+                throw Nip46ProtocolException(
+                    "Invalid NIP-46 response"
+                )
+            }
+            if (error != null && error.isEmpty()) {
+                throw Nip46ProtocolException(
+                    "Invalid NIP-46 response"
+                )
+            }
+
+            return Nip46Response(id, result, error)
+        }
+    }
+}
+
+internal fun interface Nip46RequestIdGenerator {
+    fun nextId(): String
+}
+
+internal object SecureNip46RequestIdGenerator : Nip46RequestIdGenerator {
+    private val secureRandom = SecureRandom()
+
+    override fun nextId(): String {
+        val bytes = ByteArray(32)
+        secureRandom.nextBytes(bytes)
+
+        return try {
+            bytes.joinToString("") { byte ->
+                "%02x".format(byte.toInt() and 0xff)
+            }
+        } finally {
+            Arrays.fill(bytes, 0)
+        }
+    }
+}
+
+internal class Nip46RequestContext(
+    val id: String,
+    val method: Nip46Method,
+    val expectedUserPubkey: String? = null,
+    val expectedConnectResult: String? = null,
+    unsignedEventFingerprint: ByteArray? = null
+) : AutoCloseable {
+    private var fingerprint =
+        unsignedEventFingerprint?.copyOf()
+    private var state = RequestState.PENDING
+
+    @Synchronized
+    internal fun beginResponse(
+        authChallenge: Boolean
+    ) {
+        when (state) {
+            RequestState.COMPLETED ->
+                throw Nip46ProtocolException(
+                    "NIP-46 request is already completed"
+                )
+            RequestState.PENDING,
+            RequestState.AUTH_CHALLENGED -> {
+                state =
+                    if (authChallenge) {
+                        RequestState.AUTH_CHALLENGED
+                    } else {
+                        RequestState.COMPLETED
+                    }
+            }
+        }
+    }
+
+    internal fun matchesUnsignedEvent(
+        candidate: ByteArray
+    ): Boolean {
+        val expected = fingerprint ?: return false
+        return java.security.MessageDigest.isEqual(
+            expected,
+            candidate
+        )
+    }
+
+    override fun close() {
+        fingerprint?.let { Arrays.fill(it, 0) }
+        fingerprint = null
+    }
+
+    override fun toString(): String {
+        return "Nip46RequestContext(" +
+                "id=${id.take(12)}..., " +
+                "method=${method.wireName}" +
+                ")"
+    }
+
+    private enum class RequestState {
+        PENDING,
+        AUTH_CHALLENGED,
+        COMPLETED
+    }
+}
+
+internal class Nip46OutboundRequest(
+    val eventJson: String,
+    val context: Nip46RequestContext
+) {
+    override fun toString(): String {
+        return "Nip46OutboundRequest(" +
+                "context=$context" +
+                ")"
+    }
+}
+
+internal class Nip46VerifiedResponse(
+    val response: Nip46Response
+) {
+    override fun toString(): String {
+        return "Nip46VerifiedResponse(response=$response)"
+    }
+}
+
+internal sealed interface Nip46ResponseOutcome {
+    class Success(
+        val result: String
+    ) : Nip46ResponseOutcome {
+        override fun toString(): String =
+            "Nip46ResponseOutcome.Success"
+    }
+
+    class RemoteError : Nip46ResponseOutcome {
+        override fun toString(): String =
+            "Nip46ResponseOutcome.RemoteError"
+    }
+
+    class AuthChallenge(
+        val url: String
+    ) : Nip46ResponseOutcome {
+        override fun toString(): String =
+            "Nip46ResponseOutcome.AuthChallenge"
+    }
+}
+
+internal class Nip46ProtocolLimits(
+    val maximumEventBytes: Int = 512 * 1024,
+    val maximumEncryptedContentLength: Int = 384 * 1024,
+    val maximumPayloadBytes: Int = 256 * 1024,
+    val maximumAuthUrlLength: Int = 4 * 1024
+)
+
+internal class Nip46ProtocolException(
+    message: String
+) : Exception(message)
+
+internal fun validateNip46RequestId(value: String) {
+    if (!value.matches(Regex("[0-9a-f]{64}"))) {
+        throw Nip46ProtocolException(
+            "Invalid NIP-46 request ID"
+        )
+    }
+}
+
+private fun parseJsonObject(value: String): JSONObject {
+    return try {
+        JSONObject(value)
+    } catch (_: Exception) {
+        throw Nip46ProtocolException(
+            "Invalid NIP-46 JSON"
+        )
+    }
+}
+
+private fun requireExactString(
+    json: JSONObject,
+    key: String
+): String {
+    if (!json.has(key) || json.isNull(key)) {
+        throw Nip46ProtocolException(
+            "Invalid NIP-46 JSON"
+        )
+    }
+    val value = json.get(key)
+    if (value !is String) {
+        throw Nip46ProtocolException(
+            "Invalid NIP-46 JSON"
+        )
+    }
+    return value
+}
+
+private fun optionalString(
+    json: JSONObject,
+    key: String
+): String? {
+    if (!json.has(key) || json.isNull(key)) {
+        return null
+    }
+    val value = json.get(key)
+    if (value !is String) {
+        throw Nip46ProtocolException(
+            "Invalid NIP-46 JSON"
+        )
+    }
+    return value
+}
+
+private fun requireArray(
+    json: JSONObject,
+    key: String
+): JSONArray {
+    if (!json.has(key) || json.isNull(key)) {
+        throw Nip46ProtocolException(
+            "Invalid NIP-46 JSON"
+        )
+    }
+    return json.optJSONArray(key)
+        ?: throw Nip46ProtocolException(
+            "Invalid NIP-46 JSON"
+        )
+}

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

@@ -0,0 +1,159 @@
+package com.pakstr.app.signer.bunker
+
+import android.content.Context
+import com.pakstr.app.crypto.Nip46ClientKey
+import com.pakstr.app.crypto.NostrEventVerifier
+import com.pakstr.app.debug.AppDebugLogger
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONArray
+import org.json.JSONObject
+import java.security.SecureRandom
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+
+internal class Nip46PairingClient(
+    private val relayUrls: List<String>,
+    private val clientKey: Nip46ClientKey,
+    private val pairingSecret: String,
+    connectionFactory: Nip46RelayConnectionFactory,
+    diagnosticLogger: (String) -> Unit = {}
+) : AutoCloseable {
+    constructor(
+        context: Context,
+        relayUrls: List<String>,
+        clientKey: Nip46ClientKey,
+        pairingSecret: String
+    ) : this(
+        relayUrls,
+        clientKey,
+        pairingSecret,
+        OkHttpNip46RelayConnectionFactory { message ->
+            AppDebugLogger.log(context, DIAGNOSTIC_TAG, message)
+        },
+        { message -> AppDebugLogger.log(context, DIAGNOSTIC_TAG, message) }
+    )
+    private val transport =
+        Nip46RelayTransport(
+            relayUrls = relayUrls,
+            remoteSignerPubkey = null,
+            clientPubkey = clientKey.publicKeyHex,
+            connectionFactory = connectionFactory,
+            diagnosticLogger = diagnosticLogger
+        )
+    private val completed = CountDownLatch(1)
+    private val lock = Any()
+    private var remoteSignerPubkey: String? = null
+    private val closed = AtomicBoolean(false)
+
+    init {
+        transport.start(::receiveEvent)
+    }
+
+    suspend fun awaitRelayReady(
+        timeoutMillis: Long = DEFAULT_RELAY_READY_TIMEOUT_MILLIS
+    ): Boolean = transport.awaitReady(timeoutMillis)
+
+    suspend fun awaitConnection(
+        timeoutMillis: Long = DEFAULT_TIMEOUT_MILLIS
+    ): BunkerConfig? = withContext(Dispatchers.IO) {
+        completed.await(timeoutMillis, TimeUnit.MILLISECONDS)
+        val remote = synchronized(lock) { remoteSignerPubkey }
+            ?: return@withContext null
+        val query =
+            relayUrls.joinToString("&") { relay ->
+                "relay=" + java.net.URLEncoder.encode(
+                    relay,
+                    Charsets.UTF_8.name()
+                )
+            }
+        BunkerConfig.parse("bunker://$remote?$query")
+    }
+
+    override fun close() {
+        if (closed.compareAndSet(false, true)) {
+            completed.countDown()
+            transport.close()
+        }
+    }
+
+    private fun receiveEvent(eventJson: String) {
+        val event =
+            try {
+                JSONObject(eventJson)
+            } catch (_: Exception) {
+                return
+            }
+        val author = event.optString("pubkey")
+        if (!author.matches(Regex("[0-9a-f]{64}"))) {
+            return
+        }
+        if (
+            event.optInt("kind", -1) != EVENT_KIND ||
+            !hasRecipient(event.optJSONArray("tags")) ||
+            !NostrEventVerifier.verify(event)
+        ) {
+            return
+        }
+        val response =
+            try {
+                val decrypted =
+                    clientKey.decryptNip44(
+                        event.getString("content"),
+                        author
+                    )
+                JSONObject(decrypted)
+            } catch (_: Exception) {
+                return
+            }
+        val result = response.opt("result")
+        val error = response.opt("error")
+        if (
+            result !is String ||
+            result != pairingSecret ||
+            (error != null && error != JSONObject.NULL)
+        ) {
+            return
+        }
+        synchronized(lock) {
+            if (remoteSignerPubkey == null) {
+                remoteSignerPubkey = author
+                completed.countDown()
+            }
+        }
+    }
+
+    private fun hasRecipient(tags: JSONArray?): Boolean {
+        if (tags == null) {
+            return false
+        }
+        return (0 until tags.length()).any { index ->
+            val tag = tags.optJSONArray(index)
+            tag != null &&
+                    tag.length() >= 2 &&
+                    tag.optString(0) == "p" &&
+                    tag.optString(1) == clientKey.publicKeyHex
+        }
+    }
+
+    companion object {
+        private const val DIAGNOSTIC_TAG = "NIP46"
+        private const val EVENT_KIND = 24133
+        private const val DEFAULT_RELAY_READY_TIMEOUT_MILLIS = 30_000L
+        private const val DEFAULT_TIMEOUT_MILLIS = 300_000L
+        private val secureRandom = SecureRandom()
+
+        fun generateSecret(): String {
+            val bytes = ByteArray(32)
+            secureRandom.nextBytes(bytes)
+            return try {
+                bytes.joinToString("") { byte ->
+                    "%02x".format(byte.toInt() and 0xff)
+                }
+            } finally {
+                bytes.fill(0)
+            }
+        }
+    }
+}