diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/DkgSession.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/DkgSession.kt index b7ed937f..1d3c1df7 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/DkgSession.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/DkgSession.kt @@ -154,19 +154,23 @@ data class DkgSession( * * The ritual is otherwise driven entirely by arriving messages, which would * mean a member is enrolled in the group's permanent signing quorum by a relay - * delivering an event to a phone in their pocket. Each of these three is a - * separate decision because each publishes something different and commits the - * member to something different -- see `ChillDkgRitualManager.pendingApproval`. + * delivering an event to a phone in their pocket. This is the one decision it + * asks for, and it covers the whole ceremony: the rounds after it run without + * asking -- see docs/automatic-key-ceremony.md. * * Set at creation for the member who opened the ceremony: starting one is * already the act of agreeing to be in it. */ val hostKeyApprovedAt: Instant? = null, - /** When they approved publishing their contribution to the key. */ + /** + * When they approved publishing their contribution to the key, on a row from a + * build that asked. Nothing reads or writes it now; kept rather than migrated + * away, since dropping a nullable column buys nothing. + */ val round1ApprovedAt: Instant? = null, - /** When they approved signing to confirm the combined result. */ + /** When they approved confirming the combined result. As [round1ApprovedAt]. */ val round2ApprovedAt: Instant? = null, /** diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/types/DkgApprovalStep.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/types/DkgApprovalStep.kt index 979a56f0..1f9ce120 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/types/DkgApprovalStep.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/types/DkgApprovalStep.kt @@ -1,39 +1,45 @@ package mobi.giza.compose.database.model.types /** - * One thing a ChillDKG ritual needs this device's owner to agree to before it - * will publish on their behalf. + * Everything a ChillDKG ritual has ever asked this device's owner before publishing + * on their behalf. It asks one of them now. * - * The ritual is driven by arriving messages, so without these it runs to - * completion on its own — a relay delivering an event to a phone in a pocket is - * enough to enrol its owner in a group's permanent signing quorum. Each step is a - * separate decision because each publishes something different and commits the - * member to something different, and each is presented on its own screen. + * The ritual is driven by arriving messages, so without a gate it runs to + * completion on its own -- a relay delivering an event to a phone in a pocket would + * be enough to enrol its owner in a group's permanent signing quorum. [HOST_KEY] is + * that gate, and the only one: joining is a decision nothing on the device can make + * for its owner. What follows it is not. Contributing follows from having joined, + * and confirming is a check the device makes itself, so neither is asked about + * (docs/automatic-key-ceremony.md). * - * The coordinator's two aggregations are deliberately not here. They relay other - * members' already-published messages and disclose nothing of the coordinator's - * own, so gating them would stall the whole group on one person's attention - * without protecting anybody. + * [ROUND_1] and [ROUND_2] stay because they were asked about until then, and + * `DkgSession.approvalRequestedThrough` stores a step by name: a row written by an + * older build has to keep decoding, and its request lines keep rendering. + * + * The coordinator's two aggregations were never here. They relay other members' + * already-published messages and disclose nothing of the coordinator's own, so + * gating them would stall the whole group on one person's attention without + * protecting anybody. */ enum class DkgApprovalStep { /** * Publish this device's host public key, which is what puts its owner in the - * participant set. The most consequential of the three: `n` is fixed from here, - * and every later step assumes this member is in. + * participant set -- and, since nothing else is asked, agreeing to the whole + * ceremony. `n` is fixed from here, and every later step assumes this member is + * in. */ HOST_KEY, /** - * Publish this device's contribution to the key. Every member's is mixed in, so - * this is the point at which the member's own secret material starts shaping a - * key they will be expected to help sign with. + * Publish this device's contribution to the key. Asked about by older builds; + * now taken automatically once every host key is in. */ ROUND_1, /** * Sign to confirm the coordinator's combined result matches what this device - * sent. Refusing here is what stops a coordinator substituting a different key - * than the members contributed to, so it is a check, not a formality. + * sent. Asked about by older builds; now taken automatically, since the device + * is what makes the check -- a mismatch fails the ceremony with nobody looking. */ ROUND_2 } diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/ChillDkgRitualManager.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/ChillDkgRitualManager.kt index 80ccecd1..26823acd 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/ChillDkgRitualManager.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/ChillDkgRitualManager.kt @@ -303,9 +303,8 @@ object ChillDkgRitualManager { round1Random = RandomInstance.bytes(32).toHex(), round2AuxRandom = RandomInstance.bytes(32).toHex(), // Opening a ceremony is already the act of agreeing to be in it, so this - // member is not asked again to publish the host key they just committed - // the group to. Rounds 1 and 2 are still asked for: those publish key - // material, and by then the ceremony has other people in it. + // member is never asked about it: joining is the only approval a + // ceremony asks for, and this is it. hostKeyApprovedAt = Clock.System.now(), // What this ceremony is for, if it is for anything in particular. The // coordinator's own copy of the claim they are about to put on the @@ -732,10 +731,16 @@ object ChillDkgRitualManager { val hostSeckey = deriveHostSecretKey(nostrPrivateKey) try { - // Nothing of this device's own goes out before its owner has said so. - // Each gate returns rather than throwing: the ritual is not failing, it - // is waiting on a person, and everything already received stays stored - // so it resumes the moment they approve. + // Nothing of this device's own goes out before its owner has said so, + // and joining is the one thing they are asked. It returns rather than + // throwing: the ritual is not failing, it is waiting on a person, and + // everything already received stays stored so it resumes the moment + // they approve. + // + // Rounds 1 and 2 used to be gates of their own. They were never + // decisions: contributing follows from having joined, and confirming + // is the check ChillDKG makes below, which refuses a mismatch whether + // or not anybody is looking. See docs/automatic-key-ceremony.md. if (session.hostKeyApprovedAt == null) return if (ownMessage(database, session, DkgRitualEvents.HOST_KEY) == null) { @@ -746,13 +751,6 @@ object ChillDkgRitualManager { // nothing this device can compute yet. val hostPublicKeys = hostPublicKeys(database, session) ?: return - // A second decision, and a different one: the host key only joined the - // ceremony, this contributes to the key itself. - if (session.round1ApprovedAt == null) { - announceApprovalNeeded(database, session, DkgApprovalStep.ROUND_1) - return - } - val step1 = ChillDKG.participantStep1( hostSecretKey = hostSeckey, hostPublicKeys = hostPublicKeys, @@ -781,15 +779,12 @@ object ChillDkgRitualManager { val coordinatorRound1 = session.coordinatorRound1 ?: return - // The last decision, and a real check rather than a formality: signing - // here asserts the combined result matches what this device sent, which - // is what stops a coordinator swapping in a key the members never - // contributed to. - if (session.round2ApprovedAt == null) { - announceApprovalNeeded(database, session, DkgApprovalStep.ROUND_2) - return - } - + // A real check rather than a formality: signing here asserts the + // combined result matches what this device sent, which is what stops a + // coordinator swapping in a key the members never contributed to. The + // device makes it -- `participantStep2` faults on a mismatch, and the + // catch below fails the ceremony for everyone -- so a person approving + // it would add nothing to it. val step2 = ChillDKG.participantStep2( hostSecretKey = hostSeckey, state = step1.state, @@ -1115,32 +1110,21 @@ object ChillDkgRitualManager { * What this ritual is waiting on its owner for, or null if it is waiting on * somebody else — or on nothing, being finished. * - * Mirrors the gates in [advance] rather than duplicating their reasoning: a step - * is pending exactly when [advance] would stop at it. The two must agree, or the - * screen offers an approval that does nothing, or none while the ritual sits - * still. + * Mirrors the gate in [advance]: a step is pending exactly when [advance] would + * stop at it. The two must agree, or the screen offers an approval that does + * nothing, or none while the ritual sits still. There is one gate now, joining; + * rounds 1 and 2 were gates until docs/automatic-key-ceremony.md, and are never + * returned here. + * + * Still suspending and still handed the database, though this reading needs + * neither, so a gate that does need them can come back without every caller + * changing shape. */ + @Suppress("UNUSED_PARAMETER", "RedundantSuspendModifier") suspend fun pendingApproval(database: GizaDatabase, session: DkgSession): DkgApprovalStep? { if (session.stage == DkgRitualStage.COMPLETE || session.stage == DkgRitualStage.FAILED) return null - if (session.hostKeyApprovedAt == null) return DkgApprovalStep.HOST_KEY - - if (session.round1ApprovedAt == null) { - // Nothing to contribute to until the participant set is settled: round 1 - // is computed over every member's host key, so asking earlier would be - // asking about a ceremony whose shape is not yet known. - val hostKeys = database.dkgSessionDao() - .countMessagesByKind(session.id, DkgRitualEvents.HOST_KEY) - - return if (hostKeys >= session.participantCount) DkgApprovalStep.ROUND_1 else null - } - - if (session.round2ApprovedAt == null) { - // Nothing to check until the coordinator has combined the contributions. - return if (session.coordinatorRound1 != null) DkgApprovalStep.ROUND_2 else null - } - - return null + return if (session.hostKeyApprovedAt == null) DkgApprovalStep.HOST_KEY else null } /** @@ -1188,11 +1172,15 @@ object ChillDkgRitualManager { /** * Records that this device's owner agreed to [step], then lets the ritual run as - * far as the next thing it is waiting on. + * far as the next thing it is waiting on -- which, once they have joined, is + * the end of the ceremony or another member. * * Approving a step it is not actually waiting on is a no-op rather than an error: * a stale screen left open across a redelivery should not publish anything, and - * the caller has no way to know the ritual has moved on since it was drawn. + * the caller has no way to know the ritual has moved on since it was drawn. That + * covers [DkgApprovalStep.ROUND_1] and [DkgApprovalStep.ROUND_2] too, which + * [pendingApproval] no longer returns: a screen for either left open across the + * upgrade does nothing. */ suspend fun approve( database: GizaDatabase, @@ -1263,6 +1251,9 @@ object ChillDkgRitualManager { "Your approval is needed to join the shared key ceremony. Nothing has been " + "published from this device yet." + // Never reached: rounds 1 and 2 are no longer asked for. Kept because the + // enum keeps the values for rows that recorded asking, and this is the + // wording those rows were written with -- MIGRATION_3_4 matches on it. DkgApprovalStep.ROUND_1 -> ChatMessage.TYPE_DKG_APPROVAL_NEEDED_ROUND_1 to "Everyone has joined the shared key ceremony. Your approval is needed to " + "contribute to the key." diff --git a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/CeremonyAcrossDevicesJvmTest.kt b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/CeremonyAcrossDevicesJvmTest.kt index 8be884ce..b8ce5d7a 100644 --- a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/CeremonyAcrossDevicesJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/CeremonyAcrossDevicesJvmTest.kt @@ -1,5 +1,6 @@ package mobi.giza.compose.managers +import com.vitorpamplona.quartz.nip01Core.core.Event import fr.acinq.bitcoin.ByteVector32 import fr.acinq.bitcoin.PrivateKey import fr.acinq.bitcoin.crypto.frost.Frost @@ -8,10 +9,12 @@ import kotlin.test.Test import kotlin.test.assertEquals import kotlin.test.assertNotNull import kotlin.test.assertNull +import kotlin.test.assertTrue import kotlinx.coroutines.runBlocking import mobi.giza.compose.database.model.types.DkgApprovalStep import mobi.giza.compose.database.model.types.DkgRitualStage import mobi.giza.compose.extensions.toHex +import mobi.giza.compose.nostr.dkg.DkgRitualEvents /** * A key ceremony run from proposal to key, across devices, with real ChillDKG. @@ -19,53 +22,139 @@ import mobi.giza.compose.extensions.toHex * Every other ceremony test stops at the host key, or gets its key from a trusted * dealer, so the rounds -- the part that makes the key -- were only ever run on a * phone. [CeremonyNetwork] plays the relay. + * + * Joining is the only thing a member is asked (docs/automatic-key-ceremony.md), so + * every ceremony here is driven by joins and deliveries and nothing else. */ class CeremonyAcrossDevicesJvmTest { - /** - * Today's gates, pinned: joining is not enough. Every member stops at round 1 - * and waits to be asked, and stops again at round 2. - */ + /** The whole change: after the joins, nobody is asked anything and the key exists. */ @Test - fun `members who have only joined are each asked to contribute`(): Unit = runBlocking { + fun `members who have only joined finish the ceremony`(): Unit = runBlocking { CeremonyNetwork.nip17(size = 3).use { network -> val session = network.propose(threshold = 2) network.deliverUntilQuiet() - network.devices.drop(1).forEach { member -> - assertEquals(DkgApprovalStep.HOST_KEY, network.pendingApproval(member, session.id)) - network.approve(member, session.id, DkgApprovalStep.HOST_KEY) - } + joinAll(network, session.id, network.devices) network.deliverUntilQuiet() network.devices.forEach { device -> - assertEquals( - DkgApprovalStep.ROUND_1, - network.pendingApproval(device, session.id), - "$device waits to be asked to contribute", - ) - assertEquals(DkgRitualStage.COLLECTING_HOST_KEYS, network.session(device, session.id)!!.stage) + assertNull(network.pendingApproval(device, session.id), "$device is asked nothing more") } + assertOneKey(network, session.id, network.devices) } } - /** With every approval given, every device ends with the same key. */ + /** Opening a ceremony is joining it, and the coordinator is never asked a thing. */ @Test - fun `a group's own ceremony makes one key across three devices`(): Unit = runBlocking { + fun `the coordinator is never asked`(): Unit = runBlocking { CeremonyNetwork.nip17(size = 3).use { network -> + val session = network.propose(threshold = 2) + assertNull(network.pendingApproval(network.coordinator, session.id)) + + network.deliverUntilQuiet() + assertNull(network.pendingApproval(network.coordinator, session.id)) + + joinAll(network, session.id, network.devices) + network.deliverUntilQuiet() + + assertEquals(DkgRitualStage.COMPLETE, network.session(network.coordinator, session.id)!!.stage) + } + } + + /** + * The last member to join already holds everyone else's host key, so the one + * approval carries them straight on into contributing. + */ + @Test + fun `the last member to join contributes in the same approval`(): Unit = runBlocking { + CeremonyNetwork.nip17(size = 3).use { network -> + val (_, first, last) = network.devices val session = network.propose(threshold = 2) network.deliverUntilQuiet() - for (step in DkgApprovalStep.entries) { - network.devices.forEach { device -> - if (network.pendingApproval(device, session.id) == step) { - network.approve(device, session.id, step) + network.approve(first, session.id, DkgApprovalStep.HOST_KEY) + network.deliverUntilQuiet() + + assertTrue(network.sent(last, DkgRitualEvents.HOST_KEY).isEmpty()) + network.approve(last, session.id, DkgApprovalStep.HOST_KEY) + + assertEquals(1, network.sent(last, DkgRitualEvents.HOST_KEY).size) + assertEquals( + 1, + network.sent(last, DkgRitualEvents.ROUND_1).size, + "joining last puts the contribution out with the host key", + ) + } + } + + /** + * What the round-2 approval was said to protect against, and the reason it was + * never a person's to give: a combined result that is not the one every member + * contributed to never becomes anybody's key. ChillDKG catches it -- a member + * whose share it breaks refuses at round 2, and otherwise the confirmations + * disagree and no certificate can be made over them -- and the ceremony ends + * for everyone with nobody asked anything. + * + * Here the change is in transit, so the coordinator is honest and is the one + * that finds the confirmations disagree and says so. + */ + @Test + fun `a combined result that was tampered with becomes nobody's key`(): Unit = + runBlocking { + CeremonyNetwork.nip17(size = 3).use { network -> + network.tamper = { sender, _, event -> + if (sender === network.coordinator && event.kind == DkgRitualEvents.COORDINATOR_ROUND_1) { + Event( + id = event.id, + pubKey = event.pubKey, + createdAt = event.createdAt, + kind = event.kind, + tags = event.tags, + content = flipLastByte(event.content), + sig = "", + ) + } else { + event } } - network.deliverUntilQuiet() - } - assertOneKey(network, session.id, network.devices) + val session = network.propose(threshold = 2) + network.deliverUntilQuiet() + joinAll(network, session.id, network.devices) + network.deliverUntilQuiet() + + network.devices.forEach { device -> + val theirs = assertNotNull(network.session(device, session.id)) + assertEquals(DkgRitualStage.FAILED, theirs.stage, "$device: the ceremony ended") + assertNull(theirs.thresholdPublicKey, "$device holds no key") + assertNull(theirs.secretShare, "$device keeps no share of one") + assertNull(network.pendingApproval(device, session.id), "$device was asked nothing") + } + + // Which device notices depends on which bytes were changed. That + // somebody did, out loud, is what lets the rest stop waiting. + assertTrue( + network.devices.any { network.sent(it, DkgRitualEvents.FAILURE).isNotEmpty() }, + "somebody told the group", + ) + } + } + + /** A round approval from a screen left open across the upgrade publishes nothing. */ + @Test + fun `approving a round does nothing`(): Unit = runBlocking { + CeremonyNetwork.nip17(size = 3).use { network -> + val member = network.devices[1] + val session = network.propose(threshold = 2) + network.deliverUntilQuiet() + + network.approve(member, session.id, DkgApprovalStep.ROUND_1) + network.approve(member, session.id, DkgApprovalStep.ROUND_2) + + assertTrue(network.sent(member, DkgRitualEvents.HOST_KEY).isEmpty(), "it has not joined") + assertTrue(network.sent(member, DkgRitualEvents.ROUND_1).isEmpty()) + assertEquals(DkgApprovalStep.HOST_KEY, network.pendingApproval(member, session.id)) } } @@ -90,20 +179,24 @@ class CeremonyAcrossDevicesJvmTest { ) network.deliverUntilQuiet(random) - for (step in DkgApprovalStep.entries) { - picked.forEach { device -> - if (network.pendingApproval(device, session.id) == step) { - network.approve(device, session.id, step) - } - } - network.deliverUntilQuiet(random) - } + joinAll(network, session.id, picked) + network.deliverUntilQuiet(random) assertOneKey(network, session.id, picked) assertNull(network.session(outsider, session.id), "the member not picked records nothing") } } + private suspend fun joinAll( + network: CeremonyNetwork, + sessionId: String, + devices: List, + ) = devices.forEach { device -> + if (network.pendingApproval(device, sessionId) == DkgApprovalStep.HOST_KEY) { + network.approve(device, sessionId, DkgApprovalStep.HOST_KEY) + } + } + private suspend fun assertOneKey( network: CeremonyNetwork, sessionId: String, @@ -135,5 +228,11 @@ class CeremonyAcrossDevicesJvmTest { threshold = 2 ).thresholdPublicKey.value.toHex() ) + + /** The same bytes with the last one changed: well-formed, and wrong. */ + fun flipLastByte(hex: String): String { + val last = hex.takeLast(2).toInt(16) xor 0x01 + return hex.dropLast(2) + last.toString(16).padStart(2, '0') + } } } diff --git a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/CeremonyNetwork.kt b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/CeremonyNetwork.kt index 096c23f6..9790809d 100644 --- a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/CeremonyNetwork.kt +++ b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/CeremonyNetwork.kt @@ -59,6 +59,18 @@ class CeremonyNetwork private constructor( /** Which messages each device has already been handed, by device and event id. */ private val delivered = mutableSetOf>() + /** + * What the relay does to a message on its way to one receiver: the identity by + * default. A test standing in for a dishonest sender rewrites it here, which is + * the same as the sender having written it that way -- nothing on the path + * checks a rumor's id against its content. + */ + var tamper: (sender: Device, receiver: Device, event: Event) -> Event = { _, _, event -> event } + + /** Everything [device] has queued for its room, of [kind]. */ + suspend fun sent(device: Device, kind: Int): List = + outboundOf(device).filter { it.kind == kind } + val coordinator: Device get() = devices.first() /** The device's own copy of the room, read fresh: the ritual rewrites it. */ @@ -116,11 +128,13 @@ class CeremonyNetwork private constructor( devices .filter { it !== sender } .filter { (it.publicKey to event.id) !in delivered } - .map { receiver -> receiver to event } + .map { receiver -> Triple(sender, receiver, event) } }.let { if (random != null) it.shuffled(random) else it } - handings.forEach { (receiver, event) -> - delivered += receiver.publicKey to event.id + handings.forEach { (sender, receiver, sent) -> + delivered += receiver.publicKey to sent.id + val event = tamper(sender, receiver, sent) + store(receiver, event) ChillDkgRitualManager.processRitualPayload( database = receiver.db,