async-matrix 3.0.1 → 4.0.0

data/data/matrix-spec/event-schemas/schema/m.tag.yaml

@@ -1,28 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "type": "object",
-  "title": "Tag Event",
-  "description": "Informs the client of tags on a room.",
-  "allOf": [{
-    "$ref": "core-event-schema/event.yaml"
-  }],
-  "properties": {
-    "type": {
-      "type": "string",
-      "enum": ["m.tag"]
-    },
-    "content": {
-      "type": "object",
-      "properties": {
-        "tags": {
-          "type": "object",
-          "description": "The tags on the room and their contents.",
-          "additionalProperties": {
-            "$ref": "../../api/client-server/definitions/tag.yaml"
-          }
-        }
-      }
-    }
-  },
-  "required": ["type", "content"]
-}

data/data/matrix-spec/event-schemas/schema/m.typing.yaml

@@ -1,29 +0,0 @@
-{
-    "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "type": "object",
-    "title": "Typing Event",
-    "description": "Informs the client of the list of users currently typing.",
-    "allOf": [{
-        "$ref": "core-event-schema/event.yaml"
-    }],
-    "properties": {
-        "content": {
-            "type": "object",
-            "properties": {
-                "user_ids": {
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    },
-                    "description": "The list of user IDs typing in this room, if any."
-                }
-            },
-            "required": ["user_ids"]
-        },
-        "type": {
-            "type": "string",
-            "enum": ["m.typing"]
-        }
-    },
-    "required": ["type", "content"]
-}

data/ext/async_matrix_e2ee/Cargo.toml

@@ -1,34 +0,0 @@
-[package]
-name = "async_matrix_e2ee"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-name = "async_matrix_e2ee"
-crate-type = ["cdylib"]
-
-[dependencies]
-# magnus 0.8 is required for Ruby 4.0 C-API compatibility (0.7 fails to compile
-# against Ruby 4.0: rb_fiber_raise pointer mutability + RTypedData.typed_flag).
-#
-# 0.9 is required to cross-compile for arm-linux-musl. On 32-bit musl, bindgen
-# renders timespec's padding around tv_nsec as bitfield members, so magnus 0.8's
-# `From<Timespec> for timespec` struct literal fails with E0063 (missing fields
-# `_bitfield_1`, `_bitfield_align_1`). 0.9 builds the struct with mem::zeroed
-# and assigns the two fields instead.
-magnus = "0.9"
-
-# vodozemac 0.10.0 (2026-04-13), default features (libolm-compat).
-#
-# - 0.10 is the release that fixes the all-zero / non-contributory DH issue from
-#   Soatok's review (the proposed patch was deprecated `since = "0.10.0"`), so we
-#   pin >= 0.10 rather than 0.9.
-# - There is no `strict-signatures` feature in 0.10 (it existed pre-0.10; the
-#   related signature-verification hardening was resolved upstream).
-# - There is no `fuzzing` Cargo feature: vodozemac's MAC/signature bypass is
-#   gated behind `#[cfg(fuzzing)]`, only set by `cargo fuzz`
-#   (RUSTFLAGS=--cfg fuzzing). A normal `cargo build`/`rake compile` never
-#   enables it. Never build production artifacts with `cargo fuzz`.
-[dependencies.vodozemac]
-version = "0.10"

data/ext/async_matrix_e2ee/extconf.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require "mkmf"
-require "rb_sys/mkmf"
-
-# Builds the Rust crate in this directory and produces async_matrix_e2ee.so.
-# The crate's #[magnus::init] defines the classes under Async::Matrix::E2EE.
-create_rust_makefile("async_matrix_e2ee")

data/ext/async_matrix_e2ee/src/lib.rs

