handlesignal: bridge decryption errors

pkg/connector/handlesignal.go

@@ -28,6 +28,7 @@ import (
  "maunium.net/go/mautrix/bridgev2"
  "maunium.net/go/mautrix/bridgev2/database"
  "maunium.net/go/mautrix/bridgev2/networkid"
+ "maunium.net/go/mautrix/bridgev2/simplevent"
  "maunium.net/go/mautrix/event"
 
  "go.mau.fi/mautrix-signal/pkg/signalid"
@@ -40,6 +41,7 @@ func (s *SignalClient) handleSignalEvent(rawEvt events.SignalEvent) {
  case *events.ChatEvent:
  s.Main.Bridge.QueueRemoteEvent(s.UserLogin, &Bv2ChatEvent{ChatEvent: evt, s: s})
  case *events.DecryptionError:
+ s.Main.Bridge.QueueRemoteEvent(s.UserLogin, s.wrapDecryptionError(evt))
  case *events.Receipt:
  s.handleSignalReceipt(evt)
  case *events.ReadSelf:
@@ -54,19 +56,22 @@ func (s *SignalClient) handleSignalEvent(rawEvt events.SignalEvent) {
 }
 
 func (s *SignalClient) wrapCallEvent(evt *events.Call) bridgev2.RemoteMessage {
- return &bridgev2.SimpleRemoteEvent[*events.Call]{
- Type: bridgev2.RemoteEventMessage,
- LogContext: func(c zerolog.Context) zerolog.Context {
- c = c.Stringer("sender_id", evt.Info.Sender)
- c = c.Uint64("message_ts", evt.Timestamp)
- return c
+ return &simplevent.Message[*events.Call]{
+ EventMeta: simplevent.EventMeta{
+ Type: bridgev2.RemoteEventMessage,
+ LogContext: func(c zerolog.Context) zerolog.Context {
+ c = c.Stringer("sender_id", evt.Info.Sender)
+ c = c.Uint64("message_ts", evt.Timestamp)
+ return c
+ },
+ PortalKey: s.makePortalKey(evt.Info.ChatID),
+ CreatePortal: true,
+ Sender: s.makeEventSender(evt.Info.Sender),
+ Timestamp: time.UnixMilli(int64(evt.Timestamp)),
  },
- PortalKey: s.makePortalKey(evt.Info.ChatID),
- Data: evt,
- CreatePortal: true,
- ID: signalid.MakeMessageID(evt.Info.Sender, evt.Timestamp),
- Sender: s.makeEventSender(evt.Info.Sender),
- Timestamp: time.UnixMilli(int64(evt.Timestamp)),
+ Data: evt,
+ ID: signalid.MakeMessageID(evt.Info.Sender, evt.Timestamp),
+
  ConvertMessageFunc: convertCallEvent,
  }
 }
@@ -91,6 +96,38 @@ func convertCallEvent(ctx context.Context, portal *bridgev2.Portal, intent bridg
  }, nil
 }
 
+func (s *SignalClient) wrapDecryptionError(evt *events.DecryptionError) bridgev2.RemoteMessage {
+ return &simplevent.Message[*events.DecryptionError]{
+ EventMeta: simplevent.EventMeta{
+ Type: bridgev2.RemoteEventMessage,
+ LogContext: func(c zerolog.Context) zerolog.Context {
+ c = c.Stringer("sender_id", evt.Sender)
+ return c
+ },
+ PortalKey: s.makePortalKey(evt.Sender.String()),
+ CreatePortal: true,
+ Sender: s.makeEventSender(evt.Sender),
+ Timestamp: time.UnixMilli(int64(evt.Timestamp)),
+ },
+ Data: evt,
+ ID: "decrypterr|" + signalid.MakeMessageID(evt.Sender, evt.Timestamp),
+
+ ConvertMessageFunc: convertDecryptionError,
+ }
+}
+
+func convertDecryptionError(_ context.Context, _ *bridgev2.Portal, _ bridgev2.MatrixAPI, _ *events.DecryptionError) (*bridgev2.ConvertedMessage, error) {
+ return &bridgev2.ConvertedMessage{
+ Parts: []*bridgev2.ConvertedMessagePart{{
+ Type: event.EventMessage,
+ Content: &event.MessageEventContent{
+ MsgType: event.MsgNotice,
+ Body: "Message couldn't be decrypted. It may have been in this chat or a group chat. Please check your Signal app.",
+ },
+ }},
+ }, nil
+}
+
 type Bv2ChatEvent struct {
  *events.ChatEvent
  s *SignalClient

pkg/signalmeow/events/message.go

@@ -49,8 +49,9 @@ type ChatEvent struct {
 }
 
 type DecryptionError struct {
- Sender uuid.UUID
- Err error
+ Sender uuid.UUID
+ Err error
+ Timestamp uint64
 }
 
 type Receipt struct {

pkg/signalmeow/receiving.go

@@ -276,6 +276,7 @@ func (cli *Client) incomingAPIMessageHandler(ctx context.Context, req *signalpb.
  destinationServiceID, err := libsignalgo.ServiceIDFromString(envelope.GetDestinationServiceId())
  log.Trace().
  Uint64("timestamp", envelope.GetTimestamp()).
+ Uint64("server_timestamp", envelope.GetServerTimestamp()).
  Str("destination_service_id", envelope.GetDestinationServiceId()).
  Str("source_service_id", envelope.GetSourceServiceId()).
  Uint32("source_device_id", envelope.GetSourceDevice()).
@@ -286,7 +287,7 @@ func (cli *Client) incomingAPIMessageHandler(ctx context.Context, req *signalpb.
 
  result := cli.decryptEnvelope(ctx, envelope)
 
- err = cli.handleDecryptedResult(ctx, result, destinationServiceID)
+ err = cli.handleDecryptedResult(ctx, result, destinationServiceID, envelope.GetServerTimestamp())
  if err != nil {
  log.Err(err).Msg("handleDecryptedResult error")
  return nil, err
@@ -613,6 +614,7 @@ func (cli *Client) handleDecryptedResult(
  ctx context.Context,
  result DecryptionResult,
  destinationServiceID libsignalgo.ServiceID,
+ serverTimestamp uint64,
 ) error {
  log := zerolog.Ctx(ctx)
  if result.Content == nil {
@@ -623,19 +625,20 @@ func (cli *Client) handleDecryptedResult(
  // result.Err is set if there was an error during decryption and we
  // should notifiy the user that the message could not be decrypted
  if result.Err != nil {
- log.Err(result.Err).Bool("urgent", result.Urgent).Msg("Decryption error")
  theirServiceID, err := result.SenderAddress.NameServiceID()
  if err != nil {
  log.Err(err).Msg("Name error handling decryption error")
  } else if theirServiceID.Type != libsignalgo.ServiceIDTypeACI {
  log.Warn().Any("their_service_id", theirServiceID).Msg("Sender ServiceID is not an ACI")
  }
+ log.Err(result.Err).Stringer("sender", theirServiceID).Bool("urgent", result.Urgent).Msg("Decryption error")
  // Only send decryption error event if the message was urgent,
  // to prevent spamming errors for typing notifications and whatnot
  if result.Urgent {
  cli.handleEvent(&events.DecryptionError{
- Sender: theirServiceID.UUID,
- Err: result.Err,
+ Sender: theirServiceID.UUID,
+ Err: result.Err,
+ Timestamp: serverTimestamp,
  })
  }
  // Intentionally not returning here. In most cases there's nothing besides the error so