fix(crypto): restore encrypted history and sending

Author: eleboucher

src-tauri/Cargo.toml

@@ -68,7 +68,10 @@ matrix-sdk = { version = "0.18", default-features = false, features = [
 ], optional = true }
 # `qrcode` is off by default upstream; Sable already supports QR device
 # verification, so the engine needs it for parity with the wasm backend.
-matrix-sdk-crypto = { version = "0.18", features = ["qrcode"], optional = true }
+matrix-sdk-crypto = { version = "0.18", features = [
+  "qrcode",
+  "experimental-push-secrets",
+], optional = true }
 # `bundled` compiles SQLite from source. Android's NDK ships no libsqlite3 to link
 # against at any API level, so without this the aarch64 build fails at link time.
 matrix-sdk-sqlite = { version = "0.18", features = ["crypto-store", "bundled"], optional = true }

src-tauri/src/matrix_crypto/cross_signing.rs

@@ -38,11 +38,7 @@ pub async fn invoke(
         "exportSecretsBundle" => export_secrets_bundle(machine).await,
         "importSecretsBundle" => import_secrets_bundle(machine, args).await,
 
-        // Gated in matrix-sdk-crypto 0.18 behind `experimental-push-secrets`.
-        "pushSecretToVerifiedDevices" => Err("pushSecretToVerifiedDevices: unavailable, \
-             matrix-sdk-crypto gates push_secret_to_verified_devices behind the \
-             `experimental-push-secrets` feature"
-            .to_owned()),
+        "pushSecretToVerifiedDevices" => push_secret(machine, args).await,
 
         _ => return None,
     })
@@ -191,3 +187,20 @@ mod tests {
         assert!(!object.contains_key("userSigningKey"), "{value}");
     }
 }
+
+async fn push_secret(machine: &OlmMachine, args: &Value) -> Result<Value, String> {
+    let name = opt_str_arg(args, "secretName")
+        .ok_or_else(|| "pushSecretToVerifiedDevices: missing `secretName`".to_owned())?;
+
+    let failures = machine
+        .push_secret_to_verified_devices(name.as_str().into())
+        .await
+        .map_err(|e| format!("pushSecretToVerifiedDevices failed: {e}"))?;
+
+    Ok(Value::Array(
+        failures
+            .keys()
+            .map(|device| Value::String(device.to_string()))
+            .collect(),
+    ))
+}

src-tauri/src/matrix_crypto/dispatch.rs

@@ -322,8 +322,12 @@ pub async fn invoke(machine: &OlmMachine, method: &str, args: Value) -> Result<V
                 .encrypt_room_event_raw(&room, &event_type, &content)
                 .await
                 .map_err(|e| format!("encryptRoomEvent failed: {e:?}"))?;
