confium 0.3.2 → 0.3.4

data/ext/confium_native/src/pki.rs

@@ -10,7 +10,7 @@
 //! *building* + signing lands in a follow-up once the Rust builder API
 //! stabilizes (currently `confium_pki::cert::builder` is private).
 
-use crate::util::{bytes_from_value, bytes_to_rstring, enforce_size};
+use crate::util::{bytes_from_value, bytes_to_rstring, enforce_size, parse_error};
 use chrono::{DateTime, Utc};
 use confium_pki::{
     cert::{Certificate as RustCert, CertificateSigningRequest as RustCsr},
@@ -20,7 +20,7 @@ use confium_pki::{
     xmldsig::{canonicalize, canonicalize_exclusive},
 };
 use magnus::{
-    exception, function, method, prelude::*, typed_data::Obj, DataTypeFunctions, Error, Module,
+    function, method, prelude::*, typed_data::Obj, DataTypeFunctions, Error, Module,
     Object, RHash, RString, Ruby, TryConvert, TypedData, Value,
 };
 
@@ -34,21 +34,21 @@ impl Certificate {
     fn from_der(bytes: Value) -> Result<Obj<Self>, Error> {
         let der = bytes_from_value(bytes)?;
         let cert = RustCert::from_der(&der)
-            .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| parse_error(e.to_string(), "Certificate.from_der", Some("der"), None))?;
+        let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
         Ok(ruby.obj_wrap(Self { inner: cert }))
     }
 
     fn from_pem(pem: String) -> Result<Obj<Self>, Error> {
         enforce_size(pem.len())?;
         let cert = RustCert::from_pem(&pem)
-            .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| parse_error(e.to_string(), "Certificate.from_pem", Some("pem"), None))?;
+        let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
         Ok(ruby.obj_wrap(Self { inner: cert }))
     }
 
     fn to_der(&self) -> Result<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.inner.to_der()))
     }
 
@@ -81,13 +81,13 @@ impl Certificate {
 
     fn valid_at(&self, iso8601: String) -> Result<bool, Error> {
         let now = DateTime::parse_from_rfc3339(&iso8601)
-            .map_err(|e| Error::new(exception::arg_error(), format!("invalid ISO8601 time: {e}")))?
+            .map_err(|e| crate::util::arg_error(format!("invalid ISO8601 time: {e}")))?
             .with_timezone(&Utc);
         Ok(self.inner.is_within_validity(now))
     }
 
     fn public_key_bytes(&self) -> Result<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.inner.public_key_bytes()))
     }
 }
@@ -102,21 +102,21 @@ impl Csr {
     fn from_der(bytes: Value) -> Result<Obj<Self>, Error> {
         let der = bytes_from_value(bytes)?;
         let csr = RustCsr::from_der(&der)
-            .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| parse_error(e.to_string(), "Csr.from_der", Some("der"), None))?;
+        let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
         Ok(ruby.obj_wrap(Self { inner: csr }))
     }
 
     fn from_pem(pem: String) -> Result<Obj<Self>, Error> {
         enforce_size(pem.len())?;
         let csr = RustCsr::from_pem(&pem)
-            .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| parse_error(e.to_string(), "Csr.from_pem", Some("pem"), None))?;
+        let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
         Ok(ruby.obj_wrap(Self { inner: csr }))
     }
 
     fn to_der(&self) -> Result<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.inner.to_der()))
     }
 
