From 89a3b4d8c6a15704759f2d3d70bdde1d0bf16987 Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Sun, 15 Nov 2026 01:16:29 +0200 Subject: [PATCH 01/16] fix: decrypt personal and group status stanzas with isolated sessions --- README.md | 21 ++++ client.go | 8 +- message.go | 26 ++++- receipt.go | 6 + remote_signal.go | 7 +- status_message_test.go | 235 ++++++++++++++++++++++++++++++++++++++++ status_session.go | 27 +++++ store/signal.go | 8 +- store/status_session.go | 20 ++++ types/events/events.go | 4 + types/message.go | 38 +++++++ 11 files changed, 390 insertions(+), 10 deletions(-) create mode 100644 status_message_test.go create mode 100644 status_session.go create mode 100644 store/status_session.go diff --git a/README.md b/README.md index e5a0ef861..5eb5f849b 100644 --- a/README.md +++ b/README.md @@ -82,6 +82,27 @@ go get github.com/polymorfa/hypermeow@main go mod tidy ``` +## Receiving statuses + +Personal and group `` publications use encrypted message processing; +channel statuses keep their plaintext processing path. The original transport tag +is preserved for acknowledgments. `MessageInfo.StatusKind()` distinguishes +`personal`, `group` and `channel` publications from ordinary messages, status +mentions and replies. Group-status-v2 content is unwrapped while `RawMessage` +retains the original protobuf. + +Pairwise status sessions are stored separately from chat sessions. Explicit +`meta session_scope="status"` is honored by default. Applications that consume +served AB props can install `Client.GetStatusSessionMode` before connecting to +supply `status_infra_1_1_session_split` (0 disabled, 1 receiver enabled, 2 sender +enabled, 3 forced). This receive change does not enable status publishing. + +Custom `RemoteSignal` receivers must use `RemoteReceive.StatusSession` to select +the pairwise session and carry `StatusKind` into their application event. Sender +keys remain scoped to the group and sender, and private keys and plaintext stay +in the remote store. Upgrading this library alone does not upgrade a remote +receiver's protocol or storage. + ## Newsletter observations `NewsletterMessage.ViewCounts` preserves the reported view definitions, including diff --git a/client.go b/client.go index 7630e473b..63ea496c5 100644 --- a/client.go +++ b/client.go @@ -241,6 +241,12 @@ type Client struct { // If false, decrypting a message from untrusted devices will fail. AutoTrustIdentity bool + // GetStatusSessionMode supplies the served status_infra_1_1_session_split + // value. Install before Connect; the callback may read a synchronized cache. + // Without a callback, explicit status session metadata is honored, but a + // separate session is never forced on an unmarked status. + GetStatusSessionMode func() types.StatusSessionMode + // RawNodeHandler, if non-nil, is called for every inbound node // after decoding but before standard dispatch. See [RawNodeHandler]. RawNodeHandler RawNodeHandler @@ -1164,7 +1170,7 @@ func (cli *Client) defaultNodeHandlers() map[string]nodeHandler { return map[string]nodeHandler{ "message": cli.handleEncryptedMessage, "appdata": cli.handleEncryptedMessage, - "status": cli.handleUnencryptedMessage, + "status": cli.handleStatusMessage, "receipt": cli.handleReceipt, "call": cli.handleCallEvent, "chatstate": cli.handleChatState, diff --git a/message.go b/message.go index 971974d6a..5271c68b9 100644 --- a/message.go +++ b/message.go @@ -92,6 +92,21 @@ func (cli *Client) updateMessageContactNames(ctx context.Context, info *types.Me } } +// Status publications share encrypted receive processing with messages, but keep +// their original tag for acknowledgements and their group-status provenance. +func (cli *Client) handleStatusMessage(ctx context.Context, node *waBinary.Node) { + from, ok := node.Attrs["from"].(types.JID) + if !ok || (from != types.StatusBroadcastJID && from.Server != types.GroupServer && from.Server != types.NewsletterServer) { + cli.sendAck(ctx, node, NackParsingError) + return + } + if from.Server == types.NewsletterServer { + cli.handleUnencryptedMessage(ctx, node) + } else { + cli.handleEncryptedMessage(ctx, node) + } +} + func (cli *Client) handleUnencryptedMessage(ctx context.Context, node *waBinary.Node) { info, err := cli.parseMessageInfo(node) if err != nil { @@ -232,6 +247,7 @@ func (cli *Client) parseMsgMetaInfo(node waBinary.Node) (metaInfo types.MsgMetaI metaNode := node.GetChildByTag("meta") ag := metaNode.AttrGetter() + metaInfo.SessionScope = ag.OptionalString("session_scope") metaInfo.TargetID = types.MessageID(ag.OptionalString("target_id")) metaInfo.TargetSender = ag.OptionalJIDOrEmpty("target_sender_jid") metaInfo.TargetChat = ag.OptionalJIDOrEmpty("target_chat_jid") @@ -253,6 +269,8 @@ func (cli *Client) parseMessageInfo(node *waBinary.Node) (*types.MessageInfo, er return nil, err } ag := node.AttrGetter() + info.IsStatusStanza = node.Tag == "status" + info.IsGroupStatus = info.IsStatusStanza && info.Chat.Server == types.GroupServer info.ID = types.MessageID(ag.String("id")) info.ServerID = types.MessageServerID(ag.OptionalInt("server_id")) info.Timestamp = ag.UnixTime("t") @@ -430,7 +448,7 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo, var ciphertextHash *[32]byte var err error if encType == "pkmsg" || encType == "msg" { - decrypted, ciphertextHash, err = cli.decryptDM(ctx, &child, senderEncryptionJID, encType == "pkmsg", info.Timestamp) + decrypted, ciphertextHash, err = cli.decryptDM(cli.statusSessionContext(ctx, info), &child, senderEncryptionJID, encType == "pkmsg", info.Timestamp) containsDirectMsg = true } else if info.IsGroup && encType == "skmsg" { decrypted, ciphertextHash, err = cli.decryptGroupMsg(ctx, &child, senderEncryptionJID, info.Chat, info.Timestamp) @@ -590,7 +608,7 @@ func (cli *Client) clearUntrustedIdentity(ctx context.Context, target types.JID) if err != nil { return fmt.Errorf("failed to delete identity: %w", err) } - err = cli.Store.Sessions.DeleteSession(ctx, target.SignalAddress().String()) + err = cli.Store.DeleteSession(ctx, target.SignalAddress()) if err != nil { return fmt.Errorf("failed to delete session: %w", err) } @@ -707,7 +725,7 @@ func (cli *Client) decryptDM(ctx context.Context, child *waBinary.Node, from typ pt, innerErr = cipher.DecryptMessage(decryptCtx, preKeyMsg) } return pt, innerErr - }, "prekey", from.String()) + }, "prekey", store.SignalSessionAddress(ctx, from.String())) if err != nil { return nil, nil, fmt.Errorf("failed to decrypt prekey message: %w", err) } @@ -718,7 +736,7 @@ func (cli *Client) decryptDM(ctx context.Context, child *waBinary.Node, from typ } plaintext, ciphertextHash, err = cli.bufferedDecrypt(ctx, content, serverTS, func(decryptCtx context.Context) ([]byte, error) { return cipher.Decrypt(decryptCtx, msg) - }, "normal", from.String()) + }, "normal", store.SignalSessionAddress(ctx, from.String())) if err != nil { return nil, nil, fmt.Errorf("failed to decrypt normal message: %w", err) } diff --git a/receipt.go b/receipt.go index 8f0b84067..c52dcb88f 100644 --- a/receipt.go +++ b/receipt.go @@ -273,6 +273,9 @@ func buildBaseReceipt(id string, node *waBinary.Node) waBinary.Attrs { "id": id, "to": node.Attrs["from"], } + if node.Tag == "status" { + attrs["class"] = "status" + } if recipient, ok := node.Attrs["recipient"]; ok { attrs["recipient"] = recipient } @@ -284,6 +287,9 @@ func buildBaseReceipt(id string, node *waBinary.Node) waBinary.Attrs { func (cli *Client) sendMessageReceipt(ctx context.Context, info *types.MessageInfo, node *waBinary.Node) { attrs := buildBaseReceipt(info.ID, node) + if info.Chat == types.StatusBroadcastJID || info.IsGroupStatus { + attrs["class"] = "status" + } if info.IsFromMe { attrs["type"] = string(types.ReceiptTypeSender) if info.Type == "peer_msg" { diff --git a/remote_signal.go b/remote_signal.go index e6c22d45b..2a1cda06b 100644 --- a/remote_signal.go +++ b/remote_signal.go @@ -96,7 +96,10 @@ type RemoteIdentity struct { // RemoteReceive is one `` payload of a received message. type RemoteReceive struct { // Timestamp is the provider message time; a missing value remains zero. - Timestamp time.Time + Timestamp time.Time + StatusKind types.StatusKind + // StatusSession selects a separate pairwise session, not a sender-key scope. + StatusSession bool // SenderAlt is the other provider address when Sender is normalized for // Signal encryption (for example, PN when Sender is a LID). SenderAlt types.JID @@ -395,6 +398,8 @@ func (cli *Client) decryptMessagesRemote(ctx context.Context, info *types.Messag } result, err := cli.remoteSignal.Receive(ctx, RemoteReceive{ Timestamp: info.Timestamp, + StatusKind: info.StatusKind(), + StatusSession: encType != "skmsg" && cli.usesStatusSession(info), SenderAlt: senderAlt, Chat: info.Chat, Sender: senderEncryptionJID, diff --git a/status_message_test.go b/status_message_test.go new file mode 100644 index 000000000..e657bbe8b --- /dev/null +++ b/status_message_test.go @@ -0,0 +1,235 @@ +package whatsmeow + +import ( + "context" + "errors" + "fmt" + waBinary "github.com/polymorfa/hypermeow/binary" + "github.com/polymorfa/hypermeow/proto/waE2E" + "github.com/polymorfa/hypermeow/store" + "github.com/polymorfa/hypermeow/types/events" + waLog "github.com/polymorfa/hypermeow/util/log" + "github.com/polymorfa/libsignal-protocol-go/protocol" + "github.com/polymorfa/libsignal-protocol-go/session" + "google.golang.org/protobuf/proto" + "testing" + + "github.com/polymorfa/hypermeow/types" +) + +// These envelopes are authored fixtures, not captured WhatsApp traffic. +func TestStatusStanzaReachesEncryptedReceiver(t *testing.T) { + for _, chat := range []types.JID{types.StatusBroadcastJID, types.NewJID("120363000000001", types.GroupServer)} { + t.Run(chat.Server, func(t *testing.T) { + cli, remote, sent := newTestRemote(t) + own := types.NewJID("100000000001", types.HiddenUserServer) + cli.Store.ID = &own + sender := types.JID{User: "200000000002", Server: types.HiddenUserServer, Device: 2} + _, node := encMessage("pkmsg") + node.Tag = "status" + node.Attrs["from"], node.Attrs["participant"] = chat, sender + cli.nodeHandlers["status"](context.Background(), node) + if len(remote.receives) != 1 { + t.Fatalf("encrypted receiver calls = %d, want 1", len(remote.receives)) + } + req := remote.receives[0] + if req.Chat != chat || req.Sender != sender { + t.Fatalf("routing changed: %+v", req) + } + if len(sent.nodes) == 0 { + t.Fatal("status was neither acknowledged nor receipted") + } + if node.Tag != "status" { + t.Fatal("handler changed the original transport tag") + } + }) + } +} + +func TestStatusSessionsKeepChatRatchetsSeparate(t *testing.T) { + ctx := context.Background() + own := types.JID{User: "100000000001", Server: types.HiddenUserServer, Device: 1} + sender := types.JID{User: "200000000002", Server: types.HiddenUserServer, Device: 2} + companion, mem := newSignalTestDevice(own, &store.NoopStore{}) + companion.LID = own + peer, _ := newSignalTestDevice(sender, &store.NoopStore{}) + cli := NewClient(companion, waLog.Noop) + cli.SynchronousAck = true + sent := &sentNodes{} + cli.testSendHook = sent.hook + var messages []*events.Message + cli.AddEventHandler(func(evt any) { + if e, ok := evt.(*events.Message); ok { + messages = append(messages, e) + } + }) + for _, status := range []bool{false, true, false, true} { + cryptoCtx := ctx + if status { + cryptoCtx = store.WithStatusSession(ctx) + } + builder := session.NewBuilderFromSignal(peer, own.SignalAddress(), pbSerializer) + exists, err := peer.ContainsSession(cryptoCtx, own.SignalAddress()) + if err != nil { + t.Fatal(err) + } + if !exists { + if err = builder.ProcessBundle(cryptoCtx, signalTestBundle(t, companion, uint32(own.Device))); err != nil { + t.Fatal(err) + } + } + cipher := session.NewCipher(builder, own.SignalAddress()) + text := fmt.Sprintf("synthetic %t %d", status, len(messages)) + plain, err := proto.Marshal(&waE2E.Message{Conversation: proto.String(text)}) + if err != nil { + t.Fatal(err) + } + encrypted, err := cipher.Encrypt(cryptoCtx, padMessage(plain)) + if err != nil { + t.Fatal(err) + } + kind := "msg" + if encrypted.Type() == protocol.PREKEY_TYPE { + kind = "pkmsg" + } + node := &waBinary.Node{Tag: "message", Attrs: waBinary.Attrs{"id": text, "from": sender, "t": "1700000000", "type": "text"}, Content: []waBinary.Node{{Tag: "enc", Attrs: waBinary.Attrs{"type": kind, "v": "2"}, Content: encrypted.Serialize()}}} + if status { + node.Tag = "status" + node.Attrs["from"], node.Attrs["participant"] = types.StatusBroadcastJID, sender + node.Content = append(node.GetChildren(), waBinary.Node{Tag: "meta", Attrs: waBinary.Attrs{"session_scope": "status"}}) + cli.handleStatusMessage(ctx, node) + } else { + cli.handleEncryptedMessage(ctx, node) + } + if len(messages) == 0 || messages[len(messages)-1].Message.GetConversation() != text { + t.Fatalf("content not delivered for status=%t", status) + } + if got := messages[len(messages)-1].Info.StatusKind(); (got == types.StatusKindPersonal) != status { + t.Fatalf("wrong publication kind %q", got) + } + } + for _, key := range []string{sender.SignalAddress().String(), sender.SignalAddress().String() + "_status"} { + if _, ok := mem.sessions[key]; !ok { + t.Fatalf("missing independent session %s", key) + } + } + if len(sent.nodes) != 4 { + t.Fatalf("receipts = %d", len(sent.nodes)) + } + for i, n := range sent.nodes { + if n.Tag != "receipt" { + t.Fatalf("response %d = %s", i, n.Tag) + } + if got := n.Attrs["class"]; (got == "status") != (i%2 == 1) { + t.Fatalf("response %d class = %v", i, got) + } + } +} + +func TestStatusSessionModeAndPublicationContext(t *testing.T) { + for _, mode := range []types.StatusSessionMode{types.StatusSessionDisabled, types.StatusSessionReceiverEnabled, types.StatusSessionSenderEnabled, types.StatusSessionForced} { + cli := &Client{GetStatusSessionMode: func() types.StatusSessionMode { return mode }} + for _, scope := range []string{"", "status"} { + for _, chat := range []types.JID{types.StatusBroadcastJID, types.NewJID("group", types.GroupServer), types.NewJID("sender", types.HiddenUserServer)} { + info := &types.MessageInfo{MessageSource: types.MessageSource{Chat: chat}, IsGroupStatus: chat.Server == types.GroupServer, MsgMetaInfo: types.MsgMetaInfo{SessionScope: scope}} + want := chat == types.StatusBroadcastJID || chat.Server == types.GroupServer && scope == "status" + want = want && (mode == types.StatusSessionForced || mode != types.StatusSessionDisabled && scope == "status") + if cli.usesStatusSession(info) != want { + t.Fatalf("mode=%d chat=%s scope=%s", mode, chat, scope) + } + } + } + } +} + +func TestStatusRemoteMetadataAndOutage(t *testing.T) { + for _, outage := range []bool{false, true} { + cli, remote, sent := newTestRemote(t) + own := types.NewJID("100000000001", types.HiddenUserServer) + cli.Store.ID = &own + _, node := encMessage("pkmsg") + node.Tag = "status" + node.Attrs["from"] = types.NewJID("120363000000001", types.GroupServer) + node.Attrs["participant"] = types.NewJID("200000000002", types.HiddenUserServer) + node.Content = append(node.GetChildren(), waBinary.Node{Tag: "meta", Attrs: waBinary.Attrs{"session_scope": "status"}}) + if outage { + remote.receiveErr = errors.New("synthetic remote outage") + } + cli.handleStatusMessage(context.Background(), node) + if len(remote.receives) != 1 || remote.receives[0].StatusKind != types.StatusKindGroup || !remote.receives[0].StatusSession { + t.Fatalf("lost remote status metadata: %+v", remote.receives) + } + if outage && len(sent.nodes) != 0 { + t.Fatal("acknowledged status before remote receiver accepted it") + } + } +} + +func TestStatusRejectsDirectSendersAndMissingParticipants(t *testing.T) { + for _, missingParticipant := range []bool{false, true} { + cli, remote, sent := newTestRemote(t) + own := types.NewJID("100000000001", types.HiddenUserServer) + cli.Store.ID = &own + _, node := encMessage("pkmsg") + node.Tag = "status" + if missingParticipant { + node.Attrs["from"] = types.StatusBroadcastJID + } + cli.handleStatusMessage(context.Background(), node) + if len(remote.receives) != 0 { + t.Fatal("malformed status reached decryption") + } + if len(sent.nodes) != 1 || sent.nodes[0].Tag != "ack" || sent.nodes[0].Attrs["class"] != "status" || sent.nodes[0].AttrGetter().Int("error") != NackParsingError { + t.Fatalf("wrong parse failure response: %+v", sent.nodes) + } + } +} + +func TestChannelStatusStaysPlaintextAndOrdinaryChannelMessagesStayMessages(t *testing.T) { + for _, status := range []bool{false, true} { + cli, remote, _ := newTestRemote(t) + own := types.NewJID("100000000001", types.HiddenUserServer) + cli.Store.ID = &own + data, err := proto.Marshal(&waE2E.Message{Conversation: proto.String("synthetic channel status")}) + if err != nil { + t.Fatal(err) + } + node := &waBinary.Node{Tag: "message", Attrs: waBinary.Attrs{"id": "channel", "from": types.NewJID("120363000000001", types.NewsletterServer), "t": "1700000000"}, Content: []waBinary.Node{{Tag: "plaintext", Content: data}}} + var got *events.Message + cli.AddEventHandler(func(evt any) { + if e, ok := evt.(*events.Message); ok { + got = e + } + }) + if status { + node.Tag = "status" + cli.handleStatusMessage(context.Background(), node) + } else { + cli.handleEncryptedMessage(context.Background(), node) + } + if len(remote.receives) != 0 || got == nil || got.Message.GetConversation() != "synthetic channel status" { + t.Fatal("channel content did not stay on the plaintext path") + } + if (got.Info.StatusKind() == types.StatusKindChannel) != status { + t.Fatalf("channel publication misclassified: %+v", got.Info) + } + } +} + +func TestGroupStatusWrapperIsNotAMentionOrReply(t *testing.T) { + content := &waE2E.Message{Conversation: proto.String("synthetic group status")} + for _, raw := range []*waE2E.Message{ + {GroupStatusMessageV2: &waE2E.FutureProofMessage{Message: content}}, + {GroupStatusMentionMessage: &waE2E.FutureProofMessage{Message: content}}, + {StatusMentionMessage: &waE2E.FutureProofMessage{Message: content}}, + } { + evt := (&events.Message{RawMessage: raw}).UnwrapRaw() + isPublication := raw.GetGroupStatusMessageV2() != nil + if (evt.Info.StatusKind() == types.StatusKindGroup) != isPublication { + t.Fatal("mention classified as a publication") + } + if isPublication && evt.Message != content { + t.Fatal("group status content not unwrapped") + } + } +} diff --git a/status_session.go b/status_session.go new file mode 100644 index 000000000..0c1ecbbb2 --- /dev/null +++ b/status_session.go @@ -0,0 +1,27 @@ +package whatsmeow + +import ( + "context" + + "github.com/polymorfa/hypermeow/store" + "github.com/polymorfa/hypermeow/types" +) + +func (cli *Client) usesStatusSession(info *types.MessageInfo) bool { + isStatusContext := info.Chat == types.StatusBroadcastJID || info.IsGroupStatus && info.MsgMetaInfo.SessionScope == "status" + if !isStatusContext { + return false + } + mode := types.StatusSessionReceiverEnabled + if cli.GetStatusSessionMode != nil { + mode = cli.GetStatusSessionMode() + } + return mode == types.StatusSessionForced || (mode == types.StatusSessionReceiverEnabled || mode == types.StatusSessionSenderEnabled) && info.MsgMetaInfo.SessionScope == "status" +} + +func (cli *Client) statusSessionContext(ctx context.Context, info *types.MessageInfo) context.Context { + if cli.usesStatusSession(info) { + return store.WithStatusSession(ctx) + } + return ctx +} diff --git a/store/signal.go b/store/signal.go index 728289bcf..569eb983e 100644 --- a/store/signal.go +++ b/store/signal.go @@ -97,7 +97,7 @@ func (device *Device) ContainsPreKey(ctx context.Context, preKeyID uint32) (bool } func (device *Device) LoadSession(ctx context.Context, address *protocol.SignalAddress) (*record.Session, error) { - addrString := address.String() + addrString := SignalSessionAddress(ctx, address.String()) if sess := getCachedSession(ctx, addrString); sess != nil { return sess, nil } @@ -136,7 +136,7 @@ func (device *Device) GetSubDeviceSessions(ctx context.Context, name string) ([] } func (device *Device) StoreSession(ctx context.Context, address *protocol.SignalAddress, record *record.Session) error { - addrString := address.String() + addrString := SignalSessionAddress(ctx, address.String()) if putCachedSession(ctx, addrString, record) { return nil } @@ -149,7 +149,7 @@ func (device *Device) StoreSession(ctx context.Context, address *protocol.Signal } func (device *Device) ContainsSession(ctx context.Context, remoteAddress *protocol.SignalAddress) (bool, error) { - addrString := remoteAddress.String() + addrString := SignalSessionAddress(ctx, remoteAddress.String()) if found, cached := hasCachedSession(ctx, addrString); cached { return found, nil } @@ -161,7 +161,7 @@ func (device *Device) ContainsSession(ctx context.Context, remoteAddress *protoc } func (device *Device) DeleteSession(ctx context.Context, remoteAddress *protocol.SignalAddress) error { - addrString := remoteAddress.String() + addrString := SignalSessionAddress(ctx, remoteAddress.String()) if err := device.Sessions.DeleteSession(ctx, addrString); err != nil { return fmt.Errorf("failed to delete session with %s: %w", addrString, err) } diff --git a/store/status_session.go b/store/status_session.go new file mode 100644 index 000000000..8542447e3 --- /dev/null +++ b/store/status_session.go @@ -0,0 +1,20 @@ +package store + +import "context" + +type statusSessionContextKey struct{} + +// WithStatusSession isolates pairwise status sessions from ordinary chat sessions. +// Identity, prekey and sender-key stores remain shared. The suffix follows the +// device address so SQL user-prefix migration and deletion cover both scopes. +func WithStatusSession(ctx context.Context) context.Context { + return context.WithValue(ctx, statusSessionContextKey{}, true) +} + +// SignalSessionAddress returns the storage key in the selected pairwise scope. +func SignalSessionAddress(ctx context.Context, address string) string { + if scoped, _ := ctx.Value(statusSessionContextKey{}).(bool); scoped { + return address + "_status" + } + return address +} diff --git a/types/events/events.go b/types/events/events.go index 41a566917..f9352d19d 100644 --- a/types/events/events.go +++ b/types/events/events.go @@ -428,6 +428,10 @@ func (evt *Message) UnwrapRaw() *Message { evt.Message = evt.Message.GetBotInvokeMessage().GetMessage() evt.IsBotInvoke = true } + if child := evt.Message.GetGroupStatusMessageV2().GetMessage(); child != nil { + evt.Info.IsGroupStatus = true + evt.Message = child + } if evt.Message.GetEphemeralMessage().GetMessage() != nil { evt.Message = evt.Message.GetEphemeralMessage().GetMessage() evt.IsEphemeral = true diff --git a/types/message.go b/types/message.go index 57ecfdd1c..02627f5ad 100644 --- a/types/message.go +++ b/types/message.go @@ -89,12 +89,33 @@ type MsgMetaInfo struct { TargetSender JID TargetChat JID + SessionScope string // Explicit meta session_scope, when present. + DeprecatedLIDSession *bool ThreadMessageID MessageID ThreadMessageSenderJID JID } +// StatusKind identifies a status publication, not a reply or mention notification. +type StatusKind string + +const ( + StatusKindPersonal StatusKind = "personal" + StatusKindGroup StatusKind = "group" + StatusKindChannel StatusKind = "channel" +) + +// StatusSessionMode matches the served status_infra_1_1_session_split states. +type StatusSessionMode int + +const ( + StatusSessionDisabled StatusSessionMode = iota + StatusSessionReceiverEnabled + StatusSessionSenderEnabled + StatusSessionForced +) + // MessageInfo contains metadata about an incoming message. type MessageInfo struct { MessageSource @@ -111,6 +132,8 @@ type MessageInfo struct { MsgBotInfo MsgBotInfo MsgMetaInfo MsgMetaInfo + IsStatusStanza bool // The original transport tag was status, not message. + IsGroupStatus bool IsNewsletterStatus bool VerifiedName *VerifiedName @@ -129,3 +152,18 @@ func (ms *MessageSource) SourceString() string { return ms.Chat.String() } } + +// StatusKind returns the publication audience, or empty for an ordinary message. +// Quoted status content and status mention notifications do not change the audience. +func (info *MessageInfo) StatusKind() StatusKind { + if info.IsNewsletterStatus { + return StatusKindChannel + } + if info.IsGroupStatus { + return StatusKindGroup + } + if info.Chat == StatusBroadcastJID { + return StatusKindPersonal + } + return "" +} From 4812d1be9e628557c979285e4fb86505782098a6 Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Sun, 15 Nov 2026 20:58:04 +0200 Subject: [PATCH 02/16] fix: preserve status receipt class for event routing --- receipt.go | 1 + status_message_test.go | 16 ++++++++++++++++ types/events/events.go | 2 ++ 3 files changed, 19 insertions(+) diff --git a/receipt.go b/receipt.go index c52dcb88f..75d1d81ad 100644 --- a/receipt.go +++ b/receipt.go @@ -77,6 +77,7 @@ func (cli *Client) parseReceipt(node *waBinary.Node) (*events.Receipt, []waBinar } receipt := events.Receipt{ MessageSource: source, + Class: ag.OptionalString("class"), Timestamp: ag.UnixTime("t"), Type: types.ReceiptType(ag.OptionalString("type")), MessageSender: ag.OptionalJIDOrEmpty("recipient"), diff --git a/status_message_test.go b/status_message_test.go index e657bbe8b..beb92ca64 100644 --- a/status_message_test.go +++ b/status_message_test.go @@ -233,3 +233,19 @@ func TestGroupStatusWrapperIsNotAMentionOrReply(t *testing.T) { } } } + +func TestStatusReceiptPreservesClass(t *testing.T) { + cli, _, _ := newTestRemote(t) + own := types.NewJID("100000000001", types.HiddenUserServer) + cli.Store.ID = &own + for _, class := range []string{"", "status"} { + node := waBinary.Node{Tag: "receipt", Attrs: waBinary.Attrs{"from": types.NewJID("123456789", types.HiddenUserServer), "id": "authored-receipt", "t": "1700000000", "class": class}} + receipt, _, err := cli.parseReceipt(&node) + if err != nil { + t.Fatal(err) + } + if receipt.Class != class { + t.Fatalf("class = %q, want %q", receipt.Class, class) + } + } +} diff --git a/types/events/events.go b/types/events/events.go index f9352d19d..7c919ac68 100644 --- a/types/events/events.go +++ b/types/events/events.go @@ -518,6 +518,8 @@ const ( // N.B. WhatsApp on Android sends message IDs from newest message to oldest, but WhatsApp on iOS sends them in the opposite order (oldest first). type Receipt struct { types.MessageSource + // Class preserves the wire receipt class, including status publications. + Class string MessageIDs []types.MessageID Timestamp time.Time Type types.ReceiptType From d3642885bfd70009e24ee3fd8d94f9c050a04346 Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Sun, 15 Nov 2026 21:28:18 +0200 Subject: [PATCH 03/16] fix: clear both pairwise scopes when identity changes --- message.go | 2 +- status_message_test.go | 17 +++++++++++++++++ store/signal.go | 14 ++++++++++++++ 3 files changed, 32 insertions(+), 1 deletion(-) diff --git a/message.go b/message.go index 5271c68b9..9787609e5 100644 --- a/message.go +++ b/message.go @@ -608,7 +608,7 @@ func (cli *Client) clearUntrustedIdentity(ctx context.Context, target types.JID) if err != nil { return fmt.Errorf("failed to delete identity: %w", err) } - err = cli.Store.DeleteSession(ctx, target.SignalAddress()) + err = cli.Store.DeleteSessionsForIdentity(ctx, target.SignalAddress()) if err != nil { return fmt.Errorf("failed to delete session: %w", err) } diff --git a/status_message_test.go b/status_message_test.go index beb92ca64..3f2329760 100644 --- a/status_message_test.go +++ b/status_message_test.go @@ -124,6 +124,23 @@ func TestStatusSessionsKeepChatRatchetsSeparate(t *testing.T) { t.Fatalf("response %d class = %v", i, got) } } + keys := []string{sender.SignalAddress().String(), sender.SignalAddress().String() + "_status"} + _, cached, err := companion.WithCachedSessions(ctx, keys) + if err != nil { + t.Fatal(err) + } + if err := cli.clearUntrustedIdentity(store.WithStatusSession(cached), sender); err != nil { + t.Fatal(err) + } + if err := companion.PutCachedSessions(cached); err != nil { + t.Fatal(err) + } + for _, key := range keys { + if _, ok := mem.sessions[key]; ok { + t.Fatalf("identity reset retained session %s", key) + } + } + } func TestStatusSessionModeAndPublicationContext(t *testing.T) { diff --git a/store/signal.go b/store/signal.go index 569eb983e..b4eeb2573 100644 --- a/store/signal.go +++ b/store/signal.go @@ -168,6 +168,20 @@ func (device *Device) DeleteSession(ctx context.Context, remoteAddress *protocol return nil } +// DeleteSessionsForIdentity removes both pairwise scopes after a shared identity +// change. Evict cached records too so a later flush cannot restore an old ratchet. +func (device *Device) DeleteSessionsForIdentity(ctx context.Context, remoteAddress *protocol.SignalAddress) error { + for _, key := range []string{remoteAddress.String(), remoteAddress.String() + "_status"} { + if err := device.Sessions.DeleteSession(ctx, key); err != nil { + return fmt.Errorf("failed to delete session with %s: %w", key, err) + } + if cache := getSessionCache(ctx); cache != nil { + cache.Delete(key) + } + } + return nil +} + func (device *Device) DeleteAllSessions(ctx context.Context) error { return fmt.Errorf("DeleteAllSessions: %w", ErrUnsupportedSignalStoreOperation) } From 27d3157204e7527ba3048c09452c40291003f9fc Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Sun, 15 Nov 2026 22:14:42 +0200 Subject: [PATCH 04/16] fix: keep group publication identity and receipt context across receive paths --- README.md | 4 +++- message.go | 6 +++++- remote_signal.go | 6 ++++++ status_message_test.go | 36 +++++++++++++++++++++++++++++++++++- types/events/events.go | 2 +- types/message.go | 2 +- 6 files changed, 51 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 5eb5f849b..7f892ab50 100644 --- a/README.md +++ b/README.md @@ -101,7 +101,9 @@ Custom `RemoteSignal` receivers must use `RemoteReceive.StatusSession` to select the pairwise session and carry `StatusKind` into their application event. Sender keys remain scoped to the group and sender, and private keys and plaintext stay in the remote store. Upgrading this library alone does not upgrade a remote -receiver's protocol or storage. +receiver's protocol or storage. Legacy encrypted group publications also need +`RemoteReceiveResult.StatusKind` returned after decrypt and on duplicate delivery, +so the client can select the status receipt class without seeing plaintext. ## Newsletter observations diff --git a/message.go b/message.go index 9787609e5..8eb0d4969 100644 --- a/message.go +++ b/message.go @@ -1425,7 +1425,11 @@ func (cli *Client) handleDecryptedMessage(ctx context.Context, info *types.Messa return false } evt := &events.Message{Info: *info, RawMessage: msg, RetryCount: retryCount} - return cli.dispatchEvent(evt.UnwrapRaw()) + evt.UnwrapRaw() + if evt.Info.StatusKind() == types.StatusKindGroup { + info.IsGroupStatus = true + } + return cli.dispatchEvent(evt) } // SendProtocolMessageReceipt sends a receipt for a protocol message back to the phone. diff --git a/remote_signal.go b/remote_signal.go index 2a1cda06b..be4ec130c 100644 --- a/remote_signal.go +++ b/remote_signal.go @@ -114,6 +114,8 @@ type RemoteReceive struct { // RemoteReceiveResult is what the client learns about a received payload. type RemoteReceiveResult struct { + // StatusKind preserves decrypted publication classification for legacy envelopes and duplicate receipts. + StatusKind types.StatusKind // AlreadyDelivered means the application has had this payload before; // the client only needs to acknowledge it again. AlreadyDelivered bool @@ -453,6 +455,10 @@ func (cli *Client) decryptMessagesRemote(ctx context.Context, info *types.Messag if result.AppStateKeyShare != nil { cli.handleAppStateSyncKeyShare(ctx, result.AppStateKeyShare) } + if result.StatusKind == types.StatusKindGroup && info.Chat.Server == types.GroupServer { + info.IsGroupStatus = true + } + if !result.AlreadyDelivered { cli.dispatchEvent(&events.RemoteMessage{ Info: *info, diff --git a/status_message_test.go b/status_message_test.go index 3f2329760..923548607 100644 --- a/status_message_test.go +++ b/status_message_test.go @@ -240,7 +240,7 @@ func TestGroupStatusWrapperIsNotAMentionOrReply(t *testing.T) { {GroupStatusMentionMessage: &waE2E.FutureProofMessage{Message: content}}, {StatusMentionMessage: &waE2E.FutureProofMessage{Message: content}}, } { - evt := (&events.Message{RawMessage: raw}).UnwrapRaw() + evt := (&events.Message{Info: types.MessageInfo{MessageSource: types.MessageSource{Chat: types.NewJID("120363000000001", types.GroupServer), IsGroup: true}}, RawMessage: raw}).UnwrapRaw() isPublication := raw.GetGroupStatusMessageV2() != nil if (evt.Info.StatusKind() == types.StatusKindGroup) != isPublication { t.Fatal("mention classified as a publication") @@ -266,3 +266,37 @@ func TestStatusReceiptPreservesClass(t *testing.T) { } } } + +func TestLegacyGroupStatusReceiptUsesPublicationClass(t *testing.T) { + cli, _, sent := newTestRemote(t) + own := types.NewJID("100000000001", types.HiddenUserServer) + cli.Store.ID = &own + group := types.NewJID("120363000000001", types.GroupServer) + info := types.MessageInfo{MessageSource: types.MessageSource{Chat: group, Sender: own, IsGroup: true}, ID: "authored-legacy-group"} + msg := &waE2E.Message{GroupStatusMessageV2: &waE2E.FutureProofMessage{Message: &waE2E.Message{Conversation: proto.String("authored publication")}}} + cli.handleDecryptedMessage(context.Background(), &info, msg, 0) + if info.StatusKind() != types.StatusKindGroup { + t.Fatal("receipt lost group publication context") + } + cli.sendMessageReceipt(context.Background(), &info, &waBinary.Node{Tag: "message", Attrs: waBinary.Attrs{"from": group, "participant": own, "id": string(info.ID)}}) + if len(sent.nodes) != 1 || sent.nodes[0].Attrs["class"] != "status" { + t.Fatal("legacy group publication sent a chat receipt") + } + info.Chat, info.IsGroup = own, false + if info.StatusKind() != "" { + t.Fatal("group marker reclassified a direct chat") + } +} + +func TestRemoteLegacyGroupClassificationReachesDuplicateReceipt(t *testing.T) { + cli, remote, sent := newTestRemote(t) + own := types.NewJID("100000000001", types.HiddenUserServer) + cli.Store.ID = &own + remote.result = RemoteReceiveResult{StatusKind: types.StatusKindGroup, AlreadyDelivered: true} + _, node := encMessage("skmsg") + node.Attrs["from"], node.Attrs["participant"] = types.NewJID("120363000000001", types.GroupServer), own + cli.handleEncryptedMessage(context.Background(), node) + if len(sent.nodes) != 1 || sent.nodes[0].Attrs["class"] != "status" { + t.Fatal("remote duplicate group publication sent a chat receipt") + } +} diff --git a/types/events/events.go b/types/events/events.go index 7c919ac68..cc6c36bfd 100644 --- a/types/events/events.go +++ b/types/events/events.go @@ -429,7 +429,7 @@ func (evt *Message) UnwrapRaw() *Message { evt.IsBotInvoke = true } if child := evt.Message.GetGroupStatusMessageV2().GetMessage(); child != nil { - evt.Info.IsGroupStatus = true + evt.Info.IsGroupStatus = evt.Info.Chat.Server == types.GroupServer evt.Message = child } if evt.Message.GetEphemeralMessage().GetMessage() != nil { diff --git a/types/message.go b/types/message.go index 02627f5ad..4dda54c63 100644 --- a/types/message.go +++ b/types/message.go @@ -159,7 +159,7 @@ func (info *MessageInfo) StatusKind() StatusKind { if info.IsNewsletterStatus { return StatusKindChannel } - if info.IsGroupStatus { + if info.IsGroupStatus && info.Chat.Server == GroupServer { return StatusKindGroup } if info.Chat == StatusBroadcastJID { From 7359f0a58f5833ab0de22f778de5c6d9a5b34fc3 Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Mon, 16 Nov 2026 22:07:39 +0200 Subject: [PATCH 05/16] fix: retain status classification for duplicate receipts --- README.md | 2 + message.go | 22 ++++- status_message_test.go | 83 ++++++++++++++++++- store/sqlstore/store.go | 9 +- .../upgrades/21-event-publication.sql | 2 + store/sqlstore/upgrades/upgrades_test.go | 36 ++++++-- store/store.go | 14 +++- 7 files changed, 151 insertions(+), 17 deletions(-) create mode 100644 store/sqlstore/upgrades/21-event-publication.sql diff --git a/README.md b/README.md index 7f892ab50..eaf875b42 100644 --- a/README.md +++ b/README.md @@ -287,3 +287,5 @@ Disconnect and wait for owned work to settle before accepting replacement connection authority. `FrameSocket.SetOnDisconnect` replaces the callback under the socket lock; assign the legacy field only before connecting. These additions are unreleased until their reviewed main commit is adopted. + +Custom decrypted-event buffers should implement `store.EventBufferPublicationStore` to retain the group-publication flag while atomically deleting plaintext. The SQL store implements this with migration 21. Old processed rows and custom stores without this extension have unknown legacy classification; no status is inferred from a group chat alone. diff --git a/message.go b/message.go index 8eb0d4969..647ea9191 100644 --- a/message.go +++ b/message.go @@ -488,6 +488,10 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo, } if errors.Is(err, ErrEventAlreadyProcessed) { + var processed *processedEventError + if errors.As(err, &processed) && processed.groupStatus && info.Chat.Server == types.GroupServer { + info.IsGroupStatus = true + } cli.Log.Debugf("Ignoring message %s from %s: %v", info.ID, info.SourceString(), err) continue } else if errors.Is(err, signalerror.ErrOldCounter) { @@ -568,7 +572,11 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo, } if ciphertextHash != nil && cli.EnableDecryptedEventBuffer { // Use the context passed to decryptMessages - err = cli.Store.EventBuffer.ClearBufferedEventPlaintext(ctx, *ciphertextHash) + if publications, ok := cli.Store.EventBuffer.(store.EventBufferPublicationStore); ok { + err = publications.ClearBufferedEventWithPublication(ctx, *ciphertextHash, info.StatusKind() == types.StatusKindGroup) + } else { + err = cli.Store.EventBuffer.ClearBufferedEventPlaintext(ctx, *ciphertextHash) + } if err != nil { zerolog.Ctx(ctx).Err(err). Hex("ciphertext_hash", ciphertextHash[:]). @@ -616,6 +624,16 @@ func (cli *Client) clearUntrustedIdentity(ctx context.Context, target types.JID) return nil } +type processedEventError struct { + inserted time.Time + groupStatus bool +} + +func (e *processedEventError) Error() string { + return fmt.Sprintf("%s at %s", ErrEventAlreadyProcessed, e.inserted) +} +func (e *processedEventError) Unwrap() error { return ErrEventAlreadyProcessed } + var ErrEventAlreadyProcessed = errors.New("event was already processed") // Deprecated: use ErrEventAlreadyProcessed. @@ -652,7 +670,7 @@ func (cli *Client) bufferedDecrypt( Hex("ciphertext_hash", ciphertextHash[:]). Time("insertion_time", buf.InsertTime). Msg("Returning event already processed error") - err = fmt.Errorf("%w at %s", ErrEventAlreadyProcessed, buf.InsertTime.String()) + err = &processedEventError{inserted: buf.InsertTime, groupStatus: buf.GroupStatus != nil && *buf.GroupStatus} return } zerolog.Ctx(ctx).Debug(). diff --git a/status_message_test.go b/status_message_test.go index 923548607..228069148 100644 --- a/status_message_test.go +++ b/status_message_test.go @@ -4,15 +4,18 @@ import ( "context" "errors" "fmt" + "testing" + "time" + + "github.com/polymorfa/libsignal-protocol-go/protocol" + "github.com/polymorfa/libsignal-protocol-go/session" + "google.golang.org/protobuf/proto" + waBinary "github.com/polymorfa/hypermeow/binary" "github.com/polymorfa/hypermeow/proto/waE2E" "github.com/polymorfa/hypermeow/store" "github.com/polymorfa/hypermeow/types/events" waLog "github.com/polymorfa/hypermeow/util/log" - "github.com/polymorfa/libsignal-protocol-go/protocol" - "github.com/polymorfa/libsignal-protocol-go/session" - "google.golang.org/protobuf/proto" - "testing" "github.com/polymorfa/hypermeow/types" ) @@ -300,3 +303,75 @@ func TestRemoteLegacyGroupClassificationReachesDuplicateReceipt(t *testing.T) { t.Fatal("remote duplicate group publication sent a chat receipt") } } + +// The local receive path must retain only classification after plaintext is cleared. +type publicationTestBuffer struct { + store.NoopStore + entries map[[32]byte]*store.BufferedEvent +} + +func (b *publicationTestBuffer) GetBufferedEvent(_ context.Context, hash [32]byte) (*store.BufferedEvent, error) { + return b.entries[hash], nil +} +func (b *publicationTestBuffer) PutBufferedEvent(_ context.Context, hash [32]byte, plaintext []byte, ts time.Time) error { + b.entries[hash] = &store.BufferedEvent{Plaintext: plaintext, InsertTime: time.Now(), ServerTime: ts} + return nil +} +func (b *publicationTestBuffer) DoDecryptionTxn(ctx context.Context, fn func(context.Context) error) error { + return fn(ctx) +} +func (b *publicationTestBuffer) ClearBufferedEventWithPublication(_ context.Context, hash [32]byte, groupStatus bool) error { + b.entries[hash].Plaintext = nil + b.entries[hash].GroupStatus = &groupStatus + return nil +} +func TestLocalLegacyGroupDuplicateKeepsStatusReceipt(t *testing.T) { + ctx := context.Background() + own := types.JID{User: "100000000001", Server: types.HiddenUserServer, Device: 1} + sender := types.JID{User: "200000000002", Server: types.HiddenUserServer, Device: 2} + device, _ := newSignalTestDevice(own, &store.NoopStore{}) + device.LID = own + buffer := &publicationTestBuffer{entries: make(map[[32]byte]*store.BufferedEvent)} + device.EventBuffer = buffer + cli := NewClient(device, waLog.Noop) + cli.EnableDecryptedEventBuffer = true + cli.SynchronousAck = true + sent := &sentNodes{} + cli.testSendHook = sent.hook + delivered := 0 + cli.AddEventHandler(func(evt any) { + if _, ok := evt.(*events.Message); ok { + delivered++ + } + }) + peer := newSignalTestPeer(t, device, sender) + plaintext, err := proto.Marshal(&waE2E.Message{GroupStatusMessageV2: &waE2E.FutureProofMessage{Message: &waE2E.Message{Conversation: proto.String("authored legacy publication")}}}) + if err != nil { + t.Fatal(err) + } + encrypted, err := peer.cipher.Encrypt(ctx, padMessage(plaintext)) + if err != nil { + t.Fatal(err) + } + group := types.NewJID("120363000000001", types.GroupServer) + node := &waBinary.Node{Tag: "message", Attrs: waBinary.Attrs{"from": group, "participant": sender, "id": "authored-duplicate", "t": "1700000000"}, Content: []waBinary.Node{{Tag: "enc", Attrs: waBinary.Attrs{"type": "pkmsg", "v": "2"}, Content: encrypted.Serialize()}}} + for i := 0; i < 2; i++ { + cli.handleEncryptedMessage(ctx, node) + } + if delivered != 1 { + t.Fatalf("delivered %d times, want 1", delivered) + } + if len(sent.nodes) != 2 { + t.Fatalf("sent %d nodes, want 2 receipts", len(sent.nodes)) + } + for _, receipt := range sent.nodes { + if receipt.Tag != "receipt" || receipt.Attrs["class"] != "status" { + t.Fatalf("wrong receipt: %+v", receipt) + } + } + for _, entry := range buffer.entries { + if entry.Plaintext != nil || entry.GroupStatus == nil || !*entry.GroupStatus { + t.Fatal("processed metadata did not replace plaintext") + } + } +} diff --git a/store/sqlstore/store.go b/store/sqlstore/store.go index c3f0215ba..c6861c6e9 100644 --- a/store/sqlstore/store.go +++ b/store/sqlstore/store.go @@ -1585,7 +1585,7 @@ func (s *SQLStore) DeleteExpiredPrivacyTokens(ctx context.Context, cutoff time.T const ( getBufferedEventQuery = ` - SELECT plaintext, server_timestamp, insert_timestamp FROM whatsmeow_event_buffer WHERE our_jid = $1 AND ciphertext_hash = $2 + SELECT plaintext, server_timestamp, insert_timestamp, group_status FROM whatsmeow_event_buffer WHERE our_jid = $1 AND ciphertext_hash = $2 ` putBufferedEventQuery = ` INSERT INTO whatsmeow_event_buffer (our_jid, ciphertext_hash, plaintext, server_timestamp, insert_timestamp) @@ -1602,7 +1602,7 @@ const ( func (s *SQLStore) GetBufferedEvent(ctx context.Context, ciphertextHash [32]byte) (*store.BufferedEvent, error) { var insertTimeMS, serverTimeSeconds int64 var buf store.BufferedEvent - err := s.db.QueryRow(ctx, getBufferedEventQuery, s.JID, ciphertextHash[:]).Scan(&buf.Plaintext, &serverTimeSeconds, &insertTimeMS) + err := s.db.QueryRow(ctx, getBufferedEventQuery, s.JID, ciphertextHash[:]).Scan(&buf.Plaintext, &serverTimeSeconds, &insertTimeMS, &buf.GroupStatus) if errors.Is(err, sql.ErrNoRows) { return nil, nil } else if err != nil { @@ -1628,6 +1628,11 @@ func (s *SQLStore) ClearBufferedEventPlaintext(ctx context.Context, ciphertextHa return err } +func (s *SQLStore) ClearBufferedEventWithPublication(ctx context.Context, ciphertextHash [32]byte, groupStatus bool) error { + _, err := s.db.Exec(ctx, `UPDATE whatsmeow_event_buffer SET plaintext = NULL, group_status = $3 WHERE our_jid = $1 AND ciphertext_hash = $2`, s.JID, ciphertextHash[:], groupStatus) + return err +} + func (s *SQLStore) DeleteOldBufferedHashes(ctx context.Context) error { // The WhatsApp servers only buffer events for 14 days, // so we can safely delete anything older than that. diff --git a/store/sqlstore/upgrades/21-event-publication.sql b/store/sqlstore/upgrades/21-event-publication.sql new file mode 100644 index 000000000..57c22d571 --- /dev/null +++ b/store/sqlstore/upgrades/21-event-publication.sql @@ -0,0 +1,2 @@ +-- v21 (compatible with v8+): Retain legacy group publication receipt classification without plaintext +ALTER TABLE whatsmeow_event_buffer ADD COLUMN group_status BOOLEAN; diff --git a/store/sqlstore/upgrades/upgrades_test.go b/store/sqlstore/upgrades/upgrades_test.go index 3976deb7e..c478a371c 100644 --- a/store/sqlstore/upgrades/upgrades_test.go +++ b/store/sqlstore/upgrades/upgrades_test.go @@ -157,8 +157,8 @@ func TestUpgradeFromCurrentDevSchemaAddsUsername(t *testing.T) { if err = db.Upgrade(context.Background()); err != nil { t.Fatal(err) } - if state.version != 20 || state.compatVersion != 8 { - t.Fatalf("schema version = %d/%d, want 20/8", state.version, state.compatVersion) + if state.version != 21 || state.compatVersion != 8 { + t.Fatalf("schema version = %d/%d, want 21/8", state.version, state.compatVersion) } want := "ALTER TABLE whatsmeow_contacts ADD COLUMN username TEXT;" for _, query := range state.executed { @@ -182,8 +182,8 @@ func TestUpgradeFromPublishedSchemaAddsWASARootSecret(t *testing.T) { if err = db.Upgrade(t.Context()); err != nil { t.Fatal(err) } - if state.version != 20 || state.compatVersion != 8 { - t.Fatalf("schema version = %d/%d, want 20/8", state.version, state.compatVersion) + if state.version != 21 || state.compatVersion != 8 { + t.Fatalf("schema version = %d/%d, want 21/8", state.version, state.compatVersion) } for _, query := range state.executed { if strings.Contains(query, "ALTER TABLE whatsmeow_chat_settings ADD COLUMN wasa_root_secret_id TEXT NOT NULL DEFAULT '';") { @@ -206,8 +206,8 @@ func TestUpgradeFromV19AddsHostedAccountFlag(t *testing.T) { if err = db.Upgrade(t.Context()); err != nil { t.Fatal(err) } - if state.version != 20 || state.compatVersion != 8 { - t.Fatalf("schema version = %d/%d, want 20/8", state.version, state.compatVersion) + if state.version != 21 || state.compatVersion != 8 { + t.Fatalf("schema version = %d/%d, want 21/8", state.version, state.compatVersion) } for _, query := range state.executed { if strings.Contains(query, "ALTER TABLE whatsmeow_device ADD COLUMN is_hosted BOOLEAN NOT NULL DEFAULT false;") { @@ -216,3 +216,27 @@ func TestUpgradeFromV19AddsHostedAccountFlag(t *testing.T) { } t.Fatalf("hosted account migration was not executed: %q", state.executed) } + +func TestUpgradeFromV20AddsPublicationMetadata(t *testing.T) { + state := &upgradeTestState{version: 20, compatVersion: 8} + rawDB := sql.OpenDB(&upgradeTestConnector{state: state}) + t.Cleanup(func() { _ = rawDB.Close() }) + db, err := dbutil.NewWithDB(rawDB, "postgres") + if err != nil { + t.Fatal(err) + } + db.VersionTable = "whatsmeow_version" + db.UpgradeTable = Table + if err = db.Upgrade(t.Context()); err != nil { + t.Fatal(err) + } + if state.version != 21 || state.compatVersion != 8 { + t.Fatalf("schema version = %d/%d, want 21/8", state.version, state.compatVersion) + } + for _, query := range state.executed { + if strings.Contains(query, "ALTER TABLE whatsmeow_event_buffer ADD COLUMN group_status BOOLEAN;") { + return + } + } + t.Fatalf("publication migration was not executed: %q", state.executed) +} diff --git a/store/store.go b/store/store.go index af14dd195..e395d3f33 100644 --- a/store/store.go +++ b/store/store.go @@ -183,9 +183,17 @@ type NCTSaltStore interface { } type BufferedEvent struct { - Plaintext []byte - InsertTime time.Time - ServerTime time.Time + // GroupStatus is retained after plaintext deletion; nil means older or unsupported storage. + GroupStatus *bool + Plaintext []byte + InsertTime time.Time + ServerTime time.Time +} + +// EventBufferPublicationStore atomically clears plaintext and retains only publication +// classification. Custom buffers should implement it to classify legacy duplicates. +type EventBufferPublicationStore interface { + ClearBufferedEventWithPublication(ctx context.Context, ciphertextHash [32]byte, groupStatus bool) error } type EventBuffer interface { From 5708d643b7117eb5f18815c988d44a2068769fd5 Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Mon, 16 Nov 2026 23:30:28 +0200 Subject: [PATCH 06/16] fix(receive): preserve delegated status handoff order --- client.go | 4 +++- status_message_test.go | 38 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+), 1 deletion(-) diff --git a/client.go b/client.go index 63ea496c5..4423dc762 100644 --- a/client.go +++ b/client.go @@ -1050,7 +1050,9 @@ func (cli *Client) handleFrame(ctx context.Context, data []byte, queue chan *waB // [handleEncryptedMessage]'s own DisabledFeatures.Signal branch // stays as a fallback for direct callers (DangerousInternals, // ``). - if node.Tag == "message" && cli.DisabledFeatures.Signal { + from, hasFrom := node.Attrs["from"].(types.JID) + encryptedStatus := node.Tag == "status" && hasFrom && (from == types.StatusBroadcastJID || from.Server == types.GroupServer) + if cli.DisabledFeatures.Signal && (node.Tag == "message" || encryptedStatus) { info, err := cli.parseMessageInfo(node) if err != nil { cli.Log.Warnf("Failed to parse message for Signal-disabled handoff: %v", err) diff --git a/status_message_test.go b/status_message_test.go index 228069148..b5fee3d08 100644 --- a/status_message_test.go +++ b/status_message_test.go @@ -375,3 +375,41 @@ func TestLocalLegacyGroupDuplicateKeepsStatusReceipt(t *testing.T) { } } } + +func TestSignalDisabledStatusHandoffKeepsWireOrder(t *testing.T) { + for _, chat := range []types.JID{types.StatusBroadcastJID, types.NewJID("120363000000001", types.GroupServer)} { + t.Run(chat.Server, func(t *testing.T) { + cli := NewClient(&store.Device{}, waLog.Noop) + own := types.NewJID("100000000001", types.HiddenUserServer) + cli.Store.ID, cli.Store.LID = &own, own + cli.DisabledFeatures.Signal = true + queue := make(chan *waBinary.Node, 4) // Deliberately unconsumed. + var order []string + cli.RawNodeHandler = func(_ context.Context, node *waBinary.Node) (*waBinary.Node, bool) { + order = append(order, "raw:"+node.Attrs["id"].(string)) + return node, false + } + cli.AddEventHandler(func(event any) { + if e, ok := event.(*events.UndecryptedMessage); ok { + order = append(order, "event:"+e.Info.ID) + } + }) + for _, tag := range []string{"status", "message"} { + _, node := encMessage("pkmsg") + node.Tag = tag + node.Attrs["id"], node.Attrs["from"], node.Attrs["participant"] = tag, chat, types.JID{User: "200000000002", Server: types.HiddenUserServer, Device: 2} + frame, err := waBinary.Marshal(*node) + if err != nil { + t.Fatal(err) + } + cli.handleFrame(context.Background(), frame, queue) + } + if fmt.Sprint(order) != "[raw:status event:status raw:message event:message]" { + t.Fatalf("handoff order = %v", order) + } + if len(queue) != 0 { + t.Fatalf("encrypted envelopes queued = %d", len(queue)) + } + }) + } +} From 48af73edf3b92ff455e73058fa6d53b17287b27b Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Tue, 17 Nov 2026 00:02:43 +0200 Subject: [PATCH 07/16] prekeys: keep each bundle's device identity The prekey response carries a (serialized ADVSignedDeviceIdentity) for companion devices, beside the identity key. fetchPreKeys now keeps it, and DangerousInternals gains FetchPreKeysWithIdentityNoError, which returns it with each bundle so a caller can verify a companion against its account before encrypting. Existing fetch calls are unchanged. --- internals.go | 6 +++ prekeys.go | 69 +++++++++++++++++++++++++++++++-- prekeys_device_identity_test.go | 53 +++++++++++++++++++++++++ 3 files changed, 125 insertions(+), 3 deletions(-) create mode 100644 prekeys_device_identity_test.go diff --git a/internals.go b/internals.go index b14481b53..a389c6a74 100644 --- a/internals.go +++ b/internals.go @@ -655,6 +655,12 @@ func (int *DangerousInternalClient) FetchPreKeysNoError(ctx context.Context, ret return int.c.fetchPreKeysNoError(ctx, retryDevices) } +// FetchPreKeysWithIdentityNoError fetches prekey bundles and keeps the +// each companion device's bundle carries. +func (int *DangerousInternalClient) FetchPreKeysWithIdentityNoError(ctx context.Context, devices []types.JID) map[types.JID]FetchedPreKey { + return int.c.fetchPreKeysWithIdentityNoError(ctx, devices) +} + func (int *DangerousInternalClient) FetchPreKeys(ctx context.Context, users []types.JID) (map[types.JID]preKeyResp, error) { return int.c.fetchPreKeys(ctx, users) } diff --git a/prekeys.go b/prekeys.go index 693e297ca..a6739d361 100644 --- a/prekeys.go +++ b/prekeys.go @@ -134,8 +134,57 @@ func (cli *Client) fetchPreKeysNoError(ctx context.Context, retryDevices []types } type preKeyResp struct { - bundle *prekey.Bundle - err error + bundle *prekey.Bundle + deviceIdentity []byte + err error +} + +// FetchedPreKey is one device's prekey bundle together with the +// (serialized ADVSignedDeviceIdentity) the server returned +// with it. Companion devices carry one; a primary device has none, so +// DeviceIdentity is nil. +type FetchedPreKey struct { + Bundle *prekey.Bundle + DeviceIdentity []byte +} + +// fetchPreKeysWithIdentityNoError is fetchPreKeysNoError, keeping each +// bundle's . A headless client fetches through its relay, +// which returns bundles only, so DeviceIdentity is nil there. +func (cli *Client) fetchPreKeysWithIdentityNoError(ctx context.Context, devices []types.JID) map[types.JID]FetchedPreKey { + if len(devices) == 0 { + return nil + } + if cli.isShadow() { + bundles, err := cli.shadowRelay.FetchPreKeys(ctx, devices) + if err != nil { + cli.Log.Warnf("Failed to fetch prekeys for %v via relay: %v", devices, err) + return nil + } + out := make(map[types.JID]FetchedPreKey, len(bundles)) + for jid, bundle := range bundles { + out[jid] = FetchedPreKey{Bundle: bundle} + } + return out + } + resp, err := cli.fetchPreKeys(ctx, devices) + if err != nil { + cli.Log.Warnf("Failed to fetch prekeys for %v: %v", devices, err) + return nil + } + out := make(map[types.JID]FetchedPreKey, len(devices)) + for _, jid := range devices { + r, ok := resp[jid] + if !ok { + continue + } + if r.err != nil { + cli.Log.Warnf("Failed to fetch prekey for %s: %v", jid, r.err) + continue + } + out[jid] = FetchedPreKey{Bundle: r.bundle, DeviceIdentity: r.deviceIdentity} + } + return out } func (cli *Client) fetchPreKeys(ctx context.Context, users []types.JID) (map[types.JID]preKeyResp, error) { @@ -169,11 +218,25 @@ func (cli *Client) fetchPreKeys(ctx context.Context, users []types.JID) (map[typ } jid := child.AttrGetter().JID("jid") bundle, err := nodeToPreKeyBundle(uint32(jid.Device), child) - respData[jid] = preKeyResp{bundle, err} + respData[jid] = preKeyResp{bundle: bundle, deviceIdentity: preKeyDeviceIdentity(child), err: err} } return respData, nil } +// preKeyDeviceIdentity returns the bytes of one prekey +// response entry. WhatsApp places it beside the identity key, which may sit +// under a wrapper. +func preKeyDeviceIdentity(node waBinary.Node) []byte { + for _, parent := range []waBinary.Node{node, node.GetChildByTag("keys")} { + if child, ok := parent.GetOptionalChildByTag("device-identity"); ok { + if content, ok := child.Content.([]byte); ok && len(content) > 0 { + return content + } + } + } + return nil +} + func preKeyToNode(key *keys.PreKey) waBinary.Node { var keyID [4]byte binary.BigEndian.PutUint32(keyID[:], key.KeyID) diff --git a/prekeys_device_identity_test.go b/prekeys_device_identity_test.go new file mode 100644 index 000000000..5a7be2544 --- /dev/null +++ b/prekeys_device_identity_test.go @@ -0,0 +1,53 @@ +// Copyright (c) 2026 Rajeh Taher +// Licensed under the MIT License. See LICENSE-MIT for details. + +package whatsmeow + +import ( + "bytes" + "testing" + + waBinary "github.com/polymorfa/hypermeow/binary" +) + +func TestPreKeyDeviceIdentity(t *testing.T) { + identity := []byte{0x0a, 0x01, 0x02} + cases := []struct { + name string + node waBinary.Node + want []byte + }{ + { + name: "beside the identity key", + node: waBinary.Node{Tag: "user", Content: []waBinary.Node{ + {Tag: "registration", Content: []byte{0, 0, 0, 1}}, + {Tag: "device-identity", Content: identity}, + }}, + want: identity, + }, + { + name: "inside a keys wrapper", + node: waBinary.Node{Tag: "user", Content: []waBinary.Node{ + {Tag: "keys", Content: []waBinary.Node{{Tag: "device-identity", Content: identity}}}, + }}, + want: identity, + }, + { + name: "primary device without one", + node: waBinary.Node{Tag: "user", Content: []waBinary.Node{ + {Tag: "registration", Content: []byte{0, 0, 0, 1}}, + }}, + }, + { + name: "empty element", + node: waBinary.Node{Tag: "user", Content: []waBinary.Node{{Tag: "device-identity"}}}, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + if got := preKeyDeviceIdentity(tc.node); !bytes.Equal(got, tc.want) { + t.Fatalf("preKeyDeviceIdentity = %x, want %x", got, tc.want) + } + }) + } +} From 4792d8dfc24c793711dd563079bba8fae787ec98 Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Tue, 17 Nov 2026 01:07:16 +0200 Subject: [PATCH 08/16] remote signal: forward a pkmsg's device identity A prekey message from a companion device carries beside its . Pass it to the remote Signal store in RemoteReceive.DeviceIdentity so it can verify the sender against its account before decrypting. --- remote_signal.go | 23 +++++++++++++++++++++++ remote_signal_test.go | 25 +++++++++++++++++++++++++ 2 files changed, 48 insertions(+) diff --git a/remote_signal.go b/remote_signal.go index e6c22d45b..b0b8ebbbb 100644 --- a/remote_signal.go +++ b/remote_signal.go @@ -107,6 +107,10 @@ type RemoteReceive struct { Ciphertext []byte PaddingVersion int IsFromMe bool + // DeviceIdentity is the stanza's (a serialized + // ADVSignedDeviceIdentity), which a pkmsg from a companion device + // carries. Nil for other payloads. + DeviceIdentity []byte } // RemoteReceiveResult is what the client learns about a received payload. @@ -351,6 +355,20 @@ func (s *remotePreKeyStore) UploadedPreKeyCount(ctx context.Context) (int, error return s.remote.UploadedPreKeyCount(ctx) } +// messageDeviceIdentity returns the a message stanza +// carries beside its payloads, or nil. +func messageDeviceIdentity(node *waBinary.Node) []byte { + child, ok := node.GetOptionalChildByTag("device-identity") + if !ok { + return nil + } + content, ok := child.Content.([]byte) + if !ok || len(content) == 0 { + return nil + } + return content +} + // decryptMessagesRemote is decryptMessages for a remote-keyed client: each // `` payload goes to the remote store, and only delivery metadata comes // back. Receipts, retry receipts and acks follow the local path. @@ -393,6 +411,10 @@ func (cli *Client) decryptMessagesRemote(ctx context.Context, info *types.Messag if senderEncryptionJID == info.SenderAlt && senderEncryptionJID != info.Sender { senderAlt = info.Sender } + var deviceIdentity []byte + if encType == "pkmsg" { + deviceIdentity = messageDeviceIdentity(node) + } result, err := cli.remoteSignal.Receive(ctx, RemoteReceive{ Timestamp: info.Timestamp, SenderAlt: senderAlt, @@ -403,6 +425,7 @@ func (cli *Client) decryptMessagesRemote(ctx context.Context, info *types.Messag Ciphertext: ciphertext, PaddingVersion: ag.OptionalInt("v"), IsFromMe: info.IsFromMe, + DeviceIdentity: deviceIdentity, }) var decryptErr *RemoteDecryptError isDecryptErr := errors.As(err, &decryptErr) diff --git a/remote_signal_test.go b/remote_signal_test.go index 1a325b852..b197f9132 100644 --- a/remote_signal_test.go +++ b/remote_signal_test.go @@ -4,6 +4,7 @@ package whatsmeow import ( + "bytes" "context" "errors" "fmt" @@ -290,6 +291,30 @@ func TestRemoteReceiveDeliversMetadataAndAcknowledges(t *testing.T) { } } +func TestRemoteReceiveForwardsPreKeyDeviceIdentity(t *testing.T) { + identity := []byte{0x0a, 0x01, 0x02} + for _, tc := range []struct { + encType string + want []byte + }{ + {"pkmsg", identity}, + {"msg", nil}, + } { + t.Run(tc.encType, func(t *testing.T) { + cli, remote, _ := newTestRemote(t) + info, node := encMessage(tc.encType) + node.Content = append(node.GetChildren(), waBinary.Node{Tag: "device-identity", Content: identity}) + cli.decryptMessages(context.Background(), info, node) + if len(remote.receives) != 1 { + t.Fatalf("Receive calls = %d, want 1", len(remote.receives)) + } + if got := remote.receives[0].DeviceIdentity; !bytes.Equal(got, tc.want) { + t.Fatalf("DeviceIdentity = %x, want %x", got, tc.want) + } + }) + } +} + func TestRemoteReceivePreservesProviderTimeAndAlternateSender(t *testing.T) { pn := types.NewJID("15551234567", types.DefaultUserServer) lid := types.NewJID("123456789", types.HiddenUserServer) From cb4fdbae951ef0269e839cea654cae96dd536d79 Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Tue, 17 Nov 2026 05:18:57 +0200 Subject: [PATCH 09/16] fix(signal): reject sessions cached before identity resets --- message.go | 25 ++-- send.go | 17 +++ session_cache_reset_test.go | 115 +++++++++++++++++ store/sessioncache.go | 89 +++++++++++-- store/sessioncache_reset_test.go | 214 +++++++++++++++++++++++++++++++ store/signal.go | 27 ++-- store/store.go | 4 + 7 files changed, 463 insertions(+), 28 deletions(-) create mode 100644 session_cache_reset_test.go create mode 100644 store/sessioncache_reset_test.go diff --git a/message.go b/message.go index 647ea9191..927adfd73 100644 --- a/message.go +++ b/message.go @@ -648,7 +648,10 @@ func (cli *Client) bufferedDecrypt( extraHashData ...string, ) (plaintext []byte, ciphertextHash [32]byte, err error) { if !cli.EnableDecryptedEventBuffer { - plaintext, err = decrypt(ctx) + err = cli.Store.WithSessionStateLock(ctx, func(ctx context.Context) error { + plaintext, err = decrypt(ctx) + return err + }) return } hasher := sha256.New() @@ -681,16 +684,18 @@ func (cli *Client) bufferedDecrypt( return } - err = cli.Store.EventBuffer.DoDecryptionTxn(ctx, func(ctx context.Context) (innerErr error) { - plaintext, innerErr = decrypt(ctx) - if innerErr != nil { + err = cli.Store.WithSessionStateLock(ctx, func(ctx context.Context) error { + return cli.Store.EventBuffer.DoDecryptionTxn(ctx, func(ctx context.Context) (innerErr error) { + plaintext, innerErr = decrypt(ctx) + if innerErr != nil { + return + } + innerErr = cli.Store.EventBuffer.PutBufferedEvent(ctx, ciphertextHash, plaintext, serverTimestamp) + if innerErr != nil { + innerErr = fmt.Errorf("%w: failed to save decrypted event to buffer: %w", ErrEventBufferDB, innerErr) + } return - } - innerErr = cli.Store.EventBuffer.PutBufferedEvent(ctx, ciphertextHash, plaintext, serverTimestamp) - if innerErr != nil { - innerErr = fmt.Errorf("%w: failed to save decrypted event to buffer: %w", ErrEventBufferDB, innerErr) - } - return + }) }) if err == nil { zerolog.Ctx(ctx).Debug(). diff --git a/send.go b/send.go index 5fb006be4..90958039c 100644 --- a/send.go +++ b/send.go @@ -34,6 +34,7 @@ import ( "github.com/polymorfa/hypermeow/proto/waAICommon" "github.com/polymorfa/hypermeow/proto/waCommon" "github.com/polymorfa/hypermeow/proto/waE2E" + "github.com/polymorfa/hypermeow/store" "github.com/polymorfa/hypermeow/types" "github.com/polymorfa/hypermeow/types/events" ) @@ -1526,6 +1527,22 @@ func (cli *Client) encryptMessageForDevice( // per-device encryption to the relay oracle. return cli.shadowRelay.EncryptForDevice(ctx, plaintext, to, bundle, extraAttrs) } + var node *waBinary.Node + var includeIdentity bool + err := cli.Store.WithSessionStateLock(ctx, func(ctx context.Context) (err error) { + if err = cli.Store.CheckCachedSession(ctx, store.SignalSessionAddress(ctx, to.SignalAddress().String())); err != nil { + return err + } + node, includeIdentity, err = encryptMessageForDeviceLocked(cli, ctx, plaintext, to, bundle, extraAttrs, existingSessions) + return + }) + return node, includeIdentity, err +} + +func encryptMessageForDeviceLocked( + cli *Client, ctx context.Context, plaintext []byte, to types.JID, bundle *prekey.Bundle, + extraAttrs waBinary.Attrs, existingSessions map[string]bool, +) (*waBinary.Node, bool, error) { builder := session.NewBuilderFromSignal(cli.Store, to.SignalAddress(), pbSerializer) if bundle != nil { cli.Log.Debugf("Processing prekey bundle for %s", to) diff --git a/session_cache_reset_test.go b/session_cache_reset_test.go new file mode 100644 index 000000000..1460d0391 --- /dev/null +++ b/session_cache_reset_test.go @@ -0,0 +1,115 @@ +// Copyright (c) 2026 Rajeh Taher +// +// Licensed under the MIT License. See LICENSE-MIT for details. + +package whatsmeow + +import ( + "context" + "sync" + "testing" + "time" + + "github.com/polymorfa/libsignal-protocol-go/protocol" + + "github.com/polymorfa/hypermeow/store" + "github.com/polymorfa/hypermeow/types" + waLog "github.com/polymorfa/hypermeow/util/log" +) + +func TestEncryptRejectsCacheLoadedBeforeIdentityReset(t *testing.T) { + for _, status := range []bool{false, true} { + t.Run(map[bool]string{false: "chat", true: "status"}[status], func(t *testing.T) { + own := types.NewADJID("100000000001", 0, 1) + peerJID := types.NewADJID("200000000002", 0, 2) + companion, _ := newSignalTestDevice(own, &store.NoopStore{}) + peer, _ := newSignalTestDevice(peerJID, &store.NoopStore{}) + cli := NewClient(companion, waLog.Noop) + ctx := context.Background() + if status { + ctx = store.WithStatusSession(ctx) + } + if _, _, err := cli.encryptMessageForDevice(ctx, []byte("authored initial"), peerJID, signalTestBundle(t, peer, 2), nil, nil); err != nil { + t.Fatal(err) + } + address := store.SignalSessionAddress(ctx, peerJID.SignalAddress().String()) + existing, cached, err := companion.WithCachedSessions(ctx, []string{address}) + if err != nil { + t.Fatal(err) + } + if err = companion.DeleteSessionsForIdentity(context.Background(), peerJID.SignalAddress()); err != nil { + t.Fatal(err) + } + if _, _, err = cli.encryptMessageForDevice(cached, []byte("authored stale"), peerJID, nil, nil, existing); err == nil { + t.Fatal("encrypted with a cached ratchet from before the identity reset") + } + }) + } +} + +type guardOrderBuffer struct { + store.EventBuffer + entered chan struct{} +} + +func (b *guardOrderBuffer) GetBufferedEvent(context.Context, [32]byte) (*store.BufferedEvent, error) { + return nil, nil +} +func (b *guardOrderBuffer) PutBufferedEvent(context.Context, [32]byte, []byte, time.Time) error { + return nil +} +func (b *guardOrderBuffer) DoDecryptionTxn(ctx context.Context, fn func(context.Context) error) error { + close(b.entered) + return fn(ctx) +} + +func TestBufferedDecryptOrdersTransactionAfterSessionMutation(t *testing.T) { + device, _ := newSignalTestDevice(types.NewADJID("100000000001", 0, 1), &store.NoopStore{}) + buffer := &guardOrderBuffer{entered: make(chan struct{})} + device.EventBuffer = buffer + cli := NewClient(device, waLog.Noop) + cli.EnableDecryptedEventBuffer = true + locker, ok := any(device).(interface { + WithSessionStateLock(context.Context, func(context.Context) error) error + }) + if !ok { + t.Fatal("local session mutation guard is unavailable") + } + held, release := make(chan struct{}), make(chan struct{}) + var once sync.Once + unblock := func() { once.Do(func() { close(release) }) } + defer unblock() + guarded := make(chan error, 1) + go func() { + guarded <- locker.WithSessionStateLock(context.Background(), func(context.Context) error { close(held); <-release; return nil }) + }() + <-held + done := make(chan error, 1) + go func() { + _, _, err := cli.bufferedDecrypt(context.Background(), []byte("authored guard order"), time.Unix(1700000000, 0), func(ctx context.Context) ([]byte, error) { + return []byte("authored plaintext"), device.DeleteSessionsForIdentity(ctx, protocol.NewSignalAddress("123", 1)) + }) + done <- err + }() + early := false + select { + case <-buffer.entered: + early = true + case <-time.After(50 * time.Millisecond): + } + unblock() + if err := <-guarded; err != nil { + t.Fatal(err) + } + select { + case err := <-done: + if err != nil { + t.Fatal(err) + } + case <-time.After(2 * time.Second): + t.Fatal("nested reset deadlocked") + } + if early { + t.Fatal("database transaction entered before local mutation guard") + } +} diff --git a/store/sessioncache.go b/store/sessioncache.go index 8ea28a37a..7aa083b68 100644 --- a/store/sessioncache.go +++ b/store/sessioncache.go @@ -8,6 +8,7 @@ package store import ( "context" + "errors" "fmt" "github.com/polymorfa/libsignal-protocol-go/state/record" @@ -20,15 +21,33 @@ type contextKey int const ( contextKeySessionCache contextKey = iota + contextKeySessionStateLock ) +var ErrSessionCacheInvalidated = errors.New("session cache was invalidated by an identity reset") + type sessionCacheEntry struct { - Dirty bool - Found bool - Record *record.Session + Generation uint64 + Dirty bool + Found bool + Record *record.Session +} + +type sessionCache struct { + *exsync.Map[string, sessionCacheEntry] + epoch uint64 } -type sessionCache = exsync.Map[string, sessionCacheEntry] +// WithSessionStateLock orders local session mutations before database transactions. +// The callback context permits nested operations on this device and must not escape it. +func (device *Device) WithSessionStateLock(ctx context.Context, fn func(context.Context) error) error { + if ctx.Value(contextKeySessionStateLock) == device { + return fn(ctx) + } + device.sessionStateLock.Lock() + defer device.sessionStateLock.Unlock() + return fn(context.WithValue(ctx, contextKeySessionStateLock, device)) +} type sessionIterator interface { IterateSessions(context.Context, []string, func(string, []byte) error) error @@ -78,23 +97,60 @@ func putCachedSession(ctx context.Context, addr string, record *record.Session) if cache == nil { return false } + generation := cache.epoch + if previous, ok := cache.Get(addr); ok { + generation = previous.Generation + } cache.Set(addr, sessionCacheEntry{ - Dirty: true, - Found: true, - Record: record, + Generation: generation, + Dirty: true, + Found: true, + Record: record, }) return true } +// CheckCachedSession rejects a stale cached address before local crypto can mutate identity state. +func (device *Device) CheckCachedSession(ctx context.Context, address string) error { + return device.WithSessionStateLock(ctx, func(ctx context.Context) error { + if cache := getSessionCache(ctx); cache != nil { + generation := cache.epoch + if item, ok := cache.Get(address); ok { + generation = item.Generation + } + if device.sessionResetAddresses[address] > generation { + return ErrSessionCacheInvalidated + } + } + return nil + }) +} + func (device *Device) WithCachedSessions(ctx context.Context, addresses []string) (map[string]bool, context.Context, error) { if len(addresses) == 0 { return nil, ctx, nil } + var found map[string]bool + var cached context.Context + err := device.WithSessionStateLock(ctx, func(locked context.Context) (err error) { + found, cached, err = device.withCachedSessions(locked, addresses) + return + }) + if err != nil { + return nil, ctx, err + } + return found, context.WithValue(ctx, contextKeySessionCache, getSessionCache(cached)), nil +} + +func (device *Device) withCachedSessions(ctx context.Context, addresses []string) (map[string]bool, context.Context, error) { + if len(addresses) == 0 { + return nil, ctx, nil + } wrapped := make(map[string]sessionCacheEntry, len(addresses)) existingSessions := make(map[string]bool, len(addresses)) for _, addr := range addresses { - wrapped[addr] = sessionCacheEntry{Record: record.NewSession(SignalProtobufSerializer.Session, SignalProtobufSerializer.State)} + wrapped[addr] = sessionCacheEntry{Generation: device.sessionResetEpoch, Record: record.NewSession(SignalProtobufSerializer.Session, SignalProtobufSerializer.State)} existingSessions[addr] = false } loadSession := func(addr string, rawSess []byte) error { @@ -108,7 +164,7 @@ func (device *Device) WithCachedSessions(ctx context.Context, addresses []string return nil } existingSessions[addr] = true - wrapped[addr] = sessionCacheEntry{Record: sessionRecord, Found: true} + wrapped[addr] = sessionCacheEntry{Generation: device.sessionResetEpoch, Record: sessionRecord, Found: true} return nil } if iterator, ok := device.Sessions.(sessionIterator); ok { @@ -127,21 +183,34 @@ func (device *Device) WithCachedSessions(ctx context.Context, addresses []string } } - ctx = context.WithValue(ctx, contextKeySessionCache, (*sessionCache)(exsync.NewMapWithData(wrapped))) + ctx = context.WithValue(ctx, contextKeySessionCache, &sessionCache{Map: exsync.NewMapWithData(wrapped), epoch: device.sessionResetEpoch}) return existingSessions, ctx, nil } func (device *Device) PutCachedSessions(ctx context.Context) error { + return device.WithSessionStateLock(ctx, device.putCachedSessions) +} + +func (device *Device) putCachedSessions(ctx context.Context) error { cache := getSessionCache(ctx) if cache == nil { return nil } dirtySessions := make(map[string][]byte) + invalid := false for addr, item := range cache.Iter() { if item.Dirty { + if device.sessionResetAddresses[addr] > item.Generation { + invalid = true + break + } dirtySessions[addr] = item.Record.Serialize() } } + if invalid { + cache.Clear() + return ErrSessionCacheInvalidated + } if len(dirtySessions) > 0 { err := device.Sessions.PutManySessions(ctx, dirtySessions) if err != nil { diff --git a/store/sessioncache_reset_test.go b/store/sessioncache_reset_test.go new file mode 100644 index 000000000..a70c54d35 --- /dev/null +++ b/store/sessioncache_reset_test.go @@ -0,0 +1,214 @@ +// Copyright (c) 2026 Rajeh Taher +// +// Licensed under the MIT License. See LICENSE-MIT for details. + +package store + +import ( + "bytes" + "context" + "errors" + "sync" + "testing" + "time" + + "github.com/polymorfa/libsignal-protocol-go/keys/chain" + "github.com/polymorfa/libsignal-protocol-go/protocol" + "github.com/polymorfa/libsignal-protocol-go/state/record" +) + +type resetSessionStore struct { + countingSessionStore + mu sync.Mutex + rows map[string][]byte + failDelete string + beforePut func() +} + +func (s *resetSessionStore) GetManySessions(_ context.Context, addresses []string) (map[string][]byte, error) { + s.mu.Lock() + defer s.mu.Unlock() + out := make(map[string][]byte) + for _, address := range addresses { + out[address] = bytes.Clone(s.rows[address]) + } + return out, nil +} + +func (s *resetSessionStore) PutManySessions(_ context.Context, rows map[string][]byte) error { + if s.beforePut != nil { + s.beforePut() + } + s.mu.Lock() + defer s.mu.Unlock() + for address, data := range rows { + s.rows[address] = bytes.Clone(data) + } + return nil +} + +func (s *resetSessionStore) DeleteSession(_ context.Context, address string) error { + s.mu.Lock() + defer s.mu.Unlock() + if s.failDelete == address { + return errors.New("authored delete failure") + } + delete(s.rows, address) + return nil +} + +// Authored serialization fixture only; these records are never used to encrypt. +func cacheTestSession() *record.Session { + public := append([]byte{5}, bytes.Repeat([]byte{1}, 32)...) + sess, err := record.NewSessionFromStructure(&record.SessionStructure{SessionState: &record.StateStructure{ + LocalIdentityPublic: public, RemoteIdentityPublic: public, SenderBaseKey: public, + RootKey: make([]byte, 32), SessionVersion: 3, + SenderChain: &record.ChainStructure{SenderRatchetKeyPublic: public, SenderRatchetKeyPrivate: make([]byte, 32), ChainKey: &chain.KeyStructure{Key: make([]byte, 32)}}, + }}, SignalProtobufSerializer.Session, SignalProtobufSerializer.State) + if err != nil { + panic(err) + } + return sess +} + +func TestIdentityResetRejectsAnIndependentDirtyCache(t *testing.T) { + for _, partial := range []bool{false, true} { + t.Run(map[bool]string{false: "complete", true: "partial deletion"}[partial], func(t *testing.T) { + address := protocol.NewSignalAddress("123", 1) + keys := []string{address.String(), address.String() + "_status", "unrelated:2"} + backend := &resetSessionStore{rows: make(map[string][]byte)} + for _, key := range keys { + backend.rows[key] = cacheTestSession().Serialize() + } + device := &Device{Sessions: backend} + _, cached, err := device.WithCachedSessions(context.Background(), keys) + if err != nil { + t.Fatal(err) + } + if err = device.StoreSession(cached, address, cacheTestSession()); err != nil { + t.Fatal(err) + } + if err = device.StoreSession(WithStatusSession(cached), address, cacheTestSession()); err != nil { + t.Fatal(err) + } + if partial { + backend.failDelete = keys[1] + } + err = device.DeleteSessionsForIdentity(context.Background(), address) + if (err != nil) != partial { + t.Fatalf("reset error = %v", err) + } + if err = device.PutCachedSessions(cached); err == nil { + t.Fatal("stale cache flush accepted after identity reset") + } + if _, exists := backend.rows[keys[0]]; exists { + t.Fatal("flush restored deleted chat session") + } + if _, exists := backend.rows[keys[1]]; exists != partial { + t.Fatal("flush changed status session after reset") + } + }) + } +} + +func TestIdentityResetKeepsUnrelatedAndFreshCachesUsable(t *testing.T) { + address := protocol.NewSignalAddress("123", 1) + other := protocol.NewSignalAddress("456", 2) + backend := &resetSessionStore{rows: make(map[string][]byte)} + device := &Device{Sessions: backend} + _, unrelated, err := device.WithCachedSessions(context.Background(), []string{other.String()}) + if err != nil { + t.Fatal(err) + } + if err = device.StoreSession(unrelated, other, cacheTestSession()); err != nil { + t.Fatal(err) + } + if err = device.DeleteSessionsForIdentity(context.Background(), address); err != nil { + t.Fatal(err) + } + if err = device.PutCachedSessions(unrelated); err != nil { + t.Fatal(err) + } + _, fresh, err := device.WithCachedSessions(context.Background(), []string{address.String(), address.String() + "_status"}) + if err != nil { + t.Fatal(err) + } + if err = device.StoreSession(fresh, address, cacheTestSession()); err != nil { + t.Fatal(err) + } + if err = device.StoreSession(WithStatusSession(fresh), address, cacheTestSession()); err != nil { + t.Fatal(err) + } + if err = device.PutCachedSessions(fresh); err != nil { + t.Fatal(err) + } + for _, key := range []string{address.String(), address.String() + "_status", other.String()} { + if _, ok := backend.rows[key]; !ok { + t.Fatalf("missing fresh session %s", key) + } + } +} + +func TestIdentityResetCanRebuildWithinItsOwnCache(t *testing.T) { + address := protocol.NewSignalAddress("123", 1) + backend := &resetSessionStore{rows: make(map[string][]byte)} + device := &Device{Sessions: backend} + _, cached, err := device.WithCachedSessions(context.Background(), []string{address.String()}) + if err != nil { + t.Fatal(err) + } + if err = device.DeleteSessionsForIdentity(cached, address); err != nil { + t.Fatal(err) + } + if err = device.StoreSession(cached, address, cacheTestSession()); err != nil { + t.Fatal(err) + } + if err = device.PutCachedSessions(cached); err != nil { + t.Fatal(err) + } + if _, ok := backend.rows[address.String()]; !ok { + t.Fatal("freshly rebuilt session was discarded") + } +} + +func TestIdentityResetOrdersDeletionAfterAnActiveFlush(t *testing.T) { + address := protocol.NewSignalAddress("123", 1) + entered, release := make(chan struct{}), make(chan struct{}) + var once sync.Once + unblock := func() { once.Do(func() { close(release) }) } + defer unblock() + backend := &resetSessionStore{rows: make(map[string][]byte), beforePut: func() { close(entered); <-release }} + device := &Device{Sessions: backend} + _, cached, err := device.WithCachedSessions(context.Background(), []string{address.String()}) + if err != nil { + t.Fatal(err) + } + if err = device.StoreSession(cached, address, cacheTestSession()); err != nil { + t.Fatal(err) + } + flushed := make(chan error, 1) + go func() { flushed <- device.PutCachedSessions(cached) }() + <-entered + reset := make(chan error, 1) + go func() { reset <- device.DeleteSessionsForIdentity(context.Background(), address) }() + var resetErr error + finished := false + select { + case resetErr = <-reset: + finished = true + case <-time.After(50 * time.Millisecond): + } + unblock() + if err = <-flushed; err != nil { + t.Fatal(err) + } + if !finished { + resetErr = <-reset + } + if resetErr != nil { + t.Fatal(resetErr) + } + if _, exists := backend.rows[address.String()]; exists { + t.Fatal("active flush restored a session after reset completed") + } +} diff --git a/store/signal.go b/store/signal.go index b4eeb2573..583dcc8f5 100644 --- a/store/signal.go +++ b/store/signal.go @@ -168,18 +168,29 @@ func (device *Device) DeleteSession(ctx context.Context, remoteAddress *protocol return nil } -// DeleteSessionsForIdentity removes both pairwise scopes after a shared identity -// change. Evict cached records too so a later flush cannot restore an old ratchet. +// DeleteSessionsForIdentity removes both pairwise scopes after a shared identity change. func (device *Device) DeleteSessionsForIdentity(ctx context.Context, remoteAddress *protocol.SignalAddress) error { - for _, key := range []string{remoteAddress.String(), remoteAddress.String() + "_status"} { - if err := device.Sessions.DeleteSession(ctx, key); err != nil { - return fmt.Errorf("failed to delete session with %s: %w", key, err) + return device.WithSessionStateLock(ctx, func(ctx context.Context) error { + keys := []string{remoteAddress.String(), remoteAddress.String() + "_status"} + device.sessionResetEpoch++ + if device.sessionResetAddresses == nil { + device.sessionResetAddresses = make(map[string]uint64) + } + for _, key := range keys { + device.sessionResetAddresses[key] = device.sessionResetEpoch + } + for _, key := range keys { + if err := device.Sessions.DeleteSession(ctx, key); err != nil { + return fmt.Errorf("failed to delete session with %s: %w", key, err) + } } if cache := getSessionCache(ctx); cache != nil { - cache.Delete(key) + for _, key := range keys { + cache.Set(key, sessionCacheEntry{Generation: device.sessionResetEpoch, Record: record.NewSession(SignalProtobufSerializer.Session, SignalProtobufSerializer.State)}) + } } - } - return nil + return nil + }) } func (device *Device) DeleteAllSessions(ctx context.Context) error { diff --git a/store/store.go b/store/store.go index e395d3f33..de4c3451e 100644 --- a/store/store.go +++ b/store/store.go @@ -301,6 +301,10 @@ type Device struct { LIDs LIDStore Container DeviceContainer + sessionStateLock sync.Mutex + sessionResetEpoch uint64 + sessionResetAddresses map[string]uint64 + saveDeleteLockInit sync.Once saveDeleteLock chan struct{} } From d5e902ba6d8857e4f0f98143078ac85bcabe2075 Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Tue, 17 Nov 2026 05:35:16 +0200 Subject: [PATCH 10/16] fix(signal): abort stale fan-out and retain nested guard owners --- send.go | 2 +- sendfb.go | 3 +- session_cache_reset_test.go | 29 +++++++++++++++++ store/sessioncache.go | 42 +++++++++++++++--------- store/sessioncache_reset_test.go | 56 ++++++++++++++++++++++++++++++++ store/signal.go | 8 ++--- 6 files changed, 118 insertions(+), 22 deletions(-) diff --git a/send.go b/send.go index 90958039c..16aa3158c 100644 --- a/send.go +++ b/send.go @@ -1474,7 +1474,7 @@ func (cli *Client) encryptMessageForDevices( if err != nil { // TODO return these errors if it's a fatal one (like context cancellation or database) cli.Log.Warnf("Failed to encrypt %s for %s: %v", id, jid, err) - if ctx.Err() != nil { + if ctx.Err() != nil || errors.Is(err, store.ErrSessionCacheInvalidated) { return nil, false, err } continue diff --git a/sendfb.go b/sendfb.go index d217f3843..a90520f3e 100644 --- a/sendfb.go +++ b/sendfb.go @@ -31,6 +31,7 @@ import ( "github.com/polymorfa/hypermeow/proto/waConsumerApplication" "github.com/polymorfa/hypermeow/proto/waMsgApplication" "github.com/polymorfa/hypermeow/proto/waMsgTransport" + "github.com/polymorfa/hypermeow/store" "github.com/polymorfa/hypermeow/types" "github.com/polymorfa/hypermeow/types/events" ) @@ -570,7 +571,7 @@ func (cli *Client) encryptMessageForDevicesV3( if err != nil { // TODO return these errors if it's a fatal one (like context cancellation or database) cli.Log.Warnf("Failed to encrypt %s for %s: %v", id, jid, err) - if ctx.Err() != nil { + if ctx.Err() != nil || errors.Is(err, store.ErrSessionCacheInvalidated) { return nil, err } continue diff --git a/session_cache_reset_test.go b/session_cache_reset_test.go index 1460d0391..4b5e5b454 100644 --- a/session_cache_reset_test.go +++ b/session_cache_reset_test.go @@ -6,6 +6,7 @@ package whatsmeow import ( "context" + "errors" "sync" "testing" "time" @@ -113,3 +114,31 @@ func TestBufferedDecryptOrdersTransactionAfterSessionMutation(t *testing.T) { t.Fatal("database transaction entered before local mutation guard") } } + +func TestFanoutAbortsWhenPrefetchedRecipientWasReset(t *testing.T) { + ctx := context.Background() + own := types.NewADJID("100000000001", 0, 1) + peerJID := types.JID{User: "200000000002", Server: types.HiddenUserServer, Device: 2} + coldJID := types.JID{User: "300000000003", Server: types.HiddenUserServer, Device: 3} + companion, _ := newSignalTestDevice(own, &store.NoopStore{}) + peer, _ := newSignalTestDevice(peerJID, &store.NoopStore{}) + cli := NewClient(companion, waLog.Noop) + if _, _, err := cli.encryptMessageForDevice(ctx, []byte("authored warm session"), peerJID, signalTestBundle(t, peer, 2), nil, nil); err != nil { + t.Fatal(err) + } + reset := false + cli.testSendHook = func(_ []byte) error { + reset = true + if err := companion.DeleteSessionsForIdentity(context.Background(), peerJID.SignalAddress()); err != nil { + return err + } + return errors.New("authored prekey lookup refusal") + } + _, _, err := cli.encryptMessageForDevices(ctx, []types.JID{peerJID, coldJID}, "authored-race", []byte("authored content"), nil, nil) + if !reset { + t.Fatal("authored lookup did not reach the prefetch/crypto boundary") + } + if err == nil { + t.Fatal("fan-out reported success after omitting a reset recipient") + } +} diff --git a/store/sessioncache.go b/store/sessioncache.go index 7aa083b68..ce50650bc 100644 --- a/store/sessioncache.go +++ b/store/sessioncache.go @@ -36,17 +36,27 @@ type sessionCacheEntry struct { type sessionCache struct { *exsync.Map[string, sessionCacheEntry] epoch uint64 + owner *Device +} + +type sessionStateGuard struct { + device *Device + parent *sessionStateGuard } // WithSessionStateLock orders local session mutations before database transactions. -// The callback context permits nested operations on this device and must not escape it. +// The callback context permits nested operations and must not escape the callback. +// Callers nesting different devices must use a consistent order across goroutines. func (device *Device) WithSessionStateLock(ctx context.Context, fn func(context.Context) error) error { - if ctx.Value(contextKeySessionStateLock) == device { - return fn(ctx) + held, _ := ctx.Value(contextKeySessionStateLock).(*sessionStateGuard) + for current := held; current != nil; current = current.parent { + if current.device == device { + return fn(ctx) + } } device.sessionStateLock.Lock() defer device.sessionStateLock.Unlock() - return fn(context.WithValue(ctx, contextKeySessionStateLock, device)) + return fn(context.WithValue(ctx, contextKeySessionStateLock, &sessionStateGuard{device: device, parent: held})) } type sessionIterator interface { @@ -57,7 +67,7 @@ type sessionLoader interface { IterateSession(context.Context, string, func([]byte) error) (bool, error) } -func getSessionCache(ctx context.Context) *sessionCache { +func getSessionCache(ctx context.Context, device *Device) *sessionCache { if ctx == nil { return nil } @@ -65,14 +75,14 @@ func getSessionCache(ctx context.Context) *sessionCache { if val == nil { return nil } - if cache, ok := val.(*sessionCache); ok { + if cache, ok := val.(*sessionCache); ok && cache.owner == device { return cache } return nil } -func getCachedSession(ctx context.Context, addr string) *record.Session { - cache := getSessionCache(ctx) +func getCachedSession(ctx context.Context, device *Device, addr string) *record.Session { + cache := getSessionCache(ctx, device) if cache == nil { return nil } @@ -83,8 +93,8 @@ func getCachedSession(ctx context.Context, addr string) *record.Session { return sess.Record } -func hasCachedSession(ctx context.Context, addr string) (found, cached bool) { - cache := getSessionCache(ctx) +func hasCachedSession(ctx context.Context, device *Device, addr string) (found, cached bool) { + cache := getSessionCache(ctx, device) if cache == nil { return false, false } @@ -92,8 +102,8 @@ func hasCachedSession(ctx context.Context, addr string) (found, cached bool) { return sess.Found, cached } -func putCachedSession(ctx context.Context, addr string, record *record.Session) bool { - cache := getSessionCache(ctx) +func putCachedSession(ctx context.Context, device *Device, addr string, record *record.Session) bool { + cache := getSessionCache(ctx, device) if cache == nil { return false } @@ -113,7 +123,7 @@ func putCachedSession(ctx context.Context, addr string, record *record.Session) // CheckCachedSession rejects a stale cached address before local crypto can mutate identity state. func (device *Device) CheckCachedSession(ctx context.Context, address string) error { return device.WithSessionStateLock(ctx, func(ctx context.Context) error { - if cache := getSessionCache(ctx); cache != nil { + if cache := getSessionCache(ctx, device); cache != nil { generation := cache.epoch if item, ok := cache.Get(address); ok { generation = item.Generation @@ -139,7 +149,7 @@ func (device *Device) WithCachedSessions(ctx context.Context, addresses []string if err != nil { return nil, ctx, err } - return found, context.WithValue(ctx, contextKeySessionCache, getSessionCache(cached)), nil + return found, context.WithValue(ctx, contextKeySessionCache, getSessionCache(cached, device)), nil } func (device *Device) withCachedSessions(ctx context.Context, addresses []string) (map[string]bool, context.Context, error) { @@ -183,7 +193,7 @@ func (device *Device) withCachedSessions(ctx context.Context, addresses []string } } - ctx = context.WithValue(ctx, contextKeySessionCache, &sessionCache{Map: exsync.NewMapWithData(wrapped), epoch: device.sessionResetEpoch}) + ctx = context.WithValue(ctx, contextKeySessionCache, &sessionCache{Map: exsync.NewMapWithData(wrapped), epoch: device.sessionResetEpoch, owner: device}) return existingSessions, ctx, nil } @@ -192,7 +202,7 @@ func (device *Device) PutCachedSessions(ctx context.Context) error { } func (device *Device) putCachedSessions(ctx context.Context) error { - cache := getSessionCache(ctx) + cache := getSessionCache(ctx, device) if cache == nil { return nil } diff --git a/store/sessioncache_reset_test.go b/store/sessioncache_reset_test.go index a70c54d35..be83e6436 100644 --- a/store/sessioncache_reset_test.go +++ b/store/sessioncache_reset_test.go @@ -212,3 +212,59 @@ func TestIdentityResetOrdersDeletionAfterAnActiveFlush(t *testing.T) { t.Fatal("active flush restored a session after reset completed") } } + +func TestNestedDeviceGuardsCanReturnToTheOuterDevice(t *testing.T) { + first := &Device{Sessions: &resetSessionStore{rows: make(map[string][]byte)}} + second := &Device{Sessions: &resetSessionStore{rows: make(map[string][]byte)}} + type guard interface { + WithSessionStateLock(context.Context, func(context.Context) error) error + } + outer, ok := any(first).(guard) + if !ok { + t.Fatal("session guard unavailable") + } + inner, ok := any(second).(guard) + if !ok { + t.Fatal("session guard unavailable") + } + done := make(chan error, 1) + go func() { + done <- outer.WithSessionStateLock(context.Background(), func(ctx context.Context) error { + return inner.WithSessionStateLock(ctx, func(ctx context.Context) error { + return first.DeleteSessionsForIdentity(ctx, protocol.NewSignalAddress("123", 1)) + }) + }) + }() + select { + case err := <-done: + if err != nil { + t.Fatal(err) + } + case <-time.After(250 * time.Millisecond): + t.Fatal("nested device guard deadlocked returning to the outer device") + } +} + +func TestAnotherDeviceCannotInvalidateTheContextOwnersCache(t *testing.T) { + address := protocol.NewSignalAddress("123", 1) + firstBackend := &resetSessionStore{rows: make(map[string][]byte)} + first := &Device{Sessions: firstBackend} + second := &Device{Sessions: &resetSessionStore{rows: make(map[string][]byte)}} + _, cached, err := first.WithCachedSessions(context.Background(), []string{address.String()}) + if err != nil { + t.Fatal(err) + } + fresh := cacheTestSession() + if err = first.StoreSession(cached, address, fresh); err != nil { + t.Fatal(err) + } + if err = second.DeleteSessionsForIdentity(cached, address); err != nil { + t.Fatal(err) + } + if err = first.PutCachedSessions(cached); err != nil { + t.Fatal(err) + } + if !bytes.Equal(firstBackend.rows[address.String()], fresh.Serialize()) { + t.Fatal("other device erased the owning device's pending session") + } +} diff --git a/store/signal.go b/store/signal.go index 583dcc8f5..7387933be 100644 --- a/store/signal.go +++ b/store/signal.go @@ -98,7 +98,7 @@ func (device *Device) ContainsPreKey(ctx context.Context, preKeyID uint32) (bool func (device *Device) LoadSession(ctx context.Context, address *protocol.SignalAddress) (*record.Session, error) { addrString := SignalSessionAddress(ctx, address.String()) - if sess := getCachedSession(ctx, addrString); sess != nil { + if sess := getCachedSession(ctx, device, addrString); sess != nil { return sess, nil } @@ -137,7 +137,7 @@ func (device *Device) GetSubDeviceSessions(ctx context.Context, name string) ([] func (device *Device) StoreSession(ctx context.Context, address *protocol.SignalAddress, record *record.Session) error { addrString := SignalSessionAddress(ctx, address.String()) - if putCachedSession(ctx, addrString, record) { + if putCachedSession(ctx, device, addrString, record) { return nil } @@ -150,7 +150,7 @@ func (device *Device) StoreSession(ctx context.Context, address *protocol.Signal func (device *Device) ContainsSession(ctx context.Context, remoteAddress *protocol.SignalAddress) (bool, error) { addrString := SignalSessionAddress(ctx, remoteAddress.String()) - if found, cached := hasCachedSession(ctx, addrString); cached { + if found, cached := hasCachedSession(ctx, device, addrString); cached { return found, nil } hasSession, err := device.Sessions.HasSession(ctx, addrString) @@ -184,7 +184,7 @@ func (device *Device) DeleteSessionsForIdentity(ctx context.Context, remoteAddre return fmt.Errorf("failed to delete session with %s: %w", key, err) } } - if cache := getSessionCache(ctx); cache != nil { + if cache := getSessionCache(ctx, device); cache != nil { for _, key := range keys { cache.Set(key, sessionCacheEntry{Generation: device.sessionResetEpoch, Record: record.NewSession(SignalProtobufSerializer.Session, SignalProtobufSerializer.State)}) } From c2681a14247e06a6fda1aaca21551456542adbf5 Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Tue, 17 Nov 2026 06:17:03 +0200 Subject: [PATCH 11/16] fix(signal): quarantine failed resets and bound reset history --- store/sessioncache.go | 49 ++++++++++++---- store/sessioncache_pending_test.go | 58 +++++++++++++++++++ store/sessioncache_reset_test.go | 91 ++++++++++++++++++++++++++++++ store/signal.go | 75 ++++++++++++++++++++++-- store/store.go | 3 + 5 files changed, 258 insertions(+), 18 deletions(-) create mode 100644 store/sessioncache_pending_test.go diff --git a/store/sessioncache.go b/store/sessioncache.go index ce50650bc..078484950 100644 --- a/store/sessioncache.go +++ b/store/sessioncache.go @@ -24,6 +24,9 @@ const ( contextKeySessionStateLock ) +// Bound completed reset history and outstanding deletion failures separately. +const maxSessionResetAddresses = 1024 + var ErrSessionCacheInvalidated = errors.New("session cache was invalidated by an identity reset") type sessionCacheEntry struct { @@ -120,22 +123,33 @@ func putCachedSession(ctx context.Context, device *Device, addr string, record * return true } -// CheckCachedSession rejects a stale cached address before local crypto can mutate identity state. +// CheckCachedSession rejects stale or incompletely reset state before local crypto. func (device *Device) CheckCachedSession(ctx context.Context, address string) error { return device.WithSessionStateLock(ctx, func(ctx context.Context) error { - if cache := getSessionCache(ctx, device); cache != nil { - generation := cache.epoch - if item, ok := cache.Get(address); ok { - generation = item.Generation - } - if device.sessionResetAddresses[address] > generation { - return ErrSessionCacheInvalidated - } - } - return nil + return device.checkCachedSession(ctx, address) }) } +// The caller holds sessionStateLock across validation and local state use. +func (device *Device) checkCachedSession(ctx context.Context, address string) error { + if device.sessionResetBlocked { + return ErrSessionCacheInvalidated + } + if _, pending := device.sessionResetPending[address]; pending { + return ErrSessionCacheInvalidated + } + if cache := getSessionCache(ctx, device); cache != nil { + generation := cache.epoch + if item, ok := cache.Get(address); ok { + generation = item.Generation + } + if generation < device.sessionResetFloor || device.sessionResetAddresses[address] > generation { + return ErrSessionCacheInvalidated + } + } + return nil +} + func (device *Device) WithCachedSessions(ctx context.Context, addresses []string) (map[string]bool, context.Context, error) { if len(addresses) == 0 { return nil, ctx, nil @@ -157,6 +171,17 @@ func (device *Device) withCachedSessions(ctx context.Context, addresses []string return nil, ctx, nil } + for _, address := range addresses { + // A new prefetch must not bless a row whose deletion failed. The + // previous context may be stale, so validate pending state alone. + if device.sessionResetBlocked { + return nil, ctx, ErrSessionCacheInvalidated + } + if _, pending := device.sessionResetPending[address]; pending { + return nil, ctx, ErrSessionCacheInvalidated + } + } + wrapped := make(map[string]sessionCacheEntry, len(addresses)) existingSessions := make(map[string]bool, len(addresses)) for _, addr := range addresses { @@ -210,7 +235,7 @@ func (device *Device) putCachedSessions(ctx context.Context) error { invalid := false for addr, item := range cache.Iter() { if item.Dirty { - if device.sessionResetAddresses[addr] > item.Generation { + if device.checkCachedSession(ctx, addr) != nil { invalid = true break } diff --git a/store/sessioncache_pending_test.go b/store/sessioncache_pending_test.go new file mode 100644 index 000000000..1f823ef72 --- /dev/null +++ b/store/sessioncache_pending_test.go @@ -0,0 +1,58 @@ +// Copyright (c) 2026 Rajeh Taher +// +// Licensed under the MIT License. See LICENSE-MIT for details. + +package store + +import ( + "context" + "errors" + "fmt" + "testing" + + "github.com/polymorfa/libsignal-protocol-go/protocol" +) + +func TestFailedIdentityResetAbortsTheCurrentSend(t *testing.T) { + address := protocol.NewSignalAddress("123", 1) + backend := &resetSessionStore{rows: make(map[string][]byte), failDelete: address.String() + "_status"} + device := &Device{Sessions: backend} + if err := device.DeleteSessionsForIdentity(context.Background(), address); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatalf("failed reset is not fatal to recipient fan-out: %v", err) + } + if err := device.CheckCachedSession(context.Background(), "unrelated:2"); err != nil { + t.Fatalf("one failed key blocked an unrelated session: %v", err) + } + backend.failDelete = "" + if err := device.DeleteSession(WithStatusSession(context.Background()), address); err != nil { + t.Fatal(err) + } + if err := device.CheckCachedSession(context.Background(), address.String()+"_status"); err != nil { + t.Fatalf("successful explicit deletion did not clear its pending mark: %v", err) + } +} + +func TestFailedIdentityResetBudgetNeverForgetsUnsafeRows(t *testing.T) { + backend := &resetSessionStore{rows: make(map[string][]byte)} + device := &Device{Sessions: backend} + for i := range maxSessionResetAddresses + 1 { + address := protocol.NewSignalAddress(fmt.Sprintf("authored-%d", i), 1) + backend.failDelete = address.String() + "_status" + if err := device.DeleteSessionsForIdentity(context.Background(), address); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatalf("failed reset %d was not refused: %v", i, err) + } + } + if len(device.sessionResetPending) > maxSessionResetAddresses || len(device.sessionResetAddresses) > maxSessionResetAddresses { + t.Fatal("failed reset tracking exceeded its budgets") + } + if !device.sessionResetBlocked { + t.Fatal("exhausted failure budget did not refuse unknown state") + } + backend.failDelete = "" + if err := device.DeleteSessionsForIdentity(context.Background(), protocol.NewSignalAddress("authored-0", 1)); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatalf("an unrelated successful retry cleared unknown failures: %v", err) + } + if _, _, err := device.WithCachedSessions(context.Background(), []string{"fresh:1"}); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatalf("failure budget overflow allowed a fresh cache: %v", err) + } +} diff --git a/store/sessioncache_reset_test.go b/store/sessioncache_reset_test.go index be83e6436..e056f4ca3 100644 --- a/store/sessioncache_reset_test.go +++ b/store/sessioncache_reset_test.go @@ -8,6 +8,7 @@ import ( "bytes" "context" "errors" + "fmt" "sync" "testing" "time" @@ -268,3 +269,93 @@ func TestAnotherDeviceCannotInvalidateTheContextOwnersCache(t *testing.T) { t.Fatal("other device erased the owning device's pending session") } } + +func TestFailedIdentityResetRefusesReloadUntilDeletionSucceeds(t *testing.T) { + for _, suffix := range []string{"", "_status"} { + t.Run("failed"+suffix, func(t *testing.T) { + address := protocol.NewSignalAddress("123", 1) + key := address.String() + suffix + backend := &resetSessionStore{rows: map[string][]byte{key: cacheTestSession().Serialize()}, failDelete: key} + device := &Device{Sessions: backend} + if err := device.DeleteSessionsForIdentity(context.Background(), address); err == nil { + t.Fatal("authored deletion failure was not returned") + } + ctx := context.Background() + if suffix != "" { + ctx = WithStatusSession(ctx) + } + if _, _, err := device.WithCachedSessions(ctx, []string{key}); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Errorf("failed reset allowed prefetch: %v", err) + } + if _, err := device.LoadSession(ctx, address); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Errorf("failed reset allowed direct load: %v", err) + } + if _, err := device.ContainsSession(ctx, address); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Errorf("failed reset allowed direct lookup: %v", err) + } + if err := device.StoreSession(ctx, address, cacheTestSession()); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Errorf("failed reset allowed direct write: %v", err) + } + if err := device.CheckCachedSession(ctx, key); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Errorf("failed reset allowed crypto check: %v", err) + } + backend.failDelete = "" + if err := device.DeleteSessionsForIdentity(context.Background(), address); err != nil { + t.Fatal(err) + } + _, fresh, err := device.WithCachedSessions(ctx, []string{key}) + if err != nil { + t.Fatal(err) + } + if err = device.StoreSession(fresh, address, cacheTestSession()); err != nil { + t.Fatal(err) + } + if err = device.PutCachedSessions(fresh); err != nil { + t.Fatal(err) + } + if _, ok := backend.rows[key]; !ok { + t.Fatal("successful retry did not permit a fresh session") + } + }) + } +} + +func TestIdentityResetRetentionIsBoundedWithoutAcceptingOldCaches(t *testing.T) { + address := protocol.NewSignalAddress("123", 1) + backend := &resetSessionStore{rows: make(map[string][]byte)} + device := &Device{Sessions: backend} + _, stale, err := device.WithCachedSessions(context.Background(), []string{address.String()}) + if err != nil { + t.Fatal(err) + } + if err = device.StoreSession(stale, address, cacheTestSession()); err != nil { + t.Fatal(err) + } + if err = device.DeleteSessionsForIdentity(context.Background(), address); err != nil { + t.Fatal(err) + } + for i := range 10_000 { + if err = device.DeleteSessionsForIdentity(context.Background(), protocol.NewSignalAddress(fmt.Sprintf("authored-%d", i), 1)); err != nil { + t.Fatal(err) + } + } + if retained := len(device.sessionResetAddresses); retained > 1024 { + t.Errorf("reset history retained %d entries for completed resets", retained) + } + if err = device.CheckCachedSession(stale, address.String()); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Errorf("history pruning accepted old crypto context: %v", err) + } + if err = device.PutCachedSessions(stale); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Errorf("history pruning accepted old dirty cache: %v", err) + } + _, fresh, err := device.WithCachedSessions(context.Background(), []string{address.String()}) + if err != nil { + t.Fatal(err) + } + if err = device.StoreSession(fresh, address, cacheTestSession()); err != nil { + t.Fatal(err) + } + if err = device.PutCachedSessions(fresh); err != nil { + t.Fatal(err) + } +} diff --git a/store/signal.go b/store/signal.go index 7387933be..c1262035c 100644 --- a/store/signal.go +++ b/store/signal.go @@ -97,7 +97,19 @@ func (device *Device) ContainsPreKey(ctx context.Context, preKeyID uint32) (bool } func (device *Device) LoadSession(ctx context.Context, address *protocol.SignalAddress) (*record.Session, error) { + var sess *record.Session + err := device.WithSessionStateLock(ctx, func(ctx context.Context) (err error) { + sess, err = device.loadSession(ctx, address) + return + }) + return sess, err +} + +func (device *Device) loadSession(ctx context.Context, address *protocol.SignalAddress) (*record.Session, error) { addrString := SignalSessionAddress(ctx, address.String()) + if err := device.checkCachedSession(ctx, addrString); err != nil { + return nil, err + } if sess := getCachedSession(ctx, device, addrString); sess != nil { return sess, nil } @@ -136,7 +148,16 @@ func (device *Device) GetSubDeviceSessions(ctx context.Context, name string) ([] } func (device *Device) StoreSession(ctx context.Context, address *protocol.SignalAddress, record *record.Session) error { + return device.WithSessionStateLock(ctx, func(ctx context.Context) error { + return device.storeSession(ctx, address, record) + }) +} + +func (device *Device) storeSession(ctx context.Context, address *protocol.SignalAddress, record *record.Session) error { addrString := SignalSessionAddress(ctx, address.String()) + if err := device.checkCachedSession(ctx, addrString); err != nil { + return err + } if putCachedSession(ctx, device, addrString, record) { return nil } @@ -149,7 +170,19 @@ func (device *Device) StoreSession(ctx context.Context, address *protocol.Signal } func (device *Device) ContainsSession(ctx context.Context, remoteAddress *protocol.SignalAddress) (bool, error) { + var found bool + err := device.WithSessionStateLock(ctx, func(ctx context.Context) (err error) { + found, err = device.containsSession(ctx, remoteAddress) + return + }) + return found, err +} + +func (device *Device) containsSession(ctx context.Context, remoteAddress *protocol.SignalAddress) (bool, error) { addrString := SignalSessionAddress(ctx, remoteAddress.String()) + if err := device.checkCachedSession(ctx, addrString); err != nil { + return false, err + } if found, cached := hasCachedSession(ctx, device, addrString); cached { return found, nil } @@ -161,11 +194,14 @@ func (device *Device) ContainsSession(ctx context.Context, remoteAddress *protoc } func (device *Device) DeleteSession(ctx context.Context, remoteAddress *protocol.SignalAddress) error { - addrString := SignalSessionAddress(ctx, remoteAddress.String()) - if err := device.Sessions.DeleteSession(ctx, addrString); err != nil { - return fmt.Errorf("failed to delete session with %s: %w", addrString, err) - } - return nil + return device.WithSessionStateLock(ctx, func(ctx context.Context) error { + addrString := SignalSessionAddress(ctx, remoteAddress.String()) + if err := device.Sessions.DeleteSession(ctx, addrString); err != nil { + return fmt.Errorf("failed to delete session with %s: %w", addrString, err) + } + delete(device.sessionResetPending, addrString) + return nil + }) } // DeleteSessionsForIdentity removes both pairwise scopes after a shared identity change. @@ -176,14 +212,41 @@ func (device *Device) DeleteSessionsForIdentity(ctx context.Context, remoteAddre if device.sessionResetAddresses == nil { device.sessionResetAddresses = make(map[string]uint64) } + if len(device.sessionResetAddresses)+len(keys) > maxSessionResetAddresses { + // Forgetting a reset must never make an outstanding cache valid. + // Caches older than this floor must be prefetched again. + device.sessionResetFloor = device.sessionResetEpoch + clear(device.sessionResetAddresses) + } + if device.sessionResetPending == nil { + device.sessionResetPending = make(map[string]struct{}) + } for _, key := range keys { device.sessionResetAddresses[key] = device.sessionResetEpoch + if _, pending := device.sessionResetPending[key]; !pending { + if len(device.sessionResetPending) >= maxSessionResetAddresses { + // Unknown failed keys cannot be forgotten safely. Refuse + // this Device until its backend state is reconciled. + device.sessionResetBlocked = true + } else { + device.sessionResetPending[key] = struct{}{} + } + } } + var deleteErr error for _, key := range keys { if err := device.Sessions.DeleteSession(ctx, key); err != nil { - return fmt.Errorf("failed to delete session with %s: %w", key, err) + deleteErr = errors.Join(deleteErr, fmt.Errorf("failed to delete session with %s: %w", key, err)) + } else { + delete(device.sessionResetPending, key) } } + if deleteErr != nil { + return errors.Join(ErrSessionCacheInvalidated, deleteErr) + } + if device.sessionResetBlocked { + return ErrSessionCacheInvalidated + } if cache := getSessionCache(ctx, device); cache != nil { for _, key := range keys { cache.Set(key, sessionCacheEntry{Generation: device.sessionResetEpoch, Record: record.NewSession(SignalProtobufSerializer.Session, SignalProtobufSerializer.State)}) diff --git a/store/store.go b/store/store.go index de4c3451e..97d3d214f 100644 --- a/store/store.go +++ b/store/store.go @@ -304,6 +304,9 @@ type Device struct { sessionStateLock sync.Mutex sessionResetEpoch uint64 sessionResetAddresses map[string]uint64 + sessionResetFloor uint64 + sessionResetPending map[string]struct{} + sessionResetBlocked bool saveDeleteLockInit sync.Once saveDeleteLock chan struct{} From 67a8199f4e3de1cb45417b04d65ffc4194c6955b Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Tue, 17 Nov 2026 06:28:27 +0200 Subject: [PATCH 12/16] fix(signal): count only actual reset deletion failures --- store/sessioncache_pending_test.go | 24 ++++++++++++++++++++++++ store/signal.go | 25 ++++++++++++++++--------- 2 files changed, 40 insertions(+), 9 deletions(-) diff --git a/store/sessioncache_pending_test.go b/store/sessioncache_pending_test.go index 1f823ef72..c5588ef49 100644 --- a/store/sessioncache_pending_test.go +++ b/store/sessioncache_pending_test.go @@ -56,3 +56,27 @@ func TestFailedIdentityResetBudgetNeverForgetsUnsafeRows(t *testing.T) { t.Fatalf("failure budget overflow allowed a fresh cache: %v", err) } } + +func TestSuccessfulIdentityResetDoesNotSpendFailureBudget(t *testing.T) { + backend := &resetSessionStore{rows: make(map[string][]byte)} + device := &Device{Sessions: backend} + for i := range maxSessionResetAddresses - 1 { + address := protocol.NewSignalAddress(fmt.Sprintf("authored-%d", i), 1) + backend.failDelete = address.String() + "_status" + if err := device.DeleteSessionsForIdentity(context.Background(), address); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatal(err) + } + } + backend.failDelete = "" + if err := device.DeleteSessionsForIdentity(context.Background(), protocol.NewSignalAddress("fresh", 1)); err != nil { + t.Errorf("successful reset exhausted the failure budget: %v", err) + } + for i := range maxSessionResetAddresses - 1 { + if err := device.DeleteSession(WithStatusSession(context.Background()), protocol.NewSignalAddress(fmt.Sprintf("authored-%d", i), 1)); err != nil { + t.Fatal(err) + } + } + if err := device.CheckCachedSession(context.Background(), "unrelated:1"); err != nil { + t.Errorf("tracked failures left the recovered Device blocked: %v", err) + } +} diff --git a/store/signal.go b/store/signal.go index c1262035c..c483d2d2e 100644 --- a/store/signal.go +++ b/store/signal.go @@ -223,24 +223,31 @@ func (device *Device) DeleteSessionsForIdentity(ctx context.Context, remoteAddre } for _, key := range keys { device.sessionResetAddresses[key] = device.sessionResetEpoch - if _, pending := device.sessionResetPending[key]; !pending { - if len(device.sessionResetPending) >= maxSessionResetAddresses { - // Unknown failed keys cannot be forgotten safely. Refuse - // this Device until its backend state is reconciled. - device.sessionResetBlocked = true - } else { - device.sessionResetPending[key] = struct{}{} - } - } } var deleteErr error + var failedKeys []string for _, key := range keys { if err := device.Sessions.DeleteSession(ctx, key); err != nil { deleteErr = errors.Join(deleteErr, fmt.Errorf("failed to delete session with %s: %w", key, err)) + failedKeys = append(failedKeys, key) } else { delete(device.sessionResetPending, key) } } + // The guard prevents reads during deletion. Reserve only actual + // failures, after successful deletions have freed their slots. + for _, key := range failedKeys { + if _, pending := device.sessionResetPending[key]; pending { + continue + } + if len(device.sessionResetPending) >= maxSessionResetAddresses { + // Unknown failed keys cannot be forgotten safely. Refuse + // this Device until its backend state is reconciled. + device.sessionResetBlocked = true + } else { + device.sessionResetPending[key] = struct{}{} + } + } if deleteErr != nil { return errors.Join(ErrSessionCacheInvalidated, deleteErr) } From 68e15b95460e926d4880251c478d053dad9d4a81 Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Tue, 17 Nov 2026 06:57:55 +0200 Subject: [PATCH 13/16] fix(signal): recover failed resets without losing identity --- README.md | 22 +++ message.go | 9 +- session_reset_recovery_test.go | 90 +++++++++++ store/sessioncache.go | 6 - store/sessioncache_pending_test.go | 19 ++- store/sessioncache_recovery_controls_test.go | 111 +++++++++++++ store/sessioncache_recovery_test.go | 67 ++++++++ store/signal.go | 157 +++++++++++++++---- store/store.go | 3 +- 9 files changed, 434 insertions(+), 50 deletions(-) create mode 100644 session_reset_recovery_test.go create mode 100644 store/sessioncache_recovery_controls_test.go create mode 100644 store/sessioncache_recovery_test.go diff --git a/README.md b/README.md index eaf875b42..27c6f9ff5 100644 --- a/README.md +++ b/README.md @@ -289,3 +289,25 @@ the legacy field only before connecting. These additions are unreleased until their reviewed main commit is adopted. Custom decrypted-event buffers should implement `store.EventBufferPublicationStore` to retain the group-publication flag while atomically deleting plaintext. The SQL store implements this with migration 21. Old processed rows and custom stores without this extension have unknown legacy classification; no status is inferred from a group chat alone. + +## Recovering an interrupted identity reset + +The local adapter deletes both chat and status session rows before removing their +shared identity. A failed session deletion therefore leaves the old identity in +place. Use `Device.DeleteIdentityAndSessions` when removing both; custom callers +must preserve that order and serialize other writers to the same backend. + +Failed rows stay unavailable on the current Device until deletion succeeds. +`Device.ReconcileSessionResets(ctx)` retries the tracked failures after storage +recovers. A reset that cannot retain all possible failures is refused before it +starts; it does not permanently disable the Device or discard unknown failures. +Admission retries at most two existing failures, while explicit reconciliation +can retry the full bounded set. Both reset history and tracked failures retain at +most 1,024 address entries. Pruning history invalidates older prefetched caches, +which must be loaded again. + +These guards are per Device and are not cross-process fencing. A fresh adapter +retains the original identity for surviving rows after a failed library-managed +reset; this relies on backend deletion completion and ordering. Custom-store, +transaction, process-crash and previous-release state acceptance still need their +own evidence. Restarting is not a substitute for repairing a failed backend. diff --git a/message.go b/message.go index 927adfd73..2a5d43e0a 100644 --- a/message.go +++ b/message.go @@ -612,13 +612,8 @@ func (cli *Client) decryptMessages(ctx context.Context, info *types.MessageInfo, } func (cli *Client) clearUntrustedIdentity(ctx context.Context, target types.JID) error { - err := cli.Store.Identities.DeleteIdentity(ctx, target.SignalAddress().String()) - if err != nil { - return fmt.Errorf("failed to delete identity: %w", err) - } - err = cli.Store.DeleteSessionsForIdentity(ctx, target.SignalAddress()) - if err != nil { - return fmt.Errorf("failed to delete session: %w", err) + if err := cli.Store.DeleteIdentityAndSessions(ctx, target.SignalAddress()); err != nil { + return fmt.Errorf("failed to clear identity and sessions: %w", err) } go cli.dispatchEvent(&events.IdentityChange{JID: target, Timestamp: time.Now(), Implicit: true}) return nil diff --git a/session_reset_recovery_test.go b/session_reset_recovery_test.go new file mode 100644 index 000000000..de64dd3a4 --- /dev/null +++ b/session_reset_recovery_test.go @@ -0,0 +1,90 @@ +// Copyright (c) 2026 Rajeh Taher +// Licensed under the MIT License. See LICENSE-MIT for details. + +package whatsmeow + +import ( + "context" + "errors" + "testing" + + "github.com/polymorfa/hypermeow/store" + "github.com/polymorfa/hypermeow/types" + waLog "github.com/polymorfa/hypermeow/util/log" +) + +type recoverySignalStore struct { + *memSignalStore + failDelete string + identityDeletes int +} + +func (s *recoverySignalStore) DeleteIdentity(_ context.Context, address string) error { + s.lock.Lock() + defer s.lock.Unlock() + s.identityDeletes++ + delete(s.identities, address) + return nil +} +func (s *recoverySignalStore) IsTrustedIdentity(_ context.Context, address string, key [32]byte) (bool, error) { + s.lock.Lock() + defer s.lock.Unlock() + old, found := s.identities[address] + return !found || old == key, nil +} +func (s *recoverySignalStore) DeleteSession(ctx context.Context, address string) error { + if address == s.failDelete { + return errors.New("authored deletion failure") + } + return s.memSignalStore.DeleteSession(ctx, address) +} + +// A fresh adapter shares an authored persistent-store model. This is not a +// process crash, previous-release database fixture or live WhatsApp replay. +func TestFailedIdentityResetKeepsRestartedRowsBoundToTheirIdentity(t *testing.T) { + for _, suffix := range []string{"", "_status"} { + t.Run("failed"+suffix, func(t *testing.T) { + ctx := context.Background() + own := types.NewADJID("100000000001", 0, 1) + peerJID := types.NewADJID("200000000002", 0, 2) + device, memory := newSignalTestDevice(own, &store.NoopStore{}) + backend := &recoverySignalStore{memSignalStore: memory} + device.Sessions, device.Identities = backend, backend + peer, _ := newSignalTestDevice(peerJID, &store.NoopStore{}) + client := NewClient(device, waLog.Noop) + for i, scope := range []context.Context{ctx, store.WithStatusSession(ctx)} { + if _, _, err := client.encryptMessageForDevice(scope, []byte("authored initial"), peerJID, signalTestBundle(t, peer, uint32(i+2)), nil, nil); err != nil { + t.Fatal(err) + } + } + address := peerJID.SignalAddress().String() + old := memory.identities[address] + backend.failDelete = address + suffix + if err := client.clearUntrustedIdentity(ctx, peerJID); err == nil { + t.Fatal("deletion fault was not returned") + } + if backend.identityDeletes != 0 { + t.Error("identity was deleted before both session scopes were removed") + } + fresh := &store.Device{Sessions: backend, Identities: backend} + if _, found := memory.identities[address]; !found { + t.Error("fresh adapter has a surviving row without its identity") + } + if _, err := fresh.LoadSession(map[bool]context.Context{false: ctx, true: store.WithStatusSession(ctx)}[suffix != ""], peerJID.SignalAddress()); err != nil { + t.Fatal(err) + } + other := old + other[0] ^= 1 + if trusted, err := fresh.Identities.IsTrustedIdentity(ctx, address, other); err != nil || trusted { + t.Errorf("fresh adapter accepts replacement identity after failed reset: %v", err) + } + backend.failDelete = "" + if err := client.clearUntrustedIdentity(ctx, peerJID); err != nil { + t.Fatal(err) + } + if len(memory.sessions) != 0 || len(memory.identities) != 0 { + t.Fatal("successful retry retained old identity/session rows") + } + }) + } +} diff --git a/store/sessioncache.go b/store/sessioncache.go index 078484950..f2c7a18f9 100644 --- a/store/sessioncache.go +++ b/store/sessioncache.go @@ -132,9 +132,6 @@ func (device *Device) CheckCachedSession(ctx context.Context, address string) er // The caller holds sessionStateLock across validation and local state use. func (device *Device) checkCachedSession(ctx context.Context, address string) error { - if device.sessionResetBlocked { - return ErrSessionCacheInvalidated - } if _, pending := device.sessionResetPending[address]; pending { return ErrSessionCacheInvalidated } @@ -174,9 +171,6 @@ func (device *Device) withCachedSessions(ctx context.Context, addresses []string for _, address := range addresses { // A new prefetch must not bless a row whose deletion failed. The // previous context may be stale, so validate pending state alone. - if device.sessionResetBlocked { - return nil, ctx, ErrSessionCacheInvalidated - } if _, pending := device.sessionResetPending[address]; pending { return nil, ctx, ErrSessionCacheInvalidated } diff --git a/store/sessioncache_pending_test.go b/store/sessioncache_pending_test.go index c5588ef49..30c925762 100644 --- a/store/sessioncache_pending_test.go +++ b/store/sessioncache_pending_test.go @@ -32,7 +32,7 @@ func TestFailedIdentityResetAbortsTheCurrentSend(t *testing.T) { } } -func TestFailedIdentityResetBudgetNeverForgetsUnsafeRows(t *testing.T) { +func TestFailedIdentityResetBudgetRetainsAndRecoversUnsafeRows(t *testing.T) { backend := &resetSessionStore{rows: make(map[string][]byte)} device := &Device{Sessions: backend} for i := range maxSessionResetAddresses + 1 { @@ -41,19 +41,22 @@ func TestFailedIdentityResetBudgetNeverForgetsUnsafeRows(t *testing.T) { if err := device.DeleteSessionsForIdentity(context.Background(), address); !errors.Is(err, ErrSessionCacheInvalidated) { t.Fatalf("failed reset %d was not refused: %v", i, err) } + if _, pending := device.sessionResetPending[backend.failDelete]; !pending { + t.Fatal("actual failed deletion was forgotten") + } } if len(device.sessionResetPending) > maxSessionResetAddresses || len(device.sessionResetAddresses) > maxSessionResetAddresses { t.Fatal("failed reset tracking exceeded its budgets") } - if !device.sessionResetBlocked { - t.Fatal("exhausted failure budget did not refuse unknown state") - } backend.failDelete = "" - if err := device.DeleteSessionsForIdentity(context.Background(), protocol.NewSignalAddress("authored-0", 1)); !errors.Is(err, ErrSessionCacheInvalidated) { - t.Fatalf("an unrelated successful retry cleared unknown failures: %v", err) + if err := device.ReconcileSessionResets(context.Background()); err != nil { + t.Fatal(err) + } + if len(device.sessionResetPending) != 0 { + t.Fatal("successful reconciliation retained failed keys") } - if _, _, err := device.WithCachedSessions(context.Background(), []string{"fresh:1"}); !errors.Is(err, ErrSessionCacheInvalidated) { - t.Fatalf("failure budget overflow allowed a fresh cache: %v", err) + if _, _, err := device.WithCachedSessions(context.Background(), []string{"fresh:1"}); err != nil { + t.Fatalf("recovered Device remains blocked: %v", err) } } diff --git a/store/sessioncache_recovery_controls_test.go b/store/sessioncache_recovery_controls_test.go new file mode 100644 index 000000000..e6c5296c1 --- /dev/null +++ b/store/sessioncache_recovery_controls_test.go @@ -0,0 +1,111 @@ +// Copyright (c) 2026 Rajeh Taher +// Licensed under the MIT License. See LICENSE-MIT for details. + +package store + +import ( + "context" + "errors" + "testing" + + "github.com/polymorfa/libsignal-protocol-go/protocol" +) + +type resetIdentityFaultStore struct { + NoopStore + deleteIdentity func() error +} + +func (s *resetIdentityFaultStore) DeleteIdentity(context.Context, string) error { + return s.deleteIdentity() +} + +func TestIdentityDeleteFaultCannotRestoreEitherSessionScope(t *testing.T) { + ctx := context.Background() + address := protocol.NewSignalAddress("123", 1) + backend := &resetSessionStore{rows: map[string][]byte{address.String(): cacheTestSession().Serialize(), address.String() + "_status": cacheTestSession().Serialize()}} + fault := errors.New("authored identity deletion failure") + device := &Device{Sessions: backend, Identities: &resetIdentityFaultStore{deleteIdentity: func() error { + if len(backend.rows) != 0 { + t.Error("identity deletion started before session deletion finished") + } + return fault + }}} + _, cached, err := device.WithCachedSessions(ctx, []string{address.String()}) + if err != nil { + t.Fatal(err) + } + if err = device.StoreSession(cached, address, cacheTestSession()); err != nil { + t.Fatal(err) + } + if err = device.DeleteIdentityAndSessions(ctx, address); !errors.Is(err, fault) || !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatalf("identity deletion error lost its cause or fatal classification: %v", err) + } + if err = device.PutCachedSessions(cached); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatalf("failed identity deletion allowed an old cache to flush: %v", err) + } + if len(backend.rows) != 0 { + t.Fatal("old cache restored a deleted session") + } +} + +type nestedResetSessionStore struct { + resetSessionStore + hook func(context.Context) + calls int +} + +func (s *nestedResetSessionStore) DeleteSession(ctx context.Context, address string) error { + s.calls++ + if s.hook != nil { + hook := s.hook + s.hook = nil + hook(ctx) + } + return s.resetSessionStore.DeleteSession(ctx, address) +} + +func TestReconciliationCannotConsumeAnActiveResetReservation(t *testing.T) { + address := protocol.NewSignalAddress("123", 1) + backend := &nestedResetSessionStore{resetSessionStore: resetSessionStore{rows: make(map[string][]byte), failDelete: address.String()}} + device := &Device{Sessions: backend} + backend.hook = func(ctx context.Context) { + if err := device.ReconcileSessionResets(ctx); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Errorf("reconciliation consumed an active reset: %v", err) + } + if backend.calls != 1 { + t.Error("reconciliation retried an active backend deletion") + } + } + if err := device.DeleteSessionsForIdentity(context.Background(), address); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatal(err) + } + if _, pending := device.sessionResetPending[address.String()]; !pending { + t.Fatal("active deletion failure was forgotten") + } +} + +func TestReconciliationCannotRetryItsOwnActiveDeletion(t *testing.T) { + address := protocol.NewSignalAddress("123", 1) + backend := &nestedResetSessionStore{resetSessionStore: resetSessionStore{rows: make(map[string][]byte), failDelete: address.String()}} + device := &Device{Sessions: backend} + if err := device.DeleteSessionsForIdentity(context.Background(), address); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatal(err) + } + backend.failDelete = "" + before := backend.calls + backend.hook = func(ctx context.Context) { + if err := device.ReconcileSessionResets(ctx); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Errorf("nested reconciliation consumed its caller: %v", err) + } + if backend.calls != before+1 { + t.Error("nested reconciliation repeated active backend deletion") + } + } + if err := device.ReconcileSessionResets(context.Background()); err != nil { + t.Fatal(err) + } + if len(device.sessionResetPending) != 0 { + t.Fatal("successful outer reconciliation kept pending state") + } +} diff --git a/store/sessioncache_recovery_test.go b/store/sessioncache_recovery_test.go new file mode 100644 index 000000000..303501a4a --- /dev/null +++ b/store/sessioncache_recovery_test.go @@ -0,0 +1,67 @@ +// Copyright (c) 2026 Rajeh Taher +// Licensed under the MIT License. See LICENSE-MIT for details. + +package store + +import ( + "context" + "errors" + "fmt" + "testing" + + "github.com/polymorfa/libsignal-protocol-go/protocol" +) + +type outageSessionStore struct { + resetSessionStore + failAll bool + attempts map[string]int +} + +func (s *outageSessionStore) DeleteSession(ctx context.Context, address string) error { + s.attempts[address]++ + if s.failAll { + return errors.New("authored backend outage") + } + return s.resetSessionStore.DeleteSession(ctx, address) +} + +func TestPendingResetRecoveryRetainsEveryStartedFailure(t *testing.T) { + backend := &outageSessionStore{resetSessionStore: resetSessionStore{rows: make(map[string][]byte)}, failAll: true, attempts: make(map[string]int)} + device := &Device{Sessions: backend} + for i := range maxSessionResetAddresses / 2 { + if err := device.DeleteSessionsForIdentity(context.Background(), protocol.NewSignalAddress(fmt.Sprintf("authored-%d", i), 1)); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatal(err) + } + } + fresh := protocol.NewSignalAddress("fresh", 1) + if err := device.DeleteSessionsForIdentity(context.Background(), fresh); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatalf("full failure budget admitted a new reset: %v", err) + } + if backend.attempts[fresh.String()] != 0 || backend.attempts[fresh.String()+"_status"] != 0 { + t.Error("reset started without room to retain all failures") + } + if len(device.sessionResetPending) != maxSessionResetAddresses { + t.Fatalf("lost tracked failures: %d", len(device.sessionResetPending)) + } + recovery, ok := any(device).(interface{ ReconcileSessionResets(context.Context) error }) + if !ok { + t.Fatal("no explicit pending-reset recovery path") + } + if err := recovery.ReconcileSessionResets(context.Background()); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatalf("outage recovery did not retain refusal: %v", err) + } + backend.failAll = false + if err := recovery.ReconcileSessionResets(context.Background()); err != nil { + t.Fatal(err) + } + if len(device.sessionResetPending) != 0 { + t.Fatal("successful recovery retained failed keys") + } + if err := device.DeleteSessionsForIdentity(context.Background(), fresh); err != nil { + t.Fatal(err) + } + if _, _, err := device.WithCachedSessions(context.Background(), []string{fresh.String()}); err != nil { + t.Fatalf("recovered Device remains blocked: %v", err) + } +} diff --git a/store/signal.go b/store/signal.go index c483d2d2e..5bb68801b 100644 --- a/store/signal.go +++ b/store/signal.go @@ -196,64 +196,167 @@ func (device *Device) containsSession(ctx context.Context, remoteAddress *protoc func (device *Device) DeleteSession(ctx context.Context, remoteAddress *protocol.SignalAddress) error { return device.WithSessionStateLock(ctx, func(ctx context.Context) error { addrString := SignalSessionAddress(ctx, remoteAddress.String()) + if _, pending := device.sessionResetPending[addrString]; pending { + if err := device.retrySessionResetDeletion(ctx, addrString); err != nil { + return errors.Join(ErrSessionCacheInvalidated, err) + } + return nil + } if err := device.Sessions.DeleteSession(ctx, addrString); err != nil { return fmt.Errorf("failed to delete session with %s: %w", addrString, err) } - delete(device.sessionResetPending, addrString) return nil }) } -// DeleteSessionsForIdentity removes both pairwise scopes after a shared identity change. +type pendingSessionReset struct { + active int + failed bool +} + +func (device *Device) finishSessionResetDeletion(key string, err error) { + state := device.sessionResetPending[key] + state.active-- + state.failed = err != nil + if state.active == 0 && !state.failed { + delete(device.sessionResetPending, key) + } else { + device.sessionResetPending[key] = state + } +} + +// Retries also reserve their key: a nested callback must not reconcile the +// backend operation that is currently producing its result. +func (device *Device) retrySessionResetDeletion(ctx context.Context, key string) error { + state, found := device.sessionResetPending[key] + if !found { + return nil + } + if state.active > 0 { + return ErrSessionCacheInvalidated + } + state.active++ + device.sessionResetPending[key] = state + err := device.Sessions.DeleteSession(ctx, key) + device.finishSessionResetDeletion(key, err) + return err +} + +// DeleteIdentityAndSessions removes both session scopes before their identity. +// If session deletion fails, retaining the identity keeps surviving rows bound +// to the same key even when this Device's in-memory pending set is lost. +func (device *Device) DeleteIdentityAndSessions(ctx context.Context, address *protocol.SignalAddress) error { + return device.WithSessionStateLock(ctx, func(ctx context.Context) error { + if err := device.DeleteSessionsForIdentity(ctx, address); err != nil { + return err + } + if err := device.Identities.DeleteIdentity(ctx, address.String()); err != nil { + return fmt.Errorf("%w: failed to delete identity: %w", ErrSessionCacheInvalidated, err) + } + return nil + }) +} + +// ReconcileSessionResets retries every tracked failed deletion. A key becomes +// usable only after its backend confirms deletion; failures remain pending. +func (device *Device) ReconcileSessionResets(ctx context.Context) error { + return device.WithSessionStateLock(ctx, func(ctx context.Context) error { + var retryErr error + activeReset := false + for key, state := range device.sessionResetPending { + if state.active > 0 { + activeReset = true + continue + } + if err := ctx.Err(); err != nil { + return errors.Join(ErrSessionCacheInvalidated, retryErr, err) + } + if err := device.retrySessionResetDeletion(ctx, key); err != nil { + retryErr = errors.Join(retryErr, fmt.Errorf("failed to reconcile session with %s: %w", key, err)) + } + } + if retryErr != nil || activeReset { + return errors.Join(ErrSessionCacheInvalidated, retryErr) + } + return nil + }) +} + +// makeRoomForSessionReset runs under the guard. Retry at most one deletion per +// requested key here; the explicit reconciliation method can retry the full set. +func (device *Device) makeRoomForSessionReset(ctx context.Context, keys []string) error { + fits := func() bool { + needed := len(device.sessionResetPending) + for _, key := range keys { + if _, pending := device.sessionResetPending[key]; !pending { + needed++ + } + } + return needed <= maxSessionResetAddresses + } + if fits() { + return nil + } + var retryErr error + attempts := 0 + for key, state := range device.sessionResetPending { + if state.active > 0 { + continue + } + if key == keys[0] || key == keys[1] { + continue + } + if attempts >= len(keys) { + break + } + attempts++ + if err := device.retrySessionResetDeletion(ctx, key); err != nil { + retryErr = errors.Join(retryErr, err) + } + if fits() { + return nil + } + } + return errors.Join(ErrSessionCacheInvalidated, retryErr) +} + +// DeleteSessionsForIdentity removes both scopes before replacing an identity. +// Prefer DeleteIdentityAndSessions when the shared identity must also be removed. func (device *Device) DeleteSessionsForIdentity(ctx context.Context, remoteAddress *protocol.SignalAddress) error { return device.WithSessionStateLock(ctx, func(ctx context.Context) error { keys := []string{remoteAddress.String(), remoteAddress.String() + "_status"} + // Never begin a reset whose possible failures cannot all be retained. + if err := device.makeRoomForSessionReset(ctx, keys); err != nil { + return err + } device.sessionResetEpoch++ if device.sessionResetAddresses == nil { device.sessionResetAddresses = make(map[string]uint64) } if len(device.sessionResetAddresses)+len(keys) > maxSessionResetAddresses { - // Forgetting a reset must never make an outstanding cache valid. - // Caches older than this floor must be prefetched again. device.sessionResetFloor = device.sessionResetEpoch clear(device.sessionResetAddresses) } if device.sessionResetPending == nil { - device.sessionResetPending = make(map[string]struct{}) + device.sessionResetPending = make(map[string]pendingSessionReset) } for _, key := range keys { device.sessionResetAddresses[key] = device.sessionResetEpoch + state := device.sessionResetPending[key] + state.active++ + device.sessionResetPending[key] = state } var deleteErr error - var failedKeys []string for _, key := range keys { - if err := device.Sessions.DeleteSession(ctx, key); err != nil { + err := device.Sessions.DeleteSession(ctx, key) + device.finishSessionResetDeletion(key, err) + if err != nil { deleteErr = errors.Join(deleteErr, fmt.Errorf("failed to delete session with %s: %w", key, err)) - failedKeys = append(failedKeys, key) - } else { - delete(device.sessionResetPending, key) - } - } - // The guard prevents reads during deletion. Reserve only actual - // failures, after successful deletions have freed their slots. - for _, key := range failedKeys { - if _, pending := device.sessionResetPending[key]; pending { - continue - } - if len(device.sessionResetPending) >= maxSessionResetAddresses { - // Unknown failed keys cannot be forgotten safely. Refuse - // this Device until its backend state is reconciled. - device.sessionResetBlocked = true - } else { - device.sessionResetPending[key] = struct{}{} } } if deleteErr != nil { return errors.Join(ErrSessionCacheInvalidated, deleteErr) } - if device.sessionResetBlocked { - return ErrSessionCacheInvalidated - } if cache := getSessionCache(ctx, device); cache != nil { for _, key := range keys { cache.Set(key, sessionCacheEntry{Generation: device.sessionResetEpoch, Record: record.NewSession(SignalProtobufSerializer.Session, SignalProtobufSerializer.State)}) diff --git a/store/store.go b/store/store.go index 97d3d214f..05b8ba7e1 100644 --- a/store/store.go +++ b/store/store.go @@ -305,8 +305,7 @@ type Device struct { sessionResetEpoch uint64 sessionResetAddresses map[string]uint64 sessionResetFloor uint64 - sessionResetPending map[string]struct{} - sessionResetBlocked bool + sessionResetPending map[string]pendingSessionReset saveDeleteLockInit sync.Once saveDeleteLock chan struct{} From 308ca1490621155c43b9e29d560798adaf0bd9b7 Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Tue, 17 Nov 2026 07:05:20 +0200 Subject: [PATCH 14/16] fix(signal): retry pending deletion before session access --- README.md | 5 ++- store/sessioncache.go | 9 ++-- store/sessioncache_lazy_recovery_test.go | 52 ++++++++++++++++++++++++ store/signal.go | 12 ++++++ 4 files changed, 70 insertions(+), 8 deletions(-) create mode 100644 store/sessioncache_lazy_recovery_test.go diff --git a/README.md b/README.md index 27c6f9ff5..41b46764c 100644 --- a/README.md +++ b/README.md @@ -298,8 +298,9 @@ place. Use `Device.DeleteIdentityAndSessions` when removing both; custom callers must preserve that order and serialize other writers to the same backend. Failed rows stay unavailable on the current Device until deletion succeeds. -`Device.ReconcileSessionResets(ctx)` retries the tracked failures after storage -recovers. A reset that cannot retain all possible failures is refused before it +Guarded session access retries deletion of its known pending key before using +any stored row. `Device.ReconcileSessionResets(ctx)` can also retry all tracked +failures after storage recovers. A reset that cannot retain all possible failures is refused before it starts; it does not permanently disable the Device or discard unknown failures. Admission retries at most two existing failures, while explicit reconciliation can retry the full bounded set. Both reset history and tracked failures retain at diff --git a/store/sessioncache.go b/store/sessioncache.go index f2c7a18f9..42bdda704 100644 --- a/store/sessioncache.go +++ b/store/sessioncache.go @@ -132,9 +132,6 @@ func (device *Device) CheckCachedSession(ctx context.Context, address string) er // The caller holds sessionStateLock across validation and local state use. func (device *Device) checkCachedSession(ctx context.Context, address string) error { - if _, pending := device.sessionResetPending[address]; pending { - return ErrSessionCacheInvalidated - } if cache := getSessionCache(ctx, device); cache != nil { generation := cache.epoch if item, ok := cache.Get(address); ok { @@ -144,7 +141,7 @@ func (device *Device) checkCachedSession(ctx context.Context, address string) er return ErrSessionCacheInvalidated } } - return nil + return device.reconcilePendingSession(ctx, address) } func (device *Device) WithCachedSessions(ctx context.Context, addresses []string) (map[string]bool, context.Context, error) { @@ -171,8 +168,8 @@ func (device *Device) withCachedSessions(ctx context.Context, addresses []string for _, address := range addresses { // A new prefetch must not bless a row whose deletion failed. The // previous context may be stale, so validate pending state alone. - if _, pending := device.sessionResetPending[address]; pending { - return nil, ctx, ErrSessionCacheInvalidated + if err := device.reconcilePendingSession(ctx, address); err != nil { + return nil, ctx, err } } diff --git a/store/sessioncache_lazy_recovery_test.go b/store/sessioncache_lazy_recovery_test.go new file mode 100644 index 000000000..6553a76c8 --- /dev/null +++ b/store/sessioncache_lazy_recovery_test.go @@ -0,0 +1,52 @@ +// Copyright (c) 2026 Rajeh Taher +// Licensed under the MIT License. See LICENSE-MIT for details. + +package store + +import ( + "context" + "errors" + "testing" + + "github.com/polymorfa/libsignal-protocol-go/protocol" +) + +func TestRecoveredBackendIsReconciledBeforeSessionRead(t *testing.T) { + for _, method := range []string{"prefetch", "load", "lookup", "crypto check"} { + t.Run(method, func(t *testing.T) { + ctx := WithStatusSession(context.Background()) + address := protocol.NewSignalAddress("123", 1) + key := address.String() + "_status" + backend := &resetSessionStore{rows: map[string][]byte{key: cacheTestSession().Serialize()}, failDelete: key} + device := &Device{Sessions: backend} + if err := device.DeleteSessionsForIdentity(ctx, address); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatal(err) + } + backend.failDelete = "" + var err error + switch method { + case "prefetch": + var found map[string]bool + found, _, err = device.WithCachedSessions(ctx, []string{key}) + if found[key] { + t.Error("prefetch returned the failed-deletion row") + } + case "load": + _, err = device.LoadSession(ctx, address) + case "lookup": + _, err = device.ContainsSession(ctx, address) + case "crypto check": + err = device.CheckCachedSession(ctx, key) + } + if err != nil { + t.Errorf("recovered backend remains unavailable to %s: %v", method, err) + } + if _, found := backend.rows[key]; found { + t.Error("read did not confirm deletion of its pending row") + } + if len(device.sessionResetPending) != 0 { + t.Error("confirmed deletion remains pending") + } + }) + } +} diff --git a/store/signal.go b/store/signal.go index 5bb68801b..007b68d61 100644 --- a/store/signal.go +++ b/store/signal.go @@ -242,6 +242,18 @@ func (device *Device) retrySessionResetDeletion(ctx context.Context, key string) return err } +// The caller holds the guard; known failed keys may recover without a worker +// or an operator command, but no row is accepted before confirmed deletion. +func (device *Device) reconcilePendingSession(ctx context.Context, key string) error { + if _, pending := device.sessionResetPending[key]; !pending { + return nil + } + if err := device.retrySessionResetDeletion(ctx, key); err != nil { + return errors.Join(ErrSessionCacheInvalidated, fmt.Errorf("failed to reconcile session with %s: %w", key, err)) + } + return nil +} + // DeleteIdentityAndSessions removes both session scopes before their identity. // If session deletion fails, retaining the identity keeps surviving rows bound // to the same key even when this Device's in-memory pending set is lost. From 76026f8a2d1c9800d97980bc02e191d5aba6235a Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Tue, 17 Nov 2026 07:30:19 +0200 Subject: [PATCH 15/16] fix(signal): reconcile pending resets before decryption transactions --- README.md | 9 ++ message.go | 29 +++- session_reset_transaction_test.go | 153 +++++++++++++++++++ store/sessioncache.go | 28 ++++ store/sessioncache_recovery_controls_test.go | 35 +++++ store/signal.go | 22 ++- store/sqlstore/session_transaction_test.go | 77 ++++++++++ store/sqlstore/store.go | 11 +- store/store.go | 7 + 9 files changed, 367 insertions(+), 4 deletions(-) create mode 100644 session_reset_transaction_test.go create mode 100644 store/sqlstore/session_transaction_test.go diff --git a/README.md b/README.md index 41b46764c..c83de5069 100644 --- a/README.md +++ b/README.md @@ -312,3 +312,12 @@ retains the original identity for surviving rows after a failed library-managed reset; this relies on backend deletion completion and ordering. Custom-store, transaction, process-crash and previous-release state acceptance still need their own evidence. Restarting is not a substitute for repairing a failed backend. + +Pending recovery runs before buffered decryption opens its transaction. A previously failed +deletion is not reconciled by a write that can still roll back. SQLStore marks its +transaction callbacks and also detects transactions opened directly on its +underlying database. Custom transactional SessionStores must expose +`SessionTransactionState` or mark their contexts with `WithSessionTransaction`; +callbacks must forward that context. Saved buffered plaintext bypasses new +preparation and decryption. These are source contracts, not database/crash or +previous-release acceptance evidence. diff --git a/message.go b/message.go index 2a5d43e0a..89f55be1e 100644 --- a/message.go +++ b/message.go @@ -641,9 +641,25 @@ func (cli *Client) bufferedDecrypt( serverTimestamp time.Time, decrypt func(context.Context) ([]byte, error), extraHashData ...string, +) ([]byte, [32]byte, error) { + return cli.bufferedDecryptPrepared(ctx, ciphertext, serverTimestamp, nil, decrypt, extraHashData...) +} + +func (cli *Client) bufferedDecryptPrepared( + ctx context.Context, + ciphertext []byte, + serverTimestamp time.Time, + prepare func(context.Context) error, + decrypt func(context.Context) ([]byte, error), + extraHashData ...string, ) (plaintext []byte, ciphertextHash [32]byte, err error) { if !cli.EnableDecryptedEventBuffer { err = cli.Store.WithSessionStateLock(ctx, func(ctx context.Context) error { + if prepare != nil { + if prepareErr := prepare(ctx); prepareErr != nil { + return prepareErr + } + } plaintext, err = decrypt(ctx) return err }) @@ -680,7 +696,13 @@ func (cli *Client) bufferedDecrypt( } err = cli.Store.WithSessionStateLock(ctx, func(ctx context.Context) error { + if prepare != nil { + if prepareErr := prepare(ctx); prepareErr != nil { + return prepareErr + } + } return cli.Store.EventBuffer.DoDecryptionTxn(ctx, func(ctx context.Context) (innerErr error) { + ctx = store.WithSessionTransaction(ctx) plaintext, innerErr = decrypt(ctx) if innerErr != nil { return @@ -725,6 +747,9 @@ func (cli *Client) decryptDM(ctx context.Context, child *waBinary.Node, from typ builder = session.NewBuilderFromSignal(sessionlessSignalStore{cli.Store}, from.SignalAddress(), pbSerializer) } cipher := session.NewCipher(builder, from.SignalAddress()) + prepare := func(prepareCtx context.Context) error { + return cli.Store.PrepareIdentitySessions(prepareCtx, from.SignalAddress()) + } var plaintext []byte var ciphertextHash [32]byte if isPreKey { @@ -732,7 +757,7 @@ func (cli *Client) decryptDM(ctx context.Context, child *waBinary.Node, from typ if err != nil { return nil, nil, fmt.Errorf("failed to parse prekey message: %w", err) } - plaintext, ciphertextHash, err = cli.bufferedDecrypt(ctx, content, serverTS, func(decryptCtx context.Context) ([]byte, error) { + plaintext, ciphertextHash, err = cli.bufferedDecryptPrepared(ctx, content, serverTS, prepare, func(decryptCtx context.Context) ([]byte, error) { pt, innerErr := cipher.DecryptMessage(decryptCtx, preKeyMsg) if cli.AutoTrustIdentity && errors.Is(innerErr, signalerror.ErrUntrustedIdentity) { cli.Log.Warnf("Got %v error while trying to decrypt prekey message from %s, clearing stored identity and retrying", innerErr, from) @@ -752,7 +777,7 @@ func (cli *Client) decryptDM(ctx context.Context, child *waBinary.Node, from typ if err != nil { return nil, nil, fmt.Errorf("failed to parse normal message: %w", err) } - plaintext, ciphertextHash, err = cli.bufferedDecrypt(ctx, content, serverTS, func(decryptCtx context.Context) ([]byte, error) { + plaintext, ciphertextHash, err = cli.bufferedDecryptPrepared(ctx, content, serverTS, prepare, func(decryptCtx context.Context) ([]byte, error) { return cipher.Decrypt(decryptCtx, msg) }, "normal", store.SignalSessionAddress(ctx, from.String())) if err != nil { diff --git a/session_reset_transaction_test.go b/session_reset_transaction_test.go new file mode 100644 index 000000000..aabe3a0b4 --- /dev/null +++ b/session_reset_transaction_test.go @@ -0,0 +1,153 @@ +// Copyright (c) 2026 Rajeh Taher +// Licensed under the MIT License. See LICENSE-MIT for details. + +package whatsmeow + +import ( + "context" + "errors" + "maps" + "testing" + "time" + + "github.com/polymorfa/hypermeow/store" + "github.com/polymorfa/hypermeow/types" + waLog "github.com/polymorfa/hypermeow/util/log" +) + +type pendingRollbackRowsKey struct{} +type pendingRollbackStore struct { + *recoverySignalStore + transactionDeletes int +} + +func (s *pendingRollbackStore) DeleteSession(ctx context.Context, key string) error { + if rows, ok := ctx.Value(pendingRollbackRowsKey{}).(map[string][]byte); ok { + s.transactionDeletes++ + delete(rows, key) + return nil + } + return s.recoverySignalStore.DeleteSession(ctx, key) +} +func (s *pendingRollbackStore) HasSession(ctx context.Context, key string) (bool, error) { + if rows, ok := ctx.Value(pendingRollbackRowsKey{}).(map[string][]byte); ok { + _, found := rows[key] + return found, nil + } + return s.memSignalStore.HasSession(ctx, key) +} + +type pendingRollbackBuffer struct { + store.EventBuffer + backend *pendingRollbackStore +} + +func (*pendingRollbackBuffer) GetBufferedEvent(context.Context, [32]byte) (*store.BufferedEvent, error) { + return nil, nil +} +func (*pendingRollbackBuffer) PutBufferedEvent(context.Context, [32]byte, []byte, time.Time) error { + return nil +} +func (b *pendingRollbackBuffer) DoDecryptionTxn(ctx context.Context, fn func(context.Context) error) error { + rows := maps.Clone(b.backend.sessions) + if err := fn(context.WithValue(ctx, pendingRollbackRowsKey{}, rows)); err != nil { + return err // Authored rollback model: discard transactional DELETEs. + } + b.backend.sessions = rows + return nil +} + +func TestBufferedRollbackCannotForgetAPendingSessionDeletion(t *testing.T) { + ctx := store.WithStatusSession(context.Background()) + peer := types.NewADJID("200000000002", 0, 2) + key := peer.SignalAddress().String() + "_status" + backend := &pendingRollbackStore{recoverySignalStore: &recoverySignalStore{memSignalStore: newMemSignalStore(), failDelete: key}} + // Opaque authored rows: only HasSession is used, not protocol decoding. + backend.sessions[key] = []byte("authored pending row") + device := &store.Device{Sessions: backend} + if err := device.DeleteSessionsForIdentity(ctx, peer.SignalAddress()); !errors.Is(err, store.ErrSessionCacheInvalidated) { + t.Fatal(err) + } + backend.failDelete = "" + device.EventBuffer = &pendingRollbackBuffer{backend: backend} + client := NewClient(device, waLog.Noop) + client.EnableDecryptedEventBuffer = true + fault := errors.New("authored decryption failure after lookup") + _, _, err := client.bufferedDecrypt(ctx, []byte("authored hash input, not a packet"), time.Unix(1700000000, 0), func(tx context.Context) ([]byte, error) { + if _, readErr := device.ContainsSession(tx, peer.SignalAddress()); readErr != nil { + return nil, readErr + } + return nil, fault + }) + if err == nil { + t.Fatal("decryption failure was not returned") + } + if backend.transactionDeletes != 0 { + t.Error("pending deletion was reconciled inside a rollbackable transaction") + } + if _, found := backend.sessions[key]; !found { + t.Fatal("rollback model failed to retain the original row") + } + found, err := device.ContainsSession(ctx, peer.SignalAddress()) + if err != nil { + t.Fatal(err) + } + if found { + t.Error("rollback forgot the pending marker and accepted the old row") + } + if _, found = backend.sessions[key]; found { + t.Error("later nontransactional access did not confirm deletion") + } +} + +func TestPreparedBufferedFailureCannotRollbackSessionRecovery(t *testing.T) { + ctx := context.Background() + peer := types.NewADJID("200000000002", 0, 2) + key := peer.SignalAddress().String() + backend := &pendingRollbackStore{recoverySignalStore: &recoverySignalStore{memSignalStore: newMemSignalStore(), failDelete: key}} + backend.sessions[key] = []byte("authored pending sibling row") + device := &store.Device{Sessions: backend} + if err := device.DeleteSessionsForIdentity(ctx, peer.SignalAddress()); !errors.Is(err, store.ErrSessionCacheInvalidated) { + t.Fatal(err) + } + backend.failDelete = "" + device.EventBuffer = &pendingRollbackBuffer{backend: backend} + client := NewClient(device, waLog.Noop) + client.EnableDecryptedEventBuffer = true + fault := errors.New("authored post-recovery decryption failure") + _, _, err := client.bufferedDecryptPrepared(store.WithStatusSession(ctx), []byte("authored hash input"), time.Unix(1700000000, 0), func(prepareCtx context.Context) error { + return device.PrepareIdentitySessions(prepareCtx, peer.SignalAddress()) + }, func(tx context.Context) ([]byte, error) { + return nil, fault + }) + if !errors.Is(err, fault) { + t.Fatalf("lost decryption failure: %v", err) + } + if backend.transactionDeletes != 0 { + t.Error("preparation ran inside the transaction") + } + if _, found := backend.sessions[key]; found { + t.Error("decryption rollback restored the prepared sibling deletion") + } +} + +type preparedReplayBuffer struct{ store.EventBuffer } + +func (*preparedReplayBuffer) GetBufferedEvent(context.Context, [32]byte) (*store.BufferedEvent, error) { + return &store.BufferedEvent{Plaintext: []byte("authored saved plaintext")}, nil +} +func TestBufferedReplayDoesNotPrepareOrDecryptAgain(t *testing.T) { + device := &store.Device{EventBuffer: &preparedReplayBuffer{}} + client := NewClient(device, waLog.Noop) + client.EnableDecryptedEventBuffer = true + got, _, err := client.bufferedDecryptPrepared(context.Background(), []byte("authored hash input"), time.Unix(1700000000, 0), func(context.Context) error { + t.Error("saved replay prepared sessions again") + return nil + }, func(context.Context) ([]byte, error) { + t.Error("saved replay decrypted again") + return nil, nil + }) + if err != nil || string(got) != "authored saved plaintext" { + t.Fatalf("saved replay changed: %v", err) + } +} diff --git a/store/sessioncache.go b/store/sessioncache.go index 42bdda704..29a180ded 100644 --- a/store/sessioncache.go +++ b/store/sessioncache.go @@ -22,11 +22,39 @@ type contextKey int const ( contextKeySessionCache contextKey = iota contextKeySessionStateLock + contextKeySessionTransaction ) // Bound completed reset history and outstanding deletion failures separately. const maxSessionResetAddresses = 1024 +// WithSessionTransaction marks work whose writes are not yet committed. +// Reconcile pending session deletions before entering this context. Custom +// transactional stores must mark their callbacks as well. +func WithSessionTransaction(ctx context.Context) context.Context { + if SessionTransactionActive(ctx) { + return ctx + } + return context.WithValue(ctx, contextKeySessionTransaction, true) +} + +// SessionTransactionActive reports the session-state transaction marker. +func SessionTransactionActive(ctx context.Context) bool { + if ctx == nil { + return false + } + active, _ := ctx.Value(contextKeySessionTransaction).(bool) + return active +} + +func (device *Device) sessionTransactionActive(ctx context.Context) bool { + if SessionTransactionActive(ctx) { + return true + } + backend, ok := device.Sessions.(SessionTransactionState) + return ok && backend.SessionTransactionActive(ctx) +} + var ErrSessionCacheInvalidated = errors.New("session cache was invalidated by an identity reset") type sessionCacheEntry struct { diff --git a/store/sessioncache_recovery_controls_test.go b/store/sessioncache_recovery_controls_test.go index e6c5296c1..0d5f9c072 100644 --- a/store/sessioncache_recovery_controls_test.go +++ b/store/sessioncache_recovery_controls_test.go @@ -109,3 +109,38 @@ func TestReconciliationCannotRetryItsOwnActiveDeletion(t *testing.T) { t.Fatal("successful outer reconciliation kept pending state") } } + +func TestPendingDeletionCannotBeClearedInsideKnownTransaction(t *testing.T) { + ctx := context.Background() + address := protocol.NewSignalAddress("123", 1) + key := address.String() + "_status" + backend := &resetSessionStore{rows: map[string][]byte{key: cacheTestSession().Serialize()}, failDelete: key} + device := &Device{Sessions: backend} + if err := device.DeleteSessionsForIdentity(ctx, address); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatal(err) + } + backend.failDelete = "" + tx := WithSessionTransaction(WithStatusSession(ctx)) + for _, attempt := range []func() error{ + func() error { return device.ReconcileSessionResets(tx) }, + func() error { return device.DeleteSession(tx, address) }, + func() error { return device.DeleteSessionsForIdentity(tx, address) }, + func() error { _, err := device.ContainsSession(tx, address); return err }, + } { + if err := attempt(); !errors.Is(err, ErrSessionCacheInvalidated) { + t.Fatalf("transaction cleared pending state: %v", err) + } + if _, pending := device.sessionResetPending[key]; !pending { + t.Fatal("transaction forgot pending key") + } + if _, found := backend.rows[key]; !found { + t.Fatal("transaction attempted pending deletion") + } + } + if err := device.ReconcileSessionResets(ctx); err != nil { + t.Fatal(err) + } + if len(device.sessionResetPending) != 0 { + t.Fatal("nontransactional recovery did not complete") + } +} diff --git a/store/signal.go b/store/signal.go index 007b68d61..389dfc4eb 100644 --- a/store/signal.go +++ b/store/signal.go @@ -232,7 +232,7 @@ func (device *Device) retrySessionResetDeletion(ctx context.Context, key string) if !found { return nil } - if state.active > 0 { + if state.active > 0 || device.sessionTransactionActive(ctx) { return ErrSessionCacheInvalidated } state.active++ @@ -254,6 +254,19 @@ func (device *Device) reconcilePendingSession(ctx context.Context, key string) e return nil } +// PrepareIdentitySessions reconciles pending deletions for both pairwise scopes. +// Keep the session guard held when entering a subsequent decryption transaction. +func (device *Device) PrepareIdentitySessions(ctx context.Context, address *protocol.SignalAddress) error { + return device.WithSessionStateLock(ctx, func(ctx context.Context) error { + for _, key := range []string{address.String(), address.String() + "_status"} { + if err := device.checkCachedSession(ctx, key); err != nil { + return err + } + } + return nil + }) +} + // DeleteIdentityAndSessions removes both session scopes before their identity. // If session deletion fails, retaining the identity keeps surviving rows bound // to the same key even when this Device's in-memory pending set is lost. @@ -337,6 +350,13 @@ func (device *Device) makeRoomForSessionReset(ctx context.Context, keys []string func (device *Device) DeleteSessionsForIdentity(ctx context.Context, remoteAddress *protocol.SignalAddress) error { return device.WithSessionStateLock(ctx, func(ctx context.Context) error { keys := []string{remoteAddress.String(), remoteAddress.String() + "_status"} + if device.sessionTransactionActive(ctx) { + for _, key := range keys { + if _, pending := device.sessionResetPending[key]; pending { + return ErrSessionCacheInvalidated + } + } + } // Never begin a reset whose possible failures cannot all be retained. if err := device.makeRoomForSessionReset(ctx, keys); err != nil { return err diff --git a/store/sqlstore/session_transaction_test.go b/store/sqlstore/session_transaction_test.go new file mode 100644 index 000000000..78179cf8b --- /dev/null +++ b/store/sqlstore/session_transaction_test.go @@ -0,0 +1,77 @@ +// Copyright (c) 2026 Rajeh Taher +// Licensed under the MIT License. See LICENSE-MIT for details. + +package sqlstore + +import ( + "context" + "database/sql" + "database/sql/driver" + "errors" + "testing" + + "github.com/polymorfa/hypermeow/store" + "github.com/polymorfa/hypermeow/types" +) + +type sessionTxnProbe struct{ commits, rollbacks int } +type sessionTxnConnector struct{ probe *sessionTxnProbe } + +func (c sessionTxnConnector) Connect(context.Context) (driver.Conn, error) { + return sessionTxnConn(c), nil +} +func (sessionTxnConnector) Driver() driver.Driver { return sessionTxnDriver{} } + +type sessionTxnDriver struct{} + +func (sessionTxnDriver) Open(string) (driver.Conn, error) { + return nil, errors.New("use authored connector") +} + +type sessionTxnConn struct{ probe *sessionTxnProbe } + +func (sessionTxnConn) Prepare(string) (driver.Stmt, error) { + return nil, errors.New("unexpected query") +} +func (sessionTxnConn) Close() error { return nil } +func (c sessionTxnConn) Begin() (driver.Tx, error) { return sessionTxnHandle(c), nil } + +type sessionTxnHandle struct{ probe *sessionTxnProbe } + +func (t sessionTxnHandle) Commit() error { t.probe.commits++; return nil } +func (t sessionTxnHandle) Rollback() error { t.probe.rollbacks++; return nil } + +func TestSessionTransactionStateUsesTheActualDatabaseContext(t *testing.T) { + probe := &sessionTxnProbe{} + db := sql.OpenDB(sessionTxnConnector{probe}) + t.Cleanup(func() { _ = db.Close() }) + container := NewWithDB(db, "sqlite3", nil) + backend := NewSQLStore(container, types.NewJID("100000000001", types.DefaultUserServer)) + ctx := context.Background() + if backend.SessionTransactionActive(ctx) { + t.Fatal("plain context marked transactional") + } + fault := errors.New("authored rollback") + if err := backend.DoDecryptionTxn(ctx, func(tx context.Context) error { + if !backend.SessionTransactionActive(tx) || !store.SessionTransactionActive(tx) { + t.Error("decryption transaction was not marked") + } + return fault + }); !errors.Is(err, fault) { + t.Fatal(err) + } + if err := container.db.DoTxn(ctx, nil, func(tx context.Context) error { + if !backend.SessionTransactionActive(tx) { + t.Error("raw database transaction was not detected") + } + return nil + }); err != nil { + t.Fatal(err) + } + if probe.commits != 1 || probe.rollbacks != 1 { + t.Fatalf("transaction probe: %+v", probe) + } + if backend.SessionTransactionActive(ctx) || store.SessionTransactionActive(ctx) { + t.Error("transaction state escaped its callback") + } +} diff --git a/store/sqlstore/store.go b/store/sqlstore/store.go index c6861c6e9..c0535d0f2 100644 --- a/store/sqlstore/store.go +++ b/store/sqlstore/store.go @@ -1618,9 +1618,18 @@ func (s *SQLStore) PutBufferedEvent(ctx context.Context, ciphertextHash [32]byte return err } +// SessionTransactionActive also detects transactions opened outside the event +// buffer wrapper, so pending-reset recovery cannot treat them as durable writes. +func (s *SQLStore) SessionTransactionActive(ctx context.Context) bool { + _, active := s.db.Execable(ctx).(dbutil.Transaction) + return active +} + func (s *SQLStore) DoDecryptionTxn(ctx context.Context, fn func(context.Context) error) error { ctx = context.WithValue(ctx, dbutil.ContextKeyDoTxnCallerSkip, 2) - return s.db.DoTxn(ctx, nil, fn) + return s.db.DoTxn(ctx, nil, func(tx context.Context) error { + return fn(store.WithSessionTransaction(tx)) + }) } func (s *SQLStore) ClearBufferedEventPlaintext(ctx context.Context, ciphertextHash [32]byte) error { diff --git a/store/store.go b/store/store.go index 05b8ba7e1..31b41e062 100644 --- a/store/store.go +++ b/store/store.go @@ -44,6 +44,13 @@ type SessionStore interface { MigratePNToLID(ctx context.Context, pn, lid types.JID) error } +// SessionTransactionState is an optional backend capability for transactions +// opened outside the event-buffer wrapper. Custom stores may instead mark +// transaction contexts with WithSessionTransaction. +type SessionTransactionState interface { + SessionTransactionActive(context.Context) bool +} + type PreKeyStore interface { GetOrGenPreKeys(ctx context.Context, count uint32) ([]*keys.PreKey, error) GenOnePreKey(ctx context.Context) (*keys.PreKey, error) From 55d6a8be197793942b8a2a0d0ab62be5f9b20fe2 Mon Sep 17 00:00:00 2001 From: Rajeh Taher Date: Tue, 17 Nov 2026 08:05:40 +0200 Subject: [PATCH 16/16] Keep the SQL identity cache inside its transaction boundary --- README.md | 20 +++ go.mod | 1 + store/sqlstore/identity_transaction_test.go | 116 +++++++++++++++ store/sqlstore/session_transaction_test.go | 61 ++++++++ store/sqlstore/store.go | 151 +++++++++++++------- 5 files changed, 296 insertions(+), 53 deletions(-) create mode 100644 store/sqlstore/identity_transaction_test.go diff --git a/README.md b/README.md index c83de5069..4cc75d71e 100644 --- a/README.md +++ b/README.md @@ -321,3 +321,23 @@ underlying database. Custom transactional SessionStores must expose callbacks must forward that context. Saved buffered plaintext bypasses new preparation and decryption. These are source contracts, not database/crash or previous-release acceptance evidence. + +SQL identity cache and transactions: use `SQLStore.DoDecryptionTxn` for identity +reads or writes inside a database transaction. It owns the commit/rollback boundary, +serializes identity-cache access for that device until completion, clears the +transaction's cache entries afterward and invalidates earlier identity-fetch tokens. +Nested calls with its callback context share that boundary. An externally opened +transaction cannot supply its eventual outcome, so identity operations and nested +`DoDecryptionTxn` calls in that context return `ErrUnmanagedIdentityTransaction` +before accessing the cache or running the callback. Phone-number to LID migration +also owns its transaction boundary and refuses to run inside an outer transaction. +Escaped callback contexts are +also rejected. This does not coordinate other SQLStore instances or processes that +write the same device rows; those require separate store ownership and admission. + +The SQL rollback/replay regression uses a local SQLite database and authored opaque +session bytes, not real account traffic or decrypted Signal sessions. Run it with +CGO enabled: `CGO_ENABLED=1 go test ./store/sqlstore -run TestSQLIdentityRollbackReplay`. +The SQLite driver is a test-only import; the library still does not register a driver +for applications. Cache serialization and guest-session throughput need acceptance +on the composed native candidate before merge. diff --git a/go.mod b/go.mod index bca507e8b..e7e32b9e6 100644 --- a/go.mod +++ b/go.mod @@ -14,6 +14,7 @@ require ( github.com/beeper/argo-go v1.1.2 github.com/coder/websocket v1.8.15 github.com/google/uuid v1.6.0 + github.com/mattn/go-sqlite3 v1.14.52 github.com/polymorfa/libsignal-protocol-go v0.2.3-0.20260806162910-a2adef2e8a11 github.com/rs/zerolog v1.35.1 go.mau.fi/util v0.11.0 diff --git a/store/sqlstore/identity_transaction_test.go b/store/sqlstore/identity_transaction_test.go new file mode 100644 index 000000000..0ae79afba --- /dev/null +++ b/store/sqlstore/identity_transaction_test.go @@ -0,0 +1,116 @@ +//go:build cgo + +// Copyright (c) 2026 Rajeh Taher +// Licensed under the MIT License. See LICENSE-MIT for details. + +package sqlstore_test + +import ( + "context" + "database/sql" + "errors" + "testing" + + _ "github.com/mattn/go-sqlite3" + + "github.com/polymorfa/hypermeow/store" + "github.com/polymorfa/hypermeow/store/sqlstore" + "github.com/polymorfa/hypermeow/types" +) + +// Authored SQL rollback example. Opaque session bytes are not live Signal records. +func TestSQLIdentityRollbackReplay(t *testing.T) { + for _, scope := range []string{"chat", "status"} { + t.Run(scope, func(t *testing.T) { + ctx := context.Background() + db, err := sql.Open("sqlite3", ":memory:") + if err != nil { + t.Fatal(err) + } + defer db.Close() + db.SetMaxOpenConns(1) + for _, q := range []string{ + "CREATE TABLE whatsmeow_identity_keys (our_jid TEXT, their_id TEXT, identity BLOB, PRIMARY KEY(our_jid,their_id))", + "CREATE TABLE whatsmeow_sessions (our_jid TEXT, their_id TEXT, session BLOB, PRIMARY KEY(our_jid,their_id))", + } { + if _, err = db.Exec(q); err != nil { + t.Fatal(err) + } + } + s := sqlstore.NewSQLStore(sqlstore.NewWithDB(db, "sqlite3", nil), types.NewJID("100000000001", types.DefaultUserServer)) + address := "100000000002:1" + a, b := [32]byte{1}, [32]byte{2} + if err = s.PutIdentity(ctx, address, a); err != nil { + t.Fatal(err) + } + for _, key := range []string{address, store.SignalSessionAddress(store.WithStatusSession(ctx), address)} { + if err = s.PutSession(ctx, key, []byte("old")); err != nil { + t.Fatal(err) + } + } + fault := errors.New("authored buffered-event persistence failure") + err = s.DoDecryptionTxn(ctx, func(tx context.Context) error { + if e := s.DeleteIdentity(tx, address); e != nil { + return e + } + if e := s.PutIdentity(tx, address, b); e != nil { + return e + } + key := address + if scope == "status" { + key = store.SignalSessionAddress(store.WithStatusSession(ctx), address) + } + if e := s.PutSession(tx, key, []byte("new")); e != nil { + return e + } + return fault + }) + if !errors.Is(err, fault) { + t.Fatal(err) + } + for _, key := range []string{address, store.SignalSessionAddress(store.WithStatusSession(ctx), address)} { + got, err := s.GetSession(ctx, key) + if err != nil || string(got) != "old" { + t.Fatalf("rollback session %s = %q, %v", key, got, err) + } + } + trusted, err := s.IsTrustedIdentity(ctx, address, b) + if err != nil { + t.Fatal(err) + } + if trusted { + t.Error("rolled-back replacement identity remained trusted") + } + // Replay must write B instead of skipping its write because of stale cache state. + if err = s.DoDecryptionTxn(ctx, func(tx context.Context) error { + if err := s.PutIdentity(tx, address, b); err != nil { + return err + } + keys, generation, err := s.GetManyIdentities(tx, []string{address}) + if err != nil { + return err + } + if keys[address] != b { + t.Fatal("transaction read did not see replacement identity") + } + accepted, err := s.EnsureIdentity(tx, address, b, generation) + if err == nil && !accepted { + t.Fatal("transaction rejected its own stored identity") + } + return err + }); err != nil { + t.Fatal(err) + } + var got []byte + if err = db.QueryRow("SELECT identity FROM whatsmeow_identity_keys WHERE our_jid=? AND their_id=?", s.JID, address).Scan(&got); err != nil { + t.Fatal(err) + } + if trusted, err := s.IsTrustedIdentity(ctx, address, a); err != nil || trusted { + t.Fatalf("committed replacement did not invalidate A: %v, %v", trusted, err) + } + if len(got) != 32 || got[0] != 2 { + t.Errorf("replay persisted identity %x, want B", got) + } + }) + } +} diff --git a/store/sqlstore/session_transaction_test.go b/store/sqlstore/session_transaction_test.go index 78179cf8b..f30bdbd65 100644 --- a/store/sqlstore/session_transaction_test.go +++ b/store/sqlstore/session_transaction_test.go @@ -75,3 +75,64 @@ func TestSessionTransactionStateUsesTheActualDatabaseContext(t *testing.T) { t.Error("transaction state escaped its callback") } } + +func TestIdentityAccessRejectsUnownedOuterTransaction(t *testing.T) { + probe := &sessionTxnProbe{} + db := sql.OpenDB(sessionTxnConnector{probe}) + t.Cleanup(func() { _ = db.Close() }) + container := NewWithDB(db, "sqlite3", nil) + backend := NewSQLStore(container, types.NewJID("100000000001", types.DefaultUserServer)) + err := container.db.DoTxn(context.Background(), nil, func(tx context.Context) error { + callbacks := 0 + if err := backend.DoDecryptionTxn(tx, func(context.Context) error { callbacks++; return nil }); !errors.Is(err, ErrUnmanagedIdentityTransaction) || callbacks != 0 { + t.Fatalf("outer transaction entered callback: %d, %v", callbacks, err) + } + key := [32]byte{1} + operations := []func() error{ + func() error { + return backend.MigratePNToLID(tx, types.NewJID("100000000002", types.DefaultUserServer), types.NewJID("100000000003", types.HiddenUserServer)) + }, + func() error { return backend.PutIdentity(tx, "peer:1", key) }, + func() error { return backend.DeleteIdentity(tx, "peer:1") }, + func() error { return backend.DeleteAllIdentities(tx, "peer") }, + func() error { _, e := backend.IsTrustedIdentity(tx, "peer:1", key); return e }, + func() error { _, _, e := backend.GetManyIdentities(tx, []string{"peer:1"}); return e }, + func() error { _, e := backend.EnsureIdentity(tx, "peer:1", key, 0); return e }, + } + for i, operation := range operations { + if err := operation(); !errors.Is(err, ErrUnmanagedIdentityTransaction) { + t.Errorf("operation %d: %v", i, err) + } + } + return nil + }) + if err != nil { + t.Fatal(err) + } +} + +func TestIdentityTransactionContextCannotEscape(t *testing.T) { + probe := &sessionTxnProbe{} + db := sql.OpenDB(sessionTxnConnector{probe}) + t.Cleanup(func() { _ = db.Close() }) + backend := NewSQLStore(NewWithDB(db, "sqlite3", nil), types.NewJID("100000000001", types.DefaultUserServer)) + var escaped context.Context + if err := backend.DoDecryptionTxn(context.Background(), func(tx context.Context) error { + escaped = tx + return backend.DoDecryptionTxn(tx, func(nested context.Context) error { + _, _, err := backend.GetManyIdentities(nested, nil) + return err + }) + }); err != nil { + t.Fatal(err) + } + if probe.commits != 1 { + t.Fatalf("nested call opened another transaction: %+v", probe) + } + if _, _, err := backend.GetManyIdentities(escaped, nil); !errors.Is(err, ErrUnmanagedIdentityTransaction) { + t.Fatalf("escaped context was accepted: %v", err) + } + if err := backend.DoDecryptionTxn(escaped, func(context.Context) error { t.Fatal("escaped callback ran"); return nil }); !errors.Is(err, ErrUnmanagedIdentityTransaction) { + t.Fatal(err) + } +} diff --git a/store/sqlstore/store.go b/store/sqlstore/store.go index c0535d0f2..c2537019f 100644 --- a/store/sqlstore/store.go +++ b/store/sqlstore/store.go @@ -149,18 +149,15 @@ const ( ) func (s *SQLStore) PutIdentity(ctx context.Context, address string, key [32]byte) error { - s.identityCacheLock.RLock() - cached, ok := s.identityCache[address] - s.identityCacheLock.RUnlock() - if ok && cached.Present && cached.Key == key { - return nil + unlock, err := s.lockIdentityCache(ctx) + if err != nil { + return err } - s.identityCacheLock.Lock() - defer s.identityCacheLock.Unlock() - if cached, ok = s.identityCache[address]; ok && cached.Present && cached.Key == key { + defer unlock() + if cached, ok := s.identityCache[address]; ok && cached.Present && cached.Key == key { return nil } - _, err := s.db.Exec(ctx, putIdentityQuery, s.JID, address, key[:]) + _, err = s.db.Exec(ctx, putIdentityQuery, s.JID, address, key[:]) if err == nil { s.setCachedIdentityLocked(address, identityCacheEntry{Key: key, Present: true}) } @@ -168,10 +165,13 @@ func (s *SQLStore) PutIdentity(ctx context.Context, address string, key [32]byte } func (s *SQLStore) DeleteAllIdentities(ctx context.Context, phone string) error { - s.identityCacheLock.Lock() - defer s.identityCacheLock.Unlock() + unlock, err := s.lockIdentityCache(ctx) + if err != nil { + return err + } + defer unlock() lower, upper := signalAddressRange(phone) - _, err := s.db.Exec(ctx, deleteAllIdentitiesQuery, s.JID, lower, upper) + _, err = s.db.Exec(ctx, deleteAllIdentitiesQuery, s.JID, lower, upper) if err == nil { s.identityDeleteGen++ for address := range s.identityCache { @@ -184,9 +184,12 @@ func (s *SQLStore) DeleteAllIdentities(ctx context.Context, phone string) error } func (s *SQLStore) DeleteIdentity(ctx context.Context, address string) error { - s.identityCacheLock.Lock() - defer s.identityCacheLock.Unlock() - _, err := s.db.Exec(ctx, deleteIdentityQuery, s.JID, address) + unlock, err := s.lockIdentityCache(ctx) + if err != nil { + return err + } + defer unlock() + _, err = s.db.Exec(ctx, deleteIdentityQuery, s.JID, address) if err == nil { s.identityDeleteGen++ s.setCachedIdentityLocked(address, identityCacheEntry{}) @@ -195,19 +198,16 @@ func (s *SQLStore) DeleteIdentity(ctx context.Context, address string) error { } func (s *SQLStore) IsTrustedIdentity(ctx context.Context, address string, key [32]byte) (bool, error) { - s.identityCacheLock.RLock() - cached, ok := s.identityCache[address] - s.identityCacheLock.RUnlock() - if ok { - return !cached.Present || cached.Key == key, nil + unlock, err := s.lockIdentityCache(ctx) + if err != nil { + return false, err } - s.identityCacheLock.Lock() - defer s.identityCacheLock.Unlock() - if cached, ok = s.identityCache[address]; ok { + defer unlock() + if cached, ok := s.identityCache[address]; ok { return !cached.Present || cached.Key == key, nil } var existingIdentity []byte - err := s.db.QueryRow(ctx, getIdentityQuery, s.JID, address).Scan(&existingIdentity) + err = s.db.QueryRow(ctx, getIdentityQuery, s.JID, address).Scan(&existingIdentity) if errors.Is(err, sql.ErrNoRows) { s.setCachedIdentityLocked(address, identityCacheEntry{}) // Trust if not known, it'll be saved automatically later @@ -223,8 +223,11 @@ func (s *SQLStore) IsTrustedIdentity(ctx context.Context, address string, key [3 } func (s *SQLStore) EnsureIdentity(ctx context.Context, address string, key [32]byte, deleteGeneration uint64) (bool, error) { - s.identityCacheLock.Lock() - defer s.identityCacheLock.Unlock() + unlock, err := s.lockIdentityCache(ctx) + if err != nil { + return false, err + } + defer unlock() if deleteGeneration != s.identityDeleteGen { return false, nil } @@ -271,16 +274,17 @@ func (s *SQLStore) queryManyIdentities(ctx context.Context, addresses []string) } func (s *SQLStore) GetManyIdentities(ctx context.Context, addresses []string) (map[string][32]byte, uint64, error) { + unlock, err := s.lockIdentityCache(ctx) + if err != nil { + return nil, 0, err + } + defer unlock() if len(addresses) == 0 { - s.identityCacheLock.RLock() - generation := s.identityDeleteGen - s.identityCacheLock.RUnlock() - return nil, generation, nil + return nil, s.identityDeleteGen, nil } result := make(map[string][32]byte, len(addresses)) missing := make([]string, 0, len(addresses)) seen := make(map[string]struct{}, len(addresses)) - s.identityCacheLock.RLock() generation := s.identityDeleteGen for _, address := range addresses { if _, duplicate := seen[address]; duplicate { @@ -295,25 +299,6 @@ func (s *SQLStore) GetManyIdentities(ctx context.Context, addresses []string) (m missing = append(missing, address) } } - s.identityCacheLock.RUnlock() - if len(missing) == 0 { - return result, generation, nil - } - - s.identityCacheLock.Lock() - defer s.identityCacheLock.Unlock() - generation = s.identityDeleteGen - stillMissing := missing[:0] - for _, address := range missing { - if cached, ok := s.identityCache[address]; ok { - if cached.Present { - result[address] = cached.Key - } - } else { - stillMissing = append(stillMissing, address) - } - } - missing = stillMissing if len(missing) == 0 { return result, generation, nil } @@ -608,6 +593,11 @@ func (s *SQLStore) DeleteSession(ctx context.Context, address string) error { } func (s *SQLStore) MigratePNToLID(ctx context.Context, pn, lid types.JID) error { + // Migration also owns its commit boundary and completion cache. It cannot + // report completion from a nested callback before the outer commit occurs. + if s.SessionTransactionActive(ctx) { + return ErrUnmanagedIdentityTransaction + } pnSignal := pn.SignalAddressUser() s.migratedPNSessionsCacheLock.Lock() _, migrated := s.migratedPNSessionsCache[pnSignal] @@ -627,6 +617,9 @@ func (s *SQLStore) MigratePNToLID(ctx context.Context, pn, lid types.JID) error if migrated || migrating || empty { return nil } + s.identityCacheLock.Lock() + defer s.identityCacheLock.Unlock() + defer func() { s.identityCache = nil; s.identityDeleteGen++ }() var hasPNRows bool var err error lower, upper := signalAddressRange(pnSignal) @@ -684,9 +677,6 @@ func (s *SQLStore) MigratePNToLID(ctx context.Context, pn, lid types.JID) error if err != nil { return err } - s.identityCacheLock.Lock() - clear(s.identityCache) - s.identityCacheLock.Unlock() if sessionsUpdated > 0 || senderKeysUpdated > 0 || identityKeysUpdated > 0 { s.log.Infof("Migrated %d sessions, %d identity keys and %d sender keys from %s to %s", sessionsUpdated, identityKeysUpdated, senderKeysUpdated, pnSignal, lidSignal) } else { @@ -1625,7 +1615,62 @@ func (s *SQLStore) SessionTransactionActive(ctx context.Context) bool { return active } +// ErrUnmanagedIdentityTransaction rejects identity access in a transaction whose +// commit/rollback lifecycle is not owned by this SQLStore. Use DoDecryptionTxn. +var ErrUnmanagedIdentityTransaction = errors.New("identity access requires SQLStore.DoDecryptionTxn") + +type identityTransactionKey struct{ owner *SQLStore } +type identityTransaction struct { + lock sync.Mutex + active bool +} + +func (s *SQLStore) lockIdentityCache(ctx context.Context) (func(), error) { + if tx, ok := ctx.Value(identityTransactionKey{s}).(*identityTransaction); ok { + tx.lock.Lock() + if !tx.active { + tx.lock.Unlock() + return nil, ErrUnmanagedIdentityTransaction + } + return tx.lock.Unlock, nil + } + if s.Container != nil && s.SessionTransactionActive(ctx) { + return nil, ErrUnmanagedIdentityTransaction + } + s.identityCacheLock.Lock() + return s.identityCacheLock.Unlock, nil +} + func (s *SQLStore) DoDecryptionTxn(ctx context.Context, fn func(context.Context) error) error { + if tx, ok := ctx.Value(identityTransactionKey{s}).(*identityTransaction); ok { + tx.lock.Lock() + active := tx.active + tx.lock.Unlock() + if !active { + return ErrUnmanagedIdentityTransaction + } + return fn(ctx) + } + // dbutil nests by calling fn directly. An outer transaction would outlive + // this cache guard, so fail before running the callback in that case. + if s.SessionTransactionActive(ctx) { + return ErrUnmanagedIdentityTransaction + } + // Acquire before BeginTx, never after a transaction might hold row locks. + // This excludes concurrent identity readers/writers until commit or rollback. + s.identityCacheLock.Lock() + defer s.identityCacheLock.Unlock() + tx := &identityTransaction{active: true} + defer func() { + tx.lock.Lock() + defer tx.lock.Unlock() + tx.active = false + // Neither successful nor rolled-back transaction cache entries escape. + s.identityCache = nil + // Invalidate identity fetch tokens even on rollback or commit failure. + s.identityDeleteGen++ + }() + ctx = context.WithValue(ctx, identityTransactionKey{s}, tx) ctx = context.WithValue(ctx, dbutil.ContextKeyDoTxnCallerSkip, 2) return s.db.DoTxn(ctx, nil, func(tx context.Context) error { return fn(store.WithSessionTransaction(tx))