confium 0.3.3 → 0.4.0

data/ext/confium_native/src/tc.rs

@@ -19,10 +19,10 @@ use confium_tc_frost_p256::{
 };
 use confium_tc_cmp20::inprocess as cmp20_inprocess;
 use confium_tc_gg18::inprocess as gg18_inprocess;
-use magnus::{exception, function, method, prelude::*, DataTypeFunctions, Error, Module, Object, RHash, Ruby, TryConvert, TypedData, Value};
+use magnus::{function, method, DataTypeFunctions, Error, Module, RHash, Ruby, TryConvert, TypedData, Value};
 use p256::Scalar;
 
-use crate::util::threshold_error;
+use crate::util::{bytes_from_value, bytes_to_rstring, threshold_error};
 
 #[derive(TypedData, DataTypeFunctions)]
 #[magnus(class = "Confium::TC::FrostP256::Share", size)]
@@ -37,7 +37,7 @@ impl ShareWrap {
     }
 
     fn y_bytes(&self) -> Result<magnus::RString, Error> {
-        let ruby = Ruby::get().map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+        let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
         Ok(bytes_to_rstring(&ruby, &self.y_bytes))
     }
 }
@@ -49,20 +49,16 @@ fn split_secret_into_shares(
 ) -> Result<magnus::RArray, Error> {
     let bytes = bytes_from_value(secret_bytes)?;
     if bytes.len() != 32 {
-        return Err(Error::new(
-            exception::arg_error(),
-            format!("secret must be exactly 32 bytes, got {}", bytes.len()),
+        return Err(crate::util::arg_error(format!("secret must be exactly 32 bytes, got {}", bytes.len()),
         ));
     }
     let secret_arr: [u8; 32] = bytes.as_slice().try_into().unwrap();
     let secret = scalar_from_bytes(&secret_arr).ok_or_else(|| {
-        Error::new(
-            exception::arg_error(),
-            "secret is not a valid P-256 scalar (reduce mod n failed)",
+        crate::util::arg_error("secret is not a valid P-256 scalar (reduce mod n failed)",
         )
     })?;
     let shares: Vec<Share> = split_secret(&secret, threshold, party_count);
-    let ruby = Ruby::get().map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+    let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
     let result = ruby.ary_new_capa(shares.len());
     for s in shares {
         result.push(ruby.obj_wrap(ShareWrap {
@@ -76,27 +72,25 @@ fn split_secret_into_shares(
 fn recover(shares_value: Value) -> Result<magnus::RString, Error> {
     let arr = magnus::RArray::try_convert(shares_value)?;
     let mut shares: Vec<Share> = Vec::with_capacity(arr.len());
-    for v in arr.each() {
-        let h: RHash = RHash::try_convert(v?)?;
+    for v in arr.into_iter() {
+        let h: RHash = RHash::try_convert(v)?;
         let x: u32 = h.fetch::<_, u32>("x")?;
         let y_value: Value = h.fetch::<_, Value>("y")?;
         let y_bytes = bytes_from_value(y_value)?;
         if y_bytes.len() != 32 {
-            return Err(Error::new(
-                exception::arg_error(),
-                format!("share y must be 32 bytes, got {}", y_bytes.len()),
+            return Err(crate::util::arg_error(format!("share y must be 32 bytes, got {}", y_bytes.len()),
             ));
         }
         let y_arr: [u8; 32] = y_bytes.as_slice().try_into().unwrap();
         let y = scalar_from_bytes(&y_arr).ok_or_else(|| {
-            Error::new(exception::arg_error(), "share y is not a valid P-256 scalar")
+            crate::util::arg_error("share y is not a valid P-256 scalar")
         })?;
         shares.push(Share { x, y });
     }
     let refs: Vec<&Share> = shares.iter().collect();
     let secret = recover_secret(&refs)
-        .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
-    let ruby = Ruby::get().map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+        .map_err(|e| crate::util::runtime(e.to_string()))?;
+    let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
     Ok(bytes_to_rstring(&ruby, scalar_to_bytes(&secret).as_ref()))
 }
 
@@ -114,14 +108,12 @@ fn sign(private_key_bytes: Value, message: Value) -> Result<RHash, Error> {
     let pk_bytes = bytes_from_value(private_key_bytes)?;
     let msg = bytes_from_value(message)?;
     if pk_bytes.len() != 32 {
-        return Err(Error::new(
-            exception::arg_error(),
-            format!("private key must be 32 bytes, got {}", pk_bytes.len()),
+        return Err(crate::util::arg_error(format!("private key must be 32 bytes, got {}", pk_bytes.len()),
         ));
     }
     let pk_arr: [u8; 32] = pk_bytes.as_slice().try_into().unwrap();
     let secret = scalar_from_bytes(&pk_arr).ok_or_else(|| {
-        Error::new(exception::arg_error(), "private key not a valid P-256 scalar")
+        crate::util::arg_error("private key not a valid P-256 scalar")
     })?;
     let kp = Keypair {
         secret_scalar: secret,
@@ -137,7 +129,7 @@ fn sign(private_key_bytes: Value, message: Value) -> Result<RHash, Error> {
                 Some(&msg),
                 Some(&e.to_string()),
             );
-            return Err(Error::new(exception::runtime_error(), e.to_string()));
+            return Err(crate::util::crypto_error(e.to_string(), "FrostP256.sign", "ecdsa-p256"));
         }
     };
     crate::audit::fire_event(
@@ -147,38 +139,14 @@ fn sign(private_key_bytes: Value, message: Value) -> Result<RHash, Error> {
         Some(&msg),
         None,
     );
-    let ruby = Ruby::get().map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+    let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
     let result = ruby.hash_new();
     result.aset("der", bytes_to_rstring(&ruby, &signed.der_bytes))?;
     result.aset("fixed", bytes_to_rstring(&ruby, &signed.fixed_bytes))?;
     Ok(result)
 }
 
-fn bytes_from_value(v: Value) -> Result<Vec<u8>, Error> {
-    use magnus::RString;
-    if let Ok(s) = RString::try_convert(v) {
-        return Ok(unsafe { s.as_slice() }.to_vec());
-    }
-    let arr: Vec<i64> = Vec::<i64>::try_convert(v)?;
-    arr.into_iter()
-        .map(|i| {
-            if !(0..=255).contains(&i) {
-                Err(Error::new(
-                    exception::arg_error(),
-                    format!("byte out of range 0..255: {i}"),
-                ))
-            } else {
-                Ok(i as u8)
-            }
-        })
-        .collect()
-}
 
-fn bytes_to_rstring(_ruby: &Ruby, bytes: &[u8]) -> magnus::RString {
-    let s = magnus::RString::buf_new(0);
-    s.cat(bytes);
-    s
-}
 
 // ===== ElGamal-P256 threshold encryption (KEM-style) =====
 
@@ -186,7 +154,7 @@ fn elgamal_encapsulate(ruby: &Ruby, public_key_bytes: Value) -> Result<RHash, Er
     let bytes = bytes_from_value(public_key_bytes)?;
     let pk = ElGamalPublicKey { bytes };
     let (ciphertext, shared_secret) = encapsulate(&pk)
-        .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+        .map_err(|e| crate::util::crypto_error(e.to_string(), "ElGamalP256.encapsulate", "elgamal-p256"))?;
     let result = ruby.hash_new();
     let ct_hash = ruby.hash_new();
     ct_hash.aset("c1", bytes_to_rstring(ruby, &ciphertext.c1))?;
@@ -210,8 +178,8 @@ fn elgamal_partial_decrypt(party_index: u32, share_bytes: Value, ciphertext_valu
         bytes: share_b,
     };
     let partial = partial_decrypt(&share, &ciphertext)
-        .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
-    let ruby = Ruby::get().map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+        .map_err(|e| crate::util::crypto_error(e.to_string(), "ElGamalP256.partial_decrypt", "elgamal-p256"))?;
+    let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
     let result = ruby.hash_new();
     result.aset("party_index", partial.party_index)?;
     result.aset("bytes", bytes_to_rstring(&ruby, &partial.bytes))?;
@@ -221,8 +189,8 @@ fn elgamal_partial_decrypt(party_index: u32, share_bytes: Value, ciphertext_valu
 fn elgamal_aggregate(partials_value: Value, threshold: u32, ciphertext_value: Value) -> Result<magnus::RString, Error> {
     let arr = magnus::RArray::try_convert(partials_value)?;
     let mut partials: Vec<PartialDecryption> = Vec::with_capacity(arr.len());
-    for v in arr.each() {
-        let h: RHash = RHash::try_convert(v?)?;
+    for v in arr.into_iter() {
+        let h: RHash = RHash::try_convert(v)?;
         let party_index: u32 = h.fetch::<_, u32>("party_index")?;
         let bytes_value: Value = h.fetch::<_, Value>("bytes")?;
         partials.push(PartialDecryption {
@@ -238,8 +206,8 @@ fn elgamal_aggregate(partials_value: Value, threshold: u32, ciphertext_value: Va
         c2: bytes_from_value(c2_value)?,
     };
     let shared = aggregate_partials(&partials, threshold, &ciphertext)
-        .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
-    let ruby = Ruby::get().map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+        .map_err(|e| crate::util::crypto_error(e.to_string(), "ElGamalP256.aggregate_partials", "elgamal-p256"))?;
+    let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
     Ok(bytes_to_rstring(&ruby, &shared))
 }
 
@@ -317,8 +285,8 @@ fn cmp20_sign(
 ) -> Result<magnus::RString, Error> {
     let arr = magnus::RArray::try_convert(shares_value)?;
     let mut share_bytes: Vec<Vec<u8>> = Vec::with_capacity(arr.len());
-    for v in arr.each() {
-        let s = bytes_from_value(v?)?;
+    for v in arr.into_iter() {
+        let s = bytes_from_value(v)?;
         share_bytes.push(s);
     }
     let supplied = share_bytes.len();
@@ -389,8 +357,8 @@ fn gg18_sign(
 ) -> Result<magnus::RString, Error> {
     let arr = magnus::RArray::try_convert(shares_value)?;
     let mut share_bytes: Vec<Vec<u8>> = Vec::with_capacity(arr.len());
-    for v in arr.each() {
-        let s = bytes_from_value(v?)?;
+    for v in arr.into_iter() {
+        let s = bytes_from_value(v)?;
         share_bytes.push(s);
     }
     let supplied = share_bytes.len();

data/ext/confium_native/src/transparency.rs

@@ -9,9 +9,10 @@ use confium_transparency::{
     entry::{ArtifactType, MerkleEntry},
     merkle::{Hash, InclusionProof as RustInclusionProof, MerkleTree as RustMerkleTree, Side},
 };
+use crate::util::{bytes_from_value, bytes_to_rstring};
 use magnus::{
-    exception, function, method, prelude::*, typed_data::Obj, DataTypeFunctions, Error, IntoValue,
-    Module, Object, RString, Ruby, TryConvert, TypedData, Value,
+    function, method, prelude::*, typed_data::Obj, DataTypeFunctions, Error, IntoValue,
+    Module, Object, Ruby, TypedData, Value,
 };
 
 #[derive(TypedData, DataTypeFunctions)]
@@ -30,9 +31,7 @@ impl MerkleTree {
     fn append(&self, artifact_hash: Value) -> Result<u64, Error> {
         let bytes = bytes_from_value(artifact_hash)?;
         if bytes.len() != 32 {
-            return Err(Error::new(
-                exception::arg_error(),
-                format!("artifact_hash must be exactly 32 bytes, got {}", bytes.len()),
+            return Err(crate::util::arg_error(format!("artifact_hash must be exactly 32 bytes, got {}", bytes.len()),
             ));
         }
         let mut artifact_hash = [0u8; 32];
@@ -54,7 +53,7 @@ impl MerkleTree {
     /// to iterate: `tree.to_a.map(&:sequence)` etc.
     fn entries(&self) -> Result<magnus::RArray, Error> {
         let len = self.inner.borrow().len();
-        let ruby = Ruby::get().map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+        let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
         let arr = ruby.ary_new_capa(len);
         for i in 0..(len as u64) {
             let proof = self.inclusion_proof(i)?;
@@ -74,7 +73,7 @@ impl MerkleTree {
             .consistency_proof(old_size)
             .map_err(|e| crate::util::index_error(e.to_string(), "MerkleTree.consistency_proof", Some(old_size as u64)))?;
         let ruby = Ruby::get()
-            .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+            .map_err(|e| crate::util::runtime(e.to_string()))?;
         let arr = ruby.ary_new_capa(proof.len());
         for h in &proof {
             arr.push(bytes_to_rstring(&ruby, h))?;
@@ -107,16 +106,12 @@ impl MerkleTree {
     ) -> Result<bool, Error> {
         let old_bytes = bytes_from_value(old_root)?;
         if old_bytes.len() != 32 {
-            return Err(Error::new(
-                exception::arg_error(),
-                format!("old_root must be 32 bytes, got {}", old_bytes.len()),
+            return Err(crate::util::arg_error(format!("old_root must be 32 bytes, got {}", old_bytes.len()),
             ));
         }
         let new_bytes = bytes_from_value(new_root)?;
         if new_bytes.len() != 32 {
-            return Err(Error::new(
-                exception::arg_error(),
-                format!("new_root must be 32 bytes, got {}", new_bytes.len()),
+            return Err(crate::util::arg_error(format!("new_root must be 32 bytes, got {}", new_bytes.len()),
             ));
         }
         let mut old_root_hash: Hash = [0u8; 32];
@@ -125,12 +120,10 @@ impl MerkleTree {
         new_root_hash.copy_from_slice(&new_bytes);
 
         let mut proof_hashes: Vec<Hash> = Vec::with_capacity(proof.len());
-        for item in proof.each() {
-            let bytes = bytes_from_value(item?)?;
+        for item in proof.into_iter() {
+            let bytes = bytes_from_value(item)?;
             if bytes.len() != 32 {
-                return Err(Error::new(
-                    exception::arg_error(),
-                    format!("proof entries must be 32 bytes, got {}", bytes.len()),
+                return Err(crate::util::arg_error(format!("proof entries must be 32 bytes, got {}", bytes.len()),
                 ));
             }
             let mut h: Hash = [0u8; 32];
@@ -162,7 +155,7 @@ impl MerkleTree {
         // Re-derive the leaf hash with the same algorithm the tree uses
         // internally (H(0x01 | entry_hash)).
         let leaf_hash = hash_leaf(entry.entry_hash());
-        let ruby = Ruby::get().map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+        let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
         Ok(ruby.obj_wrap(InclusionProofWrap {
             inner: proof,
             leaf_hash,
@@ -187,7 +180,7 @@ impl InclusionProofWrap {
     }
 
     fn steps(&self) -> Result<Value, Error> {
-        let ruby = Ruby::get().map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+        let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
         let result = ruby.hash_new();
         for (i, step) in self.inner.steps.iter().enumerate() {
             let step_hash = ruby.hash_new();
@@ -207,9 +200,7 @@ impl InclusionProofWrap {
     fn verify(&self, root_bytes: Value) -> Result<bool, Error> {
         let bytes = bytes_from_value(root_bytes)?;
         if bytes.len() != 32 {
-            return Err(Error::new(
-                exception::arg_error(),
-                format!("root must be exactly 32 bytes, got {}", bytes.len()),
+            return Err(crate::util::arg_error(format!("root must be exactly 32 bytes, got {}", bytes.len()),
             ));
         }
         let mut root: Hash = [0u8; 32];
@@ -234,16 +225,12 @@ impl InclusionProofWrap {
     fn verify_with_leaf(&self, leaf_bytes: Value, root_bytes: Value) -> Result<bool, Error> {
         let leaf = bytes_from_value(leaf_bytes)?;
         if leaf.len() != 32 {
-            return Err(Error::new(
-                exception::arg_error(),
-                format!("leaf_hash must be exactly 32 bytes, got {}", leaf.len()),
+            return Err(crate::util::arg_error(format!("leaf_hash must be exactly 32 bytes, got {}", leaf.len()),
             ));
         }
         let root_raw = bytes_from_value(root_bytes)?;
         if root_raw.len() != 32 {
-            return Err(Error::new(
-                exception::arg_error(),
-                format!("root must be exactly 32 bytes, got {}", root_raw.len()),
+            return Err(crate::util::arg_error(format!("root must be exactly 32 bytes, got {}", root_raw.len()),
             ));
         }
         let mut current: Hash = [0u8; 32];
@@ -261,35 +248,7 @@ impl InclusionProofWrap {
     }
 }
 
-fn bytes_from_value(v: Value) -> Result<Vec<u8>, Error> {
-    // Accept either a binary String (preferred for byte data) or an Array
-    // of small integers (also commonly used in Ruby crypto code).
-    if let Ok(s) = RString::try_convert(v) {
-        // SAFETY: we treat the string's raw bytes as opaque cryptographic
-        // input — we never interpret them as a UTF-8 string. Encoding is
-        // irrelevant for hash input.
-        return Ok(unsafe { s.as_slice() }.to_vec());
-    }
-    let arr: Vec<i64> = Vec::<i64>::try_convert(v)?;
-    arr.into_iter()
-        .map(|i| {
-            if !(0..=255).contains(&i) {
-                Err(Error::new(
-                    exception::arg_error(),
-                    format!("byte out of range 0..255: {i}"),
-                ))
-            } else {
-                Ok(i as u8)
-            }
-        })
-        .collect()
-}
 
-fn bytes_to_rstring(_ruby: &Ruby, bytes: &[u8]) -> RString {
-    let s = RString::buf_new(0);
-    s.cat(bytes);
-    s
-}
 
 fn hash_leaf(entry_hash: Hash) -> Hash {
     use sha2::{Digest, Sha256};

data/ext/confium_native/src/util.rs

@@ -3,6 +3,11 @@
 //! DRY consolidation: a single `bytes_from_value` + size cap + string
 //! conversion + typed-error helper shared by every subsystem module
 //! (composite, pki, tc, transparency, deployment, attributes).
+//!
+//! This module wraps magnus's deprecated `exception::*` constructors
+//! so the rest of the crate never touches them; their replacements
+//! need a `Ruby` handle, which the failure fallbacks here lack.
+#![allow(deprecated)]
 
 use magnus::prelude::*;
 use magnus::{exception, Error, RHash, RString, Ruby, TryConvert, Value};
@@ -14,6 +19,28 @@ use magnus::{exception, Error, RHash, RString, Ruby, TryConvert, Value};
 /// prevent trivial memory-exhaustion attacks.
 pub const MAX_INPUT_SIZE: usize = 1 << 20;
 
+/// Build a plain `RuntimeError`. Centralizes every raise site so the
+/// deprecated `magnus::exception::runtime_error()` fallback lives in
+/// exactly one place (its replacement needs a `Ruby` handle, which is
+/// unavailable when `Ruby::get()` itself fails).
+pub fn runtime(msg: impl Into<String>) -> Error {
+    let msg: String = msg.into();
+    match Ruby::get() {
+        Ok(ruby) => Error::new(ruby.exception_runtime_error(), msg),
+        Err(_) => Error::new(exception::runtime_error(), msg),
+    }
+}
+
+/// Build an `ArgumentError` — for bad argument shapes/ranges, the
+/// class callers should see before any Confium semantics apply.
+pub fn arg_error(msg: impl Into<String>) -> Error {
+    let msg: String = msg.into();
+    match Ruby::get() {
+        Ok(ruby) => Error::new(ruby.exception_arg_error(), msg),
+        Err(_) => Error::new(exception::arg_error(), msg),
+    }
+}
+
 /// Convert a Ruby value to bytes. Accepts a binary `String` (any
 /// encoding) or an `Array<Integer>`. Enforces a 1 MiB size cap.
 pub fn bytes_from_value(v: Value) -> Result<Vec<u8>, Error> {
@@ -30,10 +57,7 @@ pub fn bytes_from_value(v: Value) -> Result<Vec<u8>, Error> {
     arr.into_iter()
         .map(|i| {
             if !(0..=255).contains(&i) {
-                Err(Error::new(
-                    exception::arg_error(),
-                    format!("byte out of range 0..255: {i}"),
-                ))
+                Err(arg_error(format!("byte out of range 0..255: {i}")))
             } else {
                 Ok(i as u8)
             }
@@ -46,18 +70,15 @@ pub fn bytes_from_value(v: Value) -> Result<Vec<u8>, Error> {
 /// memory-exhaustion attacks.
 pub fn enforce_size(len: usize) -> Result<(), Error> {
     if len > MAX_INPUT_SIZE {
-        return Err(Error::new(
-            exception::arg_error(),
-            format!("input size {0} exceeds max {MAX_INPUT_SIZE}", len),
-        ));
+        return Err(arg_error(format!("input size {0} exceeds max {MAX_INPUT_SIZE}", len)));
     }
     Ok(())
 }
 
 /// Build a Ruby binary `String` from a byte slice. Avoids the UTF-8
-/// round-trip in `RString::buf_new` + `cat` for already-binary input.
-pub fn bytes_to_rstring(_ruby: &Ruby, bytes: &[u8]) -> RString {
-    let s = RString::buf_new(0);
+/// round-trip for already-binary input.
+pub fn bytes_to_rstring(ruby: &Ruby, bytes: &[u8]) -> RString {
+    let s = ruby.str_buf_new(0);
     s.cat(bytes);
     s
 }

data/lib/confium/openpgp.rb

@@ -1,33 +1,155 @@
 # 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
+  # OpenPGP ASCII armor (RFC 9580 §6) — Radix-64 framing with a
+  # CRC-24 checksum, implemented in pure Ruby.
+  #
+  # This replaced the earlier native wrapper around librnp, which
+  # pulled a full vendored Botan/json-c C/C++ build into every
+  # install just to do armor framing. The wire format is unchanged;
+  # spec/fixtures/openpgp_armor_vectors.json holds differential
+  # vectors captured from the native implementation.
   module OpenPGP
+    MESSAGE = 'message'
+    PUBLIC_KEY = 'public key'
+    SECRET_KEY = 'secret key'
+    SIGNATURE = 'signature'
+    CLEARTEXT = 'cleartext signed message'
+
+    LABELS = {
+      nil => 'MESSAGE',
+      MESSAGE => 'MESSAGE',
+      'public key' => 'PUBLIC KEY BLOCK',
+      SECRET_KEY => 'PRIVATE KEY BLOCK',
+      'private key' => 'PRIVATE KEY BLOCK',
+      SIGNATURE => 'SIGNATURE',
+      # Raw bytes cannot form a cleartext-signed message (that
+      # requires a signature packet); armor them as a plain message.
+      CLEARTEXT => 'MESSAGE',
+      'cleartext' => 'MESSAGE'
+    }.freeze
+
+    CRC_POLY = 0x1864CFB
+    CRC_INIT = 0xB704CE
+    B64_CHARS = [('A'..'Z').to_a, ('a'..'z').to_a, ('0'..'9').to_a, %w[+ /]].flatten.freeze
+    CRC_TABLE = (0..255).map do |i|
+      c = i << 16
+      8.times do
+        c = c.nobits?(0x800_000) ? c << 1 : ((c << 1) ^ CRC_POLY)
+        c &= 0xFFFFFF
+      end
+      c
+    end.freeze
+
+    private_constant :LABELS, :CRC_POLY, :CRC_INIT, :B64_CHARS, :CRC_TABLE
+
     class << self
-      # ASCII-armor encode raw bytes.
+      # ASCII-armor encode raw bytes. Output uses CRLF line endings
+      # and 76-character data lines, byte-for-byte matching the
+      # earlier native (rnp) implementation.
       #
       # @param data [String] Binary data to encode.
-      # @param type [String] Armor type — one of MESSAGE, PUBLIC_KEY,
-      #   SECRET_KEY, SIGNATURE, CLEARTEXT. Defaults to MESSAGE.
+      # @param type [String] One of MESSAGE, PUBLIC_KEY, SECRET_KEY,
+      #   SIGNATURE, CLEARTEXT (armored as a plain message). Defaults
+      #   to MESSAGE.
       # @return [String] Armored ASCII string.
+      # @raise [ArgumentError] if +type+ is not a known armor type.
       def armor(data, type = MESSAGE)
-        _native_armor(data, type)
+        label = LABELS[type]
+        raise ArgumentError, "unknown armor type: #{type.inspect}" unless label
+
+        bytes = data.to_s.b
+        b64 = [bytes].pack('m0')
+        lines = b64.scan(/.{1,76}/)
+        <<~ARMOR.gsub("\n", "\r\n")
+          -----BEGIN PGP #{label}-----
+
+          #{lines.join("\n")}
+          =#{crc24_armor(bytes)}
+          -----END PGP #{label}-----
+        ARMOR
       end
 
-      # Decode ASCII-armored data to raw bytes.
+      # Decode ASCII-armored data to raw bytes. Accepts LF or CRLF
+      # line endings, arbitrary line widths, and Armor Headers
+      # (Comment:, Version:, ...) between the BEGIN line and the
+      # blank line. The CRC-24 checksum line is verified when
+      # present.
       #
       # @param data [String] Armored ASCII string.
-      # @return [String] Raw binary data.
+      # @return [String] Raw binary data (ASCII-8BIT).
+      # @raise [Confium::ParseError] on missing delimiters, non-base64
+      #   content, or a CRC mismatch.
       def dearmor(data)
-        _native_dearmor(data)
+        b64, crc_line = extract_body(data.to_s)
+        # @type var bytes: String
+        bytes = b64.unpack1('m0')
+        return ''.b if crc_line == crc24_armor(''.b) && b64.empty?
+
+        raise ParseError, 'armor CRC-24 checksum mismatch' if crc_line && crc24_armor(bytes) != crc_line.to_s
+
+        bytes
+      end
+
+      private
+
+      # Locate the armored block, skip the BEGIN line and any Armor
+      # Headers, and split the remaining lines into the joined
+      # Radix-64 data and the checksum line (if present).
+      def extract_body(text)
+        lines = block_lines(text)
+        b64, crc_line = collect_data(lines)
+        raise ParseError, 'armored block has no data' if b64.empty? && crc_line.nil?
+
+        [b64, crc_line]
+      end
+
+      # The lines of the armored block between BEGIN and END, with
+      # the BEGIN line and any Armor Headers removed.
+      def block_lines(text)
+        slice = block_slice(text.gsub("\r\n", "\n"))
+        lines = slice.split("\n")
+        lines.shift # BEGIN
+        lines.shift while lines.first&.match?(/^\s|^[A-Za-z0-9-]+: /)
+        lines.shift if lines.first == ''
+        lines
+      end
+
+      # The text between the BEGIN and END delimiter lines.
+      def block_slice(normalized)
+        begin_line = normalized.index(/^-----BEGIN PGP [A-Z ]+-----$/)
+        raise ParseError, 'not an ASCII-armored block (no BEGIN line)' unless begin_line
+
+        end_match = normalized.match(/^-----END PGP [A-Z ]+-----$/)
+        raise ParseError, 'not an ASCII-armored block (no END line)' unless end_match
+
+        normalized[begin_line...end_match.begin(0)].to_s
+      end
+
+      def collect_data(lines)
+        b64 = +''
+        crc_line = nil
+        lines.each do |line|
+          next if line.empty?
+
+          if line.start_with?('=')
+            crc_line = line[1..]
+          elsif line.match?(%r{\A[A-Za-z0-9+/]+={0,2}\z})
+            b64 << line
+          else
+            raise ParseError, "invalid armor data line: #{line[0, 20].inspect}"
+          end
+        end
+        [b64, crc_line]
+      end
+
+      # CRC-24 (RFC 9580 §6.1), encoded as the four Radix-64
+      # characters of the 24-bit value as three big-endian bytes.
+      def crc24_armor(bytes)
+        crc = CRC_INIT
+        bytes.each_byte { |b| crc = ((crc << 8) & 0xFFFFFF) ^ CRC_TABLE[((crc >> 16) ^ b) & 0xFF] }
+        three_bytes = [crc >> 16, (crc >> 8) & 0xFF, crc & 0xFF].pack('C3')
+        [three_bytes].pack('m0')
       end
     end
   end

data/lib/confium/version.rb

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

data/lib/confium.rb

@@ -22,6 +22,13 @@ begin
   begin
     require_relative "confium_native/#{window}/confium_native"
   rescue LoadError
+    # Fall back to the flat source-build path only when the windowed
+    # binary is absent; a present-but-unloadable binary must raise its
+    # real dlopen error instead of masquerading as "not built".
+    dlext = RbConfig::CONFIG['DLEXT'] || 'so'
+    windowed = File.expand_path("confium_native/#{window}/confium_native.#{dlext}", __dir__ || '.')
+    raise if File.exist?(windowed)
+
     require_relative 'confium_native/confium_native'
   end
 rescue LoadError => e

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: confium
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Ribose Open
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-23 00:00:00.000000000 Z
+date: 2026-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -121,7 +121,6 @@ files:
 - ext/confium_native/src/deployment.rs
 - ext/confium_native/src/ers.rs
 - ext/confium_native/src/lib.rs
-- ext/confium_native/src/openpgp.rs
 - ext/confium_native/src/path.rs
 - ext/confium_native/src/pki.rs
 - ext/confium_native/src/tc.rs