confium 0.6.2 → 0.7.0

data/README.adoc

@@ -18,7 +18,7 @@ Add to your Gemfile:
 
 [source,ruby]
 ----
-gem "confium", "~> 0.3"
+gem "confium", "~> 0.7"
 ----
 
 Or install directly:
@@ -78,18 +78,38 @@ kp = Confium::TC::FrostP256.generate_keypair
 shares = Confium::TC::FrostP256.split_secret(kp["private_key"], 3, 5)
 recovered = Confium::TC::FrostP256.recover_secret(shares.first(3).map { |s| { "x" => s.x, "y" => s.y_bytes } })
 recovered == kp["private_key"]  # => true
+
+# Distributed key generation + 2-of-3 FROST-ed25519 signing (each party
+# holds its own Confium::TC::Session and only exchanges round messages)
+parties = %w[alice bob carol]
+sessions = parties.each_with_index.map do |id, i|
+  Confium::TC::Session.new("FROST-ed25519-dkg", parties: parties, threshold: 2, this_party_idx: i)
+end
+# run rounds: session.round_step(messages_in) -> {"outgoing" => [...], "complete" => bool}
+# broadcast "outgoing" payloads between sessions until every session is complete
+dkg_share = sessions.first.result  # this party's share (embeds the group public key)
+
+signers = sessions.first(2).map.with_index do |s, i|
+  Confium::TC::Session.new("FROST-ed25519",
+                           parties: parties.first(2), threshold: 2, this_party_idx: i,
+                           local_share: dkg_share, message: "authentic message")
+end
+# run rounds as above; the completed session's #result is an RFC 8032
+# Ed25519 signature verifiable under the group public key
 ----
 
-== API surface (v0.3)
+== API surface (v0.7)
 
 === `Confium::Transparency`
 - `MerkleTree.new` / `#append(artifact_hash)` / `#root` / `#length` / `#empty?` / `#inclusion_proof(seq)`
 - `InclusionProof#sequence` / `#steps` / `#verify(root)`
+- `Ots.stamp(hash)` / `Ots.verify(receipt, hash)` — OpenTimestamps anchoring interface (pure-Ruby stub; calendar-server wiring lands with the Rust client)
 
 === `Confium::Composite` — PQ migration
 - `.generate_ed25519_keypair` → `{ private_key:, public_key: }`
 - `.sign_ed25519(private_key, message)` → component Hash
-- `Signature.new(components)` / `#verify(message)` / `#component_count` / `#algorithms`
+- `Signature.new(components)` / `#verify(message)` / `#component_count` / `#algorithms` / `#to_json`
+- `.from_json(json)` / `.components_to_json(components)` / `.canonical_json(json, data)`
 - `VerificationResult#all_verified?` / `#per_component`
 
 === `Confium::Attributes` — threshold policy DSL
@@ -99,11 +119,14 @@ recovered == kp["private_key"]  # => true
 - DSL: `min_count("attr", n)`, `min_distinct("attr", n)`, `any("attr")`, `all("attr")`, `none("attr")`, `and(...)`, `or(...)`, `not(p)`
 
 === `Confium::PKI`
-- `Certificate.from_der(bytes)` / `.from_pem(str)` / `#to_der` / `#to_pem` / `#fingerprint_sha256` / `#serial_hex` / `#not_before` / `#not_after` / `#valid_at?(iso8601)` / `#public_key_bytes`
+- `Certificate.from_der(bytes)` / `.from_pem(str)` / `#to_der` / `#to_pem` / `#fingerprint_sha256` / `#serial_hex` / `#not_before` / `#not_after` / `#valid_at?(iso8601)` / `#public_key_bytes`; DER parse failures carry a byte `offset` in the error details
+- `CertificateBuilder` / `CMS::SignedDataBuilder` — build certificates and signed data in Ruby
+- `PathValidator.validate(leaf, intermediates, root, now_iso8601 = nil)` → `PathValidationResult` (chain validation leaf → root at a point in time)
 - `CSR.from_der` / `.from_pem` / `#to_der` / `#to_pem`
 - `CMS::SignedData.from_json` / `#to_json` / `#signer_count` / `#content_type` / `#content` / `#certificate_count` / `#certificate_at(i)`
 - `CMS::Content#bytes` / `#length`
 - `XMLDSig.canonicalize(xml)` / `.canonicalize_exclusive(xml)` (Canonical XML RFC 3076 + Exclusive C14N)