-            serde_json::from_str::<Value>(encrypted.content.json().get())
-                .map_err(|e| format!("encryptRoomEvent: bad encrypted content json: {e}"))
+            let encrypted_json = encrypted.content.json().get();
+            serde_json::from_str::<Value>(encrypted_json)
+                .map_err(|e| format!("encryptRoomEvent: bad encrypted content json: {e}"))?;
+
+            // Match wasm's JSON-string return type.
+            Ok(Value::String(encrypted_json.to_owned()))
         }
 
         "getSecretsFromInbox" => {

src-tauri/src/matrix_crypto/rooms.rs

@@ -353,3 +353,68 @@ pub async fn invoke(
         _ => return None,
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use matrix_sdk_crypto::CollectStrategy;
+
+    use super::{collect_strategy, encryption_settings};
+
+    #[test]
+    fn parses_every_sharing_strategy_the_webview_can_send() {
+        let cases = [
+            (
+                "identityBasedStrategy",
+                CollectStrategy::IdentityBasedStrategy,
+            ),
+            ("onlyTrustedDevices", CollectStrategy::OnlyTrustedDevices),
+            (
+                "errorOnVerifiedUserProblem",
+                CollectStrategy::ErrorOnVerifiedUserProblem,
+            ),
+            ("allDevices", CollectStrategy::AllDevices),
+        ];
+
+        for (name, expected) in cases {
+            let parsed = collect_strategy(Some(&json!(name)), "shareRoomKey")
+                .unwrap_or_else(|e| panic!("{name}: {e}"));
+            assert_eq!(
+                std::mem::discriminant(&parsed),
+                std::mem::discriminant(&expected),
+                "{name} parsed to the wrong strategy"
+            );
+        }
+    }
+
+    #[test]
+    fn rejects_an_unknown_strategy_rather_than_silently_sharing_with_everyone() {
+        let error = collect_strategy(Some(&json!("somethingElse")), "shareRoomKey").unwrap_err();
+        assert!(error.contains("somethingElse"), "{error}");
+    }
+
+    #[test]
+    fn reads_the_settings_shape_the_webview_encodes() {
+        let settings = encryption_settings(
+            &json!({
+                "encryptionSettings": {
+                    "algorithm": 1,
+                    "historyVisibility": 2,
+                    "rotationPeriod": 604_800_000_000u64,
+                    "rotationPeriodMessages": 100,
+                    "sharingStrategy": "onlyTrustedDevices",
+                }
+            }),
+            "shareRoomKey",
+        )
+        .unwrap();
+
+        assert_eq!(settings.rotation_period_msgs, 100);
+        assert_eq!(settings.rotation_period.as_secs(), 604_800);
+        assert_eq!(
+            std::mem::discriminant(&settings.sharing_strategy),
+            std::mem::discriminant(&CollectStrategy::OnlyTrustedDevices),
+        );
+    }
+}

src/app/crypto/olmMachine/backupImport.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it, vi } from 'vitest';
+import { OlmMachineProxy } from './proxy';
+import { engineInvoke } from './engineInvoke';
+
+vi.mock('./engineInvoke', () => ({
+  engineInvoke: vi.fn<(...args: never[]) => Promise<unknown>>(async () => ({
+    importedCount: 0,
+    totalCount: 0,
+  })),
+}));
+vi.mock('$generated/tauri/commands', () => ({ engineClose: vi.fn<() => Promise<void>>() }));
+
+const mockInvoke = vi.mocked(engineInvoke);
+
+const proxy = () =>
+  new OlmMachineProxy({
+    userId: '@me:example.org',
+    deviceId: 'DEVICE',
+    ed25519Key: 'ed',
+    curve25519Key: 'curve',
+    deviceCreationTimeMs: 0,
+  });
+
+const roomId = (id: string) => ({ toString: () => id });
+
+describe('importBackedUpRoomKeys', () => {
+  it('keeps every session when one room arrives as several map entries', async () => {
+    mockInvoke.mockClear();
+    const keysByRoom = new Map([
+      [roomId('!room:example.org'), new Map([['session-a', { session_id: 'session-a' }]])],
+      [roomId('!room:example.org'), new Map([['session-b', { session_id: 'session-b' }]])],
+      [roomId('!other:example.org'), new Map([['session-c', { session_id: 'session-c' }]])],
+    ]);
+
+    await proxy().importBackedUpRoomKeys(keysByRoom, undefined, '7');
+
+    const args = mockInvoke.mock.calls[0]?.[2] as {
+      keys: Record<string, Record<string, unknown>>;
+    };
+    expect(Object.keys(args.keys['!room:example.org'] ?? {})).toEqual(['session-a', 'session-b']);
+    expect(Object.keys(args.keys['!other:example.org'] ?? {})).toEqual(['session-c']);
+  });
+
+  it('passes the backup version through, not the progress listener', async () => {
+    mockInvoke.mockClear();
+    const listener = vi.fn<(a: bigint, b: bigint, c: bigint) => void>();
+
+    await proxy().importBackedUpRoomKeys(new Map(), listener, '7');
+
+    const args = mockInvoke.mock.calls[0]?.[2] as { backupVersion: unknown };
+    expect(args.backupVersion).toBe('7');
+    expect(listener).toHaveBeenCalled();
+  });
+});

src/app/crypto/olmMachine/ipcContract.test.ts

@@ -32,4 +32,10 @@ describe('engine IPC contract', () => {
 
     expect([...called].filter((method) => !handled(method)).toSorted()).toEqual([]);
   });
+
+  it('returns encrypted room content using the wasm JSON-string contract', () => {
+    expect(rust).toMatch(
+      /"encryptRoomEvent" =>[\s\S]*Ok\(Value::String\(encrypted_json\.to_owned\(\)\)\)/
+    );
+  });
 });