@@ -1,369 +0,0 @@
-//! Ruby bindings for vodozemac (Matrix Olm/Megolm), via magnus.
-//!
-//! This is the Ruby analogue of matrix-nio/vodozemac-python (which uses PyO3).
-//! It exposes vodozemac's Account / Session (Olm) and GroupSession /
-//! InboundGroupSession (Megolm) under the `Async::Matrix::E2EE` module.
-//!
-//! The API is deliberately base64-string / integer centric rather than passing
-//! wrapped key objects around: Matrix moves keys and ciphertext as base64
-//! strings inside JSON, so a string API drops straight into the protocol layer
-//! and keeps the magnus surface small.
-
-use std::cell::RefCell;
-use std::collections::HashMap;
-
-use magnus::{function, method, prelude::*, Error, Ruby};
-
-use vodozemac::{base64_decode, base64_encode, Curve25519PublicKey, Ed25519PublicKey, Ed25519Signature};
-use vodozemac::olm::{
-    Account as OlmAccount, AccountPickle, OlmMessage, PreKeyMessage, Session as OlmSession,
-    SessionConfig as OlmSessionConfig, SessionPickle,
-};
-use vodozemac::megolm::{
-    ExportedSessionKey, GroupSession as MegolmGroupSession, GroupSessionPickle,
-    InboundGroupSession as MegolmInbound, InboundGroupSessionPickle, MegolmMessage,
-    SessionConfig as MegolmSessionConfig, SessionKey,
-};
-
-// --- helpers ---------------------------------------------------------------
-
-fn rt_err<E: std::fmt::Display>(e: E) -> Error {
-    // Safe: every caller runs inside a Ruby method invocation (GVL held).
-    let ruby = Ruby::get().expect("rt_err called outside the Ruby VM");
-    Error::new(ruby.exception_runtime_error(), e.to_string())
-}
-
-fn key32(label: &str, bytes: &[u8]) -> Result<[u8; 32], Error> {
-    bytes
-        .try_into()
-        .map_err(|_| rt_err(format!("{label} must be 32 bytes, got {}", bytes.len())))
-}
-
-// --- Account ---------------------------------------------------------------
-
-#[magnus::wrap(class = "Async::Matrix::E2EE::Account", free_immediately, size)]
-struct Account(RefCell<OlmAccount>);
-
-impl Account {
-    fn new() -> Self {
-        Account(RefCell::new(OlmAccount::new()))
-    }
-
-    fn from_pickle(pickle: String, pickle_key: String) -> Result<Self, Error> {
-        let key = key32("pickle_key", pickle_key.as_bytes())?;
-        let p = AccountPickle::from_encrypted(&pickle, &key).map_err(rt_err)?;
-        Ok(Account(RefCell::new(OlmAccount::from_pickle(p))))
-    }
-
-    fn pickle(&self, pickle_key: String) -> Result<String, Error> {
-        let key = key32("pickle_key", pickle_key.as_bytes())?;
-        Ok(self.0.borrow().pickle().encrypt(&key))
-    }
-
-    fn ed25519_key(&self) -> String {
-        self.0.borrow().ed25519_key().to_base64()
-    }
-
-    fn curve25519_key(&self) -> String {
-        self.0.borrow().curve25519_key().to_base64()
-    }
-
-    fn sign(&self, message: String) -> String {
-        self.0.borrow().sign(message.as_bytes()).to_base64()
-    }
-
-    fn one_time_keys(&self) -> HashMap<String, String> {
-        self.0
-            .borrow()
-            .one_time_keys()
-            .into_iter()
-            .map(|(k, v)| (k.to_base64(), v.to_base64()))
-            .collect()
-    }
-
-    fn max_number_of_one_time_keys(&self) -> usize {
-        self.0.borrow().max_number_of_one_time_keys()
-    }
-
-    fn generate_one_time_keys(&self, count: usize) {
-        self.0.borrow_mut().generate_one_time_keys(count);
-    }
-
-    fn fallback_key(&self) -> HashMap<String, String> {
-        self.0
-            .borrow()
-            .fallback_key()
-            .into_iter()
-            .map(|(k, v)| (k.to_base64(), v.to_base64()))
-            .collect()
-    }
-
-    fn generate_fallback_key(&self) {
-        self.0.borrow_mut().generate_fallback_key();
-    }
-
-    fn mark_keys_as_published(&self) {
-        self.0.borrow_mut().mark_keys_as_published();
-    }
-
-    /// Returns a Session for sending to a peer identified by their identity and
-    /// one-time keys (both base64).
-    fn create_outbound_session(
-        &self,
-        identity_key: String,
-        one_time_key: String,
-    ) -> Result<Session, Error> {
-        let ik = Curve25519PublicKey::from_base64(&identity_key).map_err(rt_err)?;
-        let otk = Curve25519PublicKey::from_base64(&one_time_key).map_err(rt_err)?;
-        let session = self
-            .0
-            .borrow()
-            .create_outbound_session(OlmSessionConfig::version_1(), ik, otk)
-            .map_err(rt_err)?;
-        Ok(Session(RefCell::new(session)))
-    }
-
-    /// Establishes an inbound Session from a received pre-key message (base64
-    /// body, as carried in an m.room.encrypted olm `body`). Returns
-    /// `[session, plaintext]`.
-    fn create_inbound_session(
-        &self,
-        identity_key: String,
-        prekey_message_body: String,
-    ) -> Result<(Session, String), Error> {
-        let ik = Curve25519PublicKey::from_base64(&identity_key).map_err(rt_err)?;
-        let prekey = PreKeyMessage::from_base64(&prekey_message_body).map_err(rt_err)?;
-        let result = self
-            .0
-            .borrow_mut()
-            .create_inbound_session(OlmSessionConfig::version_1(), ik, &prekey)
-            .map_err(rt_err)?;
-        let plaintext = String::from_utf8(result.plaintext).map_err(rt_err)?;
-        Ok((Session(RefCell::new(result.session)), plaintext))
-    }
-}
-
-// --- Session (Olm 1:1) -----------------------------------------------------
-
-#[magnus::wrap(class = "Async::Matrix::E2EE::Session", free_immediately, size)]
-struct Session(RefCell<OlmSession>);
-
-impl Session {
-    fn session_id(&self) -> String {
-        self.0.borrow().session_id()
-    }
-
-    fn pickle(&self, pickle_key: String) -> Result<String, Error> {
-        let key = key32("pickle_key", pickle_key.as_bytes())?;
-        Ok(self.0.borrow().pickle().encrypt(&key))
-    }
-
-    fn from_pickle(pickle: String, pickle_key: String) -> Result<Self, Error> {
-        let key = key32("pickle_key", pickle_key.as_bytes())?;
-        let p = SessionPickle::from_encrypted(&pickle, &key).map_err(rt_err)?;
-        Ok(Session(RefCell::new(OlmSession::from_pickle(p))))
-    }
-
-    /// Encrypts plaintext; returns `[message_type, body_base64]` matching the
-    /// Matrix olm ciphertext shape.
-    fn encrypt(&self, plaintext: String) -> Result<(usize, String), Error> {
-        let message = self.0.borrow_mut().encrypt(plaintext.as_bytes()).map_err(rt_err)?;
-        let (mtype, ciphertext) = message.to_parts();
-        Ok((mtype, base64_encode(ciphertext)))
-    }
-
-    /// Decrypts an olm message given its type (0 = pre-key, 1 = normal) and
-    /// base64 body.
-    fn decrypt(&self, message_type: usize, body: String) -> Result<String, Error> {
-        let ciphertext = base64_decode(&body).map_err(rt_err)?;
-        let message = OlmMessage::from_parts(message_type, &ciphertext).map_err(rt_err)?;
-        let plaintext = self.0.borrow_mut().decrypt(&message).map_err(rt_err)?;
-        String::from_utf8(plaintext).map_err(rt_err)
-    }
-}
-
-// --- GroupSession (Megolm outbound) ---------------------------------------
-
-#[magnus::wrap(class = "Async::Matrix::E2EE::GroupSession", free_immediately, size)]
-struct GroupSession(RefCell<MegolmGroupSession>);
-
-impl GroupSession {
-    fn new() -> Self {
-        GroupSession(RefCell::new(MegolmGroupSession::new(MegolmSessionConfig::version_1())))
-    }
-
-    fn session_id(&self) -> String {
-        self.0.borrow().session_id()
-    }
-
-    fn message_index(&self) -> u32 {
-        self.0.borrow().message_index()
-    }
-
-    /// The session key (base64) to share with recipients via m.room_key.
-    fn session_key(&self) -> String {
-        self.0.borrow().session_key().to_base64()
-    }
-
-    /// Encrypts plaintext, returning the megolm message as base64.
-    fn encrypt(&self, plaintext: String) -> String {
-        self.0.borrow_mut().encrypt(plaintext.as_bytes()).to_base64()
-    }
-
-    fn pickle(&self, pickle_key: String) -> Result<String, Error> {
-        let key = key32("pickle_key", pickle_key.as_bytes())?;
-        Ok(self.0.borrow().pickle().encrypt(&key))
-    }
-
-    fn from_pickle(pickle: String, pickle_key: String) -> Result<Self, Error> {
-        let key = key32("pickle_key", pickle_key.as_bytes())?;
-        let p = GroupSessionPickle::from_encrypted(&pickle, &key).map_err(rt_err)?;
-        Ok(GroupSession(RefCell::new(MegolmGroupSession::from_pickle(p))))
-    }
-}
-
-// --- InboundGroupSession (Megolm inbound) ---------------------------------
-
-#[magnus::wrap(class = "Async::Matrix::E2EE::InboundGroupSession", free_immediately, size)]
-struct InboundGroupSession(RefCell<MegolmInbound>);
-
-impl InboundGroupSession {
-    /// Build from a base64 session key received in an m.room_key event.
-    fn new(session_key: String) -> Result<Self, Error> {
-        let key = SessionKey::from_base64(&session_key).map_err(rt_err)?;
-        Ok(InboundGroupSession(RefCell::new(MegolmInbound::new(
-            &key,
-            MegolmSessionConfig::version_1(),
-        ))))
-    }
-
-    /// 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()
-    }
-
-    fn first_known_index(&self) -> u32 {
-        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)?;
-        let decrypted = self.0.borrow_mut().decrypt(&msg).map_err(rt_err)?;
-        let plaintext = String::from_utf8(decrypted.plaintext).map_err(rt_err)?;
-        Ok((plaintext, decrypted.message_index))
-    }
-
-    fn pickle(&self, pickle_key: String) -> Result<String, Error> {
-        let key = key32("pickle_key", pickle_key.as_bytes())?;
-        Ok(self.0.borrow().pickle().encrypt(&key))
-    }
-
-    fn from_pickle(pickle: String, pickle_key: String) -> Result<Self, Error> {
-        let key = key32("pickle_key", pickle_key.as_bytes())?;
-        let p = InboundGroupSessionPickle::from_encrypted(&pickle, &key).map_err(rt_err)?;
-        Ok(InboundGroupSession(RefCell::new(MegolmInbound::from_pickle(p))))
-    }
-}
-
-// --- module-level functions ------------------------------------------------
-
-/// Verify an ed25519 signature. `key` and `signature` are base64; returns bool.
-fn verify_signature(key: String, message: String, signature: String) -> Result<bool, Error> {
-    let public_key = Ed25519PublicKey::from_base64(&key).map_err(rt_err)?;
-    let sig = Ed25519Signature::from_base64(&signature).map_err(rt_err)?;
-    Ok(public_key.verify(message.as_bytes(), &sig).is_ok())
-}
-
-// --- init ------------------------------------------------------------------
-
-#[magnus::init]
-fn init(ruby: &Ruby) -> Result<(), Error> {
-    let namespace = ruby.define_module("Async")?.define_module("Matrix")?.define_module("E2EE")?;
-
-    let account = namespace.define_class("Account", ruby.class_object())?;
-    account.define_singleton_method("new", function!(Account::new, 0))?;
-    account.define_singleton_method("from_pickle", function!(Account::from_pickle, 2))?;
-    account.define_method("pickle", method!(Account::pickle, 1))?;
-    account.define_method("ed25519_key", method!(Account::ed25519_key, 0))?;
-    account.define_method("curve25519_key", method!(Account::curve25519_key, 0))?;
-    account.define_method("sign", method!(Account::sign, 1))?;
-    account.define_method("one_time_keys", method!(Account::one_time_keys, 0))?;
-    account.define_method(
-        "max_number_of_one_time_keys",
-        method!(Account::max_number_of_one_time_keys, 0),
-    )?;
-    account.define_method("generate_one_time_keys", method!(Account::generate_one_time_keys, 1))?;
-    account.define_method("fallback_key", method!(Account::fallback_key, 0))?;
-    account.define_method("generate_fallback_key", method!(Account::generate_fallback_key, 0))?;
-    account.define_method("mark_keys_as_published", method!(Account::mark_keys_as_published, 0))?;
-    account.define_method("create_outbound_session", method!(Account::create_outbound_session, 2))?;
-    account.define_method("create_inbound_session", method!(Account::create_inbound_session, 2))?;
-
-    let session = namespace.define_class("Session", ruby.class_object())?;
-    session.define_singleton_method("from_pickle", function!(Session::from_pickle, 2))?;
-    session.define_method("session_id", method!(Session::session_id, 0))?;
-    session.define_method("pickle", method!(Session::pickle, 1))?;
-    session.define_method("encrypt", method!(Session::encrypt, 1))?;
-    session.define_method("decrypt", method!(Session::decrypt, 2))?;
-
-    let group = namespace.define_class("GroupSession", ruby.class_object())?;
-    group.define_singleton_method("new", function!(GroupSession::new, 0))?;
-    group.define_singleton_method("from_pickle", function!(GroupSession::from_pickle, 2))?;
-    group.define_method("session_id", method!(GroupSession::session_id, 0))?;
-    group.define_method("message_index", method!(GroupSession::message_index, 0))?;
-    group.define_method("session_key", method!(GroupSession::session_key, 0))?;
-    group.define_method("encrypt", method!(GroupSession::encrypt, 1))?;
-    group.define_method("pickle", method!(GroupSession::pickle, 1))?;
-
-    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))?;
-
-    Ok(())
-}