+- `Cnml` — institutional certificate workflow helpers
 
 === `Confium::Identity` — actor roles
 - `.actor_types` → `["manufacturer", "testing_lab", "issuing_authority_officer", "biml_director", "quorum_coordinator", "verifier"]`
@@ -123,6 +146,51 @@ recovered == kp["private_key"]  # => true
 - `.partial_decrypt(party_index, share_bytes, ciphertext)` → `{ party_index:, bytes: }`
 - `.aggregate_partials(partials, threshold, ciphertext)` → shared_secret bytes
 
+=== `Confium::TC::Cmp20` / `Confium::TC::Gg18` — threshold ECDSA protocols
+- `.keygen(threshold, parties)` → `{ public_key, shares }`
+- `.sign(shares, public_key, message)` → DER ECDSA signature
+
+=== `Confium::TC::Session` — per-party threshold sessions (real FROST)
+- `Session.new(scheme, parties:, threshold:, this_party_idx:, local_share: nil, message: nil)` — `"FROST-ed25519-dkg"` for distributed key generation, `"FROST-ed25519"` for signing (pass the DKG share and the message)
+- `#scheme_name` / `#threshold` / `#party_count` / `#this_party_idx` / `#round` / `#complete?`
+- `#round_step(messages)` → `{ "outgoing" => [{from, to, round, payload}...], "complete" => bool }` — feed each round's incoming messages, broadcast the outgoing ones
+- `#result` — after DKG: share blob (group public key + party share); after signing: RFC 8032 Ed25519 signature
+
+=== `Confium::TC::Coordinator` — quorum signing orchestration
+- `Coordinator.new(quorum_id:)` / `#create_session(message:, threshold:, scheme: "CMP20-ECDSA-P256")` / `#submit_commitment` / `#submit_share` / `#aggregate` / `#session_state`
+- `SigningSession#add_commitment` / `#add_share` / `#threshold_met?` / `#aggregate` — the seam every transport adapts to
+- `NetworkCoordinator` — TCP/NDJSON server (`#start` / `#stop` / `#running?`); `SignerClient` — remote submit + aggregate with typed `RemoteError`
+- `ShareFile` — encrypted share-file persistence
+
+=== `Confium::Store::Keystore` — key handles and remote signing
+- `Keystore.new(backend, **options)` / `.backends`
+- `#sign(key_id, algorithm, message)` → signature bytes (sign-with-handle contract; cloud KMS backends `aws-kms` / `gcp-kms` / `azure-keyvault` via cargo features)
+
+=== `Confium::Audit` — structured audit trail
+- `Audit.sink =` / `Audit.sink` / `Audit.enabled?` / `Audit.record(...)`
+- `Sink` (base) / `MemorySink` / `StderrSink` / `FileSink`
+- `OtlpSink.new(endpoint:, headers:, service_name:, ...)` — OTLP/HTTP export with retry and `#dropped` counter
+
+=== `Confium::OpenPGP`
+- `.armor(data, type)` / `.dearmor(data)` — RFC 9580 §6 ASCII armor with CRC-24 (pure Ruby)
+- `.verify_detached(message, signature, keys)` / `.verify(...)` — real signature verification when the extension is built with the `pgp` feature; `PGP_AVAILABLE` reports it
+
+=== `Confium::Transport` — coordinator clients over any transport
+- `SignerClient.new(url)` — connect over any registry transport: `tcp://host:port` (local/trusted) or `noise://host:port?key=<hex>&pinned=<hex>` (Noise_XX encrypted, stable identity + peer pinning)
+- `#register(signer_id, quorum_id)` / `#create_session(quorum_id, scheme, message, threshold, num_parties)` → session id
+- `#submit_commitment(session_id, signer_id, bytes)` / `#submit_share(session_id, signer_id, bytes)`
+- `CoordinatorServer.new(url)` — serve coordinator sessions over any linked scheme (test/in-process use)
+
+=== `Confium::ERS` — evidence records
+- `EvidenceRecord.build_initial(...)` / `#renew(...)` / `#renewal_count` (RFC 4998 / RFC 6283 archival)
+
+=== `Confium::Policy` / `Confium::SecureBytes`
+- `Policy.jurisdiction = :eu` — jurisdictional algorithm policy (EU/US profiles; SM2/SM3/SM4 for CN planned)
+- `SecureBytes.wrap(raw)` — zeroize-on-clear wrapper for private keys, shares, and secrets (`#bytes` non-destructive read, `#clear`)
+
+=== Errors
+- Typed error hierarchy (`ParseError`, `ThresholdError`, `VerificationError`, `PolicyViolationError`, ...) — native failures surface positional `details` hashes (including DER byte offsets for parse errors)
+
 == Development
 
 After checking out the repo:

data/confium.gemspec

@@ -40,6 +40,8 @@ Gem::Specification.new do |spec|
   ]
   spec.files.reject! { |f| File.directory?(f) }
   spec.files.reject! { |f| f =~ /\.(dll|so|dylib|lib|bundle)\Z/ }
+  # Windows socket diagnostic crate — development-only, never shipped.
+  spec.files.reject! { |f| f.start_with?('ext/socket-smoke/') }
   spec.require_paths = ['lib']
 
   spec.required_ruby_version = '>= 3.1.0'

data/ext/confium_native/Cargo.toml

@@ -25,6 +25,9 @@ build = "build.rs"
 pgp = ["rnp"]
 
 [dependencies]
+confium-coordinator = "0.8"
+confium-net-noise = "0.8"
+confium-net-tcp = "0.8"
 # rb-sys for Ruby C API access.
 rb-sys = { version = "0.9.124", features = ["global-allocator"] }
 
@@ -40,10 +43,15 @@ confium-pki = "0.5.6"
 confium-store = "0.5.8"
 confium-deployment = "0.3"
 confium-tc = "0.3.1"
-confium-tc-frost-p256 = "0.3"
-confium-tc-elgamal-p256 = "0.3"
-confium-tc-cmp20 = "0.3.1"
-confium-tc-gg18 = "0.3.1"
+confium-tc-frost-p256 = "0.4"
+confium-tc-elgamal-p256 = "0.4"
+confium-tc-cmp20 = "0.4"
+confium-tc-gg18 = "0.4"
+
+# Per-party session protocol: the tc-core 0.4 registry line. The 0.3-era
+# in-process drivers above keep their own registry harmlessly.
+confium-tc-session = { package = "confium-tc-core", version = "0.4.7" }
+confium-tc-frost-ed25519 = "0.4.7"
 
 # Newly published shared crypto crates (confium product restructuring).
 confium-tc-core = "0.3"

data/ext/confium_native/src/lib.rs

@@ -14,9 +14,14 @@ mod path;
 mod pki;
 mod store;
 mod tc;
+mod net;
+mod tc_session;
 mod transparency;
 mod util;
 
+#[cfg(windows)]
+mod winsock;
+
 use magnus::{function, Error, Module, Ruby};
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -29,6 +34,19 @@ fn native_loaded() -> bool {
     true
 }
 
+/// `Confium::Native.winsock_probe(tag)` — run the winsock diagnostic
+/// sequence at an arbitrary point (Windows only; no-op elsewhere).
+/// Timeline bisect for the listener bind failure: call it at ext
+/// load, suite start, and just before a ceremony to see exactly when
+/// each std net operation degrades.
+fn winsock_probe_fn(tag: String) -> Result<(), Error> {
+    #[cfg(windows)]
+    winsock::probe_on_demand(&tag);
+    #[cfg(not(windows))]
+    let _ = tag;
+    Ok(())
+}
+
 fn core_version() -> &'static str {
     // Set by build.rs at compile time from Cargo.lock. Always matches the
     // confium-core crate version the extension was built against.
@@ -37,11 +55,15 @@ fn core_version() -> &'static str {
 
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
+    #[cfg(windows)]
+    winsock::probe();
+
     let confium = ruby.define_module("Confium")?;
     let native = confium.define_module("Native")?;
     native.define_module_function("version", function!(native_version, 0))?;
     native.define_module_function("loaded?", function!(native_loaded, 0))?;
     confium.define_module_function("core_version", function!(core_version, 0))?;
+    native.define_module_function("winsock_probe", function!(winsock_probe_fn, 1))?;
 
     transparency::init(ruby, confium)?;
     openpgp_verify::init(ruby, confium)?;
