Update decryption error status events

Author: tulir

mautrix/bridge/matrix.py

@@ -33,6 +33,7 @@
     MemberStateEventContent,
     MessageEvent,
     MessageEventContent,
+    MessageStatus,
     MessageStatusReason,
     MessageType,
     PresenceEvent,
@@ -93,6 +94,44 @@
 )
 
 
+class UnencryptedMessageError(DecryptionError):
+    def __init__(self) -> None:
+        super().__init__("unencrypted message")
+
+    @property
+    def human_message(self) -> str:
+        return "the message is not encrypted"
+
+
+class EncryptionUnsupportedError(DecryptionError):
+    def __init__(self) -> None:
+        super().__init__("encryption is not supported")
+
+    @property
+    def human_message(self) -> str:
+        return "the bridge is not configured to support encryption"
+
+
+class DeviceUntrustedError(DecryptionError):
+    def __init__(self, trust: TrustState) -> None:
+        explanation = {
+            TrustState.BLACKLISTED: "device is blacklisted",
+            TrustState.UNVERIFIED: "unverified",
+            TrustState.UNKNOWN_DEVICE: "device info not found",
+            TrustState.FORWARDED: "keys were forwarded from an unknown device",
+            TrustState.CROSS_SIGNED_UNTRUSTED: (
+                "cross-signing keys changed after setting up the bridge"
+            ),
+        }.get(trust)
+        base = "your device is not trusted"
+        self.message = f"{base} ({explanation})" if explanation else base
+        super().__init__(self.message)
+
+    @property
+    def human_message(self) -> str:
+        return self.message
+
+
 class BaseMatrixHandler:
     log: TraceLogger = logging.getLogger("mau.mx")
     az: AppService
@@ -506,23 +545,23 @@ def is_command(self, message: MessageEventContent) -> tuple[bool, str]:
     async def _send_crypto_status_error(
         self,
         evt: Event,
-        err: Exception | str | None = None,
+        err: DecryptionError | None = None,
         retry_num: int = 0,
         is_final: bool = True,
         edit: EventID | None = None,
         wait_for: int | None = None,
     ) -> EventID | None:
         msg = str(err)
-        if isinstance(err, SessionNotFound):
-            msg = "the bridge hasn't received the decryption keys"
+        if isinstance(err, (SessionNotFound, UnencryptedMessageError)):
+            msg = err.human_message
         self._send_message_checkpoint(
             evt, MessageSendCheckpointStep.DECRYPTED, msg, permanent=is_final, retry_num=retry_num
         )
 
         if wait_for:
             msg += f". The bridge will retry for {wait_for} seconds"
-        full_msg = f"\u26a0\ufe0f Your message was not bridged: {msg}."
-        if msg == "encryption is not supported":
+        full_msg = f"\u26a0 Your message was not bridged: {msg}."
+        if isinstance(err, EncryptionUnsupportedError):
             full_msg = "🔒️ This bridge has not been configured to support encryption"
         event_id = None
         if self.config.get("bridge.delivery_error_reports", True):
