confium 0.4.1 → 0.6.0

data/lib/confium/tc/network_coordinator.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'socket'
+require_relative 'coordinator'
+
+module Confium
+  module TC
+    # Networked threshold-signing coordinator service.
+    #
+    # Wraps Confium::TC::Coordinator (real CMP20/GG18 combine) behind
+    # a TCP socket so signers on separate machines submit commitments
+    # and shares from their own processes:
+    #
+    #   service = Confium::TC::NetworkCoordinator.new(quorum_id: 'root')
+    #   service.start                       # binds 127.0.0.1:<ephemeral>
+    #   client = Confium::TC::SignerClient.new(port: service.port)
+    #   sid = client.create_session(message: data, threshold: 3)
+    #   client.submit_share(sid, 'signer-1', share_blob)
+    #   client.aggregate(sid)               # => 64-byte signature
+    #
+    # Protocol: one JSON object per line (NDJSON); binary fields are
+    # hex-encoded. Unknown operations and Coordinator errors come
+    # back as {"error": ..., "message": ...} lines.
+    #
+    # Transport security: none yet — plain TCP intended for loopback
+    # or private networks. The upstream noise-transport session
+    # protocol replaces this wholesale (see
+    # TODO.full/01-multi-host-threshold-signing.md).
+    class NetworkCoordinator
+      HANDLERS = {
+        'create' => lambda do |coord, req|
+          session_id = coord.create_session(
+            message: [req.fetch('message_hex')].pack('H*'),
+            threshold: req.fetch('threshold'),
+            scheme: req['scheme'] || 'CMP20-ECDSA-P256'
+          )
+          { 'session_id' => session_id }
+        end,
+        'commitment' => lambda do |coord, req|
+          session_id = req.fetch('session_id')
+          coord.submit_commitment(
+            session_id, req.fetch('signer_id'),
+            [req.fetch('bytes_hex')].pack('H*')
+          )
+          { 'ok' => true, 'state' => coord.session_state(session_id).to_s }
+        end,
+        'share' => lambda do |coord, req|
+          coord.submit_share(
+            req.fetch('session_id'), req.fetch('signer_id'),
+            [req.fetch('bytes_hex')].pack('H*')
+          )
+          { 'ok' => true }
+        end,
+        'aggregate' => lambda do |coord, req|
+          signature = coord.aggregate(req.fetch('session_id'))
+          { 'signature_hex' => signature.unpack1('H*') }
+        end
+      }.freeze
+
+      class RequestError < StandardError; end
+
+      attr_reader :quorum_id, :port
+
+      def initialize(quorum_id:, host: '127.0.0.1', port: 0, coordinator: nil)
+        @quorum_id = quorum_id
+        @host = host
+        @port = port
+        @coordinator = coordinator || Coordinator.new(quorum_id: quorum_id)
+        @server = nil
+        @accept_thread = nil
+        @mutex = Mutex.new
+      end
+
+      def start
+        raise 'already started' if @server
+
+        # RBS socket lib lacks the (host, port) overload for new
+        @server = TCPServer.new(@host.to_s, @port) # steep:ignore
+        @port = @server.addr[1]
+        @accept_thread = Thread.new { accept_loop }
+        self
+      end
+
+      def stop
+        return unless @server
+
+        server = @server
+        @server = nil
+        server.close
+        @accept_thread&.join(5)
+        nil
+      end
+
+      def running?
+        !@server.nil?
+      end
+
+      private
+
+      def accept_loop
+        loop do
+          server = @server
+          break unless server
+
+          begin
+            socket = server.accept
+          rescue IOError, Errno::EBADF, Errno::EINVAL
+            break # listener closed by #stop
+          end
+          Thread.new(socket) { |conn| serve(conn) }
+        end
+      end
+
+      def serve(socket)
+        socket.each_line do |line|
+          request = JSON.parse(line)
+          response = @mutex.synchronize { dispatch(request) }
+          socket.write("#{JSON.generate(response)}\n")
+        end
+      rescue JSON::ParserError => e
+        write_error(socket, 'RequestError', "malformed JSON: #{e.message}")
+      rescue StandardError => e
+        write_error(socket, e.class.name, e.message)
+      ensure
+        socket.close
+      end
+
+      def dispatch(request)
+        op = request['op'] or raise RequestError, 'missing "op"'
+        handler = HANDLERS[op] or raise RequestError, "unknown op: #{op}"
+
+        handler.call(@coordinator, request)
+      end
+
+      def write_error(socket, klass, message)
+        socket.write("#{JSON.generate({ 'error' => klass, 'message' => message })}\n")
+      rescue IOError
+        nil
+      end
+    end
+
+    # Client side for NetworkCoordinator. One instance per signer
+    # process; each call opens its own connection, so signers never
+    # share state.
+    class SignerClient
+      class RemoteError < StandardError
+        attr_reader :remote_class
+
+        def initialize(remote_class, message)
+          @remote_class = remote_class
+          super("#{remote_class}: #{message}")
+        end
+      end
+
+      def initialize(port:, host: '127.0.0.1')
+        @host = host
+        @port = port
+      end
+
+      def create_session(message:, threshold:, scheme: 'CMP20-ECDSA-P256')
+        response = call(
+          'op' => 'create',
+          'message_hex' => message.to_s.unpack1('H*'),
+          'threshold' => threshold,
+          'scheme' => scheme
+        )
+        response.fetch('session_id')
+      end
+
+      def submit_commitment(session_id, signer_id, commitment_bytes)
+        call(
+          'op' => 'commitment',
+          'session_id' => session_id,
+          'signer_id' => signer_id,
+          'bytes_hex' => commitment_bytes.unpack1('H*')
+        ).fetch('ok')
+      end
+
+      def submit_share(session_id, signer_id, share_bytes)
+        call(
+          'op' => 'share',
+          'session_id' => session_id,
+          'signer_id' => signer_id,
+          'bytes_hex' => share_bytes.unpack1('H*')
+        ).fetch('ok')
+      end
+
+      def aggregate(session_id)
+        response = call('op' => 'aggregate', 'session_id' => session_id)
+        [response.fetch('signature_hex')].pack('H*')
+      end
+
+      private
+
+      def call(request)
+        TCPSocket.open(@host, @port) do |socket|
+          socket.write("#{JSON.generate(request)}\n")
+          line = socket.readline
+          response = JSON.parse(line)
+          raise RemoteError.new(response['error'], response['message']) if response['error']
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/confium/tc/signing_session.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Confium
+  module TC
+    # One threshold-signing session: the state machine and the combine
+    # behind every coordinator surface. Coordinator (in-process) and
+    # NetworkCoordinator (TCP/NDJSON) are adapters over this class —
+    # they own registries and framing; the session owns the semantics:
+    #
+    #   pending → commitments_collected (T distinct commitments)
+    #          → completed (aggregate runs the scheme combine)
+    #
+    # Aggregate may be called again after completion — the combine
+    # randomizes its nonce, so each call yields a fresh (verifiable)
+    # signature over the same shares, which is what a network client
+    # retrying after a dropped response needs.
+    #
+    # Signer identity is load-bearing: one signer submitting two
+    # shares must never count twice toward the threshold, so
+    # commitments and shares are keyed by signer_id and duplicates
+    # raise.
+    class SigningSession
+      DEFAULT_UNLOCK_WINDOW = 14_400
+
+      SCHEMES = {
+        'CMP20-ECDSA-P256' => ->(shares, threshold, message) { Cmp20.sign(shares, threshold, message) },
+        'GG18-ECDSA-P256' => ->(shares, threshold, message) { Gg18.sign(shares, threshold, message) }
+      }.freeze
+
+      attr_reader :message, :threshold, :unlock_window, :scheme, :state
+
+      def initialize(message:, threshold:, unlock_window: DEFAULT_UNLOCK_WINDOW, scheme: 'CMP20-ECDSA-P256')
+        raise ArgumentError, "unknown scheme: #{scheme} (known: #{SCHEMES.keys.join(', ')})" unless SCHEMES.key?(scheme)
+
+        @message = message
+        @threshold = threshold
+        @unlock_window = unlock_window
+        @scheme = scheme
+        @state = :pending
+        # @type ivar @commitments: Hash[String, String]
+        @commitments = {}
+        # @type ivar @shares: Hash[String, String]
+        @shares = {}
+      end
+
+      def add_commitment(signer_id, commitment_bytes)
+        record(@commitments, signer_id, commitment_bytes)
+        @state = :commitments_collected if @commitments.length >= @threshold
+        self
+      end
+
+      def add_share(signer_id, share_bytes)
+        record(@shares, signer_id, share_bytes)
+        self
+      end
+
+      def commitment_count
+        @commitments.length
+      end
+
+      def share_count
+        @shares.length
+      end
+
+      def threshold_met?
+        @shares.length >= @threshold
+      end
+
+      def aggregate
+        unless threshold_met?
+          raise ThresholdError.new('Threshold not met', have_count: @shares.length, need_count: @threshold)
+        end
+
+        signature = SCHEMES.fetch(@scheme).call(@shares.values, @threshold, @message)
+        @state = :completed
+        signature
+      end
+
+      private
+
+      def record(store, signer_id, bytes)
+        if store.key?(signer_id)
+          raise ValidationError.new(
+            "duplicate submission from signer #{signer_id}",
+            param: :signer_id, expected: 'one submission per signer', actual: signer_id
+          )
+        end
+
+        store[signer_id] = bytes
+      end
+    end
+  end
+end

