async-matrix 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cde8ca8632d237c371ec9a8a4ee8a422414b7e69222ca263ba505107d1dd234
-  data.tar.gz: 24583da0bbd5f8552990e5e1ce21d1b89dbdc41f7024da7d0377e5393665ce4e
+  metadata.gz: fbcd762ae4584a018455d875317aed89d4a40751b3c5ded892451411d95cf89c
+  data.tar.gz: 49f07effb6009235cab4ac84d727a4b34cde54c7406463dedd625f037eac7a81
 SHA512:
-  metadata.gz: f2d44ac4cbd06266e2988bb99af9de6051a0504e448ec8c730fc8978d5e91e023eae0f2dc01b7c45100344285b2e591237ffa349f72e8466dc634552947e7e74
-  data.tar.gz: aaaf8397d618585875a7447c7b46ca8e1d4802cda7dbbf98d6a3b66e9e3decda4a29d6f61ae9a04acaa12abaebb888d18137bc2efed91ec628b5eedd9a4332ca
+  metadata.gz: d01ca57fe8befccd8d0e66e23b2fe52ee76cdc934785106d620c29f267467aa387437097c0e23861de8fe0da4f71e3193f201b43bc12d0bf6184343cb7038759
+  data.tar.gz: df8f42bfd7c0b163b17707be2412ef16f75350246ee2ddfed29217046c81277040800d75e8058da4e0d83a67c5ad39db30b5cdc2ce3b396035194325d8af4752

data/ext/async_matrix_e2ee/src/lib.rs

@@ -20,8 +20,9 @@ use vodozemac::olm::{
     SessionConfig as OlmSessionConfig, SessionPickle,
 };
 use vodozemac::megolm::{
-    GroupSession as MegolmGroupSession, GroupSessionPickle, InboundGroupSession as MegolmInbound,
-    InboundGroupSessionPickle, MegolmMessage, SessionConfig as MegolmSessionConfig, SessionKey,
+    ExportedSessionKey, GroupSession as MegolmGroupSession, GroupSessionPickle,
+    InboundGroupSession as MegolmInbound, InboundGroupSessionPickle, MegolmMessage,
+    SessionConfig as MegolmSessionConfig, SessionKey,
 };
 
 // --- helpers ---------------------------------------------------------------
@@ -236,6 +237,27 @@ impl InboundGroupSession {
         ))))
     }
 
+    /// Build from a base64 **exported** session key.
+    ///
+    /// This is the format room keys travel in outside of `m.room_key`: server-side
+    /// key backup (`m.megolm_backup.v1.curve25519-aes-sha2`) and
+    /// `m.forwarded_room_key` both carry an `ExportedSessionKey`, which is
+    /// version 1 and carries no signature — so `new` (which requires a signed
+    /// version 2 `SessionKey`) cannot accept them. Without this, a client can
+    /// never read history it did not receive a live `m.room_key` for.
+    ///
+    /// The resulting session is NOT signature-verified, because an exported key
+    /// has no signature to verify. That is inherent to the format: the sender
+    /// identity of such a session is only as trustworthy as whoever handed it
+    /// over, which is why the spec treats backup-restored keys as unverified.
+    fn import(exported_key: String) -> Result<Self, Error> {
+        let key = ExportedSessionKey::from_base64(&exported_key).map_err(rt_err)?;
+        Ok(InboundGroupSession(RefCell::new(MegolmInbound::import(
+            &key,
+            MegolmSessionConfig::version_1(),
+        ))))
+    }
+
     fn session_id(&self) -> String {
         self.0.borrow().session_id()
     }
@@ -244,6 +266,19 @@ impl InboundGroupSession {
         self.0.borrow().first_known_index()
     }
 
