slidge-whatsapp 0.2.2__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.7__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/notification.go

@@ -0,0 +1,457 @@
+// Copyright (c) 2021 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package whatsmeow
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"slices"
+
+	"google.golang.org/protobuf/proto"
+
+	"go.mau.fi/whatsmeow/appstate"
+	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/proto/waE2E"
+	"go.mau.fi/whatsmeow/store"
+	"go.mau.fi/whatsmeow/types"
+	"go.mau.fi/whatsmeow/types/events"
+)
+
+func (cli *Client) handleEncryptNotification(ctx context.Context, node *waBinary.Node) {
+	from := node.AttrGetter().JID("from")
+	if from == types.ServerJID {
+		count := node.GetChildByTag("count")
+		ag := count.AttrGetter()
+		otksLeft := ag.Int("value")
+		if !ag.OK() {
+			cli.Log.Warnf("Didn't get number of OTKs left in encryption notification %s", node.XMLString())
+			return
+		}
+		cli.Log.Infof("Got prekey count from server: %s", node.XMLString())
+		if otksLeft < MinPreKeyCount {
+			cli.uploadPreKeys(ctx)
+		}
+	} else if _, ok := node.GetOptionalChildByTag("identity"); ok {
+		cli.Log.Debugf("Got identity change for %s: %s, deleting all identities/sessions for that number", from, node.XMLString())
+		err := cli.Store.Identities.DeleteAllIdentities(ctx, from.User)
+		if err != nil {
+			cli.Log.Warnf("Failed to delete all identities of %s from store after identity change: %v", from, err)
+		}
+		err = cli.Store.Sessions.DeleteAllSessions(ctx, from.User)
+		if err != nil {
+			cli.Log.Warnf("Failed to delete all sessions of %s from store after identity change: %v", from, err)
+		}
+		ts := node.AttrGetter().UnixTime("t")
+		cli.dispatchEvent(&events.IdentityChange{JID: from, Timestamp: ts})
+	} else {
+		cli.Log.Debugf("Got unknown encryption notification from server: %s", node.XMLString())
+	}
+}
+
+func (cli *Client) handleAppStateNotification(ctx context.Context, node *waBinary.Node) {
+	for _, collection := range node.GetChildrenByTag("collection") {
+		ag := collection.AttrGetter()
+		name := appstate.WAPatchName(ag.String("name"))
+		version := ag.Uint64("version")
+		cli.Log.Debugf("Got server sync notification that app state %s has updated to version %d", name, version)
+		err := cli.FetchAppState(ctx, name, false, false)
+		if errors.Is(err, ErrIQDisconnected) || errors.Is(err, ErrNotConnected) {
+			// There are some app state changes right before a remote logout, so stop syncing if we're disconnected.
+			cli.Log.Debugf("Failed to sync app state after notification: %v, not trying to sync other states", err)
+			return
+		} else if err != nil {
+			cli.Log.Errorf("Failed to sync app state after notification: %v", err)
+		}
+	}
+}
+
+func (cli *Client) handlePictureNotification(ctx context.Context, node *waBinary.Node) {
+	ts := node.AttrGetter().UnixTime("t")
+	for _, child := range node.GetChildren() {
+		ag := child.AttrGetter()
+		var evt events.Picture
+		evt.Timestamp = ts
+		evt.JID = ag.JID("jid")
+		evt.Author = ag.OptionalJIDOrEmpty("author")
+		if child.Tag == "delete" {
+			evt.Remove = true
+		} else if child.Tag == "add" {
+			evt.PictureID = ag.String("id")
+		} else if child.Tag == "set" {
+			// TODO sometimes there's a hash and no ID?
+			evt.PictureID = ag.String("id")
+		} else {
+			continue
+		}
+		if !ag.OK() {
+			cli.Log.Debugf("Ignoring picture change notification with unexpected attributes: %v", ag.Error())
+			continue
+		}
+		cli.dispatchEvent(&evt)
+	}
+}
+
+func (cli *Client) handleDeviceNotification(ctx context.Context, node *waBinary.Node) {
+	cli.userDevicesCacheLock.Lock()
+	defer cli.userDevicesCacheLock.Unlock()
+	ag := node.AttrGetter()
+	from := ag.JID("from")
+	fromLID := ag.OptionalJID("lid")
+	if fromLID != nil {
+		cli.StoreLIDPNMapping(ctx, *fromLID, from)
+	}
+	cached, ok := cli.userDevicesCache[from]
+	if !ok {
+		cli.Log.Debugf("No device list cached for %s, ignoring device list notification", from)
+		return
+	}
+	var cachedLID deviceCache
+	var cachedLIDHash string
+	if fromLID != nil {
+		cachedLID = cli.userDevicesCache[*fromLID]
+		cachedLIDHash = participantListHashV2(cachedLID.devices)
+	}
+	cachedParticipantHash := participantListHashV2(cached.devices)
+	for _, child := range node.GetChildren() {
+		if child.Tag != "add" && child.Tag != "remove" {
+			cli.Log.Debugf("Unknown device list change tag %s", child.Tag)
+			continue
+		}
+		cag := child.AttrGetter()
+		deviceHash := cag.String("device_hash")
+		deviceLIDHash := cag.OptionalString("device_lid_hash")
+		deviceChild, _ := child.GetOptionalChildByTag("device")
+		changedDeviceJID := deviceChild.AttrGetter().JID("jid")
+		changedDeviceLID := deviceChild.AttrGetter().OptionalJID("lid")
+		switch child.Tag {
+		case "add":
+			cached.devices = append(cached.devices, changedDeviceJID)
+			if changedDeviceLID != nil {
+				cachedLID.devices = append(cachedLID.devices, *changedDeviceLID)
+			}
+		case "remove":
+			cached.devices = slices.DeleteFunc(cached.devices, func(existing types.JID) bool {
+				return existing == changedDeviceJID
+			})
+			if changedDeviceLID != nil {
+				cachedLID.devices = slices.DeleteFunc(cachedLID.devices, func(existing types.JID) bool {
+					return existing == *changedDeviceLID
+				})
+			}
+		case "update":
+			// ???
+		}
+		newParticipantHash := participantListHashV2(cached.devices)
+		if newParticipantHash == deviceHash {
+			cli.Log.Debugf("%s's device list hash changed from %s to %s (%s). New hash matches", from, cachedParticipantHash, deviceHash, child.Tag)
+			cli.userDevicesCache[from] = cached
+		} else {
+			cli.Log.Warnf("%s's device list hash changed from %s to %s (%s). New hash doesn't match (%s)", from, cachedParticipantHash, deviceHash, child.Tag, newParticipantHash)
+			delete(cli.userDevicesCache, from)
+		}
+		if fromLID != nil && changedDeviceLID != nil && deviceLIDHash != "" {
+			newLIDParticipantHash := participantListHashV2(cachedLID.devices)
+			if newLIDParticipantHash == deviceLIDHash {
+				cli.Log.Debugf("%s's device list hash changed from %s to %s (%s). New hash matches", fromLID, cachedLIDHash, deviceLIDHash, child.Tag)
+				cli.userDevicesCache[*fromLID] = cachedLID
+			} else {
+				cli.Log.Warnf("%s's device list hash changed from %s to %s (%s). New hash doesn't match (%s)", fromLID, cachedLIDHash, deviceLIDHash, child.Tag, newLIDParticipantHash)
+				delete(cli.userDevicesCache, *fromLID)
+			}
+		}
+	}
+}
+
+func (cli *Client) handleFBDeviceNotification(ctx context.Context, node *waBinary.Node) {
+	cli.userDevicesCacheLock.Lock()
+	defer cli.userDevicesCacheLock.Unlock()
+	jid := node.AttrGetter().JID("from")
+	userDevices := parseFBDeviceList(jid, node.GetChildByTag("devices"))
+	cli.userDevicesCache[jid] = userDevices
+}
+
+func (cli *Client) handleOwnDevicesNotification(ctx context.Context, node *waBinary.Node) {
+	cli.userDevicesCacheLock.Lock()
+	defer cli.userDevicesCacheLock.Unlock()
+	ownID := cli.getOwnID().ToNonAD()
+	if ownID.IsEmpty() {
+		cli.Log.Debugf("Ignoring own device change notification, session was deleted")
+		return
+	}
+	cached, ok := cli.userDevicesCache[ownID]
+	if !ok {
+		cli.Log.Debugf("Ignoring own device change notification, device list not cached")
+		return
+	}
+	oldHash := participantListHashV2(cached.devices)
+	expectedNewHash := node.AttrGetter().String("dhash")
+	var newDeviceList []types.JID
+	for _, child := range node.GetChildren() {
+		jid := child.AttrGetter().JID("jid")
+		if child.Tag == "device" && !jid.IsEmpty() {
+			newDeviceList = append(newDeviceList, jid)
+		}
+	}
+	newHash := participantListHashV2(newDeviceList)
+	if newHash != expectedNewHash {
+		cli.Log.Debugf("Received own device list change notification %s -> %s, but expected hash was %s", oldHash, newHash, expectedNewHash)
+		delete(cli.userDevicesCache, ownID)
+	} else {
+		cli.Log.Debugf("Received own device list change notification %s -> %s", oldHash, newHash)
+		cli.userDevicesCache[ownID] = deviceCache{devices: newDeviceList, dhash: expectedNewHash}
+	}
+}
+
+func (cli *Client) handleBlocklist(ctx context.Context, node *waBinary.Node) {
+	ag := node.AttrGetter()
+	evt := events.Blocklist{
+		Action:    events.BlocklistAction(ag.OptionalString("action")),
+		DHash:     ag.String("dhash"),
+		PrevDHash: ag.OptionalString("prev_dhash"),
+	}
+	for _, child := range node.GetChildren() {
+		ag := child.AttrGetter()
+		change := events.BlocklistChange{
+			JID:    ag.JID("jid"),
+			Action: events.BlocklistChangeAction(ag.String("action")),
+		}
+		if !ag.OK() {
+			cli.Log.Warnf("Unexpected data in blocklist event child %v: %v", child.XMLString(), ag.Error())
+			continue
+		}
+		evt.Changes = append(evt.Changes, change)
+	}
+	cli.dispatchEvent(&evt)
+}
+
+func (cli *Client) handleAccountSyncNotification(ctx context.Context, node *waBinary.Node) {
+	for _, child := range node.GetChildren() {
+		switch child.Tag {
+		case "privacy":
+			cli.handlePrivacySettingsNotification(ctx, &child)
+		case "devices":
+			cli.handleOwnDevicesNotification(ctx, &child)
+		case "picture":
+			cli.dispatchEvent(&events.Picture{
+				Timestamp: node.AttrGetter().UnixTime("t"),
+				JID:       cli.getOwnID().ToNonAD(),
+			})
+		case "blocklist":
+			cli.handleBlocklist(ctx, &child)
+		default:
+			cli.Log.Debugf("Unhandled account sync item %s", child.Tag)
+		}
+	}
+}
+
+func (cli *Client) handlePrivacyTokenNotification(ctx context.Context, node *waBinary.Node) {
+	ownJID := cli.getOwnID().ToNonAD()
+	ownLID := cli.getOwnLID().ToNonAD()
+	if ownJID.IsEmpty() {
+		cli.Log.Debugf("Ignoring privacy token notification, session was deleted")
+		return
+	}
+	tokens := node.GetChildByTag("tokens")
+	if tokens.Tag != "tokens" {
+		cli.Log.Warnf("privacy_token notification didn't contain <tokens> tag")
+		return
+	}
+	parentAG := node.AttrGetter()
+	sender := parentAG.JID("from")
+	if !parentAG.OK() {
+		cli.Log.Warnf("privacy_token notification didn't have a sender (%v)", parentAG.Error())
+		return
+	}
+	for _, child := range tokens.GetChildren() {
+		ag := child.AttrGetter()
+		if child.Tag != "token" {
+			cli.Log.Warnf("privacy_token notification contained unexpected <%s> tag", child.Tag)
+		} else if targetUser := ag.JID("jid"); targetUser != ownLID && targetUser != ownJID {
+			// Don't log about own privacy tokens for other users
+			if sender != ownJID && sender != ownLID {
+				cli.Log.Warnf("privacy_token notification contained token for different user %s", targetUser)
+			}
+		} else if tokenType := ag.String("type"); tokenType != "trusted_contact" {
+			cli.Log.Warnf("privacy_token notification contained unexpected token type %s", tokenType)
+		} else if token, ok := child.Content.([]byte); !ok {
+			cli.Log.Warnf("privacy_token notification contained non-binary token")
+		} else {
+			timestamp := ag.UnixTime("t")
+			if !ag.OK() {
+				cli.Log.Warnf("privacy_token notification is missing some fields: %v", ag.Error())
+			}
+			err := cli.Store.PrivacyTokens.PutPrivacyTokens(ctx, store.PrivacyToken{
+				User:      sender,
+				Token:     token,
+				Timestamp: timestamp,
+			})
+			if err != nil {
+				cli.Log.Errorf("Failed to save privacy token from %s: %v", sender, err)
+			} else {
+				cli.Log.Debugf("Stored privacy token from %s (ts: %v)", sender, timestamp)
+			}
+		}
+	}
+}
+
+func (cli *Client) parseNewsletterMessages(node *waBinary.Node) []*types.NewsletterMessage {
+	children := node.GetChildren()
+	output := make([]*types.NewsletterMessage, 0, len(children))
+	for _, child := range children {
+		if child.Tag != "message" {
+			continue
+		}
+		ag := child.AttrGetter()
+		msg := types.NewsletterMessage{
+			MessageServerID: ag.Int("server_id"),
+			MessageID:       ag.String("id"),
+			Type:            ag.String("type"),
+			Timestamp:       ag.UnixTime("t"),
+			ViewsCount:      0,
+			ReactionCounts:  nil,
+		}
+		for _, subchild := range child.GetChildren() {
+			switch subchild.Tag {
+			case "plaintext":
+				byteContent, ok := subchild.Content.([]byte)
+				if ok {
+					msg.Message = new(waE2E.Message)
+					err := proto.Unmarshal(byteContent, msg.Message)
+					if err != nil {
+						cli.Log.Warnf("Failed to unmarshal newsletter message: %v", err)
+						msg.Message = nil
+					}
+				}
+			case "views_count":
+				msg.ViewsCount = subchild.AttrGetter().Int("count")
+			case "reactions":
+				msg.ReactionCounts = make(map[string]int)
+				for _, reaction := range subchild.GetChildren() {
+					rag := reaction.AttrGetter()
+					msg.ReactionCounts[rag.String("code")] = rag.Int("count")
+				}
+			}
+		}
+		output = append(output, &msg)
+	}
+	return output
+}
+
+func (cli *Client) handleNewsletterNotification(ctx context.Context, node *waBinary.Node) {
+	ag := node.AttrGetter()
+	liveUpdates := node.GetChildByTag("live_updates")
+	cli.dispatchEvent(&events.NewsletterLiveUpdate{
+		JID:      ag.JID("from"),
+		Time:     ag.UnixTime("t"),
+		Messages: cli.parseNewsletterMessages(&liveUpdates),
+	})
+}
+
+type newsLetterEventWrapper struct {
+	Data newsletterEvent `json:"data"`
+}
+
+type newsletterEvent struct {
+	Join       *events.NewsletterJoin       `json:"xwa2_notify_newsletter_on_join"`
+	Leave      *events.NewsletterLeave      `json:"xwa2_notify_newsletter_on_leave"`
+	MuteChange *events.NewsletterMuteChange `json:"xwa2_notify_newsletter_on_mute_change"`
+	// _on_admin_metadata_update -> id, thread_metadata, messages
+	// _on_metadata_update
+	// _on_state_change -> id, is_requestor, state
+}
+
+func (cli *Client) handleMexNotification(ctx context.Context, node *waBinary.Node) {
+	for _, child := range node.GetChildren() {
+		if child.Tag != "update" {
+			continue
+		}
+		childData, ok := child.Content.([]byte)
+		if !ok {
+			continue
+		}
+		var wrapper newsLetterEventWrapper
+		err := json.Unmarshal(childData, &wrapper)
+		if err != nil {
+			cli.Log.Errorf("Failed to unmarshal JSON in mex event: %v", err)
+			continue
+		}
+		if wrapper.Data.Join != nil {
+			cli.dispatchEvent(wrapper.Data.Join)
+		} else if wrapper.Data.Leave != nil {
+			cli.dispatchEvent(wrapper.Data.Leave)
+		} else if wrapper.Data.MuteChange != nil {
+			cli.dispatchEvent(wrapper.Data.MuteChange)
+		}
+	}
+}
+
+func (cli *Client) handleStatusNotification(ctx context.Context, node *waBinary.Node) {
+	ag := node.AttrGetter()
+	child, found := node.GetOptionalChildByTag("set")
+	if !found {
+		cli.Log.Debugf("Status notifcation did not contain child with tag 'set'")
+		return
+	}
+	status, ok := child.Content.([]byte)
+	if !ok {
+		cli.Log.Warnf("Set status notification has unexpected content (%T)", child.Content)
+		return
+	}
+	cli.dispatchEvent(&events.UserAbout{
+		JID:       ag.JID("from"),
+		Timestamp: ag.UnixTime("t"),
+		Status:    string(status),
+	})
+}
+
+func (cli *Client) handleNotification(node *waBinary.Node) {
+	ctx := cli.BackgroundEventCtx
+	ag := node.AttrGetter()
+	notifType := ag.String("type")
+	if !ag.OK() {
+		return
+	}
+	var cancelled bool
+	defer cli.maybeDeferredAck(ctx, node)(&cancelled)
+	switch notifType {
+	case "encrypt":
+		go cli.handleEncryptNotification(ctx, node)
+	case "server_sync":
+		go cli.handleAppStateNotification(ctx, node)
+	case "account_sync":
+		go cli.handleAccountSyncNotification(ctx, node)
+	case "devices":
+		cli.handleDeviceNotification(ctx, node)
+	case "fbid:devices":
+		cli.handleFBDeviceNotification(ctx, node)
+	case "w:gp2":
+		evt, err := cli.parseGroupNotification(node)
+		if err != nil {
+			cli.Log.Errorf("Failed to parse group notification: %v", err)
+		} else {
+			cancelled = cli.dispatchEvent(evt)
+		}
+	case "picture":
+		cli.handlePictureNotification(ctx, node)
+	case "mediaretry":
+		cli.handleMediaRetryNotification(ctx, node)
+	case "privacy_token":
+		cli.handlePrivacyTokenNotification(ctx, node)
+	case "link_code_companion_reg":
+		go cli.tryHandleCodePairNotification(ctx, node)
+	case "newsletter":
+		cli.handleNewsletterNotification(ctx, node)
+	case "mex":
+		cli.handleMexNotification(ctx, node)
+	case "status":
+		cli.handleStatusNotification(ctx, node)
+	// Other types: business, disappearing_mode, server, status, pay, psa
+	default:
+		cli.Log.Debugf("Unhandled notification with type %s", notifType)
+	}
+}

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/pair-code.go

@@ -0,0 +1,245 @@
+// Copyright (c) 2023 Tulir Asokan
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package whatsmeow
+
+import (
+	"context"
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/sha256"
+	"encoding/base32"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"go.mau.fi/util/random"
+	"golang.org/x/crypto/curve25519"
+	"golang.org/x/crypto/pbkdf2"
+
+	waBinary "go.mau.fi/whatsmeow/binary"
+	"go.mau.fi/whatsmeow/types"
+	"go.mau.fi/whatsmeow/util/hkdfutil"
+	"go.mau.fi/whatsmeow/util/keys"
+)
+
+// PairClientType is the type of client to use with PairCode.
+// The type is automatically filled based on store.DeviceProps.PlatformType (which is what QR login uses).
+type PairClientType int
+
+const (
+	PairClientUnknown PairClientType = iota
+	PairClientChrome
+	PairClientEdge
+	PairClientFirefox
+	PairClientIE
+	PairClientOpera
+	PairClientSafari
+	PairClientElectron
+	PairClientUWP
+	PairClientOtherWebClient
+)
+
+var notNumbers = regexp.MustCompile("[^0-9]")
+var linkingBase32 = base32.NewEncoding("123456789ABCDEFGHJKLMNPQRSTVWXYZ")
+
+type phoneLinkingCache struct {
+	jid         types.JID
+	keyPair     *keys.KeyPair
+	linkingCode string
+	pairingRef  string
+}
+
+func generateCompanionEphemeralKey() (ephemeralKeyPair *keys.KeyPair, ephemeralKey []byte, encodedLinkingCode string) {
+	ephemeralKeyPair = keys.NewKeyPair()
+	salt := random.Bytes(32)
+	iv := random.Bytes(16)
+	linkingCode := random.Bytes(5)
+	encodedLinkingCode = linkingBase32.EncodeToString(linkingCode)
+	linkCodeKey := pbkdf2.Key([]byte(encodedLinkingCode), salt, 2<<16, 32, sha256.New)
+	linkCipherBlock, _ := aes.NewCipher(linkCodeKey)
+	encryptedPubkey := ephemeralKeyPair.Pub[:]
+	cipher.NewCTR(linkCipherBlock, iv).XORKeyStream(encryptedPubkey, encryptedPubkey)
+	ephemeralKey = make([]byte, 80)
+	copy(ephemeralKey[0:32], salt)
+	copy(ephemeralKey[32:48], iv)
+	copy(ephemeralKey[48:80], encryptedPubkey)
+	return
+}
+
+// PairPhone generates a pairing code that can be used to link to a phone without scanning a QR code.
+//
+// You must connect the client normally before calling this (which means you'll also receive a QR code
+// event, but that can be ignored when doing code pairing). You should also wait for `*events.QR` before
+// calling this to ensure the connection is fully established. If using [Client.GetQRChannel], wait for
+// the first item in the channel. Alternatively, sleeping for a second after calling Connect will probably work too.
+//
+// The exact expiry of pairing codes is unknown, but QR codes are always generated and the login websocket is closed
+// after the QR codes run out, which means there's a 160-second time limit. It is recommended to generate the pairing
+// code immediately after connecting to the websocket to have the maximum time.
+//
+// The clientType parameter must be one of the PairClient* constants, but which one doesn't matter.
+// The client display name must be formatted as `Browser (OS)`, and only common browsers/OSes are allowed
+// (the server will validate it and return 400 if it's wrong).
+//
+// See https://faq.whatsapp.com/1324084875126592 for more info
+func (cli *Client) PairPhone(ctx context.Context, phone string, showPushNotification bool, clientType PairClientType, clientDisplayName string) (string, error) {
+	if cli == nil {
+		return "", ErrClientIsNil
+	}
+	ephemeralKeyPair, ephemeralKey, encodedLinkingCode := generateCompanionEphemeralKey()
+	phone = notNumbers.ReplaceAllString(phone, "")
+	if len(phone) <= 6 {
+		return "", fmt.Errorf("phone number too short")
+	} else if strings.HasPrefix(phone, "0") {
+		return "", fmt.Errorf("international phone number required (must not start with 0)")
+	}
+	jid := types.NewJID(phone, types.DefaultUserServer)
+	resp, err := cli.sendIQ(infoQuery{
+		Namespace: "md",
+		Type:      iqSet,
+		To:        types.ServerJID,
+		Context:   ctx,
+		Content: []waBinary.Node{{
+			Tag: "link_code_companion_reg",
+			Attrs: waBinary.Attrs{
+				"jid":   jid,
+				"stage": "companion_hello",
+
+				"should_show_push_notification": strconv.FormatBool(showPushNotification),
+			},
+			Content: []waBinary.Node{
+				{Tag: "link_code_pairing_wrapped_companion_ephemeral_pub", Content: ephemeralKey},
+				{Tag: "companion_server_auth_key_pub", Content: cli.Store.NoiseKey.Pub[:]},
+				{Tag: "companion_platform_id", Content: strconv.Itoa(int(clientType))},
+				{Tag: "companion_platform_display", Content: clientDisplayName},
+				{Tag: "link_code_pairing_nonce", Content: []byte{0}},
+			},
+		}},
+	})
+	if err != nil {
+		return "", err
+	}
+	pairingRefNode, ok := resp.GetOptionalChildByTag("link_code_companion_reg", "link_code_pairing_ref")
+	if !ok {
+		return "", &ElementMissingError{Tag: "link_code_pairing_ref", In: "code link registration response"}
+	}
+	pairingRef, ok := pairingRefNode.Content.([]byte)
+	if !ok {
+		return "", fmt.Errorf("unexpected type %T in content of link_code_pairing_ref tag", pairingRefNode.Content)
+	}
+	cli.phoneLinkingCache = &phoneLinkingCache{
+		jid:         jid,
+		keyPair:     ephemeralKeyPair,
+		linkingCode: encodedLinkingCode,
+		pairingRef:  string(pairingRef),
+	}
+	return encodedLinkingCode[0:4] + "-" + encodedLinkingCode[4:], nil
+}
+
+func (cli *Client) tryHandleCodePairNotification(ctx context.Context, parentNode *waBinary.Node) {
+	err := cli.handleCodePairNotification(ctx, parentNode)
+	if err != nil {
+		cli.Log.Errorf("Failed to handle code pair notification: %s", err)
+	}
+}
+
+func (cli *Client) handleCodePairNotification(ctx context.Context, parentNode *waBinary.Node) error {
+	node, ok := parentNode.GetOptionalChildByTag("link_code_companion_reg")
+	if !ok {
+		return &ElementMissingError{
+			Tag: "link_code_companion_reg",
+			In:  "notification",
+		}
+	}
+	linkCache := cli.phoneLinkingCache
+	if linkCache == nil {
+		return fmt.Errorf("received code pair notification without a pending pairing")
+	}
+	linkCodePairingRef, _ := node.GetChildByTag("link_code_pairing_ref").Content.([]byte)
+	if string(linkCodePairingRef) != linkCache.pairingRef {
+		return fmt.Errorf("pairing ref mismatch in code pair notification")
+	}
+	wrappedPrimaryEphemeralPub, ok := node.GetChildByTag("link_code_pairing_wrapped_primary_ephemeral_pub").Content.([]byte)
+	if !ok {
+		return &ElementMissingError{
+			Tag: "link_code_pairing_wrapped_primary_ephemeral_pub",
+			In:  "notification",
+		}
+	}
+	primaryIdentityPub, ok := node.GetChildByTag("primary_identity_pub").Content.([]byte)
+	if !ok {
+		return &ElementMissingError{
+			Tag: "primary_identity_pub",
+			In:  "notification",
+		}
+	}
+
+	advSecretRandom := random.Bytes(32)
+	keyBundleSalt := random.Bytes(32)
+	keyBundleNonce := random.Bytes(12)
+
+	// Decrypt the primary device's ephemeral public key, which was encrypted with the 8-character pairing code,
+	// then compute the DH shared secret using our ephemeral private key we generated earlier.
+	primarySalt := wrappedPrimaryEphemeralPub[0:32]
+	primaryIV := wrappedPrimaryEphemeralPub[32:48]
+	primaryEncryptedPubkey := wrappedPrimaryEphemeralPub[48:80]
+	linkCodeKey := pbkdf2.Key([]byte(linkCache.linkingCode), primarySalt, 2<<16, 32, sha256.New)
+	linkCipherBlock, err := aes.NewCipher(linkCodeKey)
+	if err != nil {
+		return fmt.Errorf("failed to create link cipher: %w", err)
+	}
+	primaryDecryptedPubkey := make([]byte, 32)
+	cipher.NewCTR(linkCipherBlock, primaryIV).XORKeyStream(primaryDecryptedPubkey, primaryEncryptedPubkey)
+	ephemeralSharedSecret, err := curve25519.X25519(linkCache.keyPair.Priv[:], primaryDecryptedPubkey)
+	if err != nil {
+		return fmt.Errorf("failed to compute ephemeral shared secret: %w", err)
+	}
+
+	// Encrypt and wrap key bundle containing our identity key, the primary device's identity key and the randomness used for the adv key.
+	keyBundleEncryptionKey := hkdfutil.SHA256(ephemeralSharedSecret, keyBundleSalt, []byte("link_code_pairing_key_bundle_encryption_key"), 32)
+	keyBundleCipherBlock, err := aes.NewCipher(keyBundleEncryptionKey)
+	if err != nil {
+		return fmt.Errorf("failed to create key bundle cipher: %w", err)
+	}
+	keyBundleGCM, err := cipher.NewGCM(keyBundleCipherBlock)
+	if err != nil {
+		return fmt.Errorf("failed to create key bundle GCM: %w", err)
+	}
+	plaintextKeyBundle := concatBytes(cli.Store.IdentityKey.Pub[:], primaryIdentityPub, advSecretRandom)
+	encryptedKeyBundle := keyBundleGCM.Seal(nil, keyBundleNonce, plaintextKeyBundle, nil)
+	wrappedKeyBundle := concatBytes(keyBundleSalt, keyBundleNonce, encryptedKeyBundle)
+
+	// Compute the adv secret key (which is used to authenticate the pair-success event later)
+	identitySharedKey, err := curve25519.X25519(cli.Store.IdentityKey.Priv[:], primaryIdentityPub)
+	if err != nil {
+		return fmt.Errorf("failed to compute identity shared key: %w", err)
+	}
+	advSecretInput := append(append(ephemeralSharedSecret, identitySharedKey...), advSecretRandom...)
+	advSecret := hkdfutil.SHA256(advSecretInput, nil, []byte("adv_secret"), 32)
+	cli.Store.AdvSecretKey = advSecret
+
+	_, err = cli.sendIQ(infoQuery{
+		Namespace: "md",
+		Type:      iqSet,
+		To:        types.ServerJID,
+		Context:   ctx,
+		Content: []waBinary.Node{{
+			Tag: "link_code_companion_reg",
+			Attrs: waBinary.Attrs{
+				"jid":   linkCache.jid,
+				"stage": "companion_finish",
+			},
+			Content: []waBinary.Node{
+				{Tag: "link_code_pairing_wrapped_key_bundle", Content: wrappedKeyBundle},
+				{Tag: "companion_identity_public", Content: cli.Store.IdentityKey.Pub[:]},
+				{Tag: "link_code_pairing_ref", Content: linkCodePairingRef},
+			},
+		}},
+	})
+	return err
+}