pakstr 0.28.0 → 0.29.1

package/README.md

@@ -95,6 +95,16 @@ containers alike, because all of them are created the same way. Leave it unset o
 workstation, where Docker's default network is what you want - host networking is not
 available on Docker Desktop for macOS.
 
+**Timeouts.** So a stalled build or an unresponsive Docker daemon fails instead of hanging
+the job, the Gradle build and the builder image pull are stopped after 60 minutes, signing
+after 15, file copies into and out of containers after 10, and other Docker calls after 2.
+Containers left by a stopped or failed run are removed. If a cold build on a slow runner needs
+longer, raise the build limit with `PAKSTR_BUILD_TIMEOUT_MINUTES` (`0` disables it):
+
+```bash
+PAKSTR_BUILD_TIMEOUT_MINUTES=120 npx pakstr run
+```
+
 ---
 
 ## Documentation & License

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

@@ -22,6 +22,7 @@ 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
@@ -289,6 +290,64 @@ class SignerManagerTest {
         }
     }
 
+    @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 =
@@ -458,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

@@ -9,6 +9,7 @@ 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
@@ -60,6 +61,81 @@ class LocalAccountStoreTest {
         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()
@@ -190,5 +266,7 @@ class LocalAccountStoreTest {
     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"
     }
 }

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

@@ -5,8 +5,10 @@ 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.action.ViewActions.replaceText
 import androidx.test.espresso.assertion.ViewAssertions.matches
 import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
+import androidx.test.espresso.matcher.ViewMatchers.isChecked
 import androidx.test.espresso.matcher.ViewMatchers.withEffectiveVisibility
 import androidx.test.espresso.matcher.ViewMatchers.withId
 import androidx.test.espresso.matcher.ViewMatchers.Visibility.GONE
@@ -75,16 +77,13 @@ class SignerPickerBottomSheetTest {
     @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)
-            }
+            showPicker(scenario)
 
             onView(withId(R.id.radio_option_three))
                 .check(matches(isDisplayed()))
                 .perform(click())
+            onView(withId(R.id.radio_local_create))
+                .check(matches(isChecked()))
             onView(withId(R.id.bunker_uri_container))
                 .check(matches(withEffectiveVisibility(GONE)))
             onView(withId(R.id.button_share_pairing))
@@ -95,6 +94,36 @@ class SignerPickerBottomSheetTest {
         }
     }
 
+    @Test
+    fun local_import_can_be_cancelled_before_persistence() {
+        ActivityScenario.launch(MainActivity::class.java).use { scenario ->
+            showPicker(scenario)
+
+            onView(withId(R.id.radio_option_three)).perform(click())
+            onView(withId(R.id.radio_local_import)).perform(click())
+            onView(withId(R.id.local_nsec_container))
+                .check(matches(isDisplayed()))
+            onView(withId(R.id.local_nsec)).perform(replaceText(NSEC_ONE))
+            onView(withId(R.id.button_confirm)).perform(click())
+            onView(withId(android.R.id.button2)).perform(click())
+
+            scenario.onActivity { activity ->
+                assertTrue(!signerManager(activity).hasLocalAccount())
+            }
+        }
+    }
+
+    private fun showPicker(
+        scenario: ActivityScenario<MainActivity>
+    ) {
+        scenario.onActivity { activity ->
+            MainActivity::class.java
+                .getDeclaredMethod("showSignerPicker")
+                .apply { isAccessible = true }
+                .invoke(activity)
+        }
+    }
+
     private fun waitForLocalSelection(
         scenario: ActivityScenario<MainActivity>
     ) {
@@ -128,4 +157,9 @@ class SignerPickerBottomSheetTest {
             .apply { load(null) }
             .deleteEntry(LocalAccountStore.KEY_ALIAS)
     }
+
+    private companion object {
+        const val NSEC_ONE =
+            "nsec1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqsmhltgl"
+    }
 }

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

@@ -9,6 +9,7 @@ import android.os.Handler
 import android.os.Looper
 
 import android.view.View
+import android.view.WindowManager
 import android.webkit.PermissionRequest
 import android.webkit.WebView
 import android.widget.FrameLayout
@@ -41,6 +42,7 @@ import com.pakstr.app.permissions.interfaces.PermissionHandler
 
 import com.pakstr.app.signer.SignerManager
 import com.pakstr.app.signer.SignerType
+import com.pakstr.app.signer.local.LocalAccountImportCandidate
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -63,6 +65,8 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
     private lateinit var fab: FloatingActionButton
     private lateinit var supportUnlockGestureLayout: SupportUnlockGestureLayout
     private var bunkerPairingDialog: AlertDialog? = null
+    private var localImportDialog: AlertDialog? = null
+    private var localImportCandidate: LocalAccountImportCandidate? = null
     private var signerSetupInProgress = false
 
     private val diagnosticsHandler = Handler(Looper.getMainLooper())
@@ -375,6 +379,11 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
 
         bunkerPairingDialog?.dismiss()
         bunkerPairingDialog = null