@@ -54,6 +76,8 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     path::init(ruby, confium)?;
     deployment::init(ruby, confium)?;
     tc::init(ruby, confium)?;
+    tc_session::init(ruby, confium)?;
+    net::init(ruby, confium)?;
     audit::init(ruby, confium)?;
     ers::init(ruby, confium)?;
     Ok(())

data/ext/confium_native/src/net.rs

@@ -0,0 +1,125 @@
+//! Confium::Transport — transport-level coordinator clients.
+//!
+//! Binds the registry-transport coordinator surface: a signer dials
+//! the coordinator over any URL scheme the native library links
+//! (tcp:// for local/trusted, noise:// for encrypted sessions with
+//! key=/pinned= parameters), and a CoordinatorServer serves any
+//! linked scheme. This is the transport half of multi-host signing;
+//! the protocol half is Confium::TC::Session.
+
+use magnus::{prelude::*, DataTypeFunctions, Error, Ruby, TypedData};
+
+// Force the noise transport crate (and its `register_transport!`
+// static) into the cdylib so the noise:// scheme resolves — the
+// binding itself never names a symbol from it.
+extern crate confium_net_noise as _noise_link;
+extern crate confium_net_tcp as _tcp_link;
+
+use confium_coordinator::coordinator::client::SignerClient as RustSignerClient;
+use confium_coordinator::coordinator::net_server::CoordinatorServer as RustCoordinatorServer;
+
+fn io_error(e: std::io::Error, operation: &str) -> Error {
+    magnus::Error::new(
+        magnus::exception::io_error(),
+        format!("{operation}: {e}"),
+    )
+}
+
+/// Confium::Transport::SignerClient — a coordinator connection over a
+/// registry transport URL.
+#[derive(TypedData, DataTypeFunctions)]
+#[magnus(class = "Confium::Transport::SignerClient", size)]
+pub struct SignerClient {
+    inner: std::cell::RefCell<RustSignerClient>,
+}
+
+impl SignerClient {
+    fn initialize(ruby: &Ruby, url: String) -> Result<Self, Error> {
+        let _ = ruby;
+        let inner = RustSignerClient::connect_url(&url).map_err(|e| io_error(e, "SignerClient.new"))?;
+        Ok(Self { inner: std::cell::RefCell::new(inner) })
+    }
+
+    fn register(&self, signer_id: String, quorum_id: String) -> Result<(), Error> {
+        self.inner
+            .borrow_mut()
+            .register(&signer_id, &quorum_id)
+            .map_err(|e| io_error(e, "register"))
+    }
+
+    fn create_session(
+        &self,
+        quorum_id: String,
+        scheme: String,
+        message: String,
+        threshold: u32,
+        num_parties: u32,
+    ) -> Result<String, Error> {
+        self.inner
+            .borrow_mut()
+            .create_session(&quorum_id, &scheme, message.as_bytes(), threshold, num_parties)
+            .map_err(|e| io_error(e, "create_session"))
+    }
+
+    fn submit_commitment(&self, args: &[magnus::Value]) -> Result<(), Error> {
+        let scanned = magnus::scan_args::scan_args::<(String, String, Vec<u8>), (), (), (), (), ()>(args)
+            .map_err(|e| magnus::Error::new(magnus::exception::arg_error(), e.to_string()))?;
+        let (session_id, signer_id, commitment) = scanned.required;
+        self.inner
+            .borrow_mut()
+            .submit_commitment(&session_id, &signer_id, &commitment)
+            .map_err(|e| io_error(e, "submit_commitment"))
+    }
+
+    fn submit_share(&self, args: &[magnus::Value]) -> Result<Option<Vec<u8>>, Error> {
+        let scanned = magnus::scan_args::scan_args::<(String, String, Vec<u8>), (), (), (), (), ()>(args)
+            .map_err(|e| magnus::Error::new(magnus::exception::arg_error(), e.to_string()))?;
+        let (session_id, signer_id, share) = scanned.required;
+        self.inner
+            .borrow_mut()
+            .submit_share(&session_id, &signer_id, &share)
+            .map_err(|e| io_error(e, "submit_share"))
+    }
+}
+
+/// Confium::Transport::CoordinatorServer — serves coordinator sessions over
+/// any linked transport scheme. Held in a Ruby object; the server
+/// thread runs until the process exits.
+#[derive(TypedData, DataTypeFunctions)]
+#[magnus(class = "Confium::Transport::CoordinatorServer", size)]
+pub struct CoordinatorServer {
+    _bound: String,
+}
+
+impl CoordinatorServer {
+    fn initialize(ruby: &Ruby, url: String) -> Result<Self, Error> {
+        let _ = ruby;
+        let server = RustCoordinatorServer::new(&url);
+        let bound = server
+            .start_url(&url)
+            .map_err(|e| io_error(e, "CoordinatorServer.new"))?;
+        Ok(Self { _bound: bound })
+    }
+}
+
+pub fn init(ruby: &Ruby, parent: magnus::RModule) -> Result<(), Error> {
+    let net = parent.define_module("Transport")?;
+
+    let client = net.define_class("SignerClient", ruby.class_object())?;
+    client.define_singleton_method("new", magnus::function!(SignerClient::initialize, 1))?;
+    client.define_method("register", magnus::method!(SignerClient::register, 2))?;
+    client.define_method(
+        "create_session",
+        magnus::method!(SignerClient::create_session, 5),
+    )?;
+    client.define_method(
+        "submit_commitment",
+        magnus::method!(SignerClient::submit_commitment, -1),
+    )?;
+    client.define_method("submit_share", magnus::method!(SignerClient::submit_share, -1))?;
+
+    let server = net.define_class("CoordinatorServer", ruby.class_object())?;
+    server.define_singleton_method("new", magnus::function!(CoordinatorServer::initialize, 1))?;
+
+    Ok(())
+}

