Update dependencies and remove old matterclient lib (#2067)HEADmaster

1 files changed, 252 insertions, 0 deletions

diff --git a/vendor/go.mau.fi/whatsmeow/pair-code.go b/vendor/go.mau.fi/whatsmeow/pair-code.go
new file mode 100644
index 00000000..183c5304
--- /dev/null
+++ b/vendor/go.mau.fi/whatsmeow/pair-code.go
@@ -0,0 +1,252 @@
+// 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 (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/sha256"
+	"encoding/base32"
+	"fmt"
+	"regexp"
+	"strconv"
+
+	"golang.org/x/crypto/curve25519"
+	"golang.org/x/crypto/pbkdf2"
+
+	waBinary "go.mau.fi/whatsmeow/binary"
+	waProto "go.mau.fi/whatsmeow/binary/proto"
+	"go.mau.fi/whatsmeow/store"
+	"go.mau.fi/whatsmeow/types"
+	"go.mau.fi/whatsmeow/util/hkdfutil"
+	"go.mau.fi/whatsmeow/util/keys"
+	"go.mau.fi/whatsmeow/util/randbytes"
+)
+
+// 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
+)
+
+func platformTypeToPairClientType(platformType waProto.DeviceProps_PlatformType) PairClientType {
+	switch platformType {
+	case waProto.DeviceProps_CHROME:
+		return PairClientChrome
+	case waProto.DeviceProps_EDGE:
+		return PairClientEdge
+	case waProto.DeviceProps_FIREFOX:
+		return PairClientFirefox
+	case waProto.DeviceProps_IE:
+		return PairClientIE
+	case waProto.DeviceProps_OPERA:
+		return PairClientOpera
+	case waProto.DeviceProps_SAFARI:
+		return PairClientSafari
+	case waProto.DeviceProps_DESKTOP:
+		return PairClientElectron
+	case waProto.DeviceProps_UWP:
+		return PairClientUWP
+	default:
+		return 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 := randbytes.Make(32)
+	iv := randbytes.Make(16)
+	linkingCode := randbytes.Make(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.
+//
+// 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.
+//
+// See https://faq.whatsapp.com/1324084875126592 for more info
+func (cli *Client) PairPhone(phone string, showPushNotification bool) (string, error) {
+	clientType := platformTypeToPairClientType(store.DeviceProps.GetPlatformType())
+	clientDisplayName := store.DeviceProps.GetOs()
+
+	ephemeralKeyPair, ephemeralKey, encodedLinkingCode := generateCompanionEphemeralKey()
+	phone = notNumbers.ReplaceAllString(phone, "")
+	jid := types.NewJID(phone, types.DefaultUserServer)
+	resp, err := cli.sendIQ(infoQuery{
+		Namespace: "md",
+		Type:      iqSet,
+		To:        types.ServerJID,
+		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(parentNode *waBinary.Node) {
+	err := cli.handleCodePairNotification(parentNode)
+	if err != nil {
+		cli.Log.Errorf("Failed to handle code pair notification: %s", err)
+	}
+}
+
+func (cli *Client) handleCodePairNotification(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 := randbytes.Make(32)
+	keyBundleSalt := randbytes.Make(32)
+	keyBundleNonce := randbytes.Make(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,
+		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
+}