@@ -544,12 +583,12 @@ async def _send_crypto_status_error(
             status_content = BeeperMessageStatusEventContent(
                 network="",  # TODO set network properly
                 relates_to=RelatesTo(rel_type=RelationType.REFERENCE, event_id=evt.event_id),
-                success=False,
-                is_certain=True,
-                can_retry=True,
+                status=MessageStatus.RETRIABLE if is_final else MessageStatus.PENDING,
                 reason=MessageStatusReason.UNDECRYPTABLE,
                 error=msg,
+                message=err.human_message if err else None,
             )
+            status_content.fill_legacy_booleans()
             await self.az.intent.send_message_event(
                 evt.room_id, EventType.BEEPER_MESSAGE_STATUS, status_content
             )
@@ -564,7 +603,7 @@ async def handle_message(self, evt: MessageEvent, was_encrypted: bool = False) -
 
         if not was_encrypted and self.require_e2ee:
             self.log.warning(f"Dropping {event_id} from {user_id} as it's not encrypted!")
-            await self._send_crypto_status_error(evt, "unencrypted message", 0)
+            await self._send_crypto_status_error(evt, UnencryptedMessageError(), 0)
             return
 
         sender = await self.bridge.get_user(user_id)
@@ -714,19 +753,6 @@ async def try_handle_sync_event(self, evt: Event) -> None:
         except Exception:
             self.log.exception("Error handling manually received Matrix event")
 
-    @staticmethod
-    def _device_unverified_explanation(trust: TrustState) -> str:
-        explanation = {
-            TrustState.BLACKLISTED: "device is blacklisted",
-            TrustState.UNKNOWN_DEVICE: "device info not found",
-            TrustState.FORWARDED: "keys were forwarded from an unknown device",
-            TrustState.CROSS_SIGNED_UNTRUSTED: (
-                "cross-signing keys changed after setting up the bridge"
-            ),
-        }.get(trust)
-        base = "your device is not trusted"
-        return f"{base} ({explanation})" if explanation else base
-
     async def _post_decrypt(
         self, evt: Event, retry_num: int = 0, error_event_id: EventID | None = None
     ) -> None:
@@ -739,7 +765,7 @@ async def _post_decrypt(
             await self._send_crypto_status_error(
                 evt,
                 retry_num=retry_num,
-                err=self._device_unverified_explanation(trust_state),
+                err=DeviceUntrustedError(trust_state),
                 edit=error_event_id,
             )
             return
@@ -758,7 +784,7 @@ async def handle_encrypted(self, evt: EncryptedEvent) -> None:
                 evt.event_id,
                 evt.sender,
             )
-            await self._send_crypto_status_error(evt, "encryption is not supported")
+            await self._send_crypto_status_error(evt, EncryptionUnsupportedError())
             return
         try:
             decrypted = await self.e2ee.decrypt(evt, wait_session_timeout=3)

mautrix/errors/crypto.py

@@ -27,7 +27,9 @@ class SessionShareError(CryptoError):
 
 
 class DecryptionError(CryptoError):
-    pass
+    @property
+    def human_message(self) -> str:
+        return "the bridge failed to decrypt the message"
 
 
 class MatchingSessionDecryptionError(DecryptionError):
@@ -42,6 +44,10 @@ def __init__(self, session_id: SessionID, sender_key: IdentityKey | None = None)
         self.session_id = session_id
         self._sender_key = sender_key
 
+    @property
+    def human_message(self) -> str:
+        return "the bridge hasn't received the decryption keys"
+
     @property
     def sender_key(self) -> IdentityKey | None:
         """

mautrix/types/__init__.py

@@ -86,6 +86,7 @@
     MemberStateEventContent,
     MessageEvent,
     MessageEventContent,
+    MessageStatus,
     MessageStatusReason,
     MessageType,
     MessageUnsigned,
@@ -277,6 +278,7 @@
     "MemberStateEventContent",
     "MessageEvent",
     "MessageEventContent",
+    "MessageStatus",
     "MessageStatusReason",
     "MessageType",
     "MessageUnsigned",

mautrix/types/event/__init__.py

@@ -11,7 +11,12 @@
 )
 from .base import BaseEvent, BaseRoomEvent, BaseUnsigned, GenericEvent
 from .batch import BatchSendEvent, BatchSendStateEvent
-from .beeper import BeeperMessageStatusEvent, BeeperMessageStatusEventContent, MessageStatusReason
+from .beeper import (
+    BeeperMessageStatusEvent,
+    BeeperMessageStatusEventContent,
+    MessageStatus,
+    MessageStatusReason,
+)
 from .encrypted import (
     EncryptedEvent,
     EncryptedEventContent,

mautrix/types/event/beeper.py

@@ -32,21 +32,36 @@ def checkpoint_status(self):
         return MessageSendCheckpointStatus.PERM_FAILURE
 
 
-@dataclass
+class MessageStatus(SerializableEnum):
+    SUCCESS = "SUCCESS"
+    PENDING = "PENDNIG"
+    RETRIABLE = "FAIL_RETRIABLE"
+    FAIL = "FAIL_PERMANENT"
+
+
+@dataclass(kw_only=True)
 class BeeperMessageStatusEventContent(SerializableAttrs):
-    network: str
-    success: bool
     relates_to: RelatesTo = field(json="m.relates_to")
+    network: str = ""
+    status: Optional[MessageStatus] = None
 
     reason: Optional[MessageStatusReason] = None
     error: Optional[str] = None
     message: Optional[str] = None
+
+    success: Optional[bool] = None
+    still_working: Optional[bool] = None
     can_retry: Optional[bool] = None
     is_certain: Optional[bool] = None
 
-    still_working: Optional[bool] = None
     last_retry: Optional[EventID] = None
 
+    def fill_legacy_booleans(self) -> None:
+        self.success = self.status == MessageStatus.SUCCESS
+        if not self.success:
+            self.still_working = self.status == MessageStatus.PENDING
+            self.can_retry = self.status in (MessageStatus.PENDING, MessageStatus.RETRIABLE)
+
 
 @dataclass
 class BeeperMessageStatusEvent(BaseRoomEvent, SerializableAttrs):