data/lib/confium/tc.rb

@@ -11,7 +11,12 @@
 # for the full interface specification.
 module Confium
   module TC
-    autoload :Session, 'confium/tc/session'
-    autoload :Coordinator, 'confium/tc/coordinator'
+    # The native extension defines Confium::TC; this namespace file
+    # is eager-required from confium.rb, so autoloads never fire —
+    # the pure-Ruby companions load with the namespace directly.
+    require_relative 'tc/signing_session'
+    require_relative 'tc/coordinator'
+    require_relative 'tc/network_coordinator'
+    require_relative 'tc/share_file'
   end
 end

data/lib/confium/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Confium
-  VERSION = '0.4.1'
+  VERSION = '0.6.0'
 end

data/lib/confium.rb

@@ -10,21 +10,14 @@
 # are loaded lazily via autoload — see lib/confium/<name>.rb.
 
 require_relative 'confium/version'
+require_relative 'confium/native_windows'
 
 begin
-  # Pre-built platform gems ship one extension per C-ABI window
-  # (Ruby 3.2 broke the 3.1 ABI — object shapes — and rb-sys
-  # references the VM pointer libruby stopped exporting in 3.3, so
-  # 3.1 and 3.2 get exact-minor builds while 3.3 covers 3.3+).
-  # Source builds install the extension flat, without a version
-  # directory.
-  minor = RUBY_VERSION[/\A\d+\.\d+/]
+  # Pre-built platform gems ship one extension per ABI window (the
+  # window rules live in Confium::NativeWindows). Source builds
+  # install the extension flat, without a version directory.
   dlext = RbConfig::CONFIG['DLEXT'] || 'so'
