confium 0.4.1 → 0.6.0

data/ext/confium_native/Cargo.toml

@@ -16,6 +16,14 @@ crate-type = ["cdylib"]
 
 build = "build.rs"
 
+[features]
+# OpenPGP signature verification via a vendored librnp (librnp +
+# Botan + json-c). OFF by default: the C/C++ build would restore the
+# multi-minute compile times and heavy binaries 0.4.0 removed (armor
+# itself is pure Ruby). Source builders opt in; pre-compiled platform
+# gems always build default features.
+pgp = ["rnp"]
+
 [dependencies]
 # rb-sys for Ruby C API access.
 rb-sys = { version = "0.9.124", features = ["global-allocator"] }
@@ -57,3 +65,11 @@ serde_json = "1"
 
 [profile.release]
 lto = "off"
+
+# OpenPGP verification (feature "pgp") — vendored librnp via rnp-rs.
+# No system librnp needed; adds the Botan/json-c C/C++ build.
+[dependencies.rnp]
+package = "rnp-rs"
+version = "0.1.10"
+features = ["vendored"]
+optional = true

data/ext/confium_native/extconf.rb

@@ -7,4 +7,9 @@ create_rust_makefile('confium_native') do |r|
   r.profile = ENV.fetch('RB_SYS_CARGO_PROFILE', :dev).to_sym
   r.use_stable_api_compiled_fallback = true
   r.force_install_rust_toolchain = false
+  # rb_sys only threads --features through to cargo when the builder
+  # has a non-empty feature list; seeding it from the env var makes
+  # RB_SYS_CARGO_FEATURES=pgp bundle exec rake compile work.
+  r.features = ENV.fetch('RB_SYS_CARGO_FEATURES', '')
+                  .split(',').map(&:strip).reject(&:empty?)
 end

data/ext/confium_native/src/lib.rs

@@ -9,6 +9,7 @@ mod attributes;
 mod composite;
 mod deployment;
 mod ers;
+mod openpgp_verify;
 mod path;
 mod pki;
 mod tc;
@@ -42,6 +43,9 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     confium.define_module_function("core_version", function!(core_version, 0))?;
 
     transparency::init(ruby, confium)?;
+    openpgp_verify::init(ruby, confium)?;
+    #[cfg(feature = "pgp")]
+    openpgp_verify::init_pgp(ruby, &confium)?;
     composite::init(ruby, confium)?;
     attributes::init(ruby, confium)?;
     pki::init(ruby, confium)?;

data/ext/confium_native/src/openpgp_verify.rs

