pakstr 0.27.0 → 0.28.0

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

@@ -11,8 +11,14 @@ 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
@@ -24,6 +30,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 +248,47 @@ 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 switching_from_bunker_disconnects_and_closes_client() {
         val context =
@@ -149,6 +336,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")

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

@@ -0,0 +1,194 @@
+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.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 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"
+    }
+}

package/android-template/app/src/androidTest/java/com/pakstr/app/utils/SignerPickerBottomSheetTest.kt

@@ -0,0 +1,131 @@
+package com.pakstr.app.utils
+
+import android.content.Context
+import androidx.test.core.app.ActivityScenario
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.action.ViewActions.click
+import androidx.test.espresso.assertion.ViewAssertions.matches
+import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
+import androidx.test.espresso.matcher.ViewMatchers.withEffectiveVisibility
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import androidx.test.espresso.matcher.ViewMatchers.Visibility.GONE
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.pakstr.app.MainActivity
+import com.pakstr.app.R
+import com.pakstr.app.signer.SignerManager
+import com.pakstr.app.signer.SignerType
+import com.pakstr.app.signer.local.LocalAccountStore
+import org.junit.After
+import org.junit.Assert.assertEquals
+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 SignerPickerBottomSheetTest {
+    private lateinit var context: Context
+
+    @Before
+    fun setup() {
+        context = ApplicationProvider.getApplicationContext()
+        AppPreferences.init(context)
+        AppPreferences.saveBoolean("isFirstRun", false)
+        clearLocalAccount()
+    }
+
+    @After
+    fun teardown() {
+        clearLocalAccount()
+        context.getSharedPreferences("signer", Context.MODE_PRIVATE)
+            .edit()
+            .clear()
+            .commit()
+        AppPreferences.saveBoolean("isFirstRun", true)
+    }
+
+    @Test
+    fun cold_start_does_not_show_signer_picker() {
+        AppPreferences.saveBoolean("isFirstRun", true)
+
+        ActivityScenario.launch(MainActivity::class.java).use { scenario ->
+            scenario.onActivity { activity ->
+                assertNull(
+                    activity.supportFragmentManager
+                        .findFragmentByTag("SignerPicker")
+                )
+            }
+        }
+    }
+
+    @Test
+    fun completed_legacy_setup_migrates_signer_configuration() {
+        AppPreferences.saveBoolean("isFirstRun", false)
+
+        ActivityScenario.launch(MainActivity::class.java).use { scenario ->
+            scenario.onActivity { activity ->
+                assertTrue(signerManager(activity).isSignerConfigured())
+            }
+        }
+    }
+
+    @Test
+    fun local_option_creates_and_selects_local_signer() {
+        ActivityScenario.launch(MainActivity::class.java).use { scenario ->
+            scenario.onActivity { activity ->
+                MainActivity::class.java
+                    .getDeclaredMethod("showSignerPicker")
+                    .apply { isAccessible = true }
+                    .invoke(activity)
+            }
+
+            onView(withId(R.id.radio_option_three))
+                .check(matches(isDisplayed()))
+                .perform(click())
+            onView(withId(R.id.bunker_uri_container))
+                .check(matches(withEffectiveVisibility(GONE)))
+            onView(withId(R.id.button_share_pairing))
+                .check(matches(withEffectiveVisibility(GONE)))
+            onView(withId(R.id.button_confirm)).perform(click())
+
+            waitForLocalSelection(scenario)
+        }
+    }
+
+    private fun waitForLocalSelection(
+        scenario: ActivityScenario<MainActivity>
+    ) {
+        repeat(50) {
+            var activeType: SignerType? = null
+            scenario.onActivity { activity ->
+                activeType = signerManager(activity).getActiveType()
+            }
+            if (activeType == SignerType.LOCAL) {
+                assertEquals(SignerType.LOCAL, activeType)
+                return
+            }
+            Thread.sleep(100)
+        }
+        throw AssertionError("LOCAL signer was not selected")
+    }
+
+    private fun signerManager(activity: MainActivity): SignerManager {
+        return MainActivity::class.java
+            .getDeclaredField("signerManager")
+            .apply { isAccessible = true }
+            .get(activity) as SignerManager
+    }
+
+    private fun clearLocalAccount() {
+        context.getSharedPreferences(
+            LocalAccountStore.PREFERENCES_NAME,
+            Context.MODE_PRIVATE
+        ).edit().clear().commit()
+        KeyStore.getInstance("AndroidKeyStore")
+            .apply { load(null) }
+            .deleteEntry(LocalAccountStore.KEY_ALIAS)
+    }
+}