src/app/crypto/olmMachine/proxy.ts

@@ -3,9 +3,11 @@ import { engineClose } from '$generated/tauri/commands';
 import {
   encodeDecryptionSettings,
   encodeEncryptionSettings,
+  encodeRoomSettings,
   graftWasmPrototypes,
   keyToBase64,
   RustSdkCryptoJs,
+  toMegolmDecryptionError,
 } from './wasmClasses';
 import { engineInvoke, type EngineIdentity } from './engineInvoke';
 import type { HydrationContext } from './hydrate';
@@ -336,11 +338,15 @@ export class OlmMachineProxy {
   }
 
   async decryptRoomEvent(event: string, roomId: unknown, ...rest: unknown[]): Promise<unknown> {
-    return this.#call('decryptRoomEvent', {
-      event,
-      roomId: String(roomId),
-      decryptionSettings: encodeDecryptionSettings(rest.at(-1)),
-    });
+    try {
+      return await this.#call('decryptRoomEvent', {
+        event,
+        roomId: String(roomId),
+        decryptionSettings: encodeDecryptionSettings(rest.at(-1)),
+      });
+    } catch (error) {
+      throw toMegolmDecryptionError(error);
+    }
   }
 
   async encryptRoomEvent(roomId: unknown, eventType: string, content: string): Promise<unknown> {
@@ -391,7 +397,10 @@ export class OlmMachineProxy {
   }
 
   async setRoomSettings(roomId: unknown, settings: unknown): Promise<void> {
-    await this.#call('setRoomSettings', { roomId: String(roomId), settings });
+    await this.#call('setRoomSettings', {
+      roomId: String(roomId),
+      settings: encodeRoomSettings(settings),
+    });
   }
 
   async roomKeyCounts(): Promise<unknown> {
@@ -514,14 +523,14 @@ export class OlmMachineProxy {
     progressListener?: (progress: bigint, total: bigint, failures: bigint) => void,
     backupVersion?: string
   ): Promise<unknown> {
+    // RoomId keys compare by identity, so merge entries by their string value.
     const keys: Record<string, Record<string, unknown>> = {};
     if (keysByRoom instanceof Map) {
       for (const [roomId, sessions] of keysByRoom) {
-        const room: Record<string, unknown> = {};
+        const room = (keys[String(roomId)] ??= {});
         if (sessions instanceof Map) {
           for (const [sessionId, key] of sessions) room[String(sessionId)] = key;
         }
-        keys[String(roomId)] = room;
       }
     }
 

src/app/crypto/olmMachine/wasmClasses.test.ts

@@ -2,9 +2,11 @@ import * as RustSdkCryptoJs from '@matrix-org/matrix-sdk-crypto-wasm';
 import { describe, expect, it } from 'vitest';
 import {
   encodeDecryptionSettings,
+  encodeRoomSettings,
   encodeEncryptionSettings,
   graftWasmPrototypes,
   keyToBase64,
+  toMegolmDecryptionError,
 } from './wasmClasses';
 import type { HydrationContext } from './hydrate';
 
@@ -22,6 +24,26 @@ describe('keyToBase64', () => {
   });
 });
 