-  candidates = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.3') ? [minor, '3.3'].uniq : [minor]
-  # Windows gems carry an exact-minor window per Ruby (a PE import
-  # names the version-specific ruby DLL); other platforms share the
-  # 3.3 window for 3.3+. Prefer the exact minor when present.
-  windowed = candidates.filter_map do |w|
+  windowed = Confium::NativeWindows.candidates(RUBY_VERSION).filter_map do |w|
     path = File.expand_path("confium_native/#{w}/confium_native.#{dlext}", __dir__ || '.')
     w if File.exist?(path)
   end
@@ -92,7 +85,8 @@ require_relative 'confium/transparency'
 # of that module.
 require_relative 'confium/audit'
 
-# Eager-load the TC ShareFile Ruby companion. The native extension
-# defines `Confium::TC` as a Ruby module; this file adds the
-# `ShareFile` class for filesystem-backed share persistence.
-require_relative 'confium/tc/share_file'
+# Eager-load the TC namespace file: `Confium::TC` is native-defined,
+# so an autoload here would never fire (the PKI pattern). It
+# registers the pure-Ruby Session/Coordinator companions and the
+# ShareFile class for filesystem-backed share persistence.
+require_relative 'confium/tc'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: confium
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Ribose Open
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-24 00:00:00.000000000 Z
+date: 2026-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -121,6 +121,7 @@ files:
 - ext/confium_native/src/deployment.rs
 - ext/confium_native/src/ers.rs
 - ext/confium_native/src/lib.rs
+- ext/confium_native/src/openpgp_verify.rs
 - ext/confium_native/src/path.rs
 - ext/confium_native/src/pki.rs
 - ext/confium_native/src/tc.rs
@@ -128,10 +129,8 @@ files:
 - ext/confium_native/src/util.rs
 - lib/confium.rb
 - lib/confium/audit.rb
-- lib/confium/cfm.rb
+- lib/confium/audit/otlp_sink.rb
 - lib/confium/composite.rb
-- lib/confium/crypto.rb
-- lib/confium/digest.rb
 - lib/confium/errors.rb
 - lib/confium/errors/coerce.rb
 - lib/confium/errors/crypto_error.rb