+        localImportDialog?.setOnDismissListener(null)
+        localImportDialog?.dismiss()
+        localImportDialog = null
+        localImportCandidate?.close()
+        localImportCandidate = null
 
         if (::signerManager.isInitialized) {
             signerManager.close()
@@ -428,8 +437,21 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
         ) {
             return
         }
+        val hasLocalAccount =
+            try {
+                signerManager.hasLocalAccount()
+            } catch (_: Exception) {
+                Toast.makeText(
+                    this,
+                    R.string.signer_picker_local_status_failed,
+                    Toast.LENGTH_LONG
+                ).show()
+                signerManager.cancelSignerSelection()
+                return
+            }
         SignerPickerBottomSheet(
             hasBunkerSession = signerManager.hasBunkerSession(),
+            hasLocalAccount = hasLocalAccount,
             onAmberSelected = {
                 signerManager.setActiveType(SignerType.AMBER)
                 handleSignerSetup()
@@ -447,6 +469,23 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
                 signerSetupInProgress = true
                 createLocalAccount()
             },
+            onLocalImportSelected = { nsec ->
+                val candidate =
+                    try {
+                        signerManager.prepareLocalAccountImport(nsec)
+                    } catch (_: Exception) {
+                        null
+                    }
+                if (candidate == null) {
+                    false
+                } else {
+                    signerSetupInProgress = true
+                    localImportCandidate?.close()
+                    localImportCandidate = candidate
+                    showLocalImportConfirmation(candidate)
+                    true
+                }
+            },
             onSharePairing = { relayUrls ->
                 signerSetupInProgress = true
                 shareBunkerPairing(relayUrls)
@@ -497,6 +536,91 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
         }
     }
 
