pakstr 0.27.0 → 0.29.0

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

@@ -0,0 +1,100 @@
+package com.pakstr.app.signer
+
+import com.pakstr.app.crypto.Bip340Hash
+import com.pakstr.app.crypto.Nip46ClientKey
+import com.pakstr.app.crypto.NostrEventVerifier
+import com.pakstr.app.signer.interfaces.NostrSigner
+import com.pakstr.app.signer.local.LocalAccountStore
+import org.json.JSONObject
+
+internal class LocalSigner(
+    private val keyLoader: () -> Nip46ClientKey
+) : NostrSigner {
+    constructor(store: LocalAccountStore) : this(
+        keyLoader = {
+            store.loadKey()
+                ?: throw IllegalStateException(
+                    "Local account has not been created"
+                )
+        }
+    )
+    override suspend fun getPublicKey(): String {
+        return requireKey().use { key ->
+            key.publicKeyHex
+        }
+    }
+
+    override suspend fun signEvent(eventJson: String): String {
+        return requireKey().use { key ->
+            val event = JSONObject(eventJson)
+            val publicKey = key.publicKeyHex
+            val suppliedPublicKey = event.optString("pubkey")
+            require(
+                suppliedPublicKey.isBlank() ||
+                        suppliedPublicKey == publicKey
+            ) {
+                "Event public key does not match local signer"
+            }
+            event.put("pubkey", publicKey)
+            NostrEventBuilder.addId(event)
+
+            val eventId =
+                Bip340Hash.hexToBytes(
+                    event.getString("id")
+                )
+            val signature = key.sign(eventId)
+            try {
+                event.put(
+                    "sig",
+                    Bip340Hash.bytesToHex(signature)
+                )
+            } finally {
+                eventId.fill(0)
+                signature.fill(0)
+            }
+
+            check(NostrEventVerifier.verify(event)) {
+                "Generated signature failed verification"
+            }
+            event.toString()
+        }
+    }
+
+    override suspend fun nip04Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        throw UnsupportedOperationException(
+            "NIP-04 is not supported by the local signer"
+        )
+    }
+
+    override suspend fun nip04Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        throw UnsupportedOperationException(
+            "NIP-04 is not supported by the local signer"
+        )
+    }
+
+    override suspend fun nip44Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        return requireKey().use { key ->
+            key.encryptNip44(plaintext, pubkey)
+        }
+    }
+
+    override suspend fun nip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        return requireKey().use { key ->
+            key.decryptNip44(ciphertext, pubkey)
+        }
+    }
+
+    private fun requireKey() = keyLoader()
+}

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