@@ -143,8 +142,7 @@ files:
 - lib/confium/errors/unresolved_signer_error.rb
 - lib/confium/errors/validation_error.rb
 - lib/confium/errors/verification_error.rb
-- lib/confium/ffi.rb
-- lib/confium/lib.rb
+- lib/confium/native_windows.rb
 - lib/confium/openpgp.rb
 - lib/confium/pki.rb
 - lib/confium/pki/certificate_builder.rb
@@ -155,9 +153,9 @@ files:
 - lib/confium/secure_bytes.rb
 - lib/confium/tc.rb
 - lib/confium/tc/coordinator.rb
-- lib/confium/tc/session.rb
-- lib/confium/tc/session_stub.rb
+- lib/confium/tc/network_coordinator.rb
 - lib/confium/tc/share_file.rb
+- lib/confium/tc/signing_session.rb
 - lib/confium/transparency.rb
 - lib/confium/transparency/ots.rb
 - lib/confium/version.rb

data/lib/confium/cfm.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'ffi'
-
-module Confium
-  class CFM
-    attr_reader :ptr
-
-    def initialize
-      pptr = ::FFI::MemoryPointer.new(:pointer)
-      Confium.call_ffi(:cfm_create, pptr)
-      @ptr = ::FFI::AutoPointer.new(pptr.read_pointer, self.class.method(:destroy))
-    end
-
-    def self.destroy(ptr)
-      Confium::Lib.cfm_destroy(ptr)
-    end
-
-    def load_plugin(name, path)
-      Confium.call_ffi(:cfm_plugin_load, @ptr, name, path, nil, nil)
-    end
-  end
-end

data/lib/confium/crypto.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-# {Confium::Crypto} is the registry namespace for Confium's cryptographic
-# interfaces.
-#
-# Mirroring the Rust plugin-interface registry (TODO #02), each Ruby
-# interface module (Digest, and future Cipher, AEAD, KDF, RNG, Signature,
-# KEM, ...) registers itself here on load rather than being enumerated in
-# a central case statement. This keeps the registry open for extension
-# (OCP) and makes the set of available interfaces a single source of
-# truth.
-#
-# Example:
-#
-#   module Confium
-#     module Digest
-#       Confium::Crypto.register(:hash, self)
-#     end
-#   end
-#
-#   Confium::Crypto.lookup(:hash)  # => Confium::Digest
-module Confium
-  module Crypto
-    # @type ivar @interfaces: Hash[Symbol, untyped]
-    @interfaces = {}
-
-    class << self
-      # Register an interface +klass+ under the symbolic +name+. Adding a
-      # new interface is a one-line registration; no central switch needs
-      # editing.
-      def register(name, klass)
-        @interfaces[name] = klass
-        klass
-      end
-
-      # Resolve a registered interface by +name+. Raises ArgumentError if
-      # nothing has been registered under that name.
-      def lookup(name)
-        @interfaces.fetch(name) do
-          raise ArgumentError, "unknown interface #{name.inspect}"
-        end
-      end
-
-      # Enumerate the names of every registered interface. Primarily for
-      # introspection and tooling.
-      def interfaces
-        @interfaces.keys.dup
-      end
-    end
-  end
-end

data/lib/confium/digest.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'ffi'
-require 'digest'
-
-module Confium
-  class Digest < ::Digest::Class
-    attr_reader :name, :ptr
-
-    def initialize(cfm, name)
-      @name = name
-      pptr = ::FFI::MemoryPointer.new(:pointer)
-      Confium.call_ffi(:cfm_hash_create, cfm.ptr, pptr, name, nil, nil, nil)
-      ptr = pptr.read_pointer
-      raise if ptr.null?
-
-      @ptr = ::FFI::AutoPointer.new(ptr, self.class.method(:destroy))
-    end
-
-    def initialize_copy(source)
-      @name = source.name
-      pptr = ::FFI::MemoryPointer.new(:pointer)
-      Confium.call_ffi(:cfm_hash_clone, source.ptr, pptr)
-      ptr = pptr.read_pointer
-      @ptr = ::FFI::AutoPointer.new(ptr, self.class.method(:destroy))
-    end
-
-    def self.destroy(ptr)
-      Confium::Lib.cfm_hash_destroy(ptr)
-    end
-
-    def block_length
-      plength = ::FFI::MemoryPointer.new(:uint32)
-      Confium.call_ffi(:cfm_hash_block_size, @ptr, plength)
-      plength.read(:uint32)
-    end
-
-    def digest_length
-      plength = ::FFI::MemoryPointer.new(:uint32)
-      Confium.call_ffi(:cfm_hash_output_size, @ptr, plength)
-      plength.read(:uint32)
-    end
-
-    def update(data)
-      Confium.call_ffi(:cfm_hash_update, @ptr, data, data.bytesize)
-      self
-    end
-
-    def reset
-      Confium.call_ffi(:cfm_hash_reset, @ptr)
-      self
-    end
-
-    def finish
-      buf = ::FFI::MemoryPointer.new(:uint8, digest_length)
-      Confium.call_ffi(:cfm_hash_finalize, @ptr, buf, buf.size)
-      buf.read_bytes(buf.size)
-    end
-
-    alias << update
-  end
-end

