diff --git a/README.md b/README.md index e5a0ef861..4cc75d71e 100644 --- a/README.md +++ b/README.md @@ -82,6 +82,29 @@ 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. 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 `NewsletterMessage.ViewCounts` preserves the reported view definitions, including @@ -264,3 +287,57 @@ 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. + +## 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. +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 +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. + +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. + +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/client.go b/client.go index 7630e473b..4423dc762 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 @@ -1044,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) @@ -1164,7 +1172,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/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/internals.go b/internals.go index b14481b53..024f509b6 100644 --- a/internals.go +++ b/internals.go @@ -231,6 +231,10 @@ func (int *DangerousInternalClient) HandleConnectFailure(ctx context.Context, no int.c.handleConnectFailure(ctx, node) } +func (int *DangerousInternalClient) RefreshCAT(ctx context.Context) { + int.c.refreshCAT(ctx) +} + func (int *DangerousInternalClient) HandleConnectSuccess(ctx context.Context, node *waBinary.Node) { int.c.handleConnectSuccess(ctx, node) } @@ -367,6 +371,10 @@ func (int *DangerousInternalClient) UpdateMessageContactNames(ctx context.Contex int.c.updateMessageContactNames(ctx, info) } +func (int *DangerousInternalClient) HandleStatusMessage(ctx context.Context, node *waBinary.Node) { + int.c.handleStatusMessage(ctx, node) +} + func (int *DangerousInternalClient) HandleUnencryptedMessage(ctx context.Context, node *waBinary.Node) { int.c.handleUnencryptedMessage(ctx, node) } @@ -527,8 +535,8 @@ func (int *DangerousInternalClient) DeleteIdentityChangeState(ctx context.Contex int.c.deleteIdentityChangeState(ctx, from) } -func (int *DangerousInternalClient) HandleAppStateNotification(ctx context.Context, node *waBinary.Node) { - int.c.handleAppStateNotification(ctx, node) +func (int *DangerousInternalClient) HandleAppStateNotification(ctx context.Context, node *waBinary.Node) bool { + return int.c.handleAppStateNotification(ctx, node) } func (int *DangerousInternalClient) HandlePictureNotification(ctx context.Context, node *waBinary.Node) { @@ -655,6 +663,10 @@ func (int *DangerousInternalClient) FetchPreKeysNoError(ctx context.Context, ret return int.c.fetchPreKeysNoError(ctx, retryDevices) } +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) } @@ -767,6 +779,10 @@ func (int *DangerousInternalClient) TryHandleRetryReceipt(ctx context.Context, r int.c.tryHandleRetryReceipt(ctx, receipt, node) } +func (int *DangerousInternalClient) AcceptIncomingRetry(sender types.JID, messageID types.MessageID) bool { + return int.c.acceptIncomingRetry(sender, messageID) +} + func (int *DangerousInternalClient) HandleRetryReceipt(ctx context.Context, receipt *events.Receipt, node *waBinary.Node) error { return int.c.handleRetryReceipt(ctx, receipt, node) } @@ -895,8 +911,12 @@ func (int *DangerousInternalClient) IssuePrivacyToken(ctx context.Context, jid t return int.c.issuePrivacyToken(ctx, jid, timestamp) } -func (int *DangerousInternalClient) RawUpload(ctx context.Context, dataToUpload io.Reader, uploadSize uint64, fileHash []byte, appInfo MediaType, newsletter bool, resp *UploadResponse) error { - return int.c.rawUpload(ctx, dataToUpload, uploadSize, fileHash, appInfo, newsletter, resp) +func (int *DangerousInternalClient) Upload(ctx context.Context, plaintext []byte, appInfo MediaType, mmsType string, mediaKey []byte) (resp UploadResponse, err error) { + return int.c.upload(ctx, plaintext, appInfo, mmsType, mediaKey) +} + +func (int *DangerousInternalClient) RawUpload(ctx context.Context, dataToUpload io.Reader, uploadSize uint64, fileHash []byte, appInfo MediaType, newsletter bool, resp *UploadResponse, mmsTypeOverride ...string) error { + return int.c.rawUpload(ctx, dataToUpload, uploadSize, fileHash, appInfo, newsletter, resp, mmsTypeOverride...) } func (int *DangerousInternalClient) StoreContactUsernamesBestEffort(ctx context.Context, entries []store.ContactUsernameEntry) { diff --git a/message.go b/message.go index 971974d6a..89f55be1e 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) @@ -470,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) { @@ -550,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[:]). @@ -586,18 +612,23 @@ 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.Sessions.DeleteSession(ctx, target.SignalAddress().String()) - 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 } +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. @@ -610,9 +641,28 @@ 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 { - plaintext, err = decrypt(ctx) + 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 + }) return } hasher := sha256.New() @@ -634,7 +684,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(). @@ -645,16 +695,24 @@ func (cli *Client) bufferedDecrypt( return } - err = 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) + err = cli.Store.WithSessionStateLock(ctx, func(ctx context.Context) error { + if prepare != nil { + if prepareErr := prepare(ctx); prepareErr != nil { + return prepareErr + } } - return + return cli.Store.EventBuffer.DoDecryptionTxn(ctx, func(ctx context.Context) (innerErr error) { + ctx = store.WithSessionTransaction(ctx) + 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 + }) }) if err == nil { zerolog.Ctx(ctx).Debug(). @@ -689,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 { @@ -696,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) @@ -707,7 +768,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) } @@ -716,9 +777,9 @@ 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", from.String()) + }, "normal", store.SignalSessionAddress(ctx, from.String())) if err != nil { return nil, nil, fmt.Errorf("failed to decrypt normal message: %w", err) } @@ -1407,7 +1468,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/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) + } + }) + } +} diff --git a/receipt.go b/receipt.go index 8f0b84067..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"), @@ -273,6 +274,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 +288,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_retry_identity_test.go b/remote_retry_identity_test.go new file mode 100644 index 000000000..218cf03ed --- /dev/null +++ b/remote_retry_identity_test.go @@ -0,0 +1,46 @@ +package whatsmeow + +import ( + "bytes" + "context" + "testing" + + waBinary "github.com/polymorfa/hypermeow/binary" + "github.com/polymorfa/hypermeow/types" + "github.com/polymorfa/hypermeow/types/events" +) + +// Authored public-key envelope: these opaque identity bytes are not a live +// packet or a verified signature. Verification belongs to the remote store. +func authoredRemoteBundleNode(jid types.JID, identity []byte) waBinary.Node { + return waBinary.Node{Tag: "user", Attrs: waBinary.Attrs{"jid": jid}, Content: []waBinary.Node{ + {Tag: "registration", Content: []byte{0, 0, 0, 1}}, + {Tag: "identity", Content: testRemoteIdentity.IdentityKey[:]}, + {Tag: "skey", Content: []waBinary.Node{ + {Tag: "id", Content: []byte{0, 0, 1}}, + {Tag: "value", Content: testRemoteIdentity.SignedPreKey[:]}, + {Tag: "signature", Content: testRemoteIdentity.SignedPreKeySignature[:]}, + }}, + {Tag: "device-identity", Content: identity}, + }} +} + +func TestRemoteRetryPreservesCompanionIdentity(t *testing.T) { + cli, remote, _ := newTestRemote(t) + requester := types.JID{User: "200000000002", Device: 2, Server: types.HiddenUserServer} + remote.resendWith = marshalStanza(t, waBinary.Node{Tag: "message", Attrs: waBinary.Attrs{"id": "authored-retry", "to": requester, "type": "text"}}) + identity := []byte("authored retry identity") + bundleNode := authoredRemoteBundleNode(requester, identity) + bundle := bundleNode.GetChildren() + receipt := &events.Receipt{MessageSource: types.MessageSource{Chat: requester.ToNonAD(), Sender: requester}} + node := &waBinary.Node{Tag: "receipt", Attrs: waBinary.Attrs{"id": "authored-retry", "from": requester, "type": "retry"}, Content: []waBinary.Node{ + {Tag: "retry", Attrs: waBinary.Attrs{"id": "authored-retry", "t": "1700000000", "count": "1"}}, + bundle[0], {Tag: "keys", Content: bundle[1:]}, + }} + if err := cli.handleRetryReceipt(context.Background(), receipt, node); err != nil { + t.Fatal(err) + } + if len(remote.resends) != 1 || remote.resends[0].Bundle == nil || !bytes.Equal(remote.resends[0].DeviceIdentity, identity) { + t.Fatal("lost retry companion identity") + } +} diff --git a/remote_signal.go b/remote_signal.go index e6c22d45b..f364c0c3e 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 @@ -107,10 +110,16 @@ 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. 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 @@ -153,10 +162,12 @@ func (e *RemoteDecryptError) Unwrap() error { return e.Err } // RemoteResend asks the remote store to re-encrypt a sent message. type RemoteResend struct { - Chat types.JID - MessageID types.MessageID - Requester types.JID - EncryptionJID types.JID + // DeviceIdentity accompanies the public bundle in a retry receipt. + DeviceIdentity []byte + Chat types.JID + MessageID types.MessageID + Requester types.JID + EncryptionJID types.JID // Recipient is the original chat user when the requester is one of this // account's own devices on a direct message. Recipient types.JID @@ -351,6 +362,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,8 +418,14 @@ 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, + StatusKind: info.StatusKind(), + StatusSession: encType != "skmsg" && cli.usesStatusSession(info), SenderAlt: senderAlt, Chat: info.Chat, Sender: senderEncryptionJID, @@ -403,6 +434,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) @@ -448,6 +480,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, @@ -520,6 +556,7 @@ func (cli *Client) handleRetryReceiptRemote(ctx context.Context, receipt *events return fmt.Errorf("failed to read prekey bundle in retry receipt: %w", err) } req.Bundle = bundle + req.DeviceIdentity = append([]byte(nil), preKeyDeviceIdentity(*node)...) } if hostedSender, ok := rawHostedSender(node); ok { req.EncryptionJID = cli.hostedSignalJID(ctx, hostedSender) 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) diff --git a/send.go b/send.go index 5fb006be4..16aa3158c 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" ) @@ -1473,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 @@ -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/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 new file mode 100644 index 000000000..4b5e5b454 --- /dev/null +++ b/session_cache_reset_test.go @@ -0,0 +1,144 @@ +// Copyright (c) 2026 Rajeh Taher +// +// Licensed under the MIT License. See LICENSE-MIT for details. + +package whatsmeow + +import ( + "context" + "errors" + "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") + } +} + +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/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/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/status_message_test.go b/status_message_test.go new file mode 100644 index 000000000..17c9dd9a4 --- /dev/null +++ b/status_message_test.go @@ -0,0 +1,421 @@ +package whatsmeow + +import ( + "bytes" + "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/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) + } + } + 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) { + 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"}}) + identity := []byte("authored status companion identity") + node.Content = append(node.GetChildren(), waBinary.Node{Tag: "device-identity", Content: identity}) + 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 !bytes.Equal(remote.receives[0].DeviceIdentity, identity) { + t.Fatal("lost status companion identity") + } + 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{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") + } + if isPublication && evt.Message != content { + t.Fatal("group status content not unwrapped") + } + } +} + +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) + } + } +} + +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") + } +} + +// 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") + } + } +} + +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)) + } + }) + } +} 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/sessioncache.go b/store/sessioncache.go index 8ea28a37a..29a180ded 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,74 @@ 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 { - 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 + owner *Device } -type sessionCache = exsync.Map[string, sessionCacheEntry] +type sessionStateGuard struct { + device *Device + parent *sessionStateGuard +} + +// WithSessionStateLock orders local session mutations before database transactions. +// 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 { + 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, &sessionStateGuard{device: device, parent: held})) +} type sessionIterator interface { IterateSessions(context.Context, []string, func(string, []byte) error) error @@ -38,7 +98,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 } @@ -46,14 +106,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 } @@ -64,8 +124,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 } @@ -73,28 +133,78 @@ 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 } + 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 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 { + 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 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 device.reconcilePendingSession(ctx, address) +} + 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, device)), nil +} + +func (device *Device) withCachedSessions(ctx context.Context, addresses []string) (map[string]bool, context.Context, error) { + if len(addresses) == 0 { + 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 err := device.reconcilePendingSession(ctx, address); err != nil { + return nil, ctx, err + } + } 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 +218,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 +237,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, owner: device}) return existingSessions, ctx, nil } func (device *Device) PutCachedSessions(ctx context.Context) error { - cache := getSessionCache(ctx) + return device.WithSessionStateLock(ctx, device.putCachedSessions) +} + +func (device *Device) putCachedSessions(ctx context.Context) error { + cache := getSessionCache(ctx, device) if cache == nil { return nil } dirtySessions := make(map[string][]byte) + invalid := false for addr, item := range cache.Iter() { if item.Dirty { + if device.checkCachedSession(ctx, addr) != nil { + 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_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/sessioncache_pending_test.go b/store/sessioncache_pending_test.go new file mode 100644 index 000000000..30c925762 --- /dev/null +++ b/store/sessioncache_pending_test.go @@ -0,0 +1,85 @@ +// 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 TestFailedIdentityResetBudgetRetainsAndRecoversUnsafeRows(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 _, 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") + } + backend.failDelete = "" + 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"}); err != nil { + t.Fatalf("recovered Device remains blocked: %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/sessioncache_recovery_controls_test.go b/store/sessioncache_recovery_controls_test.go new file mode 100644 index 000000000..0d5f9c072 --- /dev/null +++ b/store/sessioncache_recovery_controls_test.go @@ -0,0 +1,146 @@ +// 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") + } +} + +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/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/sessioncache_reset_test.go b/store/sessioncache_reset_test.go new file mode 100644 index 000000000..e056f4ca3 --- /dev/null +++ b/store/sessioncache_reset_test.go @@ -0,0 +1,361 @@ +// Copyright (c) 2026 Rajeh Taher +// +// Licensed under the MIT License. See LICENSE-MIT for details. + +package store + +import ( + "bytes" + "context" + "errors" + "fmt" + "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") + } +} + +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") + } +} + +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 728289bcf..389dfc4eb 100644 --- a/store/signal.go +++ b/store/signal.go @@ -97,8 +97,20 @@ 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() - if sess := getCachedSession(ctx, addrString); sess != nil { + 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,8 +148,17 @@ 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() - if putCachedSession(ctx, addrString, record) { + 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,8 +170,20 @@ 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() - if found, cached := hasCachedSession(ctx, addrString); cached { + 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 } hasSession, err := device.Sessions.HasSession(ctx, addrString) @@ -161,13 +194,210 @@ func (device *Device) ContainsSession(ctx context.Context, remoteAddress *protoc } func (device *Device) DeleteSession(ctx context.Context, remoteAddress *protocol.SignalAddress) error { - addrString := remoteAddress.String() - if err := device.Sessions.DeleteSession(ctx, addrString); err != nil { - return fmt.Errorf("failed to delete session with %s: %w", addrString, err) + 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) + } + return nil + }) +} + +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 || device.sessionTransactionActive(ctx) { + return ErrSessionCacheInvalidated + } + state.active++ + device.sessionResetPending[key] = state + err := device.Sessions.DeleteSession(ctx, key) + device.finishSessionResetDeletion(key, err) + 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 } +// 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. +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"} + 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 + } + device.sessionResetEpoch++ + if device.sessionResetAddresses == nil { + device.sessionResetAddresses = make(map[string]uint64) + } + if len(device.sessionResetAddresses)+len(keys) > maxSessionResetAddresses { + device.sessionResetFloor = device.sessionResetEpoch + clear(device.sessionResetAddresses) + } + if device.sessionResetPending == nil { + 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 + for _, key := range keys { + 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)) + } + } + if deleteErr != nil { + return errors.Join(ErrSessionCacheInvalidated, deleteErr) + } + 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)}) + } + } + return nil + }) +} + func (device *Device) DeleteAllSessions(ctx context.Context) error { return fmt.Errorf("DeleteAllSessions: %w", ErrUnsupportedSignalStoreOperation) } 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 new file mode 100644 index 000000000..f30bdbd65 --- /dev/null +++ b/store/sqlstore/session_transaction_test.go @@ -0,0 +1,138 @@ +// 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") + } +} + +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 c3f0215ba..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 { @@ -1585,7 +1575,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 +1592,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 { @@ -1618,9 +1608,73 @@ 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 +} + +// 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, 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 { @@ -1628,6 +1682,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/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/store/store.go b/store/store.go index af14dd195..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) @@ -183,9 +190,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 { @@ -293,6 +308,12 @@ type Device struct { LIDs LIDStore Container DeviceContainer + sessionStateLock sync.Mutex + sessionResetEpoch uint64 + sessionResetAddresses map[string]uint64 + sessionResetFloor uint64 + sessionResetPending map[string]pendingSessionReset + saveDeleteLockInit sync.Once saveDeleteLock chan struct{} } diff --git a/types/events/events.go b/types/events/events.go index 41a566917..cc6c36bfd 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 = evt.Info.Chat.Server == types.GroupServer + evt.Message = child + } if evt.Message.GetEphemeralMessage().GetMessage() != nil { evt.Message = evt.Message.GetEphemeralMessage().GetMessage() evt.IsEphemeral = true @@ -514,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 diff --git a/types/message.go b/types/message.go index 57ecfdd1c..4dda54c63 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 && info.Chat.Server == GroupServer { + return StatusKindGroup + } + if info.Chat == StatusBroadcastJID { + return StatusKindPersonal + } + return "" +}