pakstr 0.27.0 → 0.29.0

package/android-template/app/src/androidTest/java/com/pakstr/app/signer/SignerManagerTest.kt

@@ -11,11 +11,18 @@ import com.pakstr.app.crypto.Nip46ClientKey
 import com.pakstr.app.signer.bunker.BunkerConfig
 import com.pakstr.app.signer.bunker.BunkerConnectionStore
 import com.pakstr.app.signer.bunker.Nip46Client
+import com.pakstr.app.signer.exceptions.SignerUnavailableException
 import com.pakstr.app.signer.interfaces.NostrSigner
+import com.pakstr.app.signer.local.LocalAccountStore
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.async
 import kotlinx.coroutines.runBlocking
+import java.security.KeyStore
+import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNull
+import org.junit.Assert.assertThrows
 import org.junit.Assert.assertTrue
 import org.junit.Assert.fail
 import org.junit.Test
@@ -24,6 +31,146 @@ import org.junit.runner.RunWith
 @RunWith(AndroidJUnit4::class)
 class SignerManagerTest {
 
+    private val context
+        get() = ApplicationProvider.getApplicationContext<Context>()
+
+    @After
+    fun clearSignerPreferences() {
+        context.getSharedPreferences("signer", Context.MODE_PRIVATE)
+            .edit()
+            .clear()
+            .commit()
+    }
+
+    @Test
+    fun fresh_manager_defaults_to_amber_but_is_not_configured() {
+        clearSignerPreferences()
+        val manager = SignerManager(context, NoOpLauncher())
+
+        assertEquals(SignerType.AMBER, manager.getActiveType())
+        assertFalse(manager.isSignerConfigured())
+    }
+
+    @Test
+    fun explicit_selection_persists_configuration_across_recreation() =
+        runBlocking {
+            clearSignerPreferences()
+            var pickerRequests = 0
+            val first = SignerManager(context, NoOpLauncher())
+            first.setActiveType(SignerType.FAKE)
+            val restored =
+                SignerManager(
+                    context,
+                    NoOpLauncher(),
+                    signerPickerRequestHandler = { pickerRequests++ }
+                )
+
+            assertTrue(restored.isSignerConfigured())
+            assertEquals(SignerType.FAKE, restored.getActiveType())
+            assertTrue(restored.getConfiguredSigner() is FakeSigner)
+            assertEquals(0, pickerRequests)
+        }
+
+    @Test
+    fun local_account_recreation_reuses_existing_identity() = runBlocking {
+        clearLocalAccount(context)
+        val first = SignerManager(context, NoOpLauncher())
+        try {
+            first.createLocalAccount()
+            val firstPublicKey = first.getCurrentUserPubkey()
+            val restored = SignerManager(context, NoOpLauncher())
+            try {
+                assertTrue(restored.isSignerConfigured())
+                assertEquals(SignerType.LOCAL, restored.getActiveType())
+                assertEquals(firstPublicKey, restored.getCurrentUserPubkey())
+            } finally {
+                restored.close()
+            }
+        } finally {
+            first.close()
+            clearLocalAccount(context)
+        }
+    }
+
+    @Test
+    fun legacy_completed_setup_migrates_configuration() {
+        clearSignerPreferences()
+        val manager = SignerManager(context, NoOpLauncher())
+
+        manager.migrateLegacySignerConfiguration(setupCompleted = true)
+
+        assertTrue(manager.isSignerConfigured())
+        assertEquals(SignerType.AMBER, manager.getActiveType())
+    }
+
+    @Test
+    fun configured_signer_waits_for_one_picker_and_resumes_all_requests() =
+        runBlocking {
+            clearSignerPreferences()
+            var pickerRequests = 0
+            val manager =
+                SignerManager(
+                    context,
+                    NoOpLauncher(),
+                    signerPickerRequestHandler = { pickerRequests++ }
+                )
+            val first =
+                async(start = CoroutineStart.UNDISPATCHED) {
+                    manager.getConfiguredSigner()
+                }
+            val second =
+                async(start = CoroutineStart.UNDISPATCHED) {
+                    manager.getConfiguredSigner()
+                }
+
+            assertEquals(1, pickerRequests)
+            assertFalse(first.isCompleted)
+            assertFalse(second.isCompleted)
+
+            manager.setActiveType(SignerType.FAKE)
+
+            assertTrue(first.await() is FakeSigner)
+            assertTrue(second.await() is FakeSigner)
+        }
+
+    @Test
+    fun dismissed_picker_returns_signer_unavailable() = runBlocking {
+        clearSignerPreferences()
+        val manager =
+            SignerManager(
+                context,
+                NoOpLauncher(),
+                signerPickerRequestHandler = {}
+            )
+        val request =
+            async(start = CoroutineStart.UNDISPATCHED) {
+                runCatching { manager.getConfiguredSigner() }.exceptionOrNull()
+            }
+
+        manager.cancelSignerSelection()
+
+        assertTrue(request.await() is SignerUnavailableException)
+    }
+
+    @Test
+    fun close_returns_signer_unavailable_to_pending_request() = runBlocking {
+        clearSignerPreferences()
+        val manager =
+            SignerManager(
+                context,
+                NoOpLauncher(),
+                signerPickerRequestHandler = {}
+            )
+        val request =
+            async(start = CoroutineStart.UNDISPATCHED) {
+                runCatching { manager.getConfiguredSigner() }.exceptionOrNull()
+            }
+
+        manager.close()
+
+        assertTrue(request.await() is SignerUnavailableException)
+    }
+
     @Test
     fun signer_change_clears_cached_user_pubkey() = runBlocking {
         val context =
@@ -102,6 +249,105 @@ class SignerManagerTest {
         }
     }
 
+    @Test
+    fun local_account_survives_manager_recreation() = runBlocking {
+        val context =
+            ApplicationProvider.getApplicationContext<Context>()
+        clearLocalAccount(context)
+        val first = SignerManager(context, NoOpLauncher())
+        val restored = SignerManager(context, NoOpLauncher())
+        try {
+            first.createLocalAccount()
+            val firstPublicKey = first.getCurrentUserPubkey()
+
+            assertEquals(SignerType.LOCAL, first.getActiveType())
+            assertEquals(SignerType.LOCAL, restored.getActiveType())
+            assertEquals(firstPublicKey, restored.getCurrentUserPubkey())
+        } finally {
+            first.close()
+            restored.close()
+            clearLocalAccount(context)
+        }
+    }
+
+    @Test
+    fun repeated_local_account_creation_reuses_identity() = runBlocking {
+        val context =
+            ApplicationProvider.getApplicationContext<Context>()
+        clearLocalAccount(context)
+        val manager = SignerManager(context, NoOpLauncher())
+        try {
+            manager.createLocalAccount()
+            val firstPublicKey = manager.getCurrentUserPubkey()
+
+            manager.createLocalAccount()
+
+            assertEquals(firstPublicKey, manager.getCurrentUserPubkey())
+            assertEquals(SignerType.LOCAL, manager.getActiveType())
+        } finally {
+            manager.close()
+            clearLocalAccount(context)
+        }
+    }
+
+    @Test
+    fun imported_local_account_survives_manager_recreation() = runBlocking {
+        clearLocalAccount(context)
+        val first = SignerManager(context, NoOpLauncher())
+        try {
+            val candidate = first.prepareLocalAccountImport(NSEC_ONE)
+            assertEquals(NPUB_ONE, candidate.npub)
+            first.importLocalAccount(candidate)
+
+            assertTrue(first.hasLocalAccount())
+            assertEquals(SignerType.LOCAL, first.getActiveType())
+            assertEquals(PUBLIC_KEY_ONE, first.getCurrentUserPubkey())
+            first.close()
+
+            val restored = SignerManager(context, NoOpLauncher())
+            try {
+                assertEquals(SignerType.LOCAL, restored.getActiveType())
+                assertEquals(PUBLIC_KEY_ONE, restored.getCurrentUserPubkey())
+                val event =
+                    restored.getSigner().signEvent(
+                        "{\"kind\":1,\"created_at\":1," +
+                                "\"tags\":[],\"content\":\"imported\"}"
+                    )
+                assertTrue(event.contains(PUBLIC_KEY_ONE))
+            } finally {
+                restored.close()
+            }
+        } finally {
+            first.close()
+            clearLocalAccount(context)
+        }
+    }
+
+    @Test
+    fun invalid_or_duplicate_import_does_not_change_signer() = runBlocking {
+        clearLocalAccount(context)
+        val manager = SignerManager(context, NoOpLauncher())
+        try {
+            manager.setActiveType(SignerType.FAKE)
+            assertThrows(IllegalArgumentException::class.java) {
+                manager.prepareLocalAccountImport("not-an-nsec")
+            }
+            assertEquals(SignerType.FAKE, manager.getActiveType())
+            assertFalse(manager.hasLocalAccount())
+
+            manager.createLocalAccount()
+            val publicKey = manager.getCurrentUserPubkey()
+            assertThrows(IllegalStateException::class.java) {
+                manager.prepareLocalAccountImport(NSEC_ONE)
+            }
+            assertEquals(SignerType.LOCAL, manager.getActiveType())
+            assertEquals(publicKey, manager.getCurrentUserPubkey())
+        } finally {
+            manager.close()
+            clearLocalAccount(context)
+        }
+    }
+
     @Test
     fun switching_from_bunker_disconnects_and_closes_client() {
         val context =
@@ -149,6 +395,20 @@ class SignerManagerTest {
         }
     }
 
+    private fun clearLocalAccount(context: Context) {
+        context.getSharedPreferences(
+            LocalAccountStore.PREFERENCES_NAME,
+            Context.MODE_PRIVATE
+        ).edit().clear().commit()
+        KeyStore.getInstance("AndroidKeyStore")
+            .apply { load(null) }
+            .deleteEntry(LocalAccountStore.KEY_ALIAS)
+        context.getSharedPreferences("signer", Context.MODE_PRIVATE)
+            .edit()
+            .clear()
+            .commit()
+    }
+
     private fun getPendingPairing(manager: SignerManager): Any? {
         return SignerManager::class.java
             .getDeclaredField("pendingPairing")
@@ -257,6 +517,12 @@ class SignerManagerTest {
         const val VALID_PUBKEY =
             "cb227f60cb2a6d982ecbfc51b9199d340afc00b1ef81b67d8e3778e097e70d2c"
         const val PAIRING_SECRET = "pending-pairing-secret"
+        const val NSEC_ONE =
+            "nsec1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqsmhltgl"
+        const val NPUB_ONE =
+            "npub10xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqpkge6d"
+        const val PUBLIC_KEY_ONE =
+            "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
     }
 
     private class NoOpLauncher : ActivityResultLauncher<Intent>() {

package/android-template/app/src/androidTest/java/com/pakstr/app/signer/local/LocalAccountStoreTest.kt

@@ -0,0 +1,272 @@
+package com.pakstr.app.signer.local
+
+import android.content.Context
+import android.util.Base64
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.security.KeyStore
+
+@RunWith(AndroidJUnit4::class)
+class LocalAccountStoreTest {
+    private lateinit var context: Context
+    private lateinit var store: LocalAccountStore
+
+    @Before
+    fun setup() {
+        context = ApplicationProvider.getApplicationContext()
+        clearState()
+        store =
+            LocalAccountStore(
+                context,
+                PREFERENCES_NAME,
+                KEY_ALIAS
+            )
+    }
+
+    @After
+    fun teardown() {
+        clearState()
+    }
+
+    @Test
+    fun account_survives_store_recreation() {
+        val createdPublicKey = store.createAccount()
+        val restored =
+            LocalAccountStore(
+                context,
+                PREFERENCES_NAME,
+                KEY_ALIAS
+            ).loadKey()
+
+        requireNotNull(restored).use { key ->
+            assertEquals(createdPublicKey, key.publicKeyHex)
+        }
+    }
+
+    @Test
+    fun repeated_creation_reuses_existing_account() {
+        val first = store.createAccount()
+        val second = store.createAccount()
+
+        assertEquals(first, second)
+    }
+
+    @Test
+    fun imported_account_survives_store_recreation() {
+        val privateKey = ByteArray(32).also { it[31] = 1 }
+
+        try {
+            val importedPublicKey = store.importAccount(privateKey)
+            val restored =
+                LocalAccountStore(
+                    context,
+                    PREFERENCES_NAME,
+                    KEY_ALIAS
+                ).loadKey()
+
+            requireNotNull(restored).use { key ->
+                assertEquals(importedPublicKey, key.publicKeyHex)
+                assertEquals(PUBLIC_KEY_ONE, key.publicKeyHex)
+            }
+            assertFalse(
+                preferences().all.values.any { value ->
+                    value.toString().contains(
+                        Base64.encodeToString(
+                            privateKey,
+                            Base64.NO_WRAP
+                        )
+                    )
+                }
+            )
+        } finally {
+            privateKey.fill(0)
+        }
+    }
+
+    @Test
+    fun import_rejects_existing_account_without_changing_it() {
+        val existingPublicKey = store.createAccount()
+        val preferences = preferences()
+        val existingIv =
+            preferences.getString(LocalAccountStore.KEY_IV, null)
+        val existingCiphertext =
+            preferences.getString(LocalAccountStore.KEY_CIPHERTEXT, null)
+        val privateKey = ByteArray(32).also { it[31] = 1 }
+
+        try {
+            assertThrows(LocalAccountAlreadyExistsException::class.java) {
+                store.importAccount(privateKey)
+            }
+            assertEquals(existingIv, preferences.getString(LocalAccountStore.KEY_IV, null))
+            assertEquals(
+                existingCiphertext,
+                preferences.getString(LocalAccountStore.KEY_CIPHERTEXT, null)
+            )
+            requireNotNull(store.loadKey()).use { key ->
+                assertEquals(existingPublicKey, key.publicKeyHex)
+            }
+        } finally {
+            privateKey.fill(0)
+        }
+    }
+
+    @Test
+    fun invalid_import_persists_nothing() {
+        val privateKey = ByteArray(32)
+
+        assertThrows(IllegalArgumentException::class.java) {
+            store.importAccount(privateKey)
+        }
+        assertNull(preferences().getString(LocalAccountStore.KEY_IV, null))
+        assertNull(
+            preferences().getString(
+                LocalAccountStore.KEY_CIPHERTEXT,
+                null
+            )
+        )
+    }
+
+    @Test
+    fun persisted_value_is_not_plaintext_private_key() {
+        store.createAccount()
+        val privateKey =
+            requireNotNull(store.loadKey()).use { key ->
+                key.withPrivateKey(ByteArray::copyOf)
+            }
+        val preferences = preferences()
+        val ciphertext =
+            requireNotNull(
+                preferences.getString(
+                    LocalAccountStore.KEY_CIPHERTEXT,
+                    null
+                )
+            )
+
+        try {
+            assertNotEquals(
+                Base64.encodeToString(privateKey, Base64.NO_WRAP),
+                ciphertext
+            )
+            assertFalse(
+                preferences.all.values.any { value ->
+                    value == Base64.encodeToString(
+                        privateKey,
+                        Base64.NO_WRAP
+                    )
+                }
+            )
+        } finally {
+            privateKey.fill(0)
+        }
+    }
+
+    @Test
+    fun incomplete_storage_fails_without_being_cleared() {
+        preferences().edit()
+            .putString(LocalAccountStore.KEY_IV, "AA==")
+            .commit()
+
+        assertThrows(LocalAccountStorageException::class.java) {
+            store.createAccount()
+        }
+        assertTrue(preferences().contains(LocalAccountStore.KEY_IV))
+        assertFalse(
+            preferences().contains(
+                LocalAccountStore.KEY_CIPHERTEXT
+            )
+        )
+    }
+
+    @Test
+    fun tampered_ciphertext_fails_without_replacement() {
+        store.createAccount()
+        val preferences = preferences()
+        val original =
+            requireNotNull(
+                preferences.getString(
+                    LocalAccountStore.KEY_CIPHERTEXT,
+                    null
+                )
+            )
+        val tampered = Base64.decode(original, Base64.NO_WRAP)
+        tampered[0] = (tampered[0].toInt() xor 1).toByte()
+        val encodedTampered =
+            Base64.encodeToString(tampered, Base64.NO_WRAP)
+        tampered.fill(0)
+        preferences.edit()
+            .putString(
+                LocalAccountStore.KEY_CIPHERTEXT,
+                encodedTampered
+            )
+            .commit()
+
+        assertThrows(LocalAccountStorageException::class.java) {
+            store.createAccount()
+        }
+        assertEquals(
+            encodedTampered,
+            preferences.getString(
+                LocalAccountStore.KEY_CIPHERTEXT,
+                null
+            )
+        )
+    }
+
+    @Test
+    fun missing_wrapping_key_does_not_generate_replacement_account() {
+        store.createAccount()
+        val ciphertext =
+            preferences().getString(
+                LocalAccountStore.KEY_CIPHERTEXT,
+                null
+            )
+        deleteKey()
+
+        assertThrows(LocalAccountStorageException::class.java) {
+            store.createAccount()
+        }
+        assertEquals(
+            ciphertext,
+            preferences().getString(
+                LocalAccountStore.KEY_CIPHERTEXT,
+                null
+            )
+        )
+    }
+
+    private fun preferences() =
+        context.getSharedPreferences(
+            PREFERENCES_NAME,
+            Context.MODE_PRIVATE
+        )
+
+    private fun clearState() {
+        if (::context.isInitialized) {
+            preferences().edit().clear().commit()
+            deleteKey()
+        }
+    }
+
+    private fun deleteKey() {
+        KeyStore.getInstance("AndroidKeyStore")
+            .apply { load(null) }
+            .deleteEntry(KEY_ALIAS)
+    }
+
+    private companion object {
+        const val PREFERENCES_NAME = "local_signer_account_test"
+        const val KEY_ALIAS = "pakstr_local_signer_wrapping_key_test"
+        const val PUBLIC_KEY_ONE =
+            "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
+    }
+}