@@ -0,0 +1,189 @@
+//! Confium::OpenPGP — OpenPGP (RFC 9580) signature verification via
+//! the vendored librnp, behind the `pgp` cargo feature.
+//!
+//! Armor (encode/decode) is pure Ruby in lib/confium/openpgp.rb and
+//! always available. This module adds verification only, and only
+//! when the extension was built with `--features pgp`: the vendored
+//! librnp brings a full Botan/json-c C/C++ build that default
+//! (platform-gem) builds deliberately exclude.
+
+use magnus::{Error, Module, RModule, Ruby, Value, function, prelude::*};
+
+use crate::util::runtime;
+
+fn stub_message(method: &str) -> String {
+    format!(
+        "Confium::OpenPGP.{} requires the pgp cargo feature — rebuild \
+         the extension with --features pgp (platform gems build \
+         default features)",
+        method
+    )
+}
+
+/// Registered when the extension builds WITHOUT the pgp feature:
+/// `Confium::OpenPGP::PGP_AVAILABLE` is false and the verify methods
+/// raise with instructions instead of pretending.
+pub fn init(_ruby: &Ruby, parent: RModule) -> Result<(), Error> {
+    let openpgp = parent.define_module("OpenPGP")?;
+    let _ = openpgp.const_set("PGP_AVAILABLE", false);
+    openpgp.define_singleton_method(
+        "verify_detached",
+        function!(
+            move |_args: &[Value]| -> Result<Value, Error> {
+                Err(runtime(stub_message("verify_detached")))
+            },
+            -1
+        ),
+    )?;
+    openpgp.define_singleton_method(
+        "verify",
+        function!(
+            move |_args: &[Value]| -> Result<Value, Error> { Err(runtime(stub_message("verify"))) },
+            -1
+        ),
+    )?;
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// pgp feature implementation
+// ---------------------------------------------------------------------------
+#[cfg(feature = "pgp")]
+mod pgp_impl {
+    use super::*;
+    use crate::util::{bytes_from_value, crypto_error, parse_error};
+
+    fn result_to_hash(ruby: &Ruby, result: &rnp::VerifyResult) -> Result<Value, Error> {
+        let hash = ruby.hash_new();
+        let _ = hash.aset("any_valid", result.any_valid().unwrap_or(false));
+        let _ = hash.aset(
+            "signature_count",
+            result.signature_count().unwrap_or(0) as i64,
+        );
+        let arr = ruby.ary_new();
+        for s in result.iter_signatures() {
+            let sh = ruby.hash_new();
+            let _ = sh.aset("valid", s.status_is_valid());
+            let _ = sh.aset("status", format!("{:?}", s.status()));
+            let _ = sh.aset("key_id", s.keyid().unwrap_or_else(|_| "?".to_string()));
+            let (created, expires) = s.times().unwrap_or((0, 0));
+            let _ = sh.aset("creation_time", created as i64);
+            let _ = sh.aset("expiration_time", expires as i64);
+            if let Ok(alg) = s.hash() {
+                let _ = sh.aset("hash", alg);
+            }
+            arr.push(sh)?;
+        }
+        let _ = hash.aset("signatures", arr);
+        Ok(hash.as_value())
+    }
+
+    fn negative_result(ruby: &Ruby) -> Result<Value, Error> {
+        // librnp reports a failed signature check as an error from
+        // rnp_op_verify_execute; for a verifier API that is the
+        // answer, not an exception.
+        let hash = ruby.hash_new();
+        let _ = hash.aset("any_valid", false);
+        let _ = hash.aset("signature_count", 0 as i64);
+        let _ = hash.aset("signatures", ruby.ary_new());
+        Ok(hash.as_value())
+    }
+
+    fn ctx() -> Result<rnp::Context, Error> {
+        rnp::Context::new().map_err(|e| crypto_error(e.to_string(), "OpenPGP", "openpgp"))
+    }
+
+    fn import_keys(context: &rnp::Context, keys: &[Value]) -> Result<(), Error> {
+        for k in keys {
+            let bytes = bytes_from_value(*k)?;
+            context
+                .import_keys(&bytes, rnp::LoadSaveFlags::PUBLIC)
+                .map_err(|e| {
+                    parse_error(e.to_string(), "OpenPGP key import", Some("openpgp"), None)
+                })?;
+        }
+        Ok(())
+    }
+
+    /// `(message, signature, keys?)` → `(message, signature, keys)`
+    fn split_args(
+        args: &[Value],
+        min: usize,
+        method: &str,
+    ) -> Result<(Value, Option<Value>, Vec<Value>), Error> {
+        if args.len() < min || args.len() > min + 1 {
+            return Err(crate::util::arg_error(format!(
+                "Confium::OpenPGP.{}: wrong number of arguments (given {}, expected {}..{})",
+                method,
+                args.len(),
+                min,
+                min + 1
+            )));
+        }
+        let keys = if args.len() == min + 1 {
+            match <magnus::RArray as magnus::TryConvert>::try_convert(args[min]) {
+                Ok(array) => array.into_iter().collect(),
+                Err(_) => vec![args[min]],
+            }
+        } else {
+            Vec::new()
+        };
+        Ok((args[0], args.get(1).copied(), keys))
+    }
+
+    pub fn verify_detached(args: &[Value]) -> Result<Value, Error> {
+        let ruby = Ruby::get().map_err(|e| runtime(e.to_string()))?;
+        let (message, signature, keys) = split_args(args, 2, "verify_detached")?;
+        let msg = bytes_from_value(message)?;
+        let sig = bytes_from_value(
+            signature.ok_or_else(|| crate::util::arg_error("missing signature"))?,
+        )?;
+
+        let context = ctx()?;
+        import_keys(&context, &keys)?;
+        let result = match rnp::verify_detached(&context, &msg, &sig) {
+            Ok(result) => result_to_hash(&ruby, &result)?,
+            Err(e) if e.kind() == rnp::ErrorKind::SignatureInvalid => negative_result(&ruby)?,
+            Err(e) => {
+                return Err(parse_error(
+                    e.to_string(),
+                    "OpenPGP.verify_detached",
+                    Some("openpgp"),
+                    None,
+                ));
+            }
+        };
+        Ok(result)
+    }
+
+    pub fn verify(args: &[Value]) -> Result<Value, Error> {
+        let ruby = Ruby::get().map_err(|e| runtime(e.to_string()))?;
+        let (signed, _signature_ignored, keys) = split_args(args, 1, "verify")?;
+        let msg = bytes_from_value(signed)?;
+
+        let context = ctx()?;
+        import_keys(&context, &keys)?;
+        let result = match rnp::verify(&context, &msg) {
+            Ok(result) => result_to_hash(&ruby, &result)?,
+            Err(e) if e.kind() == rnp::ErrorKind::SignatureInvalid => negative_result(&ruby)?,
+            Err(e) => {
+                return Err(parse_error(
+                    e.to_string(),
+                    "OpenPGP.verify",
+                    Some("openpgp"),
+                    None,
+                ));
+            }
+        };
+        Ok(result)
+    }
+}
+
+#[cfg(feature = "pgp")]
+pub fn init_pgp(_ruby: &Ruby, parent: &RModule) -> Result<(), Error> {
+    let openpgp = parent.define_module("OpenPGP")?;
+    let _ = openpgp.const_set("PGP_AVAILABLE", true);
+    openpgp.define_singleton_method("verify_detached", function!(pgp_impl::verify_detached, -1))?;
+    openpgp.define_singleton_method("verify", function!(pgp_impl::verify, -1))?;
+    Ok(())
+}

data/lib/confium/audit/otlp_sink.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'time'
+
+module Confium
+  module Audit
+    # Exports audit records to an OpenTelemetry Collector over
+    # OTLP/HTTP JSON (the logs signal — an audit event is a log
+    # record, not a span).
+    #
+    #   Confium::Audit.sink = Confium::Audit::OtlpSink.new(
+    #     endpoint: 'http://localhost:4318/v1/logs',
+    #     headers: { 'Authorization' => "Bearer #{token}" },
+    #     service_name: 'confium-issuer'
+    #   )
+    #
+    # Delivery is synchronous per record, retried with exponential
+    # backoff (retries: attempts after the first, base doubled per
+    # attempt). After the final failure the record is dropped with a
+    # $stderr report — the audit core's policy: a telemetry outage
+    # must never break signing. stdlib only.
+    class OtlpSink < Sink
+      DEFAULT_ENDPOINT = 'http://localhost:4318/v1/logs'
+      SEVERITY = { 'success' => 9, 'failure' => 17, 'error' => 17 }.freeze # INFO / ERROR
+
+      def initialize(endpoint: DEFAULT_ENDPOINT, headers: {}, service_name: 'confium', timeout: 5,
+                     retries: 2, retry_base: 0.1)
+        super()
+        @uri = URI.parse(endpoint)
+        @headers = headers
+        @service_name = service_name
+        @timeout = timeout
+        @retries = retries
+        @retry_base = retry_base
+        @dropped = 0
+      end
+
+      # Records dropped after failed delivery (diagnostic only).
+      attr_reader :dropped
+
+      def write(record)
+        payload = envelope(record)
+        deliver(JSON.generate(payload))
+      rescue StandardError => e
+        @dropped += 1
+        warn "confium: OTLP delivery failed, audit record dropped (##{@dropped}): #{e.class}: #{e.message}"
+      end
+
+      def close; end
+
+      private
+
+      # Attempts grow the backoff: retry_base * 2**attempt. When
+      # retry_base is 0 (specs) retries run without delay.
+      def deliver(body)
+        (@retries + 1).times do |attempt|
+          sleep(@retry_base * (2**attempt)) if attempt.positive? && @retry_base.positive?
+
+          response = Net::HTTP.post(@uri, body, headers.merge('Content-Type' => 'application/json'))
+          return response if response.is_a?(Net::HTTPSuccess)
+
+          raise "collector responded #{response.code}" if attempt == @retries
+        end
+      end
+
+      def headers
+        { 'User-Agent' => "confium-otlp-sink #{Confium::VERSION}" }.merge(@headers)
+      end
+
+      # OTLP/JSON logs request: one resource, one scope, one record.
+      def envelope(record)
+        {
+          'resourceLogs' => [
+            {
+              'resource' => {
+                'attributes' => [
+                  { 'key' => 'service.name', 'value' => { 'stringValue' => @service_name } },
+                  { 'key' => 'telemetry.sdk.name', 'value' => { 'stringValue' => 'confium' } },
+                  { 'key' => 'telemetry.sdk.version', 'value' => { 'stringValue' => Confium::VERSION } }
+                ]
+              },
+              'scopeLogs' => [
+                {
+                  'scope' => { 'name' => 'confium.audit' },
+                  'logRecords' => [log_record(record)]
+                }
+              ]
+            }
+          ]
+        }
+      end
+
+      def log_record(record)
+        {
+          'timeUnixNano' => (parse_time(record['timestamp']) * 1_000_000_000).to_i.to_s,
+          'severityNumber' => SEVERITY.fetch(record['result'], 9),
+          'severityText' => record['result'] == 'success' ? 'INFO' : 'ERROR',
+          'body' => { 'stringValue' => "#{record['operation']} #{record['result']}".strip },
+          'attributes' => attributes_for(record)
+        }
+      end
+
+      def attributes_for(record)
+        record.except('timestamp').map do |key, value|
+          { 'key' => key, 'value' => { 'stringValue' => value.to_s } }
+        end
+      end
+
+      def parse_time(timestamp)
+        return Time.now.to_f unless timestamp.is_a?(String)
+
+        Time.parse(timestamp).to_f
+      rescue ArgumentError
+        Time.now.to_f
+      end
+    end
+  end
+end

data/lib/confium/audit.rb

@@ -124,3 +124,5 @@ module Confium
     end
   end
 end
+
+require_relative 'audit/otlp_sink'

data/lib/confium/composite.rb

@@ -16,6 +16,32 @@ module Confium
     class Signature
       BINARY_FIELDS = %w[public_key signature].freeze
 
+      # Serialize the components this instance was built from, in the
+      # canonical wire format. Instances remember their source: built
+      # from components, or from a JSON document (which is emitted
+      # verbatim when it was canonical).
+      def to_json(*_args)
+        cached = @confium_components_json
+        return cached if cached
+
+        components = @confium_components or
+          raise Confium::Error, 'Signature was not built with component data; use Signature.new or from_json'
+        Signature.components_to_json(components)
+      end
+
+      class << self
+        # magnus exposes the constructor as a class-level `new`;
+        # capture it before this reopen shadows it (plain `super`
+        # falls through to Class#new instead).
+        alias __native_new new
+
+        def new(*args)
+          sig = __native_new(*args)
+          sig.instance_variable_set(:@confium_components, args.first) if args.first.is_a?(Array)
+          sig
+        end
+      end
+
       def self.components_to_json(components)
         JSON.generate(components.map do |component|
           component.transform_values do |value|
@@ -35,7 +61,19 @@ module Confium
           raise ArgumentError, 'expected a non-empty "components" array'
         end
 
-        new(components.map { |c| decode_binary_fields(c) })
+        sig = new(components.map { |c| decode_binary_fields(c) })
+        sig.instance_variable_set(:@confium_components, components)
+        sig.instance_variable_set(:@confium_components_json, canonical_json(json, data))
+        sig
+      end
+
+      # The canonical wire form of whatever the caller handed us: a
+      # String passes through untouched; parsed structures are
+      # re-generated from their components array.
+      def self.canonical_json(json, data)
+        return json if json.is_a?(String)
+
+        JSON.generate(data.is_a?(Hash) ? data['components'] : data)
       end
 
       def self.decode_binary_fields(component)

data/lib/confium/native_windows.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Confium
+  # Pure resolution of which native-extension ABI windows to try, in
+  # order. Extracted from the loader so the decision — the piece with
+  # the release-incident history (3.1-window segfaults on 3.2, the
+  # cross-major 3.3→4.0 TypeError, windowless platform gems) — is
+  # testable without installing eight platform gems.
+  module NativeWindows
+    # Ordered candidate windows for +ruby_version+ (e.g. "3.4.8").
+    #
+    # Background: platform gems ship one extension per ABI window.
+    # Ruby 3.2 broke the 3.1 ABI (object shapes) and rb-sys references
+    # a VM pointer libruby stopped exporting in 3.3, so 3.1/3.2/4.0
+    # get exact-minor builds while a 3.3-window binary loads on both
+    # 3.3 and 3.4. The 3.3 fallback applies within the 3.x line
+    # alone: a cross-major load (4.x) fails TypedData class-identity
+    # checks, so 4.0 must not fall back to it.
+    def self.candidates(ruby_version)
+      minor = ruby_version[/\A\d+\.\d+/]
+      raise ArgumentError, "not a ruby version: #{ruby_version.inspect}" unless minor
+
+      major = ruby_version[/\A\d+/].to_i
+      if major == 3 && Gem::Version.new(ruby_version) >= Gem::Version.new('3.3')
+        [minor, '3.3'].uniq
+      else
+        [minor]
+      end
+    end
+  end
+end

data/lib/confium/tc/coordinator.rb

@@ -1,15 +1,21 @@
 # frozen_string_literal: true
 
-# Confium::TC::Coordinator wraps the async session coordinator service.
+# Confium::TC::Coordinator coordinates an in-process threshold
+# signing session: signers submit commitments and shares at their own
+# pace; once the threshold is met, aggregation runs the real
+# threshold-ECDSA combine (CMP20 or GG18) and returns a 64-byte
+# (r, s) signature verifiable under the quorum public key.
 #
-# The coordinator enables globally distributed threshold signers to
-# participate when convenient — no simultaneity required.
+# The session semantics (state machine, duplicate-signer rejection,
+# the combine) live in SigningSession; this class is the session
+# registry and quorum-scoped entry point. NetworkCoordinator is the
+# TCP/NDJSON adapter over the same sessions.
 #
 # Usage:
 #   coordinator = Confium::TC::Coordinator.new(quorum_id: "biml-root")
 #   session_id = coordinator.create_session(message: data,
-#                                           threshold: 5,
-#                                           unlock_window: 14400)
+#                                           threshold: 3,
+#                                           scheme: "CMP20-ECDSA-P256")
 #   coordinator.submit_commitment(session_id, signer_id, commitment_bytes)
 #   # ... wait for T commitments ...
 #   coordinator.submit_share(session_id, signer_id, share_bytes)
@@ -25,43 +31,38 @@ module Confium
         @sessions = {}
       end
 
-      def create_session(message:, threshold:, unlock_window: 14_400)
+      def create_session(message:, threshold:, unlock_window: SigningSession::DEFAULT_UNLOCK_WINDOW,
+                         scheme: 'CMP20-ECDSA-P256')
         session_id = "session-#{@sessions.length + 1}"
-        @sessions[session_id] = {
-          message: message,
-          threshold: threshold,
-          unlock_window: unlock_window,
-          state: :pending,
-          commitments: [],
-          shares: []
-        }
+        @sessions[session_id] = SigningSession.new(
+          message: message, threshold: threshold,
+          unlock_window: unlock_window, scheme: scheme
+        )
         session_id
       end
 
       def session_state(session_id)
-        @sessions.dig(session_id, :state)
+        fetch(session_id).state
       end
 
       def submit_commitment(session_id, signer_id, commitment_bytes)
-        session = @sessions[session_id] or raise "Unknown session: #{session_id}"
-        session[:commitments] << { signer_id: signer_id, bytes: commitment_bytes }
-        return unless session[:commitments].length >= session[:threshold]
-
-        session[:state] = :commitments_collected
+        fetch(session_id).add_commitment(signer_id, commitment_bytes)
       end
 
       def submit_share(session_id, signer_id, share_bytes)
-        session = @sessions[session_id] or raise "Unknown session: #{session_id}"
-        session[:shares] << { signer_id: signer_id, bytes: share_bytes }
+        fetch(session_id).add_share(signer_id, share_bytes)
       end
 
       def aggregate(session_id)
-        session = @sessions[session_id] or raise "Unknown session: #{session_id}"
-        raise 'Threshold not met' if session[:shares].length < session[:threshold]
+        fetch(session_id).aggregate
+      end
+
+      private
 
-        session[:state] = :completed
-        # In real implementation, calls FFI to aggregate shares
-        session[:shares].map { |s| s[:bytes] }.join
+      def fetch(session_id)
+        @sessions.fetch(session_id) do
+          raise NotFoundError.new("Unknown session: #{session_id}", kind: :session, identifier: session_id)
+        end
       end
     end
   end