data/lib/confium/ffi.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'ffi'
-
-# {Confium::FFI} is the namespace for everything that touches the native
-# Confium shared library through Ruby-FFI.
-#
-# This file registers autoload entries for the planned FFI helper modules
-# (Library, Error, Options). They are listed in the TODO #14 architecture
-# (see `TODO.finalize/14-ruby-bindings-architecture.md`) and will be added
-# as the bindings grow; until then the autoloads are inert — they only
-# trigger a load when the corresponding constant is first referenced.
-#
-# Note: the legacy FFI library wrapper still lives at `Confium::Lib`
-# (file `confium/lib.rb`) and is autoloaded from `confium.rb`. It will be
-# migrated into `Confium::FFI::Library` in a follow-up.
-module Confium
-  module FFI
-    autoload :Library, 'confium/ffi/library'
-    autoload :Error,   'confium/ffi/error'
-    autoload :Options, 'confium/ffi/options'
-  end
-end

data/lib/confium/lib.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'ffi'
-
-module Confium
-  module Lib
-    extend ::FFI::Library
-
-    FFI_LAYOUT = {
-      cfm_create: [%i[pointer], :uint32],
-      cfm_destroy: [%i[pointer], :uint32],
-      cfm_plugin_load: [%i[pointer string string pointer pointer], :uint32],
-      cfm_hash_create: [%i[pointer pointer pointer pointer pointer pointer], :uint32],
-      cfm_hash_output_size: [%i[pointer pointer], :uint32],
-      cfm_hash_block_size: [%i[pointer pointer], :uint32],
-      cfm_hash_update: [%i[pointer pointer uint32], :uint32],
-      cfm_hash_reset: [%i[pointer], :uint32],
-      cfm_hash_clone: [%i[pointer pointer], :uint32],
-      cfm_hash_finalize: [%i[pointer pointer uint32], :uint32],
-      cfm_hash_destroy: [%i[pointer], :void]
-    }.freeze
-
-    ffi_lib([ENV.fetch('CONFIUM_LIB', nil), 'confium', 'libconfium'].compact)
-
-    FFI_LAYOUT.each do |func, ary|
-      class_eval do
-        attach_function(func, ary.first, ary.last)
-      end
-    rescue ::FFI::NotFoundError
-      # that's okay
-    end
-  end
-end

data/lib/confium/tc/session.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'confium/lib'
-
-# Confium::TC::Session wraps a threshold cryptography session.
-#
-# A session represents one signing or decryption operation involving
-# T-of-N parties. The session goes through states: pending →
-# commitments_collected → shares_collected → completed.
-#
-# Usage:
-#   session = Confium::TC::Session.new(scheme: "FROST-ed25519",
-#                                      threshold: 3,
-#                                      num_parties: 5,
-#                                      party_index: 0)
-#   session.set_local_share(share_bytes)
-#   session.round(incoming_messages) # returns outgoing messages
-#   result = session.result if session.complete?
-module Confium
-  module TC
-    class Session
-      attr_reader :scheme, :threshold, :num_parties, :party_index, :state
-
-      def initialize(scheme:, threshold:, num_parties:, party_index:)
-        @scheme = scheme
-        @threshold = threshold
-        @num_parties = num_parties
-        @party_index = party_index
-        @state = :pending
-        @local_share = nil
-        @result = nil
-      end
-
-      def set_local_share(share_bytes)
-        raise ArgumentError, 'share must be a String' unless share_bytes.is_a?(String)
-
-        @local_share = share_bytes
-      end
-
-      def complete?
-        @state == :completed
-      end
-
-      def result
-        raise 'Session not complete' unless complete?
-
-        @result
-      end
-    end
-  end
-end