gmessages/libgm/event_handler.go

292 lines
9.4 KiB
Go
Raw Normal View History

2023-06-30 11:05:33 +00:00
package libgm
2023-06-30 09:54:08 +00:00
import (
2024-02-23 18:25:31 +00:00
"bytes"
"crypto/sha256"
"encoding/base64"
"fmt"
"strings"
"google.golang.org/protobuf/proto"
"go.mau.fi/mautrix-gmessages/libgm/events"
2023-07-17 13:51:31 +00:00
"go.mau.fi/mautrix-gmessages/libgm/gmproto"
2023-06-30 09:54:08 +00:00
)
type IncomingRPCMessage struct {
*gmproto.IncomingRPCMessage
IsOld bool
Pair *gmproto.RPCPairData
Gaia *gmproto.RPCGaiaData
Message *gmproto.RPCMessageData
DecryptedData []byte
DecryptedMessage proto.Message
}
2023-07-18 21:59:51 +00:00
var responseType = map[gmproto.ActionType]proto.Message{
gmproto.ActionType_IS_BUGLE_DEFAULT: &gmproto.IsBugleDefaultResponse{},
gmproto.ActionType_GET_UPDATES: &gmproto.UpdateEvents{},
gmproto.ActionType_LIST_CONVERSATIONS: &gmproto.ListConversationsResponse{},
gmproto.ActionType_NOTIFY_DITTO_ACTIVITY: &gmproto.NotifyDittoActivityResponse{},
gmproto.ActionType_GET_CONVERSATION_TYPE: &gmproto.GetConversationTypeResponse{},
gmproto.ActionType_GET_CONVERSATION: &gmproto.GetConversationResponse{},
gmproto.ActionType_LIST_MESSAGES: &gmproto.ListMessagesResponse{},
gmproto.ActionType_SEND_MESSAGE: &gmproto.SendMessageResponse{},
gmproto.ActionType_SEND_REACTION: &gmproto.SendReactionResponse{},
gmproto.ActionType_DELETE_MESSAGE: &gmproto.DeleteMessageResponse{},
2023-09-04 22:18:01 +00:00
gmproto.ActionType_GET_PARTICIPANTS_THUMBNAIL: &gmproto.GetThumbnailResponse{},
gmproto.ActionType_GET_CONTACTS_THUMBNAIL: &gmproto.GetThumbnailResponse{},
2023-07-18 21:59:51 +00:00
gmproto.ActionType_LIST_CONTACTS: &gmproto.ListContactsResponse{},
gmproto.ActionType_LIST_TOP_CONTACTS: &gmproto.ListTopContactsResponse{},
gmproto.ActionType_GET_OR_CREATE_CONVERSATION: &gmproto.GetOrCreateConversationResponse{},
gmproto.ActionType_UPDATE_CONVERSATION: &gmproto.UpdateConversationResponse{},
}
2023-07-19 11:12:23 +00:00
func (c *Client) decryptInternalMessage(data *gmproto.IncomingRPCMessage) (*IncomingRPCMessage, error) {
msg := &IncomingRPCMessage{
IncomingRPCMessage: data,
}
switch data.BugleRoute {
case gmproto.BugleRoute_PairEvent:
msg.Pair = &gmproto.RPCPairData{}
err := proto.Unmarshal(data.GetMessageData(), msg.Pair)
if err != nil {
2023-07-31 16:44:13 +00:00
c.Logger.Trace().
Str("data", base64.StdEncoding.EncodeToString(msg.GetMessageData())).
Msg("Errored pair event content")
return nil, fmt.Errorf("failed to decode pair event: %w", err)
}
case gmproto.BugleRoute_GaiaEvent:
msg.Gaia = &gmproto.RPCGaiaData{}
err := proto.Unmarshal(data.GetMessageData(), msg.Gaia)
if err != nil {
c.Logger.Trace().
Str("data", base64.StdEncoding.EncodeToString(msg.GetMessageData())).
Msg("Errored gaia event content")
return nil, fmt.Errorf("failed to decode gaia event: %w", err)
}
case gmproto.BugleRoute_DataEvent:
msg.Message = &gmproto.RPCMessageData{}
err := proto.Unmarshal(data.GetMessageData(), msg.Message)
if err != nil {
2023-07-31 16:44:13 +00:00
c.Logger.Trace().
Str("data", base64.StdEncoding.EncodeToString(msg.GetMessageData())).
Msg("Errored data event content")
return nil, fmt.Errorf("failed to decode data event: %w", err)
}
2023-07-18 21:59:51 +00:00
responseStruct, ok := responseType[msg.Message.GetAction()]
if ok {
msg.DecryptedMessage = responseStruct.ProtoReflect().New().Interface()
}
if msg.Message.EncryptedData != nil {
2023-07-19 11:12:23 +00:00
msg.DecryptedData, err = c.AuthData.RequestCrypto.Decrypt(msg.Message.EncryptedData)
if err != nil {
2023-07-31 16:44:13 +00:00
return nil, fmt.Errorf("failed to decrypt data event: %w", err)
}
2023-07-18 21:59:51 +00:00
if msg.DecryptedMessage != nil {
err = proto.Unmarshal(msg.DecryptedData, msg.DecryptedMessage)
if err != nil {
2023-07-31 16:44:13 +00:00
c.Logger.Trace().
Str("data", base64.StdEncoding.EncodeToString(msg.DecryptedData)).
Msg("Errored decrypted data event content")
return nil, fmt.Errorf("failed to decode decrypted data event: %w", err)
2023-07-18 21:59:51 +00:00
}
}
} else if msg.Message.EncryptedData2 != nil {
msg.DecryptedData, err = c.AuthData.RequestCrypto.Decrypt(msg.Message.EncryptedData2)
if err != nil {
return nil, fmt.Errorf("failed to decrypt field 2 in data event: %w", err)
}
var ed2c gmproto.EncryptedData2Container
err = proto.Unmarshal(msg.DecryptedData, &ed2c)
if err != nil {
c.Logger.Trace().
Str("data", base64.StdEncoding.EncodeToString(msg.DecryptedData)).
Msg("Errored decrypted data event content")
return nil, fmt.Errorf("failed to decode decrypted field 2 data event: %w", err)
}
// Hacky hack to have User.handleAccountChange do the right-ish thing on startup
if strings.ContainsRune(ed2c.GetAccountChange().GetAccount(), '@') {
c.triggerEvent(&events.AccountChange{
AccountChangeOrSomethingEvent: ed2c.GetAccountChange(),
IsFake: true,
})
}
}
default:
return nil, fmt.Errorf("unknown bugle route %d", data.BugleRoute)
}
return msg, nil
}
func (c *Client) deduplicateHash(id string, hash [32]byte) bool {
2023-07-19 11:12:23 +00:00
const recentUpdatesLen = len(c.recentUpdates)
for i := c.recentUpdatesPtr + recentUpdatesLen - 1; i >= c.recentUpdatesPtr; i-- {
if c.recentUpdates[i%recentUpdatesLen].id == id {
if c.recentUpdates[i%recentUpdatesLen].hash == hash {
return true
} else {
break
}
}
}
c.recentUpdates[c.recentUpdatesPtr] = updateDedupItem{id: id, hash: hash}
2023-07-19 11:12:23 +00:00
c.recentUpdatesPtr = (c.recentUpdatesPtr + 1) % recentUpdatesLen
return false
}
func (c *Client) logContent(res *IncomingRPCMessage, thingID string, contentHash []byte) {
2023-07-19 11:12:23 +00:00
if c.Logger.Trace().Enabled() && (res.DecryptedData != nil || res.DecryptedMessage != nil) {
evt := c.Logger.Trace().Bool("is_old", res.IsOld)
if res.DecryptedMessage != nil {
evt.Str("proto_name", string(res.DecryptedMessage.ProtoReflect().Descriptor().FullName()))
}
if res.DecryptedData != nil {
evt.Str("data", base64.StdEncoding.EncodeToString(res.DecryptedData))
if contentHash != nil {
evt.Str("thing_id", thingID)
evt.Hex("data_hash", contentHash)
}
} else {
evt.Str("data", "<null>")
}
evt.Msg("Got event")
2023-07-15 13:17:02 +00:00
}
}
func (c *Client) deduplicateUpdate(id string, msg *IncomingRPCMessage) bool {
if msg.DecryptedData != nil {
contentHash := sha256.Sum256(msg.DecryptedData)
if c.deduplicateHash(id, contentHash) {
c.Logger.Trace().
Str("thing_id", id).
Hex("data_hash", contentHash[:]).
Bool("is_old", msg.IsOld).
Msg("Ignoring duplicate update")
return true
}
c.logContent(msg, id, contentHash[:])
}
return false
}
2023-07-19 11:12:23 +00:00
func (c *Client) HandleRPCMsg(rawMsg *gmproto.IncomingRPCMessage) {
msg, err := c.decryptInternalMessage(rawMsg)
if err != nil {
2023-07-19 11:12:23 +00:00
c.Logger.Err(err).Msg("Failed to decode incoming RPC message")
2024-02-26 15:08:24 +00:00
c.sessionHandler.queueMessageAck(rawMsg.ResponseID)
return
}
2023-07-19 11:12:23 +00:00
c.sessionHandler.queueMessageAck(msg.ResponseID)
if c.sessionHandler.receiveResponse(msg) {
2023-07-15 22:45:57 +00:00
return
}
switch msg.BugleRoute {
2023-07-17 13:51:31 +00:00
case gmproto.BugleRoute_PairEvent:
2023-08-10 12:40:43 +00:00
c.handlePairingEvent(msg)
case gmproto.BugleRoute_GaiaEvent:
c.handleGaiaPairingEvent(msg)
2023-07-17 13:51:31 +00:00
case gmproto.BugleRoute_DataEvent:
2023-07-19 11:12:23 +00:00
if c.skipCount > 0 {
c.skipCount--
msg.IsOld = true
}
2023-07-19 11:12:23 +00:00
c.handleUpdatesEvent(msg)
2023-06-30 09:54:08 +00:00
}
}
type WrappedMessage struct {
*gmproto.Message
IsOld bool
Data []byte
}
2024-02-23 18:25:31 +00:00
var hackyLoggedOutBytes = []byte{0x72, 0x00}
func (c *Client) handleUpdatesEvent(msg *IncomingRPCMessage) {
switch msg.Message.Action {
case gmproto.ActionType_GET_UPDATES:
2024-02-23 18:25:31 +00:00
if msg.DecryptedData == nil && bytes.Equal(msg.Message.UnencryptedData, hackyLoggedOutBytes) {
c.triggerEvent(&events.GaiaLoggedOut{})
return
}
data, ok := msg.DecryptedMessage.(*gmproto.UpdateEvents)
if !ok {
c.Logger.Error().
Type("data_type", msg.DecryptedMessage).
Bool("is_old", msg.IsOld).
Msg("Unexpected data type in GET_UPDATES event")
return
}
switch evt := data.Event.(type) {
case *gmproto.UpdateEvents_UserAlertEvent:
c.logContent(msg, "", nil)
if msg.IsOld {
return
}
c.triggerEvent(evt.UserAlertEvent)
case *gmproto.UpdateEvents_SettingsEvent:
c.Logger.Debug().
Str("data", base64.StdEncoding.EncodeToString(msg.DecryptedData)).
Bool("is_old", msg.IsOld).
Msg("Got settings event")
c.triggerEvent(evt.SettingsEvent)
case *gmproto.UpdateEvents_ConversationEvent:
for _, part := range evt.ConversationEvent.GetData() {
if c.deduplicateUpdate(part.GetConversationID(), msg) {
return
} else if msg.IsOld {
c.Logger.Debug().Str("conv_id", part.ConversationID).Msg("Ignoring old conversation event")
continue
}
c.triggerEvent(part)
}
case *gmproto.UpdateEvents_MessageEvent:
for _, part := range evt.MessageEvent.GetData() {
if c.deduplicateUpdate(part.GetMessageID(), msg) {
return
}
c.triggerEvent(&WrappedMessage{
Message: part,
IsOld: msg.IsOld,
Data: msg.DecryptedData,
})
}
case *gmproto.UpdateEvents_TypingEvent:
c.logContent(msg, "", nil)
if msg.IsOld {
return
}
c.triggerEvent(evt.TypingEvent.GetData())
case *gmproto.UpdateEvents_AccountChange:
c.logContent(msg, "", nil)
c.triggerEvent(&events.AccountChange{
AccountChangeOrSomethingEvent: evt.AccountChange,
})
default:
2023-08-21 09:10:16 +00:00
c.Logger.Warn().
Str("evt_data", base64.StdEncoding.EncodeToString(msg.GetMessageData())).
Str("decrypted_data", base64.StdEncoding.EncodeToString(msg.DecryptedData)).
2023-08-21 09:10:16 +00:00
Msg("Got unknown event type")
}
default:
2023-08-25 17:45:01 +00:00
c.Logger.Debug().
Str("evt_data", base64.StdEncoding.EncodeToString(msg.GetMessageData())).
2023-08-25 17:45:01 +00:00
Str("request_id", msg.Message.SessionID).
Str("action_type", msg.Message.Action.String()).
Bool("is_old", msg.IsOld).
2023-08-25 17:45:01 +00:00
Msg("Got unexpected response")
}
}