diff --git a/composeApp/src/commonMain/composeResources/values/strings.xml b/composeApp/src/commonMain/composeResources/values/strings.xml index 65dc161c..bf1770b1 100644 --- a/composeApp/src/commonMain/composeResources/values/strings.xml +++ b/composeApp/src/commonMain/composeResources/values/strings.xml @@ -456,6 +456,9 @@ Re-issue every member's share without changing the group's key or this room. Current share epoch: %1$s Next share epoch: %1$s + Active share epoch: %1$s + Unchanged group key: %1$s + Share holders: %1$s Refreshing does not erase old backups. If a threshold of old shares is compromised, make a new group key instead. Every share holder must take part before the new shares can activate. Commitments: %1$s of %2$s diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ChatMessageDao.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ChatMessageDao.kt index 32006323..4ffff0b8 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ChatMessageDao.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/dao/ChatMessageDao.kt @@ -71,6 +71,12 @@ interface ChatMessageDao { unresolvedTypes: Collection ): List + @Query( + "SELECT * FROM ChatMessage WHERE reEnrollmentSessionId = :sessionId " + + "AND messageType = :messageType AND senderPublicKey = :actor LIMIT 1" + ) + suspend fun findReEnrollmentNotice(sessionId: String, messageType: String, actor: HexKey): ChatMessage? + @Upsert suspend fun upsert(chatMessage: mobi.giza.compose.database.model.ChatMessage): Long } \ No newline at end of file diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/ChatMessage.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/ChatMessage.kt index bb2f5530..4cec6e2f 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/ChatMessage.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/database/model/ChatMessage.kt @@ -334,6 +334,22 @@ data class ChatMessage( val FROST_SETTLEMENTS = setOf(TYPE_FROST_COMPLETE, TYPE_FROST_FAILED) /** Every signing line, for rendering them as system lines rather than bubbles. */ + const val TYPE_REENROLLMENT_STARTED = "reEnrollmentStarted" + const val TYPE_REENROLLMENT_READY = "reEnrollmentReady" + const val TYPE_REENROLLMENT_ACTIVATING = "reEnrollmentActivating" + const val TYPE_REENROLLMENT_COMPLETE = "reEnrollmentComplete" + const val TYPE_REENROLLMENT_FAILED = "reEnrollmentFailed" + + val REENROLLMENT_TYPES = setOf( + TYPE_REENROLLMENT_STARTED, + TYPE_REENROLLMENT_READY, + TYPE_REENROLLMENT_ACTIVATING, + TYPE_REENROLLMENT_COMPLETE, + TYPE_REENROLLMENT_FAILED, + ) + + val REENROLLMENT_AUTHORED_TYPES = setOf(TYPE_REENROLLMENT_STARTED, TYPE_REENROLLMENT_FAILED) + val FROST_TYPES = setOf( TYPE_FROST_STARTED, TYPE_FROST_NONCE, diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManager.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManager.kt index 5603cf0a..71aebce2 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManager.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManager.kt @@ -20,11 +20,13 @@ import fr.acinq.bitcoin.crypto.frost.FrostRefresh import fr.acinq.bitcoin.crypto.frost.RefreshCandidate import fr.acinq.bitcoin.crypto.frost.RefreshDealerFault import fr.acinq.bitcoin.utils.Either +import fr.acinq.secp256k1.Secp256k1 import kotlin.time.Clock import kotlin.time.Duration.Companion.minutes import kotlin.time.Instant import kotlinx.coroutines.CancellationException import mobi.giza.compose.database.GizaDatabase +import mobi.giza.compose.database.model.ChatMessage import mobi.giza.compose.database.model.DkgSession import mobi.giza.compose.database.model.FrostReEnrollmentMessage import mobi.giza.compose.database.model.FrostReEnrollmentSession @@ -80,7 +82,9 @@ object FrostReEnrollmentManager { require(roomMembers.containsAll(participants)) { "Every share holder must be in the Marmot room" } require(participants.size == key.participantCount) { "The share-holder roster does not match the ceremony" } require(FrostSignerOrder.signerIdOf(database, key, userPublicKey) != null) { "This device is not a share holder" } - require(key.publicShareList()?.size == key.participantCount) { "A complete public-share table is required" } + require(hasValidPublicShares(key)) { + "A validated current public-share table is required; repair it with current members before refreshing" + } require( database.frostSigningSessionDao().getSessionsForChatRoom(localChatRoom.chatRoom.id) .none { it.dkgSessionId == key.id && it.stage != FrostSigningStage.COMPLETE && it.stage != FrostSigningStage.FAILED } @@ -105,6 +109,7 @@ object FrostReEnrollmentManager { joinApprovedAt = Clock.System.now(), ) database.frostReEnrollmentDao().upsert(session) + announceStarted(database, session) check( broadcast( database, localChatRoom, session, ReEnrollmentEvents.PROPOSAL, key.thresholdPublicKey.orEmpty(), @@ -246,7 +251,9 @@ object FrostReEnrollmentManager { sessionId: String, ) = database.frostReEnrollmentDao().getSessionById(sessionId)?.let { session -> if (session.stage != ReEnrollmentStage.ACTIVATING) return@let null - FrostSigningManager.proposeRefreshActivation(database, localChatRoom, userPublicKey, session) + val activation = FrostSigningManager.proposeRefreshActivation(database, localChatRoom, userPublicKey, session) + noteActivation(database, session) + activation } /** Validate and atomically apply a signed key-epoch state. */ @@ -264,7 +271,9 @@ object FrostReEnrollmentManager { val candidateShares = session.candidatePublicShareList() ?: return null val candidateSecret = session.candidateSecretShare ?: return null val currentState = GroupKeyStateManager.keyStateFor(database, chatRoomId) ?: return null - if (session.stage != ReEnrollmentStage.ACTIVATING) return null + if (session.stage != ReEnrollmentStage.ACTIVATING && + !(session.stage == ReEnrollmentStage.FAILED && session.readyAt != null) + ) return null if (key.shareEpoch != session.currentShareEpoch || currentState.shareEpoch != session.currentShareEpoch) return null if (state.shareEpoch != session.nextShareEpoch || state.refreshSessionId != session.id) return null if (state.refreshTranscriptHash != session.transcriptHash) return null @@ -298,6 +307,10 @@ object FrostReEnrollmentManager { ) database.frostReEnrollmentDao().scrubMessagesByKind(session.id, ReEnrollmentEvents.PRIVATE_EVALUATION) database.marmotInnerEventDao().scrubContentByChatRoomAndKind(chatRoomId, ReEnrollmentEvents.PRIVATE_EVALUATION) + announce( + database, session, ChatMessage.TYPE_REENROLLMENT_COMPLETE, + "Share epoch ${session.nextShareEpoch} is active. The previous local share material was retired.", + ) } } return state @@ -336,7 +349,7 @@ object FrostReEnrollmentManager { if (nextEpoch != key.shareEpoch + 1 || threshold != key.threshold || members.size != key.participantCount) return null if (!thresholdPublicKey.equals(key.thresholdPublicKey, ignoreCase = true)) return null if (state.dkgSessionId != key.id || state.shareEpoch != key.shareEpoch || previousState.id != previousStateId) return null - if (key.publicShareList()?.size != key.participantCount) return null + if (!hasValidPublicShares(key)) return null val session = FrostReEnrollmentSession( id = sessionId, @@ -353,6 +366,7 @@ object FrostReEnrollmentManager { dealerRandom = RandomInstance.bytes(32).toHex(), ) database.frostReEnrollmentDao().upsert(session) + announceStarted(database, session) replayStoredMessages(database, localChatRoom, session) return session } @@ -508,7 +522,13 @@ object FrostReEnrollmentManager { val ready = database.frostReEnrollmentDao().getMessagesByKind(session.id, ReEnrollmentEvents.READY) if (ready.size < session.participantCount || ready.any { it.payload != session.transcriptHash }) return - moveTo(database, session, ReEnrollmentStage.ACTIVATING) + val activating = moveTo(database, session, ReEnrollmentStage.ACTIVATING) + if (session.stage != ReEnrollmentStage.ACTIVATING && activating.stage == ReEnrollmentStage.ACTIVATING) { + announce( + database, session, ChatMessage.TYPE_REENROLLMENT_READY, + "All ${session.participantCount} members verified the same candidate for share epoch ${session.nextShareEpoch}.", + ) + } } catch (e: CancellationException) { throw e } catch (e: Throwable) { @@ -521,6 +541,39 @@ object FrostReEnrollmentManager { } } + private suspend fun announceStarted(database: GizaDatabase, session: FrostReEnrollmentSession) = announce( + database, session, ChatMessage.TYPE_REENROLLMENT_STARTED, + "proposed refreshing every member's signing share without changing the group key.", + ) + + suspend fun noteActivation(database: GizaDatabase, session: FrostReEnrollmentSession) = announce( + database, session, ChatMessage.TYPE_REENROLLMENT_ACTIVATING, + "A quorum was asked to sign share epoch ${session.nextShareEpoch} into use.", + ) + + private suspend fun announce( + database: GizaDatabase, + session: FrostReEnrollmentSession, + messageType: String, + content: String, + actor: HexKey = session.coordinatorPublicKey, + ) { + if (database.chatMessageDao().findReEnrollmentNotice(session.id, messageType, actor) != null) return + database.chatMessageDao().upsert( + ChatMessage( + senderPublicKey = actor, + isUserMessage = actor == session.userPublicKey, + giftWrapPayloadId = null, + marmotGroupEventId = null, + marmotInnerEventId = null, + chatRoomId = session.chatRoomId, + content = content, + messageType = messageType, + reEnrollmentSessionId = session.id, + ) + ) + } + private suspend fun activeKey(database: GizaDatabase, session: FrostReEnrollmentSession): DkgSession = database.dkgSessionDao().getSessionById(session.dkgSessionId)?.takeIf { it.stage == DkgRitualStage.COMPLETE && it.shareEpoch == session.currentShareEpoch @@ -571,6 +624,17 @@ object FrostReEnrollmentManager { return Crypto.sha256(input.encodeToByteArray()).toHex() } + fun hasValidPublicShares(key: DkgSession): Boolean { + val shares = key.publicShareList() ?: return false + if (shares.size != key.participantCount) return false + val thresholdPublicKey = key.thresholdPublicKey?.hexToByteArray() ?: return false + return runCatching { + Secp256k1.frostThresholdInfoValidate( + thresholdPublicKey, shares.map { it.value.toByteArray() }.toTypedArray(), key.threshold, + ) + }.getOrDefault(false) + } + /** Hash a public-share table. This contains no secret material. */ fun publicSharesHash(publicShares: List): String = Crypto.sha256((PUBLIC_SHARES_TAG + publicShares.joinToString(",") { it.value.toHex() }).encodeToByteArray()).toHex() @@ -655,10 +719,15 @@ object FrostReEnrollmentManager { stage = ReEnrollmentStage.FAILED, failureReason = reason, dealerRandom = null, - candidateSecretShare = null, + candidateSecretShare = if (current.readyAt == null) null else current.candidateSecretShare, ) } database.frostReEnrollmentDao().scrubMessagesByKind(session.id, ReEnrollmentEvents.PRIVATE_EVALUATION) + announce( + database, current, ChatMessage.TYPE_REENROLLMENT_FAILED, + "abandoned the share refresh. The previous group key and active share epoch are unchanged.", + actor = current.userPublicKey, + ) broadcast(database, localChatRoom, current, ReEnrollmentEvents.FAILURE, reason) } 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 bbacd2e4..86f0cb94 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostSigningManager.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/managers/FrostSigningManager.kt @@ -634,7 +634,8 @@ object FrostSigningManager { if (innerEvent.kind != FrostSigningEvents.PROPOSAL_V2 || refresh.dkgSessionId != key.id || refresh.nextShareEpoch != proposalEpoch || refresh.candidateSecretShare == null || refresh.candidatePublicShareList() == null || - refresh.stage != mobi.giza.compose.database.model.types.ReEnrollmentStage.ACTIVATING + (refresh.stage != mobi.giza.compose.database.model.types.ReEnrollmentStage.ACTIVATING && + !(refresh.stage == mobi.giza.compose.database.model.types.ReEnrollmentStage.FAILED && refresh.readyAt != null)) ) { logger.w("Signing proposal $sessionId does not have a valid activation candidate; dropping") return null @@ -741,6 +742,7 @@ object FrostSigningManager { database.frostSigningSessionDao().upsert(session) database.frostSigningSessionDao().upsertItems(itemsOver(sessionId, unsignedEvents)) announceStarted(database, session) + refresh?.let { FrostReEnrollmentManager.noteActivation(database, it) } logger.i( "Recorded signing session $sessionId over ${describe(unsignedEvents.size)} " + @@ -1063,7 +1065,8 @@ object FrostSigningManager { refresh.stage !in setOf( mobi.giza.compose.database.model.types.ReEnrollmentStage.ACTIVATING, mobi.giza.compose.database.model.types.ReEnrollmentStage.COMPLETE, - ) + ) && !(refresh.stage == mobi.giza.compose.database.model.types.ReEnrollmentStage.FAILED && + refresh.readyAt != null) ) ) { logger.i("Activation session $sessionId has no matching staged candidate; leaving it") @@ -2266,7 +2269,8 @@ object FrostSigningManager { refresh.stage !in setOf( mobi.giza.compose.database.model.types.ReEnrollmentStage.ACTIVATING, mobi.giza.compose.database.model.types.ReEnrollmentStage.COMPLETE, - ) + ) && !(refresh.stage == mobi.giza.compose.database.model.types.ReEnrollmentStage.FAILED && + refresh.readyAt != null) ) ) { logger.i("Activation session $sessionId has no staged candidate to resend") diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ChatRoomMessagingScreen.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ChatRoomMessagingScreen.kt index 45ac06e2..a4797b61 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ChatRoomMessagingScreen.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ChatRoomMessagingScreen.kt @@ -49,6 +49,7 @@ import mobi.giza.compose.repository.NostrRepository import mobi.giza.compose.ui.composable.navigation.routes.ChatRoomDetailRoute import mobi.giza.compose.ui.composable.navigation.routes.DkgRitualRoute import mobi.giza.compose.ui.composable.navigation.routes.ProposalListRoute +import mobi.giza.compose.ui.composable.navigation.routes.ReEnrollmentRoute import mobi.giza.compose.ui.composable.navigation.routes.proposalDestination import mobi.giza.compose.ui.composable.navigation.routes.Route import mobi.giza.compose.ui.composable.widgets.LoadingDataIndicator @@ -196,6 +197,11 @@ fun ChatRoomMessagingScreen( ) ) }, + onOpenReEnrollment = { sessionId -> + onNavigateToRoute( + ReEnrollmentRoute(activeUserPublicKey, chatRoomId, sessionId) + ) + }, // The notice has just counted the proposals // waiting on this member and said so. Opening // the room's whole signing history from it diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ReEnrollmentScreen.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ReEnrollmentScreen.kt index 3fc5cf0c..55710200 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ReEnrollmentScreen.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/ReEnrollmentScreen.kt @@ -21,6 +21,7 @@ import androidx.compose.material3.TopAppBar import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect import androidx.compose.ui.Modifier +import androidx.compose.ui.text.style.TextOverflow import androidx.lifecycle.viewmodel.compose.viewModel import mobi.giza.compose.database.model.types.ReEnrollmentPurpose import mobi.giza.compose.database.model.types.ReEnrollmentStage @@ -29,6 +30,7 @@ import mobi.giza.compose.repository.ChatRepository import mobi.giza.compose.repository.ReEnrollmentRepository import mobi.giza.compose.resources.Res import mobi.giza.compose.resources.abandon +import mobi.giza.compose.resources.active_share_epoch import mobi.giza.compose.resources.approve_share_repair import mobi.giza.compose.resources.ask_again import mobi.giza.compose.resources.commitments_received @@ -44,6 +46,7 @@ import mobi.giza.compose.resources.refresh_backup_warning import mobi.giza.compose.resources.refresh_complete import mobi.giza.compose.resources.refresh_error import mobi.giza.compose.resources.refresh_failed +import mobi.giza.compose.resources.refresh_member_roster import mobi.giza.compose.resources.refresh_pending_activation import mobi.giza.compose.resources.refresh_shares_description import mobi.giza.compose.resources.refresh_signing_shares @@ -55,6 +58,7 @@ import mobi.giza.compose.resources.repair_helpers_responded import mobi.giza.compose.resources.repair_public_table_verified import mobi.giza.compose.resources.repair_share import mobi.giza.compose.resources.refresh_stage +import mobi.giza.compose.resources.refresh_unchanged_group_key import mobi.giza.compose.resources.refresh_waiting_on_members import mobi.giza.compose.ui.composable.navigation.routes.ReEnrollmentRoute import mobi.giza.compose.ui.composable.navigation.routes.Route @@ -134,11 +138,31 @@ fun ReEnrollmentScreen( Text(stringResource(Res.string.refresh_shares_description)) Text(stringResource(Res.string.refresh_all_members_required)) } + state.thresholdPublicKey?.let { groupKey -> + Text( + stringResource(Res.string.refresh_unchanged_group_key, groupKey), + style = MaterialTheme.typography.bodySmall, + maxLines = 1, + overflow = TextOverflow.MiddleEllipsis, + ) + } + Text( + stringResource( + Res.string.refresh_member_roster, + session.participantPublicKeySet().sorted().joinToString { + it.memberName(state.localChatRoom.localParticipants, session.userPublicKey) + }, + ) + ) Card(modifier = Modifier.fillMaxWidth()) { Column(modifier = Modifier.padding(MaterialTheme.spacing.containerPadding)) { - Text(stringResource(Res.string.current_share_epoch, session.currentShareEpoch)) - if (session.purpose != ReEnrollmentPurpose.REPAIR) { - Text(stringResource(Res.string.next_share_epoch, session.nextShareEpoch)) + if (session.stage == ReEnrollmentStage.COMPLETE) { + Text(stringResource(Res.string.active_share_epoch, session.nextShareEpoch)) + } else { + Text(stringResource(Res.string.current_share_epoch, session.currentShareEpoch)) + if (session.purpose != ReEnrollmentPurpose.REPAIR) { + Text(stringResource(Res.string.next_share_epoch, session.nextShareEpoch)) + } } Text(stringResource(Res.string.of_members_will_be_needed_to_sign_with_this, session.threshold, session.participantCount)) Text(stringResource(Res.string.refresh_stage, session.stage.name)) diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/widgets/chat/ChatTranscript.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/widgets/chat/ChatTranscript.kt index e70b510c..f704425b 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/widgets/chat/ChatTranscript.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/composable/widgets/chat/ChatTranscript.kt @@ -45,6 +45,7 @@ import androidx.compose.material.icons.filled.History import androidx.compose.material.icons.filled.Groups import androidx.compose.material.icons.filled.PanTool import androidx.compose.material.icons.filled.PersonAdd +import androidx.compose.material.icons.filled.Refresh import androidx.compose.material.icons.filled.Upload import androidx.compose.material.icons.filled.WorkspacePremium import androidx.compose.material.icons.filled.Info @@ -87,6 +88,7 @@ import mobi.giza.compose.resources.loading import mobi.giza.compose.resources.no_chat_message_relays_were_found_for_this import mobi.giza.compose.resources.private_to_you import mobi.giza.compose.resources.review +import mobi.giza.compose.resources.refresh_signing_shares import mobi.giza.compose.resources.waiting_for_your_signature import mobi.giza.compose.resources.you import mobi.giza.compose.resources.private_to @@ -121,6 +123,7 @@ fun ChatTranscript( * and cannot say which one it meant. */ onOpenSigning: (sessionId: String?) -> Unit, + onOpenReEnrollment: (sessionId: String) -> Unit, /** Opens the room's proposals, all of them, whatever their state. */ onOpenProposals: () -> Unit, ) { @@ -369,6 +372,19 @@ fun ChatTranscript( return@items } + if (localChatMessage.chatMessage.messageType in ChatMessage.REENROLLMENT_TYPES) { + RitualNotice( + localChatMessage = localChatMessage, + isAnswered = true, + isSettled = true, + onClick = localChatMessage.chatMessage.reEnrollmentSessionId?.let { sessionId -> + { onOpenReEnrollment(sessionId) } + }, + opens = stringResource(Res.string.refresh_signing_shares), + ) + return@items + } + // Signing lines are the same kind of thing and get // the same treatment -- nobody said them either -- // but they lead somewhere else, because what a @@ -852,6 +868,12 @@ private fun RitualNotice( ChatMessage.TYPE_FROST_RESENT -> Icons.Default.Campaign ChatMessage.TYPE_FROST_APPROVAL_NEEDED -> Icons.Default.Draw + ChatMessage.TYPE_REENROLLMENT_STARTED, + ChatMessage.TYPE_REENROLLMENT_READY, + ChatMessage.TYPE_REENROLLMENT_ACTIVATING -> Icons.Default.Refresh + ChatMessage.TYPE_REENROLLMENT_COMPLETE -> Icons.Default.CheckCircle + ChatMessage.TYPE_REENROLLMENT_FAILED -> Icons.Default.ErrorOutline + ChatMessage.TYPE_CHRONICLE_REQUESTED -> Icons.Default.History ChatMessage.TYPE_CHRONICLE_SENT -> Icons.Default.Upload ChatMessage.TYPE_CHRONICLE_RECEIVED -> Icons.Default.Download @@ -886,6 +908,7 @@ private fun RitualNotice( val tint = when { chatMessage.messageType == ChatMessage.TYPE_DKG_FAILED || chatMessage.messageType == ChatMessage.TYPE_FROST_FAILED || + chatMessage.messageType == ChatMessage.TYPE_REENROLLMENT_FAILED || chatMessage.messageType == ChatMessage.TYPE_MEMBER_INVITE_FAILED || chatMessage.messageType == ChatMessage.TYPE_CHANGE_REJECTED -> MaterialTheme.colorScheme.error @@ -920,7 +943,8 @@ private fun RitualNotice( // so it follows a rename and is not stuck on the "LOADING..." // placeholder a member is given the moment they are first seen. if (chatMessage.messageType in ChatMessage.DKG_AUTHORED_TYPES || - chatMessage.messageType in ChatMessage.FROST_AUTHORED_TYPES + chatMessage.messageType in ChatMessage.FROST_AUTHORED_TYPES || + chatMessage.messageType in ChatMessage.REENROLLMENT_AUTHORED_TYPES ) { withStyle( SpanStyle(color = ProfileColor.fromPublicKey(chatMessage.senderPublicKey)) diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/model/ReEnrollmentViewModel.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/model/ReEnrollmentViewModel.kt index 8bae2b6f..c7830a5d 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/model/ReEnrollmentViewModel.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/model/ReEnrollmentViewModel.kt @@ -53,11 +53,14 @@ class ReEnrollmentViewModel( uiState = ReEnrollmentUIState.Error("This group cannot refresh its shares") return@launch } + val thresholdPublicKey = chatRepository.groupKeyState(chatRoomId)?.thresholdPublicKey combine( reEnrollmentRepository.observeSessionById(sessionId), reEnrollmentRepository.observeMessages(sessionId), ) { session, messages -> - session?.let { ReEnrollmentUIState.Loaded(room, it, messages, reEnrollmentRepository.pendingApproval(it)) } + session?.let { + ReEnrollmentUIState.Loaded(room, it, messages, reEnrollmentRepository.pendingApproval(it), thresholdPublicKey) + } }.collect { state -> state?.let { uiState = it } } } } diff --git a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/ReEnrollmentUIState.kt b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/ReEnrollmentUIState.kt index 42748c32..a05f2879 100644 --- a/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/ReEnrollmentUIState.kt +++ b/composeApp/src/commonMain/kotlin/mobi/giza/compose/ui/view/state/ReEnrollmentUIState.kt @@ -13,6 +13,7 @@ sealed interface ReEnrollmentUIState { val session: FrostReEnrollmentSession, val messages: List, val pendingApproval: Boolean, + val thresholdPublicKey: String? = null, ) : ReEnrollmentUIState { val commitments: Int get() = messages.count { it.kind == ReEnrollmentEvents.COMMITMENTS } val evaluations: Int get() = messages.count { diff --git a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManagerJvmTest.kt b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManagerJvmTest.kt index 51fce045..d76beac2 100644 --- a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManagerJvmTest.kt +++ b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/FrostReEnrollmentManagerJvmTest.kt @@ -12,6 +12,7 @@ import fr.acinq.bitcoin.crypto.frost.KeyMaterial import kotlin.test.AfterTest import kotlin.test.Test import kotlin.test.assertEquals +import kotlin.test.assertFailsWith import kotlin.test.assertFalse import kotlin.test.assertNotNull import kotlin.test.assertNull @@ -19,6 +20,7 @@ import kotlin.test.assertTrue import kotlinx.coroutines.runBlocking import mobi.giza.compose.database.GizaDatabase import mobi.giza.compose.database.builder.getRoomDatabase +import mobi.giza.compose.database.model.ChatMessage import mobi.giza.compose.database.model.ChatRoom import mobi.giza.compose.database.model.DkgParticipantMessage import mobi.giza.compose.database.model.DkgSession @@ -37,18 +39,18 @@ import mobi.giza.compose.nostr.frost.GroupKeyStateEvent import mobi.giza.compose.nostr.frost.ReEnrollmentEvents class FrostReEnrollmentManagerJvmTest { - private val participants = 3 - private val threshold = 2 - private val keyMaterial: KeyMaterial = Frost.trustedDealerKeygen( + private var participants = 3 + private var threshold = 2 + private var keyMaterial: KeyMaterial = Frost.trustedDealerKeygen( PrivateKey(ByteVector32("1c0ffee0000000000000000000000000000000000000000000000000000000a1")), participants, threshold, ) - private val thresholdPublicKey = keyMaterial.thresholdPublicKey.value.toHex() - private val roomId = SharedKeyDerivation.marmotGroupId(thresholdPublicKey) + private var thresholdPublicKey = keyMaterial.thresholdPublicKey.value.toHex() + private var roomId = SharedKeyDerivation.marmotGroupId(thresholdPublicKey) private val ceremonyId = "ceremony".padEnd(64, '0') - private val members = listOf("a", "b", "c").map { it.repeat(64) } - private val hostKeys = listOf("2a", "2b", "2c").map { it.padEnd(66, '0') } + private var members = listOf("a", "b", "c").map { it.repeat(64) } + private var hostKeys = listOf("2a", "2b", "2c").map { it.padEnd(66, '0') } private val devices = mutableListOf() private val delivered = mutableSetOf() @@ -141,8 +143,26 @@ class FrostReEnrollmentManagerJvmTest { } } - private suspend fun openDevices(signerHostKeys: List = hostKeys) { - devices += List(participants) { index -> Device(index, signerHostKeys).apply { open() } } + private suspend fun openDevices( + participantCount: Int = participants, + minimumSigners: Int = threshold, + signerHostKeys: List? = null, + ) { + require(devices.isEmpty()) + participants = participantCount + threshold = minimumSigners + keyMaterial = Frost.trustedDealerKeygen( + PrivateKey(ByteVector32("1c0ffee0000000000000000000000000000000000000000000000000000000a1")), + participants, + threshold, + ) + thresholdPublicKey = keyMaterial.thresholdPublicKey.value.toHex() + roomId = SharedKeyDerivation.marmotGroupId(thresholdPublicKey) + members = List(participants) { index -> ('a' + index).toString().repeat(64) } + hostKeys = List(participants) { index -> "2${'a' + index}".padEnd(66, '0') } + val orderedHostKeys = signerHostKeys ?: hostKeys + require(orderedHostKeys.size == participants) + devices += List(participants) { index -> Device(index, orderedHostKeys).apply { open() } } } private suspend fun pump( @@ -189,6 +209,32 @@ class FrostReEnrollmentManagerJvmTest { } } + @Test + fun `an unavailable or invalid public table prevents any refresh message`() = runBlocking { + openDevices() + val coordinator = devices[0] + val key = coordinator.db.dkgSessionDao().getSessionById(ceremonyId)!! + coordinator.db.dkgSessionDao().upsert(key.copy(publicShares = null)) + val missing = assertFailsWith { + FrostReEnrollmentManager.proposeReEnrollment(coordinator.db, coordinator.room, coordinator.member) + } + assertTrue(missing.message!!.contains("repair it with current members")) + + val fabricated = Frost.trustedDealerKeygen( + PrivateKey(ByteVector32("8".repeat(64))), participants, threshold, + ).publicShares.joinToString(",") { it.value.toHex() } + coordinator.db.dkgSessionDao().upsert(key.copy(publicShares = fabricated)) + assertFailsWith { + FrostReEnrollmentManager.proposeReEnrollment(coordinator.db, coordinator.room, coordinator.member) + } + assertTrue( + coordinator.db.marmotInnerEventDao().getByChatRoomAndKinds( + roomId, + listOf(ReEnrollmentEvents.PROPOSAL, ReEnrollmentEvents.COMMITMENTS, ReEnrollmentEvents.PRIVATE_EVALUATION), + ).isEmpty() + ) + } + @Test fun `all members reach activation with the same verified candidate`() = runBlocking { openDevices() @@ -222,8 +268,12 @@ class FrostReEnrollmentManagerJvmTest { assertEquals(participants * (participants - 1), direct.distinctBy { it.id }.size) } - private suspend fun refreshAndActivate(signerHostKeys: List = hostKeys) { - openDevices(signerHostKeys) + private suspend fun refreshAndActivate( + signerHostKeys: List? = null, + participantCount: Int = participants, + minimumSigners: Int = threshold, + ) { + openDevices(participantCount, minimumSigners, signerHostKeys) devices[0].let { FrostReEnrollmentManager.proposeReEnrollment(it.db, it.room, it.member) } pump { it.kind == ReEnrollmentEvents.PROPOSAL } devices.drop(1).forEach { device -> @@ -382,6 +432,200 @@ class FrostReEnrollmentManagerJvmTest { } } + @Test + fun `a signed activation takes precedence over a local failure`() = runBlocking { + openDevices() + devices[0].let { FrostReEnrollmentManager.proposeReEnrollment(it.db, it.room, it.member) } + pump { it.kind == ReEnrollmentEvents.PROPOSAL } + devices.drop(1).forEach { device -> + FrostReEnrollmentManager.approve(device.db, device.room, device.session()!!.id) + } + pump() + val activation = devices[0].let { + FrostReEnrollmentManager.proposeActivation(it.db, it.room, it.member, it.session()!!.id) + }!! + val target = devices[2] + target.receive( + MarmotInnerEvent( + id = "f".repeat(64), + publicKey = devices[0].member, + chatRoomId = roomId, + kind = ReEnrollmentEvents.FAILURE, + tags = ReEnrollmentEvents.assembleTags(activation.refreshSessionId!!), + content = "A local failure arrived before the signature", + createdAt = kotlin.time.Instant.fromEpochSeconds(1_700_000_100), + ) + ) + val failed = target.session()!! + assertEquals(ReEnrollmentStage.FAILED, failed.stage) + assertNotNull(failed.candidateSecretShare) + assertNotNull(failed.candidatePublicShares) + assertEquals(0, target.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch) + + pump { it.kind == FrostSigningEvents.PROPOSAL_V2 } + FrostSigningManager.approve(devices[1].db, devices[1].room, activation.id) + pump { it.kind in FrostSigningEvents.ALL } + + devices.forEach { device -> + assertEquals(1, device.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch) + assertEquals(ReEnrollmentStage.COMPLETE, device.session()!!.stage) + assertNull(device.session()!!.candidateSecretShare) + } + val signed = target.db.groupSignedEventDao().getByKind(ReEnrollmentEvents.KEY_EPOCH_STATE).single().toEvent() + assertTrue(Nip01Crypto.verify(signed.sig.hexToByteArray(), signed.id.hexToByteArray(), roomId.hexToByteArray())) + } + + @Test + fun `activation retry keeps the candidate and uses fresh nonce seeds`() = runBlocking { + openDevices() + devices[0].let { FrostReEnrollmentManager.proposeReEnrollment(it.db, it.room, it.member) } + pump { it.kind == ReEnrollmentEvents.PROPOSAL } + devices.drop(1).forEach { device -> + FrostReEnrollmentManager.approve(device.db, device.room, device.session()!!.id) + } + pump() + val refreshId = devices[2].session()!!.id + val candidate = devices[2].session()!! + val first = devices[0].let { + FrostReEnrollmentManager.proposeActivation(it.db, it.room, it.member, refreshId) + }!! + pump { it.kind == FrostSigningEvents.PROPOSAL_V2 } + devices.drop(1).forEach { device -> FrostSigningManager.decline(device.db, device.room, first.id) } + pump() + + devices.forEach { device -> + assertEquals(mobi.giza.compose.database.model.types.FrostSigningStage.FAILED, + device.db.frostSigningSessionDao().getSessionById(first.id)!!.stage) + } + assertEquals(candidate.candidateSecretShare, devices[2].session()!!.candidateSecretShare) + assertEquals(candidate.candidatePublicShares, devices[2].session()!!.candidatePublicShares) + + val coordinator = devices[2] + val retry = FrostReEnrollmentManager.proposeActivation(coordinator.db, coordinator.room, coordinator.member, refreshId)!! + assertTrue(retry.id != first.id) + pump { it.kind == FrostSigningEvents.PROPOSAL_V2 } + devices.forEach { device -> + val original = device.db.frostSigningSessionDao().getItems(first.id).single().nonceRandom + val replacement = device.db.frostSigningSessionDao().getItems(retry.id).single().nonceRandom + assertTrue(original != replacement) + } + devices.filter { it.member != coordinator.member }.forEach { device -> + FrostSigningManager.approve(device.db, device.room, retry.id) + } + pump() + + devices.forEach { device -> + assertEquals(1, device.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch) + assertEquals(ReEnrollmentStage.COMPLETE, device.session()!!.stage) + assertNull(device.session()!!.candidateSecretShare) + } + val signed = coordinator.db.groupSignedEventDao().getByKind(ReEnrollmentEvents.KEY_EPOCH_STATE).single().toEvent() + assertTrue(Nip01Crypto.verify(signed.sig.hexToByteArray(), signed.id.hexToByteArray(), roomId.hexToByteArray())) + } + + @Test + fun `a delayed activation signature activates from persisted state`() = runBlocking { + openDevices() + devices[0].let { FrostReEnrollmentManager.proposeReEnrollment(it.db, it.room, it.member) } + pump { it.kind == ReEnrollmentEvents.PROPOSAL } + devices.drop(1).forEach { device -> + FrostReEnrollmentManager.approve(device.db, device.room, device.session()!!.id) + } + pump() + val activation = devices[0].let { + FrostReEnrollmentManager.proposeActivation(it.db, it.room, it.member, it.session()!!.id) + }!! + pump { it.kind == FrostSigningEvents.PROPOSAL_V2 } + devices.drop(1).forEach { device -> FrostSigningManager.approve(device.db, device.room, activation.id) } + pump { it.kind != FrostSigningEvents.SIGNATURE } + + val waiting = devices.filter { it.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch == 0L } + assertTrue(waiting.isNotEmpty()) + waiting.forEach { device -> + assertNotNull(device.session()!!.candidateSecretShare) + assertEquals(0, device.db.groupKeyStateDao().getByChatRoomId(roomId)!!.shareEpoch) + } + pump { it.kind == FrostSigningEvents.SIGNATURE } + + devices.forEach { device -> + assertEquals(1, device.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch) + assertEquals(1, device.db.groupKeyStateDao().getByChatRoomId(roomId)!!.shareEpoch) + assertNull(device.session()!!.candidateSecretShare) + } + } + + @Test + fun `out-of-order messages replay from storage and duplicates are idempotent`() = runBlocking { + openDevices() + devices[0].let { FrostReEnrollmentManager.proposeReEnrollment(it.db, it.room, it.member) } + pump { it.kind != ReEnrollmentEvents.PROPOSAL } + devices.drop(1).forEach { assertNull(it.session()) } + + delivered.clear() + pump { it.kind == ReEnrollmentEvents.PROPOSAL } + devices.drop(1).forEach { device -> + FrostReEnrollmentManager.approve(device.db, device.room, device.session()!!.id) + } + pump() + + val staged = devices.map { it.session()!! } + assertEquals(List(participants) { ReEnrollmentStage.ACTIVATING }, staged.map { it.stage }) + assertEquals(1, staged.map { it.transcriptHash }.toSet().size) + delivered.clear() + pump() + assertEquals(staged, devices.map { it.session()!! }) + } + + @Test + fun `a conflicting ready transcript cannot start activation`() = runBlocking { + openDevices() + devices[0].let { FrostReEnrollmentManager.proposeReEnrollment(it.db, it.room, it.member) } + pump { it.kind == ReEnrollmentEvents.PROPOSAL } + devices.drop(1).forEach { device -> + FrostReEnrollmentManager.approve(device.db, device.room, device.session()!!.id) + } + pump { it.kind != ReEnrollmentEvents.READY } + + val target = devices[1] + val refresh = target.session()!! + val ready = devices[0].db.marmotInnerEventDao() + .getByChatRoomAndKinds(roomId, listOf(ReEnrollmentEvents.READY)) + .single { ReEnrollmentEvents.parseSessionId(it.tags) == refresh.id } + target.receive(ready.copy(content = "00".repeat(32))) + + assertEquals(ReEnrollmentStage.CANDIDATE_READY, target.session()!!.stage) + assertNull(FrostReEnrollmentManager.proposeActivation(target.db, target.room, target.member, refresh.id)) + assertEquals(0, target.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch) + } + + @Test + fun `three of five members refresh and the last member can coordinate signing`() = runBlocking { + refreshAndActivate(participantCount = 5, minimumSigners = 3) + devices.forEach { device -> + assertEquals(1, device.db.dkgSessionDao().getSessionById(ceremonyId)!!.shareEpoch) + assertEquals(ReEnrollmentStage.COMPLETE, device.session()!!.stage) + } + val evaluations = devices.flatMap { device -> + device.db.marmotInnerEventDao().getByChatRoomAndKinds(roomId, listOf(ReEnrollmentEvents.PRIVATE_EVALUATION)) + }.distinctBy { it.id } + assertEquals(participants * (participants - 1), evaluations.size) + assertTrue(evaluations.all { it.content.isEmpty() }) + + val coordinator = devices.last() + val after = FrostSigningManager.proposeSigning( + coordinator.db, coordinator.room, coordinator.member, 1, emptyArray(), "three of five refresh", + ) + pump { it.kind == FrostSigningEvents.PROPOSAL_V2 } + devices.filter { it.member != coordinator.member }.forEach { device -> + FrostSigningManager.approve(device.db, device.room, after.id) + } + pump() + val signed = coordinator.db.groupSignedEventDao().getByKind(1).single { + it.content == "three of five refresh" + }.toEvent() + assertTrue(Nip01Crypto.verify(signed.sig.hexToByteArray(), signed.id.hexToByteArray(), roomId.hexToByteArray())) + } + @Test fun `a resend names missing members and republishes the same private bytes`() = runBlocking { openDevices() @@ -467,6 +711,21 @@ class FrostReEnrollmentManagerJvmTest { .getByChatRoomAndKinds(roomId, listOf(ReEnrollmentEvents.PRIVATE_EVALUATION)) .all { it.content.isEmpty() } ) + val notices = device.db.chatMessageDao().getChatMessagesByChatRoomId(roomId) + .map { it.chatMessage } + .filter { it.reEnrollmentSessionId == refresh.id } + assertEquals( + setOf( + ChatMessage.TYPE_REENROLLMENT_STARTED, + ChatMessage.TYPE_REENROLLMENT_READY, + ChatMessage.TYPE_REENROLLMENT_ACTIVATING, + ChatMessage.TYPE_REENROLLMENT_COMPLETE, + ), + notices.map { it.messageType }.toSet(), + ) + assertEquals(notices.size, notices.map { it.messageType }.toSet().size) + assertTrue(notices.none { it.content.contains(key.secretShare!!) }) + assertTrue(notices.none { it.content.contains(keyMaterial.secretShares[index].value.toHex()) }) } val after = devices[0].let { diff --git a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/GroupFixtures.kt b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/GroupFixtures.kt index f1f439e3..c6b1a7c6 100644 --- a/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/GroupFixtures.kt +++ b/composeApp/src/jvmTest/kotlin/mobi/giza/compose/managers/GroupFixtures.kt @@ -160,9 +160,9 @@ internal object GroupFixtures { private fun signature(material: KeyMaterial, eventId: String): String = signWith(material, SharedKeyDerivation.derive(thresholdKeyOf(material), path).cache, ByteVector(eventId.hexToByteArray())).toHex() - /** A 2-of-3 FROST signature by [material]'s quorum over [message] under [cache] -- a leaf's, an address's, the room's. */ + /** A threshold FROST signature by [material]'s quorum over [message] under [cache]. */ fun signWith(material: KeyMaterial, cache: TweakCache, message: ByteVector): ByteVector64 { - val signerIds = listOf(0, 1) + val signerIds = (0 until material.threshold).toList() val nonces = signerIds.map { signerId -> SecretNonce.generate( @@ -178,8 +178,8 @@ internal object GroupFixtures { aggregatedNonce = IndividualNonce.aggregate(nonces.map { it.second }).right!!, signerIds = signerIds.map { it.toUInt() }, signerPublicShares = signerIds.map { material.publicShares[it] }, - nParticipants = PARTICIPANTS, - threshold = THRESHOLD, + nParticipants = material.nParticipants, + threshold = material.threshold, tweakCache = cache, message = message, )