+    private fun showLocalImportConfirmation(
+        candidate: LocalAccountImportCandidate
+    ) {
+        if (localImportCandidate !== candidate) {
+            return
+        }
+        if (isFinishing || isDestroyed) {
+            discardLocalAccountImport()
+            return
+        }
+        var confirmed = false
+        val dialog =
+            AlertDialog.Builder(this)
+                .setTitle(R.string.signer_picker_local_confirm_title)
+                .setMessage(
+                    getString(
+                        R.string.signer_picker_local_confirm_message,
+                        candidate.npub
+                    )
+                )
+                .setPositiveButton(
+                    R.string.signer_picker_local_confirm
+                ) { _, _ ->
+                    confirmed = true
+                    confirmLocalAccountImport(candidate)
+                }
+                .setNegativeButton(
+                    R.string.signer_picker_local_cancel,
+                    null
+                )
+                .create()
+        dialog.setOnDismissListener {
+            if (!confirmed) {
+                discardLocalAccountImport()
+            }
+            if (localImportDialog === dialog) {
+                localImportDialog = null
+            }
+        }
+        localImportDialog = dialog
+        dialog.show()
+        dialog.window?.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
+    }
+
+    private fun confirmLocalAccountImport(
+        candidate: LocalAccountImportCandidate
+    ) {
+        if (localImportCandidate !== candidate) {
+            return
+        }
+        localImportCandidate = null
+        lifecycleScope.launch {
+            val imported =
+                withContext(Dispatchers.IO) {
+                    try {
+                        signerManager.importLocalAccount(candidate)
+                        true
+                    } catch (cancelled: CancellationException) {
+                        candidate.close()
+                        throw cancelled
+                    } catch (_: Exception) {
+                        false
+                    }
+                }
+            signerSetupInProgress = false
+            if (imported) {
+                handleSignerSetup()
+            } else {
+                signerManager.cancelSignerSelection()
+                Toast.makeText(
+                    this@MainActivity,
+                    R.string.signer_picker_local_import_failed,
+                    Toast.LENGTH_LONG
+                ).show()
+            }
+        }
+    }
+
+    private fun discardLocalAccountImport() {
+        localImportCandidate?.close()
+        localImportCandidate = null
+        signerSetupInProgress = false
+        signerManager.cancelSignerSelection()
+    }
+
     private fun shareBunkerPairing(relayUrls: List<String>) {
         lifecycleScope.launch {
             val pairingUri =

package/android-template/app/src/main/java/com/pakstr/app/crypto/Nip19Codec.kt

@@ -0,0 +1,181 @@
+package com.pakstr.app.crypto
+
+internal class InvalidNsecException : IllegalArgumentException(
+    "Invalid nsec"
+)
+
+internal object Nip19Codec {
+    private const val NSEC_HRP = "nsec"
+    private const val NPUB_HRP = "npub"
+    private const val PAYLOAD_SIZE = 32
+    private const val CHECKSUM_SIZE = 6
+    private const val MAX_ENCODED_LENGTH = 90
+    private const val BECH32_CONSTANT = 1
+    private const val CHARSET =
+        "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+    private val reverseCharset = IntArray(128) { -1 }.apply {
+        CHARSET.forEachIndexed { index, character ->
+            this[character.code] = index
+        }
+    }
+
+    fun decodeNsec(value: String): ByteArray {
+        if (
+            value.isEmpty() ||
+            value.length > MAX_ENCODED_LENGTH ||
+            value != value.lowercase()
+        ) {
+            throw InvalidNsecException()
+        }
+
+        val separator = value.lastIndexOf('1')
+        if (
+            separator < 1 ||
+            separator + CHECKSUM_SIZE + 1 > value.length
+        ) {
+            throw InvalidNsecException()
+        }
+
+        val hrp = value.substring(0, separator)
+        if (
+            hrp != NSEC_HRP ||
+            hrp.any { it.code !in 33..126 }
+        ) {
+            throw InvalidNsecException()
+        }
+
+        val data = IntArray(value.length - separator - 1)
+        value.substring(separator + 1).forEachIndexed { index, character ->
+            val decoded =
+                if (character.code < reverseCharset.size) {
+                    reverseCharset[character.code]
+                } else {
+                    -1
+                }
+            if (decoded < 0) {
+                throw InvalidNsecException()
+            }
+            data[index] = decoded
+        }
+        if (polymod(hrpExpand(hrp) + data) != BECH32_CONSTANT) {
+            throw InvalidNsecException()
+        }
+
+        val decoded = convertBits(
+            data.copyOf(data.size - CHECKSUM_SIZE),
+            fromBits = 5,
+            toBits = 8,
+            pad = false
+        )
+        if (decoded.size != PAYLOAD_SIZE) {
+            decoded.fill(0)
+            throw InvalidNsecException()
+        }
+        return ByteArray(decoded.size) { index ->
+            decoded[index].toByte()
+        }.also {
+            decoded.fill(0)
+        }
+    }
+
+    fun encodeNpub(publicKey: ByteArray): String {
+        require(publicKey.size == PAYLOAD_SIZE) {
+            "Public key must be exactly 32 bytes"
+        }
+        val data = convertBits(
+            IntArray(publicKey.size) { index ->
+                publicKey[index].toInt() and 0xff
+            },
+            fromBits = 8,
+            toBits = 5,
+            pad = true
+        )
+        val checksum = createChecksum(NPUB_HRP, data)
+        return buildString {
+            append(NPUB_HRP)
+            append('1')
+            (data + checksum).forEach { append(CHARSET[it]) }
+        }
+    }
+
+    private fun createChecksum(
+        hrp: String,
+        data: IntArray
+    ): IntArray {
+        val values = hrpExpand(hrp) + data + IntArray(CHECKSUM_SIZE)
+        val remainder = polymod(values) xor BECH32_CONSTANT
+        return IntArray(CHECKSUM_SIZE) { index ->
+            (remainder shr (5 * (CHECKSUM_SIZE - 1 - index))) and 31
+        }
+    }
+
+    private fun hrpExpand(hrp: String): IntArray {
+        val result = IntArray(hrp.length * 2 + 1)
+        hrp.forEachIndexed { index, character ->
+            result[index] = character.code shr 5
+            result[hrp.length + 1 + index] = character.code and 31
+        }
+        return result
+    }
+
+    private fun polymod(values: IntArray): Int {
+        var checksum = 1
+        val generators = intArrayOf(
+            0x3b6a57b2,
+            0x26508e6d,
+            0x1ea119fa,
+            0x3d4233dd,
+            0x2a1462b3
+        )
+        values.forEach { value ->
+            val top = checksum ushr 25
+            checksum = (checksum and 0x1ffffff) shl 5 xor value
+            generators.forEachIndexed { index, generator ->
+                if ((top shr index) and 1 != 0) {
+                    checksum = checksum xor generator
+                }
+            }
+        }
+        return checksum
+    }
+
+    private fun convertBits(
+        values: IntArray,
+        fromBits: Int,
+        toBits: Int,
+        pad: Boolean
+    ): IntArray {
+        var accumulator = 0
+        var bitCount = 0
+        val output = ArrayList<Int>()
+        val fromMask = (1 shl fromBits) - 1
+        val toMask = (1 shl toBits) - 1
+
+        values.forEach { value ->
+            if (value < 0 || value ushr fromBits != 0) {
+                throw InvalidNsecException()
+            }
+            accumulator =
+                ((accumulator and ((1 shl (fromBits + toBits - 1)) - 1))
+                        shl fromBits) or (value and fromMask)
+            bitCount += fromBits
+            while (bitCount >= toBits) {
+                bitCount -= toBits
+                output += (accumulator ushr bitCount) and toMask
+            }
+        }
+
+        if (pad) {
+            if (bitCount > 0) {
+                output += (accumulator shl (toBits - bitCount)) and toMask
+            }
+        } else if (
+            bitCount >= fromBits ||
+            ((accumulator shl (toBits - bitCount)) and toMask) != 0
+        ) {
+            throw InvalidNsecException()
+        }
+
+        return output.toIntArray()
+    }
+}

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

@@ -14,6 +14,8 @@ 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
@@ -196,6 +198,29 @@ class SignerManager(
         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()