+    /// Export this session at `index`, base64, for uploading to key backup or
+    /// forwarding to another device. Returns nil when the ratchet has already
+    /// moved past `index` and can no longer produce a key for it — megolm
+    /// ratchets forward only, so an earlier index is unrecoverable by design.
+    fn export_at(&self, index: u32) -> Option<String> {
+        self.0.borrow_mut().export_at(index).map(|key| key.to_base64())
+    }
+
+    /// Export at the earliest index this session can still reach.
+    fn export_at_first_known_index(&self) -> String {
+        self.0.borrow().export_at_first_known_index().to_base64()
+    }
+
     /// Decrypts a base64 megolm message; returns `[plaintext, message_index]`.
     fn decrypt(&self, message: String) -> Result<(String, u32), Error> {
         let msg = MegolmMessage::from_base64(&message).map_err(rt_err)?;
@@ -316,11 +351,17 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
 
     let inbound = namespace.define_class("InboundGroupSession", ruby.class_object())?;
     inbound.define_singleton_method("new", function!(InboundGroupSession::new, 1))?;
+    inbound.define_singleton_method("import", function!(InboundGroupSession::import, 1))?;
     inbound.define_singleton_method("from_pickle", function!(InboundGroupSession::from_pickle, 2))?;
     inbound.define_method("session_id", method!(InboundGroupSession::session_id, 0))?;
     inbound.define_method("first_known_index", method!(InboundGroupSession::first_known_index, 0))?;
     inbound.define_method("decrypt", method!(InboundGroupSession::decrypt, 1))?;
     inbound.define_method("pickle", method!(InboundGroupSession::pickle, 1))?;
+    inbound.define_method("export_at", method!(InboundGroupSession::export_at, 1))?;
+    inbound.define_method(
+        "export_at_first_known_index",
+        method!(InboundGroupSession::export_at_first_known_index, 0),
+    )?;
 
     namespace.define_module_function("verify_signature", function!(verify_signature, 3))?;
 

data/lib/async/matrix/e2ee.rb

@@ -56,6 +56,43 @@ __END__
       inbound.session_id.should == group.session_id
     end
 
+    it "imports an exported session key" do
+      # The path room keys take out of server-side key backup and out of
+      # m.forwarded_room_key. Without .import these are unusable, and a client
+      # can never read history it did not get a live m.room_key for.
+      group   = Async::Matrix::E2EE::GroupSession.new
+      inbound = Async::Matrix::E2EE::InboundGroupSession.new(group.session_key)
+      message = group.encrypt("restored from backup")
+
+      exported = inbound.export_at_first_known_index
+      restored = Async::Matrix::E2EE::InboundGroupSession.import(exported)
+
+      restored.session_id.should == group.session_id
+      restored.decrypt(message).first.should == "restored from backup"
+    end
+
+    it "rejects an exported key passed to .new, which requires a signature" do
+      # .new takes a version-2 SessionKey and verifies its signature; an exported
+      # key is version 1 and unsigned, so it must go through .import instead.
+      group    = Async::Matrix::E2EE::GroupSession.new
+      inbound  = Async::Matrix::E2EE::InboundGroupSession.new(group.session_key)
+      exported = inbound.export_at_first_known_index
+
+      lambda {
+        Async::Matrix::E2EE::InboundGroupSession.new(exported)
+      }.should.raise(RuntimeError)
+    end
+
+    it "exports at a given message index" do
+      group   = Async::Matrix::E2EE::GroupSession.new
+      inbound = Async::Matrix::E2EE::InboundGroupSession.new(group.session_key)
+      3.times { |i| group.encrypt("msg #{i}") }
+
+      Async::Matrix::E2EE::InboundGroupSession
+        .import(inbound.export_at(0))
+        .first_known_index.should == 0
+    end
+
     it "round-trips an olm 1:1 message" do
       alice = Async::Matrix::E2EE::Account.new
       bob   = Async::Matrix::E2EE::Account.new

data/lib/async/matrix/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module Matrix
-    VERSION = "2.0.1"
+    VERSION = "2.1.0"
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-matrix
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Nathan Kidd
@@ -191,6 +191,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: lefthook
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
 description: Async-native Matrix protocol primitives built on the Socketry async ecosystem.
   Provides well-known discovery, event notification, and application service models.
 email: