slidge-whatsapp 0.2.5__cp312-cp312-manylinux_2_36_aarch64.whl → 0.2.6__cp312-cp312-manylinux_2_36_aarch64.whl

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

@@ -8,6 +8,7 @@ package whatsmeow
 
 import (
 	"bytes"
+	"context"
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/base64"
@@ -24,6 +25,13 @@ import (
 	"go.mau.fi/whatsmeow/util/keys"
 )
 
+var (
+	AdvPrefixAccountSignature                                = []byte{6, 0}
+	AdvPrefixDeviceSignatureGenerate                         = []byte{6, 1}
+	AdvHostedPrefixDeviceIdentityAccountSignature            = []byte{6, 5}
+	AdvHostedPrefixDeviceIdentityDeviceSignatureVerification = []byte{6, 6}
+)
+
 func (cli *Client) handleIQ(node *waBinary.Node) {
 	children := node.GetChildren()
 	if len(children) != 1 || node.Attrs["from"] != types.ServerJID {
@@ -82,34 +90,40 @@ func (cli *Client) handlePairSuccess(node *waBinary.Node) {
 	deviceIdentityBytes, _ := pairSuccess.GetChildByTag("device-identity").Content.([]byte)
 	businessName, _ := pairSuccess.GetChildByTag("biz").Attrs["name"].(string)
 	jid, _ := pairSuccess.GetChildByTag("device").Attrs["jid"].(types.JID)
+	lid, _ := pairSuccess.GetChildByTag("device").Attrs["lid"].(types.JID)
 	platform, _ := pairSuccess.GetChildByTag("platform").Attrs["name"].(string)
 
 	go func() {
-		err := cli.handlePair(deviceIdentityBytes, id, businessName, platform, jid)
+		err := cli.handlePair(context.TODO(), deviceIdentityBytes, id, businessName, platform, jid, lid)
 		if err != nil {
 			cli.Log.Errorf("Failed to pair device: %v", err)
 			cli.Disconnect()
-			cli.dispatchEvent(&events.PairError{ID: jid, BusinessName: businessName, Platform: platform, Error: err})
+			cli.dispatchEvent(&events.PairError{ID: jid, LID: lid, BusinessName: businessName, Platform: platform, Error: err})
 		} else {
 			cli.Log.Infof("Successfully paired %s", cli.Store.ID)
-			cli.dispatchEvent(&events.PairSuccess{ID: jid, BusinessName: businessName, Platform: platform})
+			cli.dispatchEvent(&events.PairSuccess{ID: jid, LID: lid, BusinessName: businessName, Platform: platform})
 		}
 	}()
 }
 
-func (cli *Client) handlePair(deviceIdentityBytes []byte, reqID, businessName, platform string, jid types.JID) error {
+func (cli *Client) handlePair(ctx context.Context, deviceIdentityBytes []byte, reqID, businessName, platform string, jid, lid types.JID) error {
 	var deviceIdentityContainer waAdv.ADVSignedDeviceIdentityHMAC
 	err := proto.Unmarshal(deviceIdentityBytes, &deviceIdentityContainer)
 	if err != nil {
 		cli.sendPairError(reqID, 500, "internal-error")
 		return &PairProtoError{"failed to parse device identity container in pair success message", err}
 	}
+	isHostedAccount := deviceIdentityContainer.AccountType != nil && *deviceIdentityContainer.AccountType == waAdv.ADVEncryptionType_HOSTED
 
 	h := hmac.New(sha256.New, cli.Store.AdvSecretKey)
+	if isHostedAccount {
+		h.Write(AdvHostedPrefixDeviceIdentityAccountSignature)
+	}
 	h.Write(deviceIdentityContainer.Details)
+
 	if !bytes.Equal(h.Sum(nil), deviceIdentityContainer.HMAC) {
 		cli.Log.Warnf("Invalid HMAC from pair success message")
-		cli.sendPairError(reqID, 401, "not-authorized")
+		cli.sendPairError(reqID, 401, "hmac-mismatch")
 		return ErrPairInvalidDeviceIdentityHMAC
 	}
 
@@ -120,12 +134,12 @@ func (cli *Client) handlePair(deviceIdentityBytes []byte, reqID, businessName, p
 		return &PairProtoError{"failed to parse signed device identity in pair success message", err}
 	}
 
-	if !verifyDeviceIdentityAccountSignature(&deviceIdentity, cli.Store.IdentityKey) {
-		cli.sendPairError(reqID, 401, "not-authorized")
+	if !verifyDeviceIdentityAccountSignature(&deviceIdentity, cli.Store.IdentityKey, isHostedAccount) {
+		cli.sendPairError(reqID, 401, "signature-mismatch")
 		return ErrPairInvalidDeviceSignature
 	}
 
-	deviceIdentity.DeviceSignature = generateDeviceSignature(&deviceIdentity, cli.Store.IdentityKey)[:]
+	deviceIdentity.DeviceSignature = generateDeviceSignature(&deviceIdentity, cli.Store.IdentityKey, isHostedAccount)[:]
 
 	var deviceIdentityDetails waAdv.ADVDeviceIdentity
 	err = proto.Unmarshal(deviceIdentity.Details, &deviceIdentityDetails)
@@ -141,8 +155,8 @@ func (cli *Client) handlePair(deviceIdentityBytes []byte, reqID, businessName, p
 
 	cli.Store.Account = proto.Clone(&deviceIdentity).(*waAdv.ADVSignedDeviceIdentity)
 
-	mainDeviceJID := jid
-	mainDeviceJID.Device = 0
+	mainDeviceLID := lid
+	mainDeviceLID.Device = 0
 	mainDeviceIdentity := *(*[32]byte)(deviceIdentity.AccountSignatureKey)
 	deviceIdentity.AccountSignatureKey = nil
 
@@ -153,16 +167,18 @@ func (cli *Client) handlePair(deviceIdentityBytes []byte, reqID, businessName, p
 	}
 
 	cli.Store.ID = &jid
+	cli.Store.LID = lid
 	cli.Store.BusinessName = businessName
 	cli.Store.Platform = platform
-	err = cli.Store.Save()
+	err = cli.Store.Save(ctx)
 	if err != nil {
 		cli.sendPairError(reqID, 500, "internal-error")
 		return &PairDatabaseError{"failed to save device store", err}
 	}
-	err = cli.Store.Identities.PutIdentity(mainDeviceJID.SignalAddress().String(), mainDeviceIdentity)
+	cli.StoreLIDPNMapping(ctx, lid, jid)
+	err = cli.Store.Identities.PutIdentity(ctx, mainDeviceLID.SignalAddress().String(), mainDeviceIdentity)
 	if err != nil {
-		_ = cli.Store.Delete()
+		_ = cli.Store.Delete(ctx)
 		cli.sendPairError(reqID, 500, "internal-error")
 		return &PairDatabaseError{"failed to store main device identity", err}
 	}
@@ -189,7 +205,7 @@ func (cli *Client) handlePair(deviceIdentityBytes []byte, reqID, businessName, p
 		}},
 	})
 	if err != nil {
-		_ = cli.Store.Delete()
+		_ = cli.Store.Delete(ctx)
 		return fmt.Errorf("failed to send pairing confirmation: %w", err)
 	}
 	return nil
@@ -208,7 +224,7 @@ func concatBytes(data ...[]byte) []byte {
 	return output
 }
 
-func verifyDeviceIdentityAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair) bool {
+func verifyDeviceIdentityAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair, isHostedAccount bool) bool {
 	if len(deviceIdentity.AccountSignatureKey) != 32 || len(deviceIdentity.AccountSignature) != 64 {
 		return false
 	}
@@ -216,12 +232,20 @@ func verifyDeviceIdentityAccountSignature(deviceIdentity *waAdv.ADVSignedDeviceI
 	signatureKey := ecc.NewDjbECPublicKey(*(*[32]byte)(deviceIdentity.AccountSignatureKey))
 	signature := *(*[64]byte)(deviceIdentity.AccountSignature)
 
-	message := concatBytes([]byte{6, 0}, deviceIdentity.Details, ikp.Pub[:])
+	prefix := AdvPrefixAccountSignature
+	if isHostedAccount {
+		prefix = AdvHostedPrefixDeviceIdentityAccountSignature
+	}
+	message := concatBytes(prefix, deviceIdentity.Details, ikp.Pub[:])
 	return ecc.VerifySignature(signatureKey, message, signature)
 }
 
-func generateDeviceSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair) *[64]byte {
-	message := concatBytes([]byte{6, 1}, deviceIdentity.Details, ikp.Pub[:], deviceIdentity.AccountSignatureKey)
+func generateDeviceSignature(deviceIdentity *waAdv.ADVSignedDeviceIdentity, ikp *keys.KeyPair, isHostedAccount bool) *[64]byte {
+	prefix := AdvPrefixDeviceSignatureGenerate
+	if isHostedAccount {
+		prefix = AdvHostedPrefixDeviceIdentityDeviceSignatureVerification
+	}
+	message := concatBytes(prefix, deviceIdentity.Details, ikp.Pub[:], deviceIdentity.AccountSignatureKey)
 	sig := ecc.CalculateSignature(ecc.NewDjbECPrivateKey(*ikp.Priv), message)
 	return &sig
 }

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

@@ -29,11 +29,12 @@ const (
 	MinPreKeyCount = 5
 )
 
-func (cli *Client) getServerPreKeyCount() (int, error) {
+func (cli *Client) getServerPreKeyCount(ctx context.Context) (int, error) {
 	resp, err := cli.sendIQ(infoQuery{
 		Namespace: "encrypt",
 		Type:      "get",
 		To:        types.ServerJID,
+		Context:   ctx,
 		Content: []waBinary.Node{
 			{Tag: "count"},
 		},
@@ -47,11 +48,11 @@ func (cli *Client) getServerPreKeyCount() (int, error) {
 	return val, ag.Error()
 }
 
-func (cli *Client) uploadPreKeys() {
+func (cli *Client) uploadPreKeys(ctx context.Context) {
 	cli.uploadPreKeysLock.Lock()
 	defer cli.uploadPreKeysLock.Unlock()
 	if cli.lastPreKeyUpload.Add(10 * time.Minute).After(time.Now()) {
-		sc, _ := cli.getServerPreKeyCount()
+		sc, _ := cli.getServerPreKeyCount(ctx)
 		if sc >= WantedPreKeyCount {
 			cli.Log.Debugf("Canceling prekey upload request due to likely race condition")
 			return
@@ -59,13 +60,14 @@ func (cli *Client) uploadPreKeys() {
 	}
 	var registrationIDBytes [4]byte
 	binary.BigEndian.PutUint32(registrationIDBytes[:], cli.Store.RegistrationID)
-	preKeys, err := cli.Store.PreKeys.GetOrGenPreKeys(WantedPreKeyCount)
+	preKeys, err := cli.Store.PreKeys.GetOrGenPreKeys(ctx, WantedPreKeyCount)
 	if err != nil {
 		cli.Log.Errorf("Failed to get prekeys to upload: %v", err)
 		return
 	}
 	cli.Log.Infof("Uploading %d new prekeys to server", len(preKeys))
 	_, err = cli.sendIQ(infoQuery{
+		Context:   ctx,
 		Namespace: "encrypt",
 		Type:      "set",
 		To:        types.ServerJID,
@@ -82,11 +84,13 @@ func (cli *Client) uploadPreKeys() {
 		return
 	}
 	cli.Log.Debugf("Got response to uploading prekeys")
-	err = cli.Store.PreKeys.MarkPreKeysAsUploaded(preKeys[len(preKeys)-1].KeyID)
+	err = cli.Store.PreKeys.MarkPreKeysAsUploaded(ctx, preKeys[len(preKeys)-1].KeyID)
 	if err != nil {
 		cli.Log.Warnf("Failed to mark prekeys as uploaded: %v", err)
+		return
 	}
 	cli.lastPreKeyUpload = time.Now()
+	return
 }
 
 type preKeyResp struct {

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

@@ -7,6 +7,7 @@
 package whatsmeow
 
 import (
+	"context"
 	"fmt"
 
 	waBinary "go.mau.fi/whatsmeow/binary"
@@ -87,7 +88,7 @@ func (cli *Client) SendPresence(state types.Presence) error {
 //
 //	cli.SendPresence(types.PresenceAvailable)
 func (cli *Client) SubscribePresence(jid types.JID) error {
-	privacyToken, err := cli.Store.PrivacyTokens.GetPrivacyToken(jid)
+	privacyToken, err := cli.Store.PrivacyTokens.GetPrivacyToken(context.TODO(), jid)
 	if err != nil {
 		return fmt.Errorf("failed to get privacy token: %w", err)
 	} else if privacyToken == nil {

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

@@ -7,6 +7,7 @@
 package whatsmeow
 
 import (
+	"context"
 	"strconv"
 	"time"
 
@@ -16,7 +17,7 @@ import (
 )
 
 // TryFetchPrivacySettings will fetch the user's privacy settings, either from the in-memory cache or from the server.
-func (cli *Client) TryFetchPrivacySettings(ignoreCache bool) (*types.PrivacySettings, error) {
+func (cli *Client) TryFetchPrivacySettings(ctx context.Context, ignoreCache bool) (*types.PrivacySettings, error) {
 	if cli == nil {
 		return nil, ErrClientIsNil
 	} else if val := cli.privacySettingsCache.Load(); val != nil && !ignoreCache {
@@ -24,6 +25,7 @@ func (cli *Client) TryFetchPrivacySettings(ignoreCache bool) (*types.PrivacySett
 	}
 	resp, err := cli.sendIQ(infoQuery{
 		Namespace: "privacy",
+		Context:   ctx,
 		Type:      iqGet,
 		To:        types.ServerJID,
 		Content:   []waBinary.Node{{Tag: "privacy"}},
@@ -43,11 +45,11 @@ func (cli *Client) TryFetchPrivacySettings(ignoreCache bool) (*types.PrivacySett
 
 // GetPrivacySettings will get the user's privacy settings. If an error occurs while fetching them, the error will be
 // logged, but the method will just return an empty struct.
-func (cli *Client) GetPrivacySettings() (settings types.PrivacySettings) {
+func (cli *Client) GetPrivacySettings(ctx context.Context) (settings types.PrivacySettings) {
 	if cli == nil || cli.MessengerConfig != nil {
 		return
 	}
-	settingsPtr, err := cli.TryFetchPrivacySettings(false)
+	settingsPtr, err := cli.TryFetchPrivacySettings(ctx, false)
 	if err != nil {
 		cli.Log.Errorf("Failed to fetch privacy settings: %v", err)
 	} else {
@@ -59,8 +61,8 @@ func (cli *Client) GetPrivacySettings() (settings types.PrivacySettings) {
 // SetPrivacySetting will set the given privacy setting to the given value.
 // The privacy settings will be fetched from the server after the change and the new settings will be returned.
 // If an error occurs while fetching the new settings, will return an empty struct.
-func (cli *Client) SetPrivacySetting(name types.PrivacySettingType, value types.PrivacySetting) (settings types.PrivacySettings, err error) {
-	settingsPtr, err := cli.TryFetchPrivacySettings(false)
+func (cli *Client) SetPrivacySetting(ctx context.Context, name types.PrivacySettingType, value types.PrivacySetting) (settings types.PrivacySettings, err error) {
+	settingsPtr, err := cli.TryFetchPrivacySettings(ctx, false)
 	if err != nil {
 		return settings, err
 	}
@@ -155,17 +157,14 @@ func (cli *Client) parsePrivacySettings(privacyNode *waBinary.Node, settings *ty
 	return &evt
 }
 
-func (cli *Client) handlePrivacySettingsNotification(privacyNode *waBinary.Node) {
+func (cli *Client) handlePrivacySettingsNotification(ctx context.Context, privacyNode *waBinary.Node) {
 	cli.Log.Debugf("Parsing privacy settings change notification")
-	settings, err := cli.TryFetchPrivacySettings(false)
+	settings, err := cli.TryFetchPrivacySettings(ctx, false)
 	if err != nil {
 		cli.Log.Errorf("Failed to fetch privacy settings when handling change: %v", err)
 		return
 	}
 	evt := cli.parsePrivacySettings(privacyNode, settings)
-	// The data isn't be reliable if the fetch failed, so only cache if it didn't fail
-	if err == nil {
-		cli.privacySettingsCache.Store(settings)
-	}
+	cli.privacySettingsCache.Store(settings)
 	cli.dispatchEvent(evt)
 }

slidge_whatsapp/vendor/go.mau.fi/whatsmeow/proto/waAdv/WAAdv.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.36.1
+// 	protoc-gen-go v1.36.6
 // 	protoc        v3.21.12
 // source: waAdv/WAAdv.proto
 
@@ -9,11 +9,10 @@ package waAdv
 import (
 	reflect "reflect"
 	sync "sync"
+	unsafe "unsafe"
 
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-
-	_ "embed"
 )
 
 const (
@@ -421,17 +420,49 @@ func (x *ADVSignedDeviceIdentityHMAC) GetAccountType() ADVEncryptionType {
 
 var File_waAdv_WAAdv_proto protoreflect.FileDescriptor
 
-//go:embed WAAdv.pb.raw
-var file_waAdv_WAAdv_proto_rawDesc []byte
+const file_waAdv_WAAdv_proto_rawDesc = "" +
+	"\n" +
+	"\x11waAdv/WAAdv.proto\x12\x05WAAdv\"\xcd\x01\n" +
+	"\x0fADVKeyIndexList\x12\x14\n" +
+	"\x05rawID\x18\x01 \x01(\rR\x05rawID\x12\x1c\n" +
+	"\ttimestamp\x18\x02 \x01(\x04R\ttimestamp\x12\"\n" +
+	"\fcurrentIndex\x18\x03 \x01(\rR\fcurrentIndex\x12&\n" +
+	"\fvalidIndexes\x18\x04 \x03(\rB\x02\x10\x01R\fvalidIndexes\x12:\n" +
+	"\vaccountType\x18\x05 \x01(\x0e2\x18.WAAdv.ADVEncryptionTypeR\vaccountType\"\x8f\x01\n" +
+	"\x15ADVSignedKeyIndexList\x12\x18\n" +
+	"\adetails\x18\x01 \x01(\fR\adetails\x12*\n" +
+	"\x10accountSignature\x18\x02 \x01(\fR\x10accountSignature\x120\n" +
+	"\x13accountSignatureKey\x18\x03 \x01(\fR\x13accountSignatureKey\"\xd9\x01\n" +
+	"\x11ADVDeviceIdentity\x12\x14\n" +
+	"\x05rawID\x18\x01 \x01(\rR\x05rawID\x12\x1c\n" +
+	"\ttimestamp\x18\x02 \x01(\x04R\ttimestamp\x12\x1a\n" +
+	"\bkeyIndex\x18\x03 \x01(\rR\bkeyIndex\x12:\n" +
+	"\vaccountType\x18\x04 \x01(\x0e2\x18.WAAdv.ADVEncryptionTypeR\vaccountType\x128\n" +
+	"\n" +
+	"deviceType\x18\x05 \x01(\x0e2\x18.WAAdv.ADVEncryptionTypeR\n" +
+	"deviceType\"\xbb\x01\n" +
+	"\x17ADVSignedDeviceIdentity\x12\x18\n" +
+	"\adetails\x18\x01 \x01(\fR\adetails\x120\n" +
+	"\x13accountSignatureKey\x18\x02 \x01(\fR\x13accountSignatureKey\x12*\n" +
+	"\x10accountSignature\x18\x03 \x01(\fR\x10accountSignature\x12(\n" +
+	"\x0fdeviceSignature\x18\x04 \x01(\fR\x0fdeviceSignature\"\x87\x01\n" +
+	"\x1bADVSignedDeviceIdentityHMAC\x12\x18\n" +
+	"\adetails\x18\x01 \x01(\fR\adetails\x12\x12\n" +
+	"\x04HMAC\x18\x02 \x01(\fR\x04HMAC\x12:\n" +
+	"\vaccountType\x18\x03 \x01(\x0e2\x18.WAAdv.ADVEncryptionTypeR\vaccountType*)\n" +
+	"\x11ADVEncryptionType\x12\b\n" +
+	"\x04E2EE\x10\x00\x12\n" +
+	"\n" +
+	"\x06HOSTED\x10\x01B!Z\x1fgo.mau.fi/whatsmeow/proto/waAdv"
 
 var (
 	file_waAdv_WAAdv_proto_rawDescOnce sync.Once
-	file_waAdv_WAAdv_proto_rawDescData = file_waAdv_WAAdv_proto_rawDesc
+	file_waAdv_WAAdv_proto_rawDescData []byte
 )
 
 func file_waAdv_WAAdv_proto_rawDescGZIP() []byte {
 	file_waAdv_WAAdv_proto_rawDescOnce.Do(func() {
-		file_waAdv_WAAdv_proto_rawDescData = protoimpl.X.CompressGZIP(file_waAdv_WAAdv_proto_rawDescData)
+		file_waAdv_WAAdv_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_waAdv_WAAdv_proto_rawDesc), len(file_waAdv_WAAdv_proto_rawDesc)))
 	})
 	return file_waAdv_WAAdv_proto_rawDescData
 }
@@ -467,7 +498,7 @@ func file_waAdv_WAAdv_proto_init() {
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_waAdv_WAAdv_proto_rawDesc,
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_waAdv_WAAdv_proto_rawDesc), len(file_waAdv_WAAdv_proto_rawDesc)),
 			NumEnums:      1,
 			NumMessages:   5,
 			NumExtensions: 0,
@@ -479,7 +510,6 @@ func file_waAdv_WAAdv_proto_init() {
 		MessageInfos:      file_waAdv_WAAdv_proto_msgTypes,
 	}.Build()
 	File_waAdv_WAAdv_proto = out.File
-	file_waAdv_WAAdv_proto_rawDesc = nil
 	file_waAdv_WAAdv_proto_goTypes = nil
 	file_waAdv_WAAdv_proto_depIdxs = nil
 }