@@ -135,8 +135,8 @@ impl SignedData {
     fn from_json(json: String) -> Result<Obj<Self>, Error> {
         enforce_size(json.len())?;
         let sd: RustSignedData = serde_json::from_str(&json)
-            .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| parse_error(e.to_string(), "SignedData.from_json", Some("json"), None))?;
+        let ruby = Ruby::get().map_err(|e| crate::util::runtime(e.to_string()))?;
         Ok(ruby.obj_wrap(Self {
             inner: std::cell::RefCell::new(sd),
         }))
@@ -162,15 +162,11 @@ impl SignedData {
         certificates: Value,
     ) -> Result<Obj<Self>, Error> {
         if signature.is_nil() {
-            return Err(Error::new(
-                exception::arg_error(),
-                "signature is required",
+            return Err(crate::util::arg_error("signature is required",
             ));
         }
         if certificates.is_nil() {
-            return Err(Error::new(
-                exception::arg_error(),
-                "certificates is required",
+            return Err(crate::util::arg_error("certificates is required",
             ));
         }
 
@@ -179,16 +175,15 @@ impl SignedData {
 
         let certs_array: magnus::RArray = magnus::RArray::try_convert(certificates)?;
         let mut cert_ders = Vec::with_capacity(certs_array.len());
-        for item in certs_array.each() {
-            let v = item?;
+        for v in certs_array.into_iter() {
             let der = bytes_from_value(v)?;
             enforce_size(der.len())?;
             cert_ders.push(der);
         }
 
-        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 sd = build_detached_signature(Vec::new(), algorithm, sig_bytes, cert_ders)
-            .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+            .map_err(|e| crate::util::runtime(e.to_string()))?;
         Ok(ruby.obj_wrap(Self {
             inner: std::cell::RefCell::new(sd),
         }))
@@ -196,7 +191,7 @@ impl SignedData {
 
     fn to_json(&self) -> Result<String, Error> {
         serde_json::to_string(&*self.inner.borrow())
-            .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))
+            .map_err(|e| crate::util::runtime(e.to_string()))
     }
 
     /// Encode this SignedData as DER bytes (RFC 5652 ContentInfo).
@@ -204,9 +199,9 @@ impl SignedData {
     /// The output is parseable by `openssl cms` / `openssl pkcs7` and
     /// any standards-compliant CMS consumer.
     fn to_der(&self) -> Result<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()))?;
         let der = encode_signed_data_der(&self.inner.borrow())
-            .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+            .map_err(|e| crate::util::runtime(e.to_string()))?;
         Ok(bytes_to_rstring(&ruby, &der))
     }
 
@@ -225,7 +220,7 @@ impl SignedData {
     fn content(&self) -> Result<Option<Obj<CertWrapper>>, Error> {
         // Wrap the optional content bytes in a small value object so Ruby
         // can ask `.present?` / `.bytes` without juggling nil-vs-string.
-        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()))?;
         match &self.inner.borrow().encap_content_info.content {
             Some(bytes) => {
                 let wrapper = CertWrapper {
@@ -242,16 +237,17 @@ impl SignedData {
     }
 
     fn certificate_at(&self, index: usize) -> Result<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()))?;
         self.inner
             .borrow()
             .certificates
             .get(index)
             .map(|c| bytes_to_rstring(&ruby, c))
             .ok_or_else(|| {
-                Error::new(
-                    exception::index_error(),
+                crate::util::index_error(
                     format!("certificate index {index} out of range"),
+                    "SignedData.certificate_at",
+                    Some(index as u64),
                 )
             })
     }
@@ -294,8 +290,8 @@ impl SignedData {
             } else {
                 Err(format!("unsupported signature algorithm OID: {oid}"))
             }
-        }).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(ruby.obj_wrap(CmsVerificationResult { inner: result }))
     }
 }
@@ -349,7 +345,7 @@ pub struct CertWrapper {
 
 impl CertWrapper {
     fn bytes(&self) -> Result<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.bytes))
     }
 
@@ -362,12 +358,12 @@ impl CertWrapper {
 
 fn xmldsig_canonicalize(xml: String) -> Result<String, Error> {
     enforce_size(xml.len())?;
-    canonicalize(&xml).map_err(|e| Error::new(exception::runtime_error(), e.to_string()))
+    canonicalize(&xml).map_err(|e| parse_error(e.to_string(), "XMLDSig.canonicalize", Some("xml"), None))
 }
 
 fn xmldsig_canonicalize_exclusive(xml: String) -> Result<String, Error> {
     enforce_size(xml.len())?;
-    canonicalize_exclusive(&xml).map_err(|e| Error::new(exception::runtime_error(), e.to_string()))
+    canonicalize_exclusive(&xml).map_err(|e| parse_error(e.to_string(), "XMLDSig.canonicalize_exclusive", Some("xml"), None))
 }
 
 pub fn init(ruby: &Ruby, parent: magnus::RModule) -> Result<(), Error> {

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)?;
@@ -72,9 +71,9 @@ impl MerkleTree {
             .inner
             .borrow()
             .consistency_proof(old_size)
-            .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+            .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];
@@ -142,7 +135,7 @@ impl MerkleTree {
             .borrow()
             .verify_consistency(old_root_hash, new_root_hash, old_size, new_size, &proof_hashes)
             .map(|_| true)
-            .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))
+            .map_err(|e| crate::util::verification_error(e.to_string(), "MerkleTree.verify_consistency", None, None))
     }
 
     fn root(&self) -> Value {
@@ -155,14 +148,14 @@ impl MerkleTree {
         let tree = self.inner.borrow();
         let proof = tree
             .inclusion_proof(seq)
-            .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+            .map_err(|e| crate::util::index_error(e.to_string(), "MerkleTree.inclusion_proof", Some(seq)))?;
         let entry = tree
             .entry(seq)
-            .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+            .map_err(|e| crate::util::index_error(e.to_string(), "MerkleTree.inclusion_proof", Some(seq)))?;
         // 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};