@@ -48,7 +48,7 @@ class NostrBridge(
                     try {
                         val pk =
                             signerManager
-                                .getSigner()
+                                .getConfiguredSigner()
                                 .getPublicKey()
                         resolve(
                             callbackId,
@@ -107,7 +107,7 @@ class NostrBridge(
 
                         val result =
                             signerManager
-                                .getSigner()
+                                .getConfiguredSigner()
                                 .signEvent(
                                     payload
                                 )
@@ -180,7 +180,7 @@ class NostrBridge(
 
                         val result =
                             signerManager
-                                .getSigner()
+                                .getConfiguredSigner()
                                 .nip04Encrypt(
                                     pubkey,
                                     plaintext
@@ -254,7 +254,7 @@ class NostrBridge(
 
                         val result =
                             signerManager
-                                .getSigner()
+                                .getConfiguredSigner()
                                 .nip04Decrypt(
                                     pubkey,
                                     ciphertext
@@ -318,7 +318,7 @@ class NostrBridge(
 
                         val result =
                             signerManager
-                                .getSigner()
+                                .getConfiguredSigner()
                                 .nip44Encrypt(
                                     json.getString("pubkey"),
                                     json.getString("plaintext")
@@ -373,7 +373,7 @@ class NostrBridge(
 
                         val result =
                             signerManager
-                                .getSigner()
+                                .getConfiguredSigner()
                                 .nip44Decrypt(
                                     json.getString("pubkey"),
                                     json.getString("ciphertext")

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

@@ -14,12 +14,17 @@ import com.pakstr.app.signer.bunker.Nip46PairingUri
 import com.pakstr.app.signer.bunker.RelayNip46Client
 import com.pakstr.app.signer.exceptions.SignerUnavailableException
 import com.pakstr.app.signer.interfaces.NostrSigner
+import com.pakstr.app.signer.local.LocalAccountAlreadyExistsException
+import com.pakstr.app.signer.local.LocalAccountImportCandidate
+import com.pakstr.app.signer.local.LocalAccountStore
+import kotlinx.coroutines.CompletableDeferred
 import org.json.JSONObject
 
 class SignerManager(
     context: Context,
     private val amberLauncher: ActivityResultLauncher<Intent>,
-    private val bunkerAuthChallengeHandler: ((String) -> Unit)? = null
+    private val bunkerAuthChallengeHandler: ((String) -> Unit)? = null,
+    private val signerPickerRequestHandler: (() -> Unit)? = null
 ) {
     private val context = context.applicationContext
     private val prefs =
@@ -30,10 +35,14 @@ class SignerManager(
     private val bunkerStore by lazy {
         BunkerConnectionStore(this.context)
     }
+    private val localAccountStore by lazy {
+        LocalAccountStore(this.context)
+    }
 
     private var activeSigner: NostrSigner? = null
     private var currentUserPubkey: String? = null
     private var pendingPairing: PendingPairing? = null
+    private var pendingSignerSelection: CompletableDeferred<Boolean>? = null
 
     init {
         AppDebugLogger.log(
@@ -44,7 +53,7 @@ class SignerManager(
     }
 
     fun getActiveType(): SignerType? {
-        val value = prefs.getString("type", SignerType.AMBER.name)
+        val value = prefs.getString(KEY_SIGNER_TYPE, SignerType.AMBER.name)
         return try {
             SignerType.valueOf(value.toString())
         } catch (_: IllegalArgumentException) {
@@ -52,6 +61,20 @@ class SignerManager(
         }
     }
 
+    fun isSignerConfigured(): Boolean =
+        prefs.getBoolean(KEY_SIGNER_CONFIGURED, false)
+
+    fun migrateLegacySignerConfiguration(setupCompleted: Boolean) {
+        if (prefs.contains(KEY_SIGNER_CONFIGURED)) {
+            return
+        }
+        if (setupCompleted || prefs.contains(KEY_SIGNER_TYPE)) {
+            prefs.edit {
+                putBoolean(KEY_SIGNER_CONFIGURED, true)
+            }
+        }
+    }
+
     fun hasBunkerSession(): Boolean {
         return try {
             val connection = bunkerStore.restore() ?: return false
@@ -169,6 +192,35 @@ class SignerManager(
         setActiveTypeWithoutClosing(type)
     }
 
+    fun createLocalAccount() {
+        localAccountStore.createAccount()
+        closeActiveSigner()
+        setActiveTypeWithoutClosing(SignerType.LOCAL)
+    }
+
+    fun hasLocalAccount(): Boolean = localAccountStore.hasAccount()
+
+    internal fun prepareLocalAccountImport(
+        nsec: String
+    ): LocalAccountImportCandidate {
+        if (localAccountStore.hasAccount()) {
+            throw LocalAccountAlreadyExistsException()
+        }
+        return LocalAccountImportCandidate.parse(nsec)
+    }
+
+    internal fun importLocalAccount(
+        candidate: LocalAccountImportCandidate
+    ) {
+        try {
+            candidate.withPrivateKey(localAccountStore::importAccount)
+            closeActiveSigner()
+            setActiveTypeWithoutClosing(SignerType.LOCAL)
+        } finally {
+            candidate.close()
+        }
+    }
+
     fun logoutBunker() {
         try {
             (activeSigner as? BunkerSigner)?.disconnect()
@@ -182,6 +234,56 @@ class SignerManager(
         }
     }
 
+    suspend fun getConfiguredSigner(): NostrSigner {
+        if (isSignerConfigured()) {
+            return getSigner()
+        }
+
+        var shouldRequestPicker = false
+        val selection =
+            synchronized(this) {
+                if (isSignerConfigured()) {
+                    null
+                } else {
+                    pendingSignerSelection
+                        ?: CompletableDeferred<Boolean>().also {
+                            pendingSignerSelection = it
+                            shouldRequestPicker = true
+                        }
+                }
+            }
+
+        if (selection == null) {
+            return getSigner()
+        }
+        if (shouldRequestPicker) {
+            val handler = signerPickerRequestHandler
+            if (handler == null) {
+                cancelSignerSelection()
+            } else {
+                try {
+                    handler()
+                } catch (_: Exception) {
+                    cancelSignerSelection()
+                }
+            }
+        }
+        if (!selection.await()) {
+            throw SignerUnavailableException("Signer selection was dismissed")
+        }
+        return getSigner()
+    }
+
+    fun cancelSignerSelection() {
+        val selection =
+            synchronized(this) {
+                pendingSignerSelection.also {
+                    pendingSignerSelection = null
+                }
+            }
+        selection?.complete(false)
+    }
+
     fun getSigner(): NostrSigner {
         activeSigner?.let { return it }
         val activeType = getActiveType()
@@ -195,6 +297,7 @@ class SignerManager(
             when (activeType) {
                 SignerType.AMBER -> createAmberSigner()
                 SignerType.BUNKER -> createBunkerSigner()
+                SignerType.LOCAL -> createLocalSigner()
                 SignerType.FAKE -> FakeSigner()
                 null -> throw IllegalStateException("No signer selected")
             }
@@ -204,6 +307,7 @@ class SignerManager(
 
     fun close() {
         cancelBunkerPairing()
+        cancelSignerSelection()
         closeActiveSigner()
     }
 
@@ -289,10 +393,36 @@ class SignerManager(
         return BunkerSigner(context, client)
     }
 
+    private fun createLocalSigner(): LocalSigner {
+        try {
+            localAccountStore.loadKey()?.use { key ->
+                currentUserPubkey = key.publicKeyHex
+            } ?: throw SignerUnavailableException(
+                "Local account has not been created"
+            )
+        } catch (error: SignerUnavailableException) {
+            throw error
+        } catch (error: Exception) {
+            throw IllegalStateException(
+                "Unable to restore local account",
+                error
+            )
+        }
+        return LocalSigner(localAccountStore)
+    }
+
     private fun setActiveTypeWithoutClosing(type: SignerType) {
         prefs.edit {
-            putString("type", type.name)
+            putString(KEY_SIGNER_TYPE, type.name)
+            putBoolean(KEY_SIGNER_CONFIGURED, true)
         }
+        val selection =
+            synchronized(this) {
+                pendingSignerSelection.also {
+                    pendingSignerSelection = null
+                }
+            }
+        selection?.complete(true)
     }
 
     private fun closeActiveSigner() {
@@ -319,6 +449,8 @@ class SignerManager(
     }
 
     private companion object {
+        const val KEY_SIGNER_TYPE = "type"
+        const val KEY_SIGNER_CONFIGURED = "signer_configured"
         const val BUNKER_PERMISSIONS =
             "sign_event,nip04_encrypt,nip04_decrypt," +
                     "nip44_encrypt,nip44_decrypt"

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

@@ -3,6 +3,7 @@ package com.pakstr.app.signer
 enum class SignerType {
     AMBER,
     BUNKER,
+    LOCAL,
     FAKE
 
 }

package/android-template/app/src/main/java/com/pakstr/app/signer/local/LocalAccountImportCandidate.kt

@@ -0,0 +1,42 @@
+package com.pakstr.app.signer.local
+
+import com.pakstr.app.crypto.Nip19Codec
+import com.pakstr.app.crypto.Nip46ClientKey
+
+internal class LocalAccountImportCandidate private constructor(
+    private val key: Nip46ClientKey,
+    val npub: String
+) : AutoCloseable {
+
+    internal fun <T> withPrivateKey(
+        block: (ByteArray) -> T
+    ): T = key.withPrivateKey(block)
+
+    override fun close() {
+        key.close()
+    }
+
+    companion object {
+        fun parse(nsec: String): LocalAccountImportCandidate {
+            val privateKey = Nip19Codec.decodeNsec(nsec)
+            return try {
+                val key = Nip46ClientKey.fromPrivateKey(privateKey)
+                try {
+                    val publicKey = key.publicKey
+                    val npub =
+                        try {
+                            Nip19Codec.encodeNpub(publicKey)
+                        } finally {
+                            publicKey.fill(0)
+                        }
+                    LocalAccountImportCandidate(key, npub)
+                } catch (error: Exception) {
+                    key.close()
+                    throw error
+                }
+            } finally {
+                privateKey.fill(0)
+            }
+        }
+    }
+}

package/android-template/app/src/main/java/com/pakstr/app/signer/local/LocalAccountStore.kt

@@ -0,0 +1,260 @@
+package com.pakstr.app.signer.local
+
+import android.content.Context
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyProperties
+import android.util.Base64
+import com.pakstr.app.crypto.Nip46ClientKey
+import java.security.KeyStore
+import javax.crypto.Cipher
+import javax.crypto.KeyGenerator
+import javax.crypto.SecretKey
+import javax.crypto.spec.GCMParameterSpec
+
+internal class LocalAccountStorageException(
+    message: String,
+    cause: Throwable? = null
+) : Exception(message, cause)
+
+internal class LocalAccountAlreadyExistsException :
+    IllegalStateException("Local account already exists")
+
+internal class LocalAccountStore(
+    context: Context,
+    private val preferencesName: String = PREFERENCES_NAME,
+    private val keyAlias: String = KEY_ALIAS
+) {
+    private val context = context.applicationContext
+    private val preferences =
+        this.context.getSharedPreferences(
+            preferencesName,
+            Context.MODE_PRIVATE
+        )
+
+    fun createAccount(): String =
+        synchronized(STORAGE_LOCK) {
+            if (hasAccountLocked()) {
+                return@synchronized requireNotNull(
+                    loadKeyLocked()
+                ).use { key ->
+                    key.publicKeyHex
+                }
+            }
+
+            val key = Nip46ClientKey.generate()
+            try {
+                key.withPrivateKey(::saveNewKey)
+                key.publicKeyHex
+            } finally {
+                key.close()
+            }
+        }
+
+    fun importAccount(privateKey: ByteArray): String =
+        synchronized(STORAGE_LOCK) {
+            if (hasAccountLocked()) {
+                throw LocalAccountAlreadyExistsException()
+            }
+
+            Nip46ClientKey.fromPrivateKey(privateKey).use { key ->
+                key.withPrivateKey(::saveNewKey)
+                key.publicKeyHex
+            }
+        }
+
+    fun hasAccount(): Boolean =
+        synchronized(STORAGE_LOCK) {
+            hasAccountLocked()
+        }
+
+    fun loadKey(): Nip46ClientKey? =
+        synchronized(STORAGE_LOCK) {
+            loadKeyLocked()
+        }
+
+    private fun hasAccountLocked(): Boolean {
+        val hasIv = preferences.contains(KEY_IV)
+        val hasCiphertext = preferences.contains(KEY_CIPHERTEXT)
+        if (hasIv != hasCiphertext) {
+            throw LocalAccountStorageException(
+                "Local account storage is incomplete"
+            )
+        }
+        return hasIv
+    }
+
+    private fun loadKeyLocked(): Nip46ClientKey? {
+        if (!hasAccountLocked()) {
+            return null
+        }
+
+        val encodedIv = preferences.getString(KEY_IV, null)
+            ?: throw LocalAccountStorageException(
+                "Local account storage is incomplete"
+            )
+        val encodedCiphertext =
+            preferences.getString(KEY_CIPHERTEXT, null)
+                ?: throw LocalAccountStorageException(
+                    "Local account storage is incomplete"
+                )
+        val iv = decode(encodedIv)
+        val ciphertext = decode(encodedCiphertext)
+        var privateKey: ByteArray? = null
+
+        return try {
+            val wrappingKey = loadWrappingKey()
+            privateKey = decrypt(wrappingKey, iv, ciphertext)
+            Nip46ClientKey.fromPrivateKey(privateKey)
+        } catch (error: LocalAccountStorageException) {
+            throw error
+        } catch (error: Exception) {
+            throw LocalAccountStorageException(
+                "Unable to restore local account",
+                error
+            )
+        } finally {
+            iv.fill(0)
+            ciphertext.fill(0)
+            privateKey?.fill(0)
+        }
+    }
+
+    private fun saveNewKey(privateKey: ByteArray) {
+        if (hasAccountLocked()) {
+            throw LocalAccountAlreadyExistsException()
+        }
+
+        val wrappingKey = getOrCreateWrappingKey()
+        val cipher = Cipher.getInstance(TRANSFORMATION)
+        cipher.init(Cipher.ENCRYPT_MODE, wrappingKey)
+        cipher.updateAAD(AUTHENTICATED_DATA)
+        val ciphertext = cipher.doFinal(privateKey)
+        val iv = cipher.iv
+
+        try {
+            val saved =
+                preferences.edit()
+                    .putString(
+                        KEY_IV,
+                        Base64.encodeToString(iv, Base64.NO_WRAP)
+                    )
+                    .putString(
+                        KEY_CIPHERTEXT,
+                        Base64.encodeToString(
+                            ciphertext,
+                            Base64.NO_WRAP
+                        )
+                    )
+                    .commit()
+            if (!saved) {
+                throw LocalAccountStorageException(
+                    "Unable to store local account"
+                )
+            }
+        } finally {
+            iv.fill(0)
+            ciphertext.fill(0)
+        }
+    }
+
+    private fun decrypt(
+        wrappingKey: SecretKey,
+        iv: ByteArray,
+        ciphertext: ByteArray
+    ): ByteArray {
+        val cipher = Cipher.getInstance(TRANSFORMATION)
+        cipher.init(
+            Cipher.DECRYPT_MODE,
+            wrappingKey,
+            GCMParameterSpec(GCM_TAG_SIZE_BITS, iv)
+        )
+        cipher.updateAAD(AUTHENTICATED_DATA)
+        return cipher.doFinal(ciphertext)
+    }
+
+    private fun getOrCreateWrappingKey(): SecretKey {
+        val keyStore = loadKeyStore()
+        val existing = keyStore.getKey(keyAlias, null)
+        if (existing != null) {
+            return existing as? SecretKey
+                ?: throw LocalAccountStorageException(
+                    "Invalid local account wrapping key"
+                )
+        }
+
+        return try {
+            val generator =
+                KeyGenerator.getInstance(
+                    KeyProperties.KEY_ALGORITHM_AES,
+                    ANDROID_KEY_STORE
+                )
+            generator.init(
+                KeyGenParameterSpec.Builder(
+                    keyAlias,
+                    KeyProperties.PURPOSE_ENCRYPT or
+                            KeyProperties.PURPOSE_DECRYPT
+                )
+                    .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
+                    .setEncryptionPaddings(
+                        KeyProperties.ENCRYPTION_PADDING_NONE
+                    )
+                    .setKeySize(WRAPPING_KEY_SIZE_BITS)
+                    .build()
+            )
+            generator.generateKey()
+        } catch (error: Exception) {
+            throw LocalAccountStorageException(
+                "Unable to create local account wrapping key",
+                error
+            )
+        }
+    }
+
+    private fun loadWrappingKey(): SecretKey {
+        val key = loadKeyStore().getKey(keyAlias, null)
+            ?: throw LocalAccountStorageException(
+                "Local account wrapping key is unavailable"
+            )
+        return key as? SecretKey
+            ?: throw LocalAccountStorageException(
+                "Invalid local account wrapping key"
+            )
+    }
+
+    private fun loadKeyStore(): KeyStore {
+        return try {
+            KeyStore.getInstance(ANDROID_KEY_STORE)
+                .apply { load(null) }
+        } catch (error: Exception) {
+            throw LocalAccountStorageException(
+                "Unable to access local account storage",
+                error
+            )
+        }
+    }
+
+    private fun decode(value: String): ByteArray {
+        return try {
+            Base64.decode(value, Base64.NO_WRAP)
+        } catch (error: IllegalArgumentException) {
+            throw LocalAccountStorageException(
+                "Local account storage is invalid",
+                error
+            )
+        }
+    }
+
+    internal companion object {
+        const val PREFERENCES_NAME = "local_signer_account"
+        const val KEY_ALIAS = "pakstr_local_signer_wrapping_key_v1"
+        const val KEY_IV = "iv"
+        const val KEY_CIPHERTEXT = "ciphertext"
+        private val STORAGE_LOCK = Any()
+        private const val ANDROID_KEY_STORE = "AndroidKeyStore"
+        private const val TRANSFORMATION = "AES/GCM/NoPadding"
+        private const val GCM_TAG_SIZE_BITS = 128
+        private const val WRAPPING_KEY_SIZE_BITS = 256
+        private val AUTHENTICATED_DATA =
+            "pakstr/local-account/v1".toByteArray(Charsets.UTF_8)
+    }
+}