+describe('toMegolmDecryptionError', () => {
+  it('preserves the missing-room-key type needed by the backup downloader', () => {
+    const error = toMegolmDecryptionError(
+      'decryptRoomEvent failed: MissingRoomKey(None)'
+    ) as RustSdkCryptoJs.MegolmDecryptionError;
+
+    expect(error).toBeInstanceOf(RustSdkCryptoJs.MegolmDecryptionError);
+    expect(error.code).toBe(RustSdkCryptoJs.DecryptionErrorCode.MissingRoomKey);
+    expect(error.maybe_withheld).toBeUndefined();
+  });
+
+  it('uses the generic wasm error code for an unclassified Rust failure', () => {
+    const error = toMegolmDecryptionError(
+      'decryptRoomEvent failed: Store error'
+    ) as RustSdkCryptoJs.MegolmDecryptionError;
+
+    expect(error.code).toBe(RustSdkCryptoJs.DecryptionErrorCode.UnableToDecrypt);
+  });
+});
+
 describe('encodeEncryptionSettings', () => {
   it('loses nothing that JSON.stringify would drop', () => {
     const settings = new RustSdkCryptoJs.EncryptionSettings();
@@ -100,3 +122,20 @@ describe('graftWasmPrototypes', () => {
     expect(Object.hasOwn(grafted, 'id')).toBe(true);
   });
 });
+
+describe('encodeRoomSettings', () => {
+  it('reads the wasm accessors that JSON.stringify would drop', () => {
+    const settings = new RustSdkCryptoJs.RoomSettings();
+    settings.onlyAllowTrustedDevices = true;
+    settings.sessionRotationPeriodMs = 604800000;
+    settings.sessionRotationPeriodMessages = 100;
+
+    expect(JSON.parse(JSON.stringify(settings))).not.toHaveProperty('onlyAllowTrustedDevices');
+    expect(encodeRoomSettings(settings)).toMatchObject({
+      algorithm: settings.algorithm,
+      onlyAllowTrustedDevices: true,
+      sessionRotationPeriodMs: 604800000,
+      sessionRotationPeriodMessages: 100,
+    });
+  });
+});

src/app/crypto/olmMachine/wasmClasses.ts

@@ -32,10 +32,23 @@ export const collectStrategyName = (strategy: unknown): string => {
   return 'allDevices';
 };
 
-// Wasm accessors live on the prototype, so JSON would carry only the internal pointer, and a
-// dropped `sharingStrategy` silently means "share room keys with every device".
 const num = (value: unknown) => (typeof value === 'bigint' ? Number(value) : value);
 
+// Read wasm prototype getters before crossing the JSON boundary.
+export const encodeRoomSettings = (settings: unknown): Record<string, unknown> | null => {
+  if (settings === null || typeof settings !== 'object') return null;
+  const s = settings as Record<string, unknown>;
+  return {
+    algorithm: s.algorithm,
+    encryptStateEvents: s.encryptStateEvents,
+    onlyAllowTrustedDevices: s.onlyAllowTrustedDevices,
+    sessionRotationPeriodMs: num(s.sessionRotationPeriodMs),
+    sessionRotationPeriodMessages: num(s.sessionRotationPeriodMessages),
+  };
+};
+
+// Wasm accessors live on the prototype, so JSON would carry only the internal pointer, and a
+// dropped `sharingStrategy` silently means "share room keys with every device".
 export const encodeEncryptionSettings = (settings: unknown): Record<string, unknown> | null => {
   if (settings === null || typeof settings !== 'object') return null;
   const s = settings as Record<string, unknown>;
@@ -53,6 +66,28 @@ export const encodeDecryptionSettings = (settings: unknown): Record<string, unkn
   return { senderDeviceTrustRequirement: typeof trust === 'number' ? trust : 0 };
 };
 
+const errorMessage = (error: unknown): string =>
+  error instanceof Error ? error.message : String(error);
+
+export const toMegolmDecryptionError = (error: unknown): unknown => {
+  const description = errorMessage(error);
+  const codes = RustSdkCryptoJs.DecryptionErrorCode;
+  let code = codes.UnableToDecrypt;
+
+  if (description.includes('MissingRoomKey')) code = codes.MissingRoomKey;
+  else if (description.includes('UnknownMessageIndex')) code = codes.UnknownMessageIndex;
+  else if (description.includes('MismatchedIdentityKeys')) code = codes.MismatchedIdentityKeys;
+  else if (description.includes('VerificationViolation')) {
+    code = codes.SenderIdentityVerificationViolation;
+  } else if (description.includes('UnsignedDevice')) code = codes.UnsignedSenderDevice;
+  else if (description.includes('SenderIdentityNotTrusted(None')) code = codes.UnknownSenderDevice;
+  else if (description.includes('MismatchedSender')) code = codes.MismatchedSender;
+
+  const wrapped = { code, description, maybe_withheld: undefined };
+  Object.setPrototypeOf(wrapped, RustSdkCryptoJs.MegolmDecryptionError.prototype);
+  return wrapped;
+};
+
 const hasOwnPrototype = (name: string): boolean => {
   const candidate = (RustSdkCryptoJs as Record<string, unknown>)[name];
   return typeof candidate === 'function' && 'prototype' in candidate;