pakstr 0.27.0 → 0.28.0

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

@@ -0,0 +1,245 @@
+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 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 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) {
+        check(!hasAccountLocked()) {
+            "Local account already exists"
+        }
+
+        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)
+    }
+}

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

@@ -1,5 +1,6 @@
 package com.pakstr.app.utils
 
+import android.content.DialogInterface
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
@@ -15,8 +16,10 @@ class SignerPickerBottomSheet(
     private val hasBunkerSession: Boolean,
     private val onAmberSelected: () -> Unit,
     private val onBunkerSelected: (String) -> Boolean,
+    private val onLocalSelected: () -> Unit,
     private val onSharePairing: (List<String>) -> Unit,
-    private val onBunkerLogout: () -> Unit
+    private val onBunkerLogout: () -> Unit,
+    private val onDismissed: () -> Unit = {}
 ) : BottomSheetDialogFragment() {
 
     override fun onCreateView(
@@ -61,15 +64,17 @@ class SignerPickerBottomSheet(
         updateBunkerControls()
 
         confirm.setOnClickListener {
-            if (radioGroup.checkedRadioButtonId == R.id.radio_option_two) {
-                val value = uriInput.text?.toString().orEmpty().trim()
-                if (!onBunkerSelected(value)) {
-                    uriContainer.error =
-                        getString(R.string.signer_picker_invalid_bunker)
-                    return@setOnClickListener
+            when (radioGroup.checkedRadioButtonId) {
+                R.id.radio_option_two -> {
+                    val value = uriInput.text?.toString().orEmpty().trim()
+                    if (!onBunkerSelected(value)) {
+                        uriContainer.error =
+                            getString(R.string.signer_picker_invalid_bunker)
+                        return@setOnClickListener
+                    }
                 }
-            } else {
-                onAmberSelected()
+                R.id.radio_option_three -> onLocalSelected()
+                else -> onAmberSelected()
             }
             dismiss()
         }
@@ -98,4 +103,9 @@ class SignerPickerBottomSheet(
             dismiss()
         }
     }
+
+    override fun onDismiss(dialog: DialogInterface) {
+        super.onDismiss(dialog)
+        onDismissed()
+    }
 }

package/android-template/app/src/main/res/layout/dialog_picker.xml

@@ -77,6 +77,24 @@
             android:text="@string/signer_picker_bunker"
             android:textColor="#1F2937"
             android:textSize="16sp" />
+
+        <RadioButton
+            android:id="@+id/radio_option_three"
+            android:layout_width="match_parent"
+            android:layout_height="64dp"
+            android:layout_marginBottom="12dp"
+            android:background="@drawable/selector_radio_card"
+            android:button="@null"
+            android:drawableStart="@drawable/ic_menu_browser"
+            android:drawableEnd="@drawable/selector_radio_checkmark"
+            android:drawablePadding="16dp"
+            android:drawableTint="@drawable/selector_radio_tint"
+            android:fontFamily="sans-serif-medium"
+            android:paddingStart="20dp"
+            android:paddingEnd="20dp"
+            android:text="@string/signer_picker_local"
+            android:textColor="#1F2937"
+            android:textSize="16sp" />
     </RadioGroup>
 
     <com.google.android.material.textfield.TextInputLayout

package/android-template/app/src/main/res/values/strings.xml

@@ -66,9 +66,11 @@
 
     <string name="signer_settings">Signer settings</string>
     <string name="signer_picker_title">Choose a signer</string>
-    <string name="signer_picker_subtitle">Use Amber or connect to a NIP-46 remote signer.</string>
+    <string name="signer_picker_subtitle">Use Amber, connect to a remote signer, or create an app-local account.</string>
     <string name="signer_picker_amber">Continue with Amber</string>
     <string name="signer_picker_bunker">Connect to remote signer (Bunker)</string>
+    <string name="signer_picker_local">Create app-local account</string>
+    <string name="signer_picker_local_failed">Unable to create the app-local account.</string>
     <string name="signer_picker_bunker_hint">Paste a bunker:// connection</string>
     <string name="signer_picker_share_pairing">Share a nostrconnect:// pairing</string>
     <string name="signer_picker_logout_bunker">Disconnect remote signer</string>

package/android-template/app/src/main/res/xml/backup_rules.xml

@@ -1,13 +1,6 @@
-<?xml version="1.0" encoding="utf-8"?><!--
-   Sample backup rules file; uncomment and customize as necessary.
-   See https://developer.android.com/guide/topics/data/autobackup
-   for details.
-   Note: This file is ignored for devices older than API 31
-   See https://developer.android.com/about/versions/12/backup-restore
--->
+<?xml version="1.0" encoding="utf-8"?>
 <full-backup-content>
-    <!--
-   <include domain="sharedpref" path="."/>
-   <exclude domain="sharedpref" path="device.xml"/>
--->
+    <exclude
+        domain="sharedpref"
+        path="local_signer_account.xml" />
 </full-backup-content>

package/android-template/app/src/main/res/xml/data_extraction_rules.xml

@@ -1,19 +1,13 @@
-<?xml version="1.0" encoding="utf-8"?><!--
-   Sample data extraction rules file; uncomment and customize as necessary.
-   See https://developer.android.com/about/versions/12/backup-restore#xml-changes
-   for details.
--->
+<?xml version="1.0" encoding="utf-8"?>
 <data-extraction-rules>
     <cloud-backup>
-        <!-- TODO: Use <include> and <exclude> to control what is backed up.
-        <include .../>
-        <exclude .../>
-        -->
+        <exclude
+            domain="sharedpref"
+            path="local_signer_account.xml" />
     </cloud-backup>
-    <!--
     <device-transfer>
-        <include .../>
-        <exclude .../>
+        <exclude
+            domain="sharedpref"
+            path="local_signer_account.xml" />
     </device-transfer>
-    -->
 </data-extraction-rules>

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

@@ -0,0 +1,110 @@
+package com.pakstr.app.signer
+
+import com.pakstr.app.crypto.Bip340Hash
+import com.pakstr.app.crypto.Nip46ClientKey
+import com.pakstr.app.crypto.NostrEventVerifier
+import kotlinx.coroutines.runBlocking
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class LocalSignerTest {
+    @Test
+    fun returns_same_public_key_after_key_reload() = runBlocking {
+        val privateKey = privateKey(3)
+        val expected =
+            Nip46ClientKey.fromPrivateKey(privateKey).use { key ->
+                key.publicKeyHex
+            }
+        val signer = signer(privateKey)
+
+        assertEquals(expected, signer.getPublicKey())
+        assertEquals(expected, signer.getPublicKey())
+    }
+
+    @Test
+    fun signs_event_with_valid_bip340_signature() = runBlocking {
+        val privateKey = privateKey(7)
+        val signer = signer(privateKey)
+        val signed = JSONObject(signer.signEvent(unsignedEvent().toString()))
+
+        assertEquals(signer.getPublicKey(), signed.getString("pubkey"))
+        assertEquals(64, signed.getString("id").length)
+        assertEquals(128, signed.getString("sig").length)
+        assertTrue(NostrEventVerifier.verify(signed))
+        assertFalse(signed.toString().contains(Bip340Hash.bytesToHex(privateKey)))
+    }
+
+    @Test
+    fun rejects_event_for_different_public_key() {
+        val signer = signer(privateKey(9))
+        val event =
+            unsignedEvent()
+                .put("pubkey", "a".repeat(64))
+
+        assertThrows(IllegalArgumentException::class.java) {
+            runBlocking {
+                signer.signEvent(event.toString())
+            }
+        }
+    }
+
+    @Test
+    fun nip44_round_trip_uses_local_key() = runBlocking {
+        val alice = signer(privateKey(11))
+        val bob = signer(privateKey(12))
+        val ciphertext =
+            alice.nip44Encrypt(
+                bob.getPublicKey(),
+                "local secret"
+            )
+
+        assertEquals(
+            "local secret",
+            bob.nip44Decrypt(
+                alice.getPublicKey(),
+                ciphertext
+            )
+        )
+    }
+
+    @Test
+    fun nip04_is_explicitly_unsupported() {
+        val signer = signer(privateKey(13))
+
+        assertThrows(UnsupportedOperationException::class.java) {
+            runBlocking {
+                signer.nip04Encrypt("a".repeat(64), "plaintext")
+            }
+        }
+        assertThrows(UnsupportedOperationException::class.java) {
+            runBlocking {
+                signer.nip04Decrypt("a".repeat(64), "ciphertext")
+            }
+        }
+    }
+
+    private fun signer(privateKey: ByteArray): LocalSigner {
+        return LocalSigner {
+            Nip46ClientKey.fromPrivateKey(privateKey)
+        }
+    }
+
+    private fun unsignedEvent(): JSONObject {
+        return JSONObject()
+            .put("created_at", 1_700_000_000)
+            .put("kind", 1)
+            .put("tags", JSONArray())
+            .put("content", "hello from local signer")
+    }
+
+    private fun privateKey(value: Int): ByteArray {
+        return ByteArray(32).also {
+            it[31] = value.toByte()
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pakstr",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "description": "CLI for packaging Nostr web apps into Android APKs",
   "type": "commonjs",
   "main": "dist/index.js",