data/ext/confium_native/src/tc_session.rs

@@ -0,0 +1,268 @@
+//! Confium::TC::Session — per-party threshold protocol sessions.
+//!
+//! Binds `confium_tc_core::Session`: each signer process runs ONE
+//! session for its own party, feeding it the messages received from
+//! the peers and sending on what `round_step` produces. The scheme
+//! never leaves the process — this is the per-party half of the
+//! multi-host signing story (the NetworkCoordinator is the transport
+//! half).
+//!
+//!   session = Confium::TC::Session.new("FROST-ed25519-dkg",
+//!                                      parties: ["p0", "p1", "p2"],
+//!                                      threshold: 2,
+//!                                      this_party_idx: 0)
+//!   loop do
+//!     result = session.round_step(incoming)
+//!     break if result["complete"]
+//!     incoming = broadcast(result["outgoing"])
+//!   end
+//!   session.result
+//!
+//! Messages are Hashes with string keys: `"from"`, `"to"` (nil for
+//! broadcast), `"round"`, `"payload"` (binary String).
+
+use magnus::{prelude::*, DataTypeFunctions, Error, Module, RArray, RHash, Ruby, TryConvert, TypedData, Value};
+
+// Force the frost-ed25519 crate (and its `inventory::submit!` calls for
+// FrostEd25519 + FrostEd25519Dkg) to be linked into the cdylib even
+// though the binding itself never names a symbol from it — otherwise
+// the linker drops the registration statics and `Session::create`
+// reports the scheme as unknown.
+extern crate confium_tc_frost_ed25519 as _frost_ed25519_link;
+
+use confium_tc_session::{
+    session::{Session as RustSession, SessionParams}, share::Share, Error as TcError, Message,
+    Party, PartyList,
+};
+// (confium-tc-session is the renamed confium-tc-core 0.4.7 dependency.)
+
+fn typed_session_error(e: TcError, operation: &str) -> Error {
+    let ruby = match Ruby::get() {
+        Ok(r) => r,
+        Err(_) => return Error::new(magnus::exception::runtime_error(), e.to_string()),
+    };
+    let details = crate::util::new_details(&ruby);
+    let _ = details.aset("operation", operation);
+    crate::util::confium_error(e.to_string(), "Error", details)
+}
+
+/// Confium::TC::Session — see the module docs.
+#[derive(TypedData, DataTypeFunctions)]
+#[magnus(class = "Confium::TC::Session", size)]
+pub struct Session {
+    inner: std::cell::RefCell<RustSession>,
+}
+
+fn bytes_arg(v: Value, name: &str) -> Result<Vec<u8>, Error> {
+    crate::util::bytes_from_value(v)
+        .map_err(|e| crate::util::arg_error(format!("Session: {name}: {e}")))
+}
+
+impl Session {
+    fn initialize(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
+        let scanned = magnus::scan_args::scan_args::<(String,), (Option<RHash>,), (), (), (), ()>(args)
+            .map_err(|e| crate::util::arg_error(e.to_string()))?;
+        let scheme = scanned.required.0;
+        let raw_opts = scanned
+            .optional
+            .0
+            .ok_or_else(|| crate::util::arg_error("Session.new: options Hash is required"))?;
+        // Ruby callers pass keywords (`parties: [...]`), which arrive as
+        // symbol keys; accept both symbol and string keys.
+        let opts = ruby.hash_new();
+        raw_opts.foreach(|k: Value, v: Value| {
+            let key: String = if k.is_kind_of(ruby.class_symbol()) {
+                k.funcall("to_s", ())?
+            } else {
+                <String as TryConvert>::try_convert(k)?
+            };
+            opts.aset(key, v)?;
+            Ok(magnus::r_hash::ForEach::Continue)
+        })?;
+
+        let required = |key: &str| -> Result<Value, Error> {
+            opts.fetch(key).map_err(|_| {
+                crate::util::arg_error(format!("Session.new: :{key} is required"))
+            })
+        };
+        let parties_val = required("parties")?;
+        let ids: Vec<String> = <Vec<String> as TryConvert>::try_convert(parties_val).map_err(|_| {
+            crate::util::arg_error("Session.new: :parties must be an Array of String ids")
+        })?;
+        if ids.len() < 2 {
+            return Err(crate::util::arg_error(
+                "Session.new: at least two parties are required",
+            ));
+        }
+        let mut parties = PartyList::new();
+        for id in &ids {
+            parties.push(Party::new(id.clone(), None::<String>));
+        }
+
+        let threshold: u32 = <u32 as TryConvert>::try_convert(required("threshold")?)
+            .map_err(|_| crate::util::arg_error("Session.new: :threshold must be an Integer"))?;
+        let this_party_idx: usize = <usize as TryConvert>::try_convert(required("this_party_idx")?)
+            .map_err(|_| {
+                crate::util::arg_error("Session.new: :this_party_idx must be an Integer")
+            })?;
+
+        let local_share_v: Value = opts
+            .get("local_share")
+            .unwrap_or_else(|| ruby.qnil().as_value());
+        let local_share: Option<Share> = if local_share_v.is_nil() {
+            None
+        } else {
+            Some(Share::new(
+                scheme.clone(),
+                bytes_arg(local_share_v, "local_share")?,
+            ))
+        };
+        let message_v: Value = opts
+            .get("message")
+            .unwrap_or_else(|| ruby.qnil().as_value());
+        let message: Option<Vec<u8>> = if message_v.is_nil() {
+            None
+        } else {
+            Some(bytes_arg(message_v, "message")?)
+        };
+
+        let params = SessionParams {
+            scheme: scheme.clone(),
+            parties,
+            threshold,
+            this_party_idx,
+            local_share,
+            message,
+        };
+        let inner = RustSession::create(&params)
+            .map_err(|e| typed_session_error(e, "Session.new"))?;
+        let _ = ruby;
+        Ok(Self {
+            inner: std::cell::RefCell::new(inner),
+        })
+    }
+
+    fn scheme_name(&self) -> String {
+        self.inner.borrow().scheme_name().to_string()
+    }
+
+    fn threshold(&self) -> u32 {
+        self.inner.borrow().threshold()
+    }
+
+    fn party_count(&self) -> usize {
+        self.inner.borrow().party_count()
+    }
+
+    fn this_party_idx(&self) -> usize {
+        self.inner.borrow().this_party_idx()
+    }
+
+    fn round(&self) -> u8 {
+        self.inner.borrow().round()
+    }
+
+    fn complete(&self) -> bool {
+        self.inner.borrow().is_complete()
+    }
+
+    fn round_step(&self, args: &[Value]) -> Result<RHash, Error> {
+        let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
+        let scanned =
+            magnus::scan_args::scan_args::<(), (Option<Value>,), (), (), (), ()>(args)
+                .map_err(|e| crate::util::arg_error(e.to_string()))?;
+        let incoming = match scanned.optional.0 {
+            Some(v) if !v.is_nil() => parse_messages(&ruby, v)?,
+            _ => Vec::new(),
+        };
+
+        let result = self
+            .inner
+            .borrow_mut()
+            .round_step(&incoming)
+            .map_err(|e| typed_session_error(e, "Session#round_step"))?;
+
+        let out = ruby.hash_new();
+        let arr = ruby.ary_new();
+        for m in &result.outgoing {
+            let h = ruby.hash_new();
+            let _ = h.aset("from", m.from_party_id.as_str());
+            let to: Value = match &m.to_party_id {
+                Some(t) => ruby.str_new(t).as_value(),
+                None => ruby.qnil().as_value(),
+            };
+            let _ = h.aset("to", to);
+            let _ = h.aset("round", m.round as i64);
+            let _ = h.aset(
+                "payload",
+                crate::util::bytes_to_rstring(&ruby, &m.payload),
+            );
+            arr.push(h)?;
+        }
+        let _ = out.aset("outgoing", arr);
+        let _ = out.aset("complete", result.complete);
+        Ok(out)
+    }
+
+    fn result(&self) -> Result<magnus::RString, Error> {
+        let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
+        let bytes = self
+            .inner
+            .borrow()
+            .result()
+            .map_err(|e| typed_session_error(e, "Session#result"))?;
+        Ok(crate::util::bytes_to_rstring(&ruby, &bytes))
+    }
+}
+
+fn parse_messages(ruby: &Ruby, value: Value) -> Result<Vec<Message>, Error> {
+    let arr: RArray = <RArray as TryConvert>::try_convert(value)
+        .map_err(|_| crate::util::arg_error("Session#round_step: incoming must be an Array"))?;
+    let mut out = Vec::with_capacity(arr.len());
+    for item in arr.into_iter() {
+        let h: RHash = <RHash as TryConvert>::try_convert(item).map_err(|_| {
+            crate::util::arg_error("Session#round_step: each message must be a Hash")
+        })?;
+        let fetch = |key: &str| -> Result<Value, Error> {
+            h.fetch(key)
+                .map_err(|_| crate::util::arg_error(format!("message: '{key}' is required")))
+        };
+        let from: String = <String as TryConvert>::try_convert(fetch("from")?)
+            .map_err(|_| crate::util::arg_error("message: 'from' must be a String"))?;
+        let to_v: Value = fetch("to")?;
+        let to: Option<String> = if to_v.is_nil() {
+            None
+        } else {
+            Some(
+                <String as TryConvert>::try_convert(to_v)
+                    .map_err(|_| crate::util::arg_error("message: 'to' must be a String"))?,
+            )
+        };
+        let round: u8 = <u8 as TryConvert>::try_convert(fetch("round")?)
+            .map_err(|_| crate::util::arg_error("message: 'round' must be an Integer"))?;
+        let payload: Value = fetch("payload")?;
+        let payload = crate::util::bytes_from_value(payload)?;
+        let msg = match to {
+            Some(t) => Message::directed(from, t, round, payload),
+            None => Message::broadcast(from, round, payload),
+        };
+        out.push(msg);
+        let _ = ruby;
+    }
+    Ok(out)
+}
+
+pub fn init(ruby: &Ruby, parent: magnus::RModule) -> Result<(), Error> {
+    let tc = parent.define_module("TC")?;
+    let class = tc.define_class("Session", ruby.class_object())?;
+    class.define_singleton_method("new", magnus::function!(Session::initialize, -1))?;
+    class.define_method("scheme_name", magnus::method!(Session::scheme_name, 0))?;
+    class.define_method("threshold", magnus::method!(Session::threshold, 0))?;
+    class.define_method("party_count", magnus::method!(Session::party_count, 0))?;
+    class.define_method("this_party_idx", magnus::method!(Session::this_party_idx, 0))?;
+    class.define_method("round", magnus::method!(Session::round, 0))?;
+    class.define_method("complete?", magnus::method!(Session::complete, 0))?;
+    class.define_method("round_step", magnus::method!(Session::round_step, -1))?;
+    class.define_method("result", magnus::method!(Session::result, 0))?;
+    Ok(())
+}