confium 0.3.2-x86_64-linux

data/lib/confium/errors/validation_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Raised when input is well-formed but semantically invalid (wrong size,
+# out-of-range value, etc.).
+module Confium
+  class ValidationError < Confium::Error
+    attr_reader :param, :expected, :actual
+
+    def initialize(message = nil, details_hash = nil, **kwargs)
+      message, kwargs = Confium::Errors::Coerce.args(message, details_hash, kwargs)
+      @param = kwargs.delete(:param)
+      @expected = kwargs.delete(:expected)
+      @actual = kwargs.delete(:actual)
+      super(message, details: { param: @param, expected: @expected, actual: @actual, **kwargs })
+    end
+  end
+end

data/lib/confium/errors/verification_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Raised when a signature / hash / proof fails to verify.
+module Confium
+  class VerificationError < Confium::Error
+    attr_reader :signer_index, :algorithm
+
+    def initialize(message = nil, details_hash = nil, **kwargs)
+      message, kwargs = Confium::Errors::Coerce.args(message, details_hash, kwargs)
+      @signer_index = kwargs.delete(:signer_index)
+      @algorithm = kwargs.delete(:algorithm)
+      super(message, details: { signer_index: @signer_index, algorithm: @algorithm, **kwargs })
+    end
+  end
+end

data/lib/confium/errors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Root of all Confium errors. Loaded by every subclass file.
+module Confium
+  module Errors
+    # Marker namespace for error-hierarchy internals. `Coerce` lives
+    # under here so subclasses can reference it as
+    # `Confium::Errors::Coerce.args(...)` without polluting the
+    # top-level `Confium` namespace.
+  end
+
+  class Error < StandardError
+    attr_reader :details
+
+    def initialize(message = nil, details: {})
+      @details = details.transform_keys(&:to_sym)
+      super(message)
+    end
+
+    def to_h
+      { class: self.class.name, message: message, details: details }
+    end
+  end
+end
+
+require_relative 'errors/coerce'

data/lib/confium/ffi.rb

@@ -0,0 +1,23 @@
+# 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

@@ -0,0 +1,33 @@
+# 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/openpgp.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Confium::OpenPGP — OpenPGP (RFC 9580) via bundled rnp-rs.
+#
+# The native extension provides _native_armor / _native_dearmor.
+# This file adds the idiomatic Ruby wrappers with default args.
+#
+# Architecture: RNP is HARD-BUNDLED in the native extension. No
+# external gem dependency. Users get OpenPGP armor encode/decode
+# out of the box.
+
+module Confium
+  module OpenPGP
+    class << self
+      # ASCII-armor encode raw bytes.
+      #
+      # @param data [String] Binary data to encode.
+      # @param type [String] Armor type — one of MESSAGE, PUBLIC_KEY,
+      #   SECRET_KEY, SIGNATURE, CLEARTEXT. Defaults to MESSAGE.
+      # @return [String] Armored ASCII string.
+      def armor(data, type = MESSAGE)
+        _native_armor(data, type)
+      end
+
+      # Decode ASCII-armored data to raw bytes.
+      #
+      # @param data [String] Armored ASCII string.
+      # @return [String] Raw binary data.
+      def dearmor(data)
+        _native_dearmor(data)
+      end
+    end
+  end
+end

data/lib/confium/pki/certificate_builder.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Confium::PKI::CertificateBuilder — construct and sign X.509 v3
+# certificates.
+#
+# This is a pure-Ruby interface that uses the Rust extension's
+# existing Certificate and signing primitives. For full DER builder
+# support (custom extensions, complex subject names), a future Rust
+# crate update will add Certificate::Builder natively.
+#
+# Usage:
+#   builder = Confium::PKI::CertificateBuilder.new
+#   builder.subject = "/CN=test.example.com/O=Confium"
+#   builder.serial = rand(1..1 << 128)
+#   builder.not_before = Time.now
+#   builder.not_after = Time.now + (365 * 24 * 3600)
+#   cert = builder.build_self_signed(algorithm: :ed25519, private_key: key_bytes)
+
+module Confium
+  module PKI
+    class CertificateBuilder
+      attr_accessor :subject, :issuer, :serial, :not_before, :not_after
+
+      def initialize
+        @subject = ''
+        @issuer = nil # nil = self-signed
+        @serial = rand(1..(1 << 128))
+        @not_before = Time.now
+        @not_after = Time.now + (365 * 24 * 3600)
+      end
+
+      # Build a self-signed certificate.
+      #
+      # @param algorithm [Symbol] :ed25519 or :ecdsa_p256
+      # @param private_key [String] 32-byte private key
+      # @return [Hash] metadata about the built cert (not a Certificate
+      #   object yet — full DER construction needs x509-cert builder
+      #   support in the Rust extension)
+      def build_self_signed(algorithm:, private_key:)
+        kp = case algorithm
+             when :ed25519
+               Confium::Composite.generate_ed25519_keypair
+             when :ecdsa_p256
+               Confium::TC::FrostP256.generate_keypair
+             else
+               raise ArgumentError, "unsupported algorithm: #{algorithm}"
+             end
+
+        {
+          subject: @subject,
+          serial: @serial.to_s(16),
+          not_before: @not_before.iso8601,
+          not_after: @not_after.iso8601,
+          algorithm: algorithm.to_s,
+          public_key_hex: kp['public_key'].unpack1('H*')
+        }
+      end
+    end
+  end
+end

data/lib/confium/pki/cms/signed_data_builder.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'digest'
+
+# Confium::PKI::CMS::SignedDataBuilder — construct CMS SignedData
+# envelopes with one or more signers.
+#
+# Delegates to the Rust `confium_pki::cms::build_detached_signature`
+# via `Confium::PKI::CMS::SignedData.build_detached`. The Ruby side
+# only computes the per-signer signature bytes (via the existing
+# Confium::Composite / Confium::TC signers); the envelope assembly
+# happens in Rust so the JSON model + DER encoding stay authoritative.
+#
+# Usage:
+#   builder = Confium::PKI::CMS::SignedDataBuilder.new
+#   builder.content = "hello world".b
+#   builder.add_signer(cert_der: der_bytes, private_key: key_bytes, algorithm: :ed25519)
+#   sd = builder.build
+#   sd.to_json  # => JSON wire format
+#   sd.to_der   # => RFC 5652 ContentInfo DER bytes
+
+module Confium
+  module PKI
+    module CMS
+      class SignedDataBuilder
+        attr_accessor :content
+
+        SIGNATURE_ALGORITHM_OID = {
+          ed25519: '1.3.101.112',
+          ecdsa_p256: '1.2.840.10045.4.3.2'
+        }.freeze
+
+        def initialize
+          @content = nil
+          @signers = []
+        end
+
+        def add_signer(cert_der:, private_key:, algorithm:)
+          algorithm = algorithm.to_sym unless algorithm.is_a?(Symbol)
+          unless SIGNATURE_ALGORITHM_OID.key?(algorithm)
+            raise ArgumentError,
+                  "unsupported algorithm: #{algorithm.inspect} \
+                   (expected one of: #{SIGNATURE_ALGORITHM_OID.keys.join(', ')})"
+          end
+          @signers << {
+            cert_der: cert_der,
+            private_key: private_key,
+            algorithm: algorithm
+          }
+        end
+
+        # Build a SignedData with a detached signature over `@content`.
+        # For multi-signer composites, the first signer is used as the
+        # primary; additional signers are ignored until the upstream
+        # Rust `build_detached_signature` supports multi-signer input.
+        #
+        # @return [Confium::PKI::CMS::SignedData]
+        def build
+          raise ArgumentError, 'at least one signer is required' if @signers.empty?
+          raise ArgumentError, '#content is required (detached builder)' if @content.nil?
+
+          primary = @signers.first
+          payload_bytes = @content.respond_to?(:bytes) ? @content.bytes : @content
+          signature = sign_payload(primary[:algorithm], primary[:private_key], payload_bytes)
+          algorithm_oid = SIGNATURE_ALGORITHM_OID.fetch(primary[:algorithm])
+
+          SignedData.build_detached(
+            signature,
+            algorithm_oid,
+            @signers.map { |s| s[:cert_der] }
+          )
+        end
+
+        private
+
+        def sign_payload(algorithm, private_key, payload)
+          case algorithm
+          when :ed25519
+            result = Confium::Composite.sign_ed25519(private_key, payload)
+            result.fetch('signature')
+          when :ecdsa_p256
+            result = Confium::TC::FrostP256.sign(private_key, payload)
+            result.fetch('signature')
+          else
+            raise ArgumentError, "unsupported algorithm: #{algorithm.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/confium/pki/cms.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Confium::PKI::CMS namespace file.
+#
+# The CMS module itself is defined by the native Rust extension via
+# magnus (SignedData, Content, VerificationResult). This file registers
+# autoloads for pure-Ruby companions that wrap the native SignedData
+# with a builder API.
+module Confium
+  module PKI
+    module CMS
+      autoload :SignedDataBuilder, 'confium/pki/cms/signed_data_builder'
+    end
+  end
+end

data/lib/confium/pki/cnml.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# OIML CNML certificate profile definition.
+#
+# Defines the required X.509 extensions for measuring instrument
+# certificates per OIML R 76 (non-automatic weighing instruments)
+# and the broader CNML framework.
+#
+# This is an interface definition — the actual OIML R 76 PDF is a
+# paid publication. The extension OIDs listed here are from public
+# OIML documentation and the BIPM/CIPM MRA framework.
+
+module Confium
+  module PKI
+    module CNML
+      # Required X.509 v3 extensions for a CNML certificate.
+      REQUIRED_EXTENSIONS = {
+        # Standard X.509 extensions required by CNML:
+        '2.5.29.19' => 'basicConstraints (CA=true for IA certs, CA=false for leaf)',
+        '2.5.29.15' => 'keyUsage (digitalSignature for signing certs)',
+        '2.5.29.37' => 'extKeyUsage (id-kp-OCSPSigning or custom CNML OIDs)',
+        '2.5.29.14' => 'subjectKeyIdentifier (required for CMS signer resolution)',
+        '2.5.29.35' => 'authorityKeyIdentifier (required for chain building)'
+      }.freeze
+
+      # Optional but recommended extensions.
+      OPTIONAL_EXTENSIONS = {
+        '2.5.29.31' => 'cRLDistributionPoints (for revocation checking)',
+        '2.5.29.32' => 'certificatePolicies (CNML policy OID)',
+        '1.3.6.1.5.5.7.1.1' => 'authorityInfoAccess (OCSP responder URL)'
+      }.freeze
+
+      # CNML certificate roles (maps to ActorType in Confium::Identity).
+      CERT_ROLES = %i[
+        manufacturer
+        testing_lab
+        issuing_authority_officer
+        biml_director
+        quorum_coordinator
+        verifier
+      ].freeze
+
+      # Validate that a certificate has the required CNML extensions.
+      # This is a structural check (extension OID presence), not a
+      # semantic check (extension value correctness). Full validation
+      # requires the OIML R 76 specification.
+      #
+      # @param cert [Confium::PKI::Certificate] the cert to check
+      # @return [Array<String>] list of missing required extension OIDs
+      def self.missing_extensions(_cert)
+        # Full implementation requires parsing the cert's extensions,
+        # which needs the x509-cert crate exposed through the Ruby
+        # extension. For now, returns an empty array (no validation).
+        #
+        # TODO: when confium-pki exposes Certificate#extensions, walk
+        # the extension list and cross-reference against
+        # REQUIRED_EXTENSIONS.
+        []
+      end
+
+      # The list of required extension OIDs.
+      # @return [Array<String>]
+      def self.required_extension_oids
+        REQUIRED_EXTENSIONS.keys
+      end
+
+      # The list of optional extension OIDs.
+      # @return [Array<String>]
+      def self.optional_extension_oids
+        OPTIONAL_EXTENSIONS.keys
+      end
+
+      # All known CNML certificate roles.
+      # @return [Array<Symbol>]
+      def self.cert_roles
+        CERT_ROLES
+      end
+    end
+  end
+end

data/lib/confium/pki.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Confium::PKI namespace file.
+#
+# The PKI module itself is defined by the native Rust extension via
+# magnus at require time (see ext/confium_native/src/pki.rs). This file
+# registers pure-Ruby autoloads for the PKI submodules that wrap or
+# extend the native surface.
+module Confium
+  module PKI
+    autoload :CMS, 'confium/pki/cms'
+  end
+end

data/lib/confium/policy.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+# Jurisdictional policy enforcement for Confium.
+#
+# Different jurisdictions require different algorithms and key sizes:
+#   - EU: no RSA < 2048, ECDSA P-256+ accepted, Ed25519 accepted
+#   - US: SHA-1 legacy accepted, ECDSA P-256 accepted
+#   - China: SM2/SM3/SM4 required (not currently implemented)
+#
+# Set the active policy via:
+#   Confium::Policy.jurisdiction = :eu
+#
+# When a policy is active, cert verification and signing operations
+# check the algorithm/key-size against the policy's allowed list.
+# Violations raise Confium::PolicyViolationError.
+
+module Confium
+  module Policy
+    @jurisdiction = nil
+    @fips_mode = false
+
+    # Built-in jurisdictional policies. Each is a Hash mapping
+    # algorithm name to minimum key bits.
+    JURISDICTIONS = {
+      # EU: eIDAS + GDPR alignment. RSA >= 2048, ECDSA P-256+.
+      eu: {
+        rsa: 2048,
+        ecdsa_p256: 256,
+        ecdsa_p384: 384,
+        ed25519: 256,
+        name: 'European Union (eIDAS)'
+      },
+      # US: NIST SP 800-131A. RSA >= 2048, ECDSA P-256+, SHA-1 legacy.
+      us: {
+        rsa: 2048,
+        ecdsa_p256: 256,
+        ecdsa_p384: 384,
+        ed25519: 256,
+        sha1_legacy: true,
+        name: 'United States (NIST SP 800-131A)'
+      },
+      # OIML CNML: international, follows BIPM recommendations.
+      cnml: {
+        rsa: 2048,
+        ecdsa_p256: 256,
+        ecdsa_p384: 384,
+        ed25519: 256,
+        name: 'OIML CNML (BIPM)'
+      }
+    }.freeze
+
+    class << self
+      # @return [Symbol, nil] the active jurisdiction (:eu, :us, :cnml)
+      attr_reader :jurisdiction
+
+      # @return [Boolean] whether FIPS 140 mode is enabled
+      attr_reader :fips_mode
+
+      # Set the active jurisdiction. When non-nil, all signing and
+      # verification operations check algorithms against the policy.
+      # @param value [Symbol, nil] one of JURISDICTIONS.keys or nil
+      # @raise [ArgumentError] if value is not a known jurisdiction
+      def jurisdiction=(value)
+        if value.nil?
+          @jurisdiction = nil
+          return
+        end
+        unless JURISDICTIONS.key?(value.to_sym)
+          raise ArgumentError,
+                "unknown jurisdiction: #{value} (known: #{JURISDICTIONS.keys.join(', ')})"
+        end
+        @jurisdiction = value.to_sym
+      end
+
+      # Enable/disable FIPS 140 mode. When enabled, only FIPS-approved
+      # algorithms are accepted. Ed25519 is NOT FIPS-approved (as of
+      # FIPS 186-5 draft); ECDSA P-256/P-384 are.
+      # @param value [Boolean]
+      def fips_mode=(value)
+        @fips_mode = !value.nil?
+        @jurisdiction = :us if @fips_mode && @jurisdiction.nil?
+      end
+
+      # Check whether an algorithm + key size is allowed under the
+      # active policy.
+      # @param algorithm [String, Symbol] e.g. "rsa", "ecdsa_p256"
+      # @param key_bits [Integer] the key size in bits
+      # @return [Boolean]
+      # @raise [Confium::PolicyViolationError] if the algorithm is
+      #   disallowed or the key size is too small
+      def check!(algorithm, key_bits:)
+        alg = algorithm.to_sym
+
+        if @fips_mode
+          # FIPS mode: only FIPS-approved algorithms.
+          fips_approved = %i[ecdsa_p256 ecdsa_p384 rsa]
+          unless fips_approved.include?(alg)
+            raise Confium::PolicyViolationError.new(
+              "algorithm #{alg} is not FIPS-approved",
+              policy: :fips,
+              violation: :unapproved_algorithm
+            )
+          end
+        end
+
+        return true unless @jurisdiction
+
+        policy = JURISDICTIONS[@jurisdiction]
+        return true unless policy
+
+        min_bits = policy[alg]
+        return true if min_bits.nil?
+
+        if key_bits < min_bits
+          raise Confium::PolicyViolationError.new(
+            "#{alg} key size #{key_bits} below #{min_bits} for #{@jurisdiction}",
+            policy: @jurisdiction,
+            violation: :key_too_small
+          )
+        end
+
+        true
+      end
+
+      # The list of known jurisdiction identifiers.
+      # @return [Array<Symbol>]
+      def known_jurisdictions
+        JURISDICTIONS.keys
+      end
+
+      # Reset all policies to defaults (no jurisdiction, no FIPS).
+      def reset!
+        @jurisdiction = nil
+        @fips_mode = false
+      end
+    end
+  end
+end

data/lib/confium/secure_bytes.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# SecureBytes wraps sensitive cryptographic byte data (private keys,
+# Shamir shares, shared secrets) with zeroize-on-clear semantics.
+#
+# MRI Ruby's String is backed by a heap-allocated char buffer that
+# persists until GC. SecureBytes overwrites that buffer with zeros
+# when #clear is called (explicitly or via finalizer).
+#
+# Usage:
+#   key = Confium::SecureBytes.wrap(raw_bytes)
+#   key.bytes  # non-destructive read
+#   key.clear  # zeroize + deallocate
+#
+# After #clear, #bytes raises Confium::ClearedError.
+
+module Confium
+  class SecureBytes
+    # Raised when #bytes is called after #clear.
+    class ClearedError < Confium::Error
+      def initialize(message = 'SecureBytes already cleared')
+        super(message, details: {})
+      end
+    end
+
+    # Create a SecureBytes wrapping a copy of the given String.
+    # The original String's contents are NOT modified; callers should
+    # zeroize the original separately if needed.
+    # @param raw [String] binary String (any encoding; bytes are copied)
+    # @return [Confium::SecureBytes]
+    def self.wrap(raw)
+      new(raw)
+    end
+
+    # @api private
+    def initialize(raw)
+      @buffer = raw.dup.force_encoding(Encoding::ASCII_8BIT)
+      @cleared = false
+      # Register finalizer to zeroize if the object is GC'd without
+      # an explicit #clear call.
+      ObjectSpace.define_finalizer(self, finalizer_proc)
+    end
+
+    # Non-destructive read of the wrapped bytes.
+    # @return [String] binary String (ASCII-8BIT encoding)
+    # @raise [ClearedError] if #clear was already called
+    def bytes
+      raise ClearedError if @cleared
+
+      @buffer.dup
+    end
+
+    # Destructive read: returns a copy, then zeroizes the original.
+    # @return [String] binary String
+    # @raise [ClearedError] if #clear was already called
+    def bytes!
+      raise ClearedError if @cleared
+
+      copy = @buffer.dup
+      clear
+      copy
+    end
+
+    # Number of bytes. Returns 0 after #clear.
+    # @return [Integer]
+    def length
+      @cleared ? 0 : @buffer.bytesize
+    end
+
+    alias size length
+
+    # Whether the buffer has been cleared.
+    # @return [Boolean]
+    def cleared?
+      @cleared
+    end
+
+    # Zeroize the buffer immediately. Idempotent.
+    # @return [self]
+    def clear
+      return self if @cleared
+
+      # Overwrite every byte with 0x00 in place.
+      @buffer.replace("\x00" * @buffer.bytesize)
+      @buffer = nil
+      @cleared = true
+      self
+    end
+
+    # String representation for debugging. Does NOT expose the raw bytes.
+    # @return [String]
+    def inspect
+      if @cleared
+        "#<Confium::SecureBytes:0x#{object_id.to_s(16)} CLEARED>"
+      else
+        "#<Confium::SecureBytes:0x#{object_id.to_s(16)} #{length} bytes>"
+      end
+    end
+
+    private
+
+    # Finalizer proc that zeroizes the buffer if GC collects this
+    # object without an explicit #clear. Uses object_id to find the
+    # buffer — but since the buffer is an instance variable that may
+    # already be collected, this is a best-effort path. Explicit #clear
+    # is the recommended path.
+    # @return [Proc]
+    def finalizer_proc
+      method(:finalize)
+    end
+
+    # Called by the GC finalizer.
+    def finalize(_id)
+      # Best-effort: the buffer may already be collected by the time
+      # the finalizer runs. If @buffer still exists, zeroize it.
+      # This is a closure over the instance — MRI guarantees the
+      # finalizer runs after the object is unreachable but before
+      # the buffer's memory is reused.
+      return if @cleared
+
+      @buffer&.replace("\x00" * @buffer.bytesize)
+      @buffer = nil
+      @cleared = true
+    end
+  end
+end