diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/FrostSigningSessionDao.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/FrostSigningSessionDao.kt index b1f23073..0f30919c 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/FrostSigningSessionDao.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/FrostSigningSessionDao.kt @@ -83,6 +83,13 @@ interface FrostSigningSessionDao { suspend fun getSessionsForChatRoom(chatRoomId: String): List /** Sessions of one key still running: what a share rotation has to end. */ + /** Sessions still running that [userPublicKey]'s owner has neither approved nor declined. */ + @Query( + "SELECT * FROM FrostSigningSession WHERE userPublicKey = :userPublicKey AND stage NOT IN ('COMPLETE', 'FAILED') " + + "AND signApprovedAt IS NULL AND signDeclinedAt IS NULL ORDER BY createdAt ASC" + ) + suspend fun getOpenUnansweredSessionsFor(userPublicKey: HexKey): List + @Query("SELECT * FROM FrostSigningSession WHERE dkgSessionId = :dkgSessionId AND stage NOT IN ('COMPLETE', 'FAILED')") suspend fun getOpenSessionsForKey(dkgSessionId: String): List diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/repository/DatabaseNostrRepository.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/repository/DatabaseNostrRepository.kt index 414a37cf..7d105ec7 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/repository/DatabaseNostrRepository.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/repository/DatabaseNostrRepository.kt @@ -59,6 +59,7 @@ import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import mobi.giza.compose.managers.ChillDkgRitualManager +import mobi.giza.compose.managers.FrostSigningManager import mobi.giza.compose.managers.ShareRefreshManager import com.vitorpamplona.quartz.nip01Core.core.toHexKey import mobi.giza.compose.identity.Identity @@ -154,6 +155,9 @@ class DatabaseNostrRepository( database = database, userPublicKey = userPublicKey, nostrPrivateKey = privateKey + ) + FrostSigningManager.resumeVouched( + database = database, + userPublicKey = userPublicKey, ) } } diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostSigningManager.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostSigningManager.kt index 8fcca9db..a3a9095e 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostSigningManager.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostSigningManager.kt @@ -441,14 +441,14 @@ object FrostSigningManager { } // The other answer a device can give on its owner's behalf, and only to one - // question: what the room a ceremony it finished signs with. For that there - // is exactly one true statement, and `vouchesFor` signs nothing else -- - // any other proposal, a key state included, is asked about as before. - // docs/automatic-key-ceremony.md, Phase 7. - if (FrostSigningEvents.isProposal(innerEvent.kind) && signsAsItsOwnKeyState(database, session)) { - logger.i("Session ${session.id} is the key state of a ceremony this device finished; signing") - update(database, session) { it.copy(signApprovedAt = Clock.System.now()) } - } + // question: what the room a ceremony it finished signs with, or a rotation + // it completed. For that there is exactly one true statement, and + // `vouchesFor` signs nothing else -- any other proposal, a key state + // included, is asked about as before. docs/automatic-key-ceremony.md, + // Phase 7, and docs/rotate-shares-single-approval.md, Phase 5. + // A rotation's key state can arrive before the rotation completes here, and + // is asked again then ([resumeAt]). + if (FrostSigningEvents.isProposal(innerEvent.kind)) approveIfVouched(database, session) if (session.stage == FrostSigningStage.FAILED) { logger.i("Session $sessionId already failed; ignoring kind ${innerEvent.kind}") @@ -1941,11 +1941,45 @@ object FrostSigningManager { * [generation], which has just become signable here. A session proposed while * this device still waited on that generation's certificate stops at the share * it did not yet have; nothing else would wake it until the next message. + * + * That includes the generation's own key state, which the coordinator proposes + * the moment its certificate verifies -- often before this device's. On arrival + * this device could not vouch for it, since the rotation it names was not yet + * complete here; now it can, so it asks again rather than leaving the owner a + * question the device can answer (docs/rotate-shares-single-approval.md, Phase 5). */ suspend fun resumeAt(database: GizaDatabase, localChatRoom: LocalChatRoom, dkgSessionId: String, generation: Int) { database.frostSigningSessionDao().getOpenSessionsForKey(dkgSessionId) .filter { (it.generation ?: 0) == generation && it.chatRoomId == localChatRoom.chatRoom.id } - .forEach { advance(database, localChatRoom, it.id) } + .forEach { session -> + approveIfVouched(database, session) + advance(database, localChatRoom, session.id) + } + } + + /** + * Signs every open key state this user's device can now vouch for and has not + * been answered about -- what a build that asked about them left waiting. Run + * by the sweep beside the rituals' (docs/rotate-shares-single-approval.md, + * Phase 5). Returns how many it approved. + */ + suspend fun resumeVouched(database: GizaDatabase, userPublicKey: HexKey): Int { + var approved = 0 + database.frostSigningSessionDao().getOpenUnansweredSessionsFor(userPublicKey).forEach { session -> + if (!approveIfVouched(database, session)) return@forEach + val localChatRoom = database.chatRoomDao().findChatRoomById(session.chatRoomId) ?: return@forEach + advance(database, localChatRoom, session.id) + approved += 1 + } + return approved + } + + /** Approves [session] on its owner's behalf when [signsAsItsOwnKeyState] says this device can. */ + private suspend fun approveIfVouched(database: GizaDatabase, session: FrostSigningSession): Boolean { + if (!signsAsItsOwnKeyState(database, session)) return false + logger.i("Session ${session.id} is a key state this device can vouch for; signing") + update(database, session) { it.copy(signApprovedAt = Clock.System.now()) } + return true } /** diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/GroupKeyStateManager.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/GroupKeyStateManager.kt index 0b1dcab3..60c82131 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/GroupKeyStateManager.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/GroupKeyStateManager.kt @@ -13,6 +13,7 @@ import mobi.giza.compose.database.model.types.DkgRitualStage import mobi.giza.compose.database.model.GroupKeyState import mobi.giza.compose.database.model.GroupSignedEvent import mobi.giza.compose.database.model.intermdiate.LocalChatRoom +import mobi.giza.compose.database.model.types.ShareRefreshStage import mobi.giza.compose.database.model.types.ShareStanding import mobi.giza.compose.nostr.frost.GroupKeyStateEvent import mobi.giza.compose.nostr.subgroup.SubgroupBirthCertificateEvent @@ -616,11 +617,13 @@ object GroupKeyStateManager { * [claimFrom] checks the derivation, the same check [stateFrom] makes; * 6. claiming the parent the ceremony was run for, or none for a group's own, * with a certificate that parent's quorum signed -- [claimFrom] again; - * 7. with no state for that room already signed on this device; - * 8. and naming no share generation and no member binding. A rotation's key - * state, or one binding an id to a new identity, says more than the - * ceremony did -- which shares the group now signs with, who holds an id -- - * and that is its owner's to agree to (docs/frost-share-refresh.md). + * 7. with no state for that room already signed on this device -- or, for a + * state naming share generation `h`, none signed at `h` or later; + * 8. and naming no share generation and no member binding -- **unless** it + * is the one key state a rotation this device completed implies + * ([vouchesForGeneration], docs/rotate-shares-single-approval.md, Phase 5). + * A state binding an id to a new identity is never vouched for: who holds + * an id is governance, not arithmetic, and its owner decides it. */ suspend fun vouchesFor( database: GizaDatabase, @@ -652,13 +655,72 @@ object GroupKeyStateManager { // 6's parent if (claim.parentChatRoomId != key.parentChatRoomId) return false - // 7 val signed = stateAmong(database.groupSignedEventDao().getByKind(GroupKeyStateEvent.KIND), claim.chatRoomId) - if (signed != null) return false + val generation = claim.generation + if (generation == null) { + // 7, for a ceremony's state + if (signed != null) return false + // 8: a binding is never vouched for + return claim.memberBindings == null + } + // 7, for a rotation's + if (signed != null && (signed.generation ?: 0) >= generation) return false // 8 - if (claim.generation != null || claim.memberBindings != null) return false + return vouchesForGeneration(database, session, key, unsigned, claim, signed) + } + /** + * Whether a key state naming share generation `h` is exactly the one a + * rotation this device completed implies (docs/rotate-shares-single-approval.md, + * Phase 5). For such a rotation every fact the state names is one this device + * holds and has checked against the certificate: the table, the rotation, who + * it retired. So there is one true statement, and a person shown it has + * nothing to add. Every one of these has to hold: + * + * - generation `h` is the one this device signs with, and it holds a share + * of it -- a device withheld from `h` neither signs at `h` nor vouches for + * a table it did not help make; + * - the rotation that made `h` is the one the state names, and it is + * complete here; + * - the state's public-share hash is this device's table at `h`; + * - the ids it retires are the ids this device's roster at `h` retires; + * - it binds no id to a new identity; + * - the signing session is at `h`; + * - its path and parent are the ones the room's signed state already names, + * when there is one -- [proposeGeneration] copies them from it. + */ + private suspend fun vouchesForGeneration( + database: GizaDatabase, + session: FrostSigningSession, + key: DkgSession, + unsigned: Event, + claim: GroupKeyState, + signed: GroupKeyState?, + ): Boolean { + val generation = claim.generation ?: return false + val tags = GroupKeyStateEvent.parseShareGeneration(unsigned.tags).getOrNull() ?: return false + if (tags.bindings.isNotEmpty() || claim.memberBindings != null) return false + if ((session.generation ?: 0) != generation) return false + + val active = ShareGenerations.active(database, key) + if (active.generation != generation || active.secretShare == null) return false + val publicShares = active.publicShares ?: return false + if (ShareGenerations.publicSharesHash(publicShares) != claim.publicSharesHash) return false + if (tags.retiredIds.sorted() != active.roster.filter { it.standing == ShareStanding.RETIRED }.map { it.participantId }.sorted()) return false + + val refreshId = tags.refreshId ?: return false + val row = database.keyShareDao().getGeneration(key.id, generation) ?: return false + if (row.refreshSessionId != refreshId) return false + val refresh = database.shareRefreshDao().getSessionById(refreshId) ?: return false + if (refresh.stage != ShareRefreshStage.COMPLETE || refresh.dkgSessionId != key.id || refresh.baseGeneration + 1 != generation) return false + + if (signed != null) { + if (claim.derivationPath != signed.derivationPath) return false + if (claim.parentChatRoomId != signed.parentChatRoomId) return false + val certificate = { json: String? -> json?.let { Event.fromJsonOrNull(it)?.id } } + if (certificate(claim.birthCertificateJson) != certificate(signed.birthCertificateJson)) return false + } return true } diff --git a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/ShareRefreshRitualJvmTest.kt b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/ShareRefreshRitualJvmTest.kt index 03f6d9d2..fbe26bbd 100644 --- a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/ShareRefreshRitualJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/ShareRefreshRitualJvmTest.kt @@ -493,13 +493,13 @@ class ShareRefreshRitualJvmTest { } /** - * What a recipient is asked before the old shares are deleted: to take part, - * and -- until Phase 5 -- to sign the new generation's key state. The - * proposer is asked nothing: proposing was taking part, its device proposes - * the key state, and a proposer's signature is its proposal. + * The whole of the change: a recipient is asked one thing before the old + * shares are deleted -- to take part. Storing the new share and signing the + * new generation's key state follow from it. The proposer is asked nothing: + * proposing was taking part. */ @Test - fun `a recipient is asked to take part and to sign the new key state`() = runBlocking { + fun `a recipient is asked only to take part`() = runBlocking { val group = Group(3, 2) val all = devicesFor(group) val refresh = propose(all[0]) @@ -508,7 +508,7 @@ class ShareRefreshRitualJvmTest { val rotation = listOf(Ask.Rotation(mobi.giza.compose.database.model.types.ShareRefreshApprovalStep.DEAL)) assertEquals(emptyList(), asks[0], "the proposer, whose proposal was its answer") - all.drop(1).forEach { device -> assertEquals(rotation + Ask.KeyState, asks[device.index], "device ${device.index}") } + all.drop(1).forEach { device -> assertEquals(rotation, asks[device.index], "device ${device.index}") } all.forEach { device -> assertEquals(1, device.db.groupKeyStateDao().getByChatRoomId(group.roomId)?.generation, "device ${device.index}") assertNull(device.key().secretShare, "device ${device.index} kept the old share") @@ -516,29 +516,147 @@ class ShareRefreshRitualJvmTest { } /** - * Today's key state, pinned: a rotation complete on every device still waits - * on each owner but the proposer's to sign the new generation, and until a quorum has, every - * device keeps the share it was meant to delete. + * A completed rotation's key state is the one statement its recipients' + * devices can vouch for, so they sign it with nobody asked, and every device + * deletes the share it was meant to delete. */ @Test - fun `a completed rotation waits on its owners to sign the new key state`() = runBlocking { + fun `a completed rotation signs its new key state and the old shares go, with nobody asked`() = runBlocking { val group = Group(3, 2) val all = devicesFor(group) val refresh = propose(all[0]) pump(all) - approveAll(all, refresh.id) + all.forEach { ShareRefreshManager.approve(it.db, it.room, refresh.id, it.privateKey) } pump(all) - all.forEach { assertEquals(ShareRefreshStage.COMPLETE, it.refresh(refresh.id)?.stage) } - all.drop(1).forEach { device -> + all.forEach { device -> + assertEquals(ShareRefreshStage.COMPLETE, device.refresh(refresh.id)?.stage) + assertEquals(1, device.db.groupKeyStateDao().getByChatRoomId(group.roomId)?.generation, "device ${device.index}") + assertNull(device.key().secretShare, "device ${device.index} kept the old share") val signing = device.db.frostSigningSessionDao() - val keyState = signing.getSessionsForChatRoom(group.roomId).single() - assertEquals(1, keyState.generation) - assertTrue(FrostSigningManager.isAwaitingApproval(keyState, signing.getItems(keyState.id)), "device ${device.index} was not asked") - assertNotNull(device.key().secretShare, "device ${device.index} deleted before the group signed") + assertTrue(signing.getSessionsForChatRoom(group.roomId).none { FrostSigningManager.isAwaitingApproval(it, signing.getItems(it.id)) }, "device ${device.index} was asked") } } + /** + * The coordinator proposes the key state the moment its own certificate + * verifies, so a recipient can hear the proposal first. It cannot vouch for a + * rotation not yet complete here; once the certificate arrives, it can, and + * does, without its owner. + */ + @Test + fun `a key state heard before the certificate is vouched for once the certificate arrives`() = runBlocking { + val group = Group(3, 2) + val all = devicesFor(group) + val refresh = propose(all[0]) + pump(all) + all.forEach { ShareRefreshManager.approve(it.db, it.room, refresh.id, it.privateKey) } + pump(all, hold = { it.kind == ShareRefreshEvents.CERTIFICATE }) + + val member = all[1] + val signing = member.db.frostSigningSessionDao() + val keyState = signing.getSessionsForChatRoom(group.roomId).single() + assertEquals(1, keyState.generation) + assertNull(keyState.signApprovedAt, "not vouched for before the rotation completes here") + assertTrue(member.refresh(refresh.id)!!.stage != ShareRefreshStage.COMPLETE) + + pump(all) + assertNotNull(signing.getSessionById(keyState.id)?.signApprovedAt, "vouched for once it completes") + all.forEach { device -> + assertEquals(1, device.db.groupKeyStateDao().getByChatRoomId(group.roomId)?.generation, "device ${device.index}") + assertNull(device.key().secretShare, "device ${device.index}") + } + } + + /** Each rule, broken on its own, leaves a rotation's key state with the member. */ + @Test + fun `a device vouches for its rotation's key state and nothing else`() = runBlocking { + val group = Group(3, 2) + val all = devicesFor(group) + val refresh = propose(all[0]) + pump(all) + // Every device completes the rotation; the key state is proposed, and held. + all.forEach { ShareRefreshManager.approve(it.db, it.room, refresh.id, it.privateKey) } + pump(all, hold = { FrostSigningEvents.isProposal(it.kind) }) + val (coordinator, member) = all + assertEquals(ShareRefreshStage.COMPLETE, member.refresh(refresh.id)?.stage) + + val proposed = coordinator.db.frostSigningSessionDao().getSessionsForChatRoom(group.roomId).single() + val session = proposed.copy(userPublicKey = member.publicKey, signApprovedAt = null) + val item = coordinator.db.frostSigningSessionDao().getItems(proposed.id).single() + val event = Event.fromJson(item.unsignedEventJson) + fun with(tags: Array>) = listOf(item.copy(unsignedEventJson = Event(event.id, event.pubKey, event.createdAt, event.kind, tags, event.content, event.sig).toJson())) + fun replacing(name: String, value: String) = with(event.tags.map { if (it.firstOrNull() == name) arrayOf(name, value) else it }.toTypedArray()) + suspend fun vouches(on: Device = member, s: mobi.giza.compose.database.model.FrostSigningSession = session, items: List = listOf(item)) = + GroupKeyStateManager.vouchesFor(on.db, s.copy(userPublicKey = on.publicKey), items) + + assertTrue(vouches(), "the one true statement") + assertTrue(!vouches(items = replacing("frost_pubshares", "ab".repeat(32))), "another table") + assertTrue(!vouches(items = replacing("frost_refresh", "cd".repeat(32))), "another rotation") + assertTrue(!vouches(items = with(event.tags + arrayOf("frost_retired", group.idOf[2].toString()))), "retiring someone this rotation did not") + val binding = mobi.giza.compose.nostr.frost.GroupKeyStateEvent.MemberBinding(group.idOf[2], KeyPair().pubKey.toHexKey(), group.hostKeys[0]) + assertTrue(!vouches(items = with(event.tags + arrayOf("frost_member", binding.encode()))), "binding an id to a new identity") + assertTrue(!vouches(s = session.copy(generation = 0)), "a session at another generation") + assertTrue(!vouches(items = replacing("frost_generation", "2")), "a generation this device does not sign with") + assertTrue(!vouches(s = session.copy(derivationPath = SharedKeyDerivation.formatPath(listOf(9420L, 0L, 1L)))), "at another path") + + // A rotation not complete here: the same statement, from a device that has not finished. + member.db.shareRefreshDao().upsert(member.refresh(refresh.id)!!.copy(stage = ShareRefreshStage.COLLECTING_ROUND_2)) + assertTrue(!vouches(), "a rotation that is not complete here") + member.db.shareRefreshDao().upsert(member.refresh(refresh.id)!!.copy(stage = ShareRefreshStage.COMPLETE)) + + // Once the group has signed it, the next statement at the same generation is not the one true one. + all.forEach { it.received.clear() } + pump(all) + assertEquals(1, member.db.groupKeyStateDao().getByChatRoomId(group.roomId)?.generation) + assertTrue(!vouches(), "a room already holding a state at this generation") + } + + /** A member withheld from the rotation holds no share of it, and vouches for nothing it did not help make. */ + @Test + fun `a withheld member does not vouch for the new key state`() = runBlocking { + val group = Group(3, 2) + val all = devicesFor(group) + val withheld = all[2] + val refresh = propose(all[0], mapOf(group.idOf[2] to ShareStanding.STALE)) + pump(all) + all.forEach { ShareRefreshManager.approve(it.db, it.room, refresh.id, it.privateKey) } + pump(all, hold = { FrostSigningEvents.isProposal(it.kind) }) + assertEquals(ShareRefreshStage.COMPLETE, withheld.refresh(refresh.id)?.stage) + + val proposed = all[0].db.frostSigningSessionDao().getSessionsForChatRoom(group.roomId).single() + val items = all[0].db.frostSigningSessionDao().getItems(proposed.id) + assertTrue(GroupKeyStateManager.vouchesFor(all[1].db, proposed.copy(userPublicKey = all[1].publicKey), items), "a recipient does") + assertTrue(!GroupKeyStateManager.vouchesFor(withheld.db, proposed.copy(userPublicKey = withheld.publicKey), items), "the withheld member does not") + } + + /** A key state an older build left asking is answered by the sweep, once. */ + @Test + fun `a key state left asking by an older build is signed from the sweep`() = runBlocking { + val group = Group(3, 2) + val all = devicesFor(group) + val refresh = propose(all[0]) + pump(all) + all.forEach { ShareRefreshManager.approve(it.db, it.room, refresh.id, it.privateKey) } + pump(all, hold = { FrostSigningEvents.isProposal(it.kind) }) + + // The proposal arrives at a member as an older build filed it: stored, asked, not vouched for. + val member = all[1] + val proposal = outbox(all[0]).first { FrostSigningEvents.isProposal(it.kind) } + member.received += proposal.id + member.db.marmotInnerEventDao().upsert(proposal.copy(chatRoomId = group.roomId)) + val shareRefresh = member.refresh(refresh.id)!! + member.db.shareRefreshDao().upsert(shareRefresh.copy(stage = ShareRefreshStage.COLLECTING_ROUND_2)) + FrostSigningManager.processSigningPayload(member.db, member.room, Event(proposal.id, proposal.publicKey, proposal.createdAt.epochSeconds, proposal.kind, proposal.tags, proposal.content, ""), member.publicKey) + member.db.shareRefreshDao().upsert(shareRefresh) + val filed = member.db.frostSigningSessionDao().getSessionsForChatRoom(group.roomId).single() + assertNull(filed.signApprovedAt, "filed and asked, as the older build left it") + + assertEquals(1, FrostSigningManager.resumeVouched(member.db, member.publicKey)) + assertNotNull(member.db.frostSigningSessionDao().getSessionById(filed.id)?.signApprovedAt) + assertEquals(0, FrostSigningManager.resumeVouched(member.db, member.publicKey), "once") + } + @Test fun `a withheld member ends with the new table and no share, and declines to sign`() = runBlocking { val group = Group(3, 2) @@ -648,11 +766,15 @@ class ShareRefreshRitualJvmTest { val all = devicesFor(group) val refresh = propose(all[0]) pump(all) - approveAll(all, refresh.id) + // The key state is held on its way, so the rotation completes with nothing signed yet. + all.forEach { ShareRefreshManager.approve(it.db, it.room, refresh.id, it.privateKey) } + pump(all, hold = { FrostSigningEvents.isProposal(it.kind) }) + all.forEach { assertEquals(ShareRefreshStage.COMPLETE, it.refresh(refresh.id)?.stage) } // Not yet: the old share stays until the new ones have signed something. all.forEach { assertNotNull(it.key().secretShare, "device ${it.index} deleted before the group signed") } + pump(all) approveSigning(all) all.forEach { device ->