slidge-whatsapp 0.2.5__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.7__cp311-cp311-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/extra.go

@@ -3,6 +3,9 @@ package armadillo
 import (
 	"google.golang.org/protobuf/proto"
 
+	"go.mau.fi/whatsmeow/proto/instamadilloAddMessage"
+	"go.mau.fi/whatsmeow/proto/instamadilloDeleteMessage"
+	"go.mau.fi/whatsmeow/proto/instamadilloSupplementMessage"
 	"go.mau.fi/whatsmeow/proto/waArmadilloApplication"
 	"go.mau.fi/whatsmeow/proto/waCommon"
 	"go.mau.fi/whatsmeow/proto/waConsumerApplication"
@@ -29,6 +32,10 @@ var (
 	_ MessageApplicationSub = (*waMultiDevice.MultiDevice)(nil)                 // 5
 	_ MessageApplicationSub = (*Unsupported_Voip)(nil)                          // 6
 	_ MessageApplicationSub = (*waArmadilloApplication.Armadillo)(nil)          // 7
+
+	_ MessageApplicationSub = (*instamadilloAddMessage.AddMessagePayload)(nil)
+	_ MessageApplicationSub = (*instamadilloSupplementMessage.SupplementMessagePayload)(nil)
+	_ MessageApplicationSub = (*instamadilloDeleteMessage.DeleteMessagePayload)(nil)
 )
 
 func (*Unsupported_BusinessApplication) IsMessageApplicationSub() {}