enquo-core 0.7.0.2.gb37f667-x86_64-linux → 0.7.0.5.gb281772-x86_64-linux

data/ext/enquo/src/lib.rs

@@ -1,320 +1,40 @@
-#[macro_use]
-extern crate rutie;
+mod field;
+mod root;
+mod root_key;
 
-use enquo_core::{key_provider, Boolean, Date, Field, Root, Text, I64};
-use rutie::{
-    AnyObject, Boolean as RBoolean, Class, Integer, Module, Object, RString, Symbol,
-    VerifiedObject, VM,
-};
+#[magnus::init]
+fn init() -> Result<(), magnus::Error> {
+    let base_mod = magnus::define_module("Enquo")?;
 
-class!(EnquoRoot);
-class!(EnquoRootKeyStatic);
-class!(EnquoField);
+    root::init(&base_mod)?;
+    root_key::init(&base_mod)?;
+    field::init(&base_mod)?;
 
-wrappable_struct!(Root<'static>, RootWrapper, ROOT_WRAPPER);
-wrappable_struct!(
-    key_provider::Static,
-    StaticRootKeyWrapper,
-    STATIC_ROOT_KEY_WRAPPER
-);
-wrappable_struct!(Field, FieldWrapper, FIELD_WRAPPER);
+    Ok(())
+}
 
-fn maybe_raise<T, E: std::error::Error>(r: Result<T, E>, s: &str) -> T {
-    r.map_err(|e| {
-        VM::raise(
-            Class::from_existing("Enquo").get_nested_class("Error"),
-            &format!("{s}: {e}"),
+fn enquo_exception() -> Result<magnus::ExceptionClass, magnus::Error> {
+    magnus::ExceptionClass::from_value(magnus::eval("::Enquo::Error")?).ok_or_else(|| {
+        magnus::Error::new(
+            magnus::exception::runtime_error(),
+            "failed to get RClass from Enquo::Error value".to_string(),
         )
     })
-    .unwrap()
-}
-
-unsafe_methods!(
-    EnquoRoot,
-    _rbself,
-    fn enquo_root_new_from_static_root_key(root_key_obj: EnquoRootKeyStatic) -> EnquoRoot {
-        let rk = root_key_obj.get_data(&*STATIC_ROOT_KEY_WRAPPER);
-        let root = maybe_raise(Root::new(rk), "Failed to create Enquo::Root");
-
-        let klass = Module::from_existing("Enquo").get_nested_class("Root");
-        klass.wrap_data(root, &*ROOT_WRAPPER)
-    },
-    fn enquo_root_field(relation_obj: RString, name_obj: RString) -> EnquoField {
-        let relation = relation_obj.to_vec_u8_unchecked();
-        let name = name_obj.to_vec_u8_unchecked();
-
-        let root = _rbself.get_data(&*ROOT_WRAPPER);
-
-        let field = maybe_raise(
-            root.field(&relation, &name),
-            "Failed to create Enquo::Field",
-        );
-
-        let klass = Module::from_existing("Enquo").get_nested_class("Field");
-        klass.wrap_data(field, &*FIELD_WRAPPER)
-    }
-);
-
-unsafe_methods!(
-    EnquoRootKeyStatic,
-    _rbself,
-    fn enquo_root_key_static_new(root_key_obj: RString) -> EnquoRootKeyStatic {
-        let root_key = root_key_obj.to_vec_u8_unchecked();
-
-        let k = key_provider::Static::new(&root_key);
-        let klass = Module::from_existing("Enquo")
-            .get_nested_class("RootKey")
-            .get_nested_class("Static");
-        klass.wrap_data(k, &*STATIC_ROOT_KEY_WRAPPER)
-    },
-);
-
-impl VerifiedObject for EnquoRootKeyStatic {
-    fn is_correct_type<T: Object>(object: &T) -> bool {
-        let klass = Module::from_existing("Enquo")
-            .get_nested_class("RootKey")
-            .get_nested_class("Static");
-        klass.case_equals(object)
-    }
-
-    fn error_message() -> &'static str {
-        "Provided object is not an Enquo::RootKey::Static instance"
-    }
 }
 
-// rustfmt fucks this so it doesn't compile
-#[rustfmt::skip]
-unsafe_methods!(
-    EnquoField,
-    rbself,
-    fn enquo_field_encrypt_boolean(b_obj: RBoolean, context_obj: RString, mode_obj: Symbol) -> RString {
-        let b = b_obj.to_bool();
-        let context = context_obj.to_vec_u8_unchecked();
-        let mode = mode_obj.to_str();
-
-        let field = rbself.get_data(&*FIELD_WRAPPER);
-
-        let mut res = maybe_raise(
-            if mode == "unsafe" {
-                Boolean::new_with_unsafe_parts(b, &context, field)
-            } else {
-                Boolean::new(b, &context, field)
-            },
-            "Failed to create encrypted boolean",
-        );
-        if mode == "no_query" {
-            res.make_unqueryable();
-        }
-
-        RString::new_utf8(&maybe_raise(serde_json::to_string(&res), "Failed to JSONify ciphertext"))
-    },
-    fn enquo_field_decrypt_boolean(ciphertext_obj: RString, context_obj: RString) -> RBoolean {
-        let ct = ciphertext_obj.to_str_unchecked();
-        let context = context_obj.to_vec_u8_unchecked();
-
-        let field = rbself.get_data(&*FIELD_WRAPPER);
-
-        let e_value: Boolean =
-            maybe_raise(serde_json::from_str(ct), "Failed to deserialize ciphertext");
-
-        let value = maybe_raise(
-            e_value.decrypt(&context, field),
-            "Failed to decrypt boolean value",
-        );
-        RBoolean::new(value)
-    },
-    fn enquo_field_encrypt_i64(i_obj: Integer, context_obj: RString, mode_obj: Symbol) -> RString {
-        let i = i_obj.to_i64();
-        let context = context_obj.to_vec_u8_unchecked();
-        let mode = mode_obj.to_str();
-
-        let field = rbself.get_data(&*FIELD_WRAPPER);
-
-        let mut res = maybe_raise(
-            if mode == "unsafe" {
-                I64::new_with_unsafe_parts(i, &context, field)
-            } else {
-                I64::new(i, &context, field)
-            },
-            "Failed to create encrypted i64",
-        );
-        if mode == "no_query" {
-            res.make_unqueryable();
-        }
-
-        RString::new_utf8(&maybe_raise(serde_json::to_string(&res), "Failed to JSONify ciphertext"))
-    },
-    fn enquo_field_decrypt_i64(ciphertext_obj: RString, context_obj: RString) -> Integer {
-        let ct = ciphertext_obj.to_str_unchecked();
-        let context = context_obj.to_vec_u8_unchecked();
+fn maybe_raise<T, E: std::error::Error>(
+    r: Result<T, E>,
+    s: Option<&str>,
+) -> Result<T, magnus::Error> {
+    let ex_class = enquo_exception()?;
 
-        let field = rbself.get_data(&*FIELD_WRAPPER);
-
-        let e_value: I64 =
-            maybe_raise(serde_json::from_str(ct), "Failed to deserialize ciphertext");
-
-
-        let value = maybe_raise(
-            e_value.decrypt(&context, field),
-            "Failed to decrypt i64 value",
-        );
-        Integer::from(value)
-    },
-    fn enquo_field_encrypt_date(
-        y_obj: Integer,
-        m_obj: Integer,
-        d_obj: Integer,
-        context_obj: RString,
-        mode_obj: Symbol
-    ) -> RString {
-        let y = y_obj.to_i32() as i16;
-        let m = m_obj.to_i32() as u8;
-        let d = d_obj.to_i32() as u8;
-        let context = context_obj.to_vec_u8_unchecked();
-        let mode = mode_obj.to_str();
-
-        let field = rbself.get_data(&*FIELD_WRAPPER);
-
-        let mut res = maybe_raise(
-            if mode == "unsafe" {
-                Date::new_with_unsafe_parts(
-                    (y, m, d),
-                    &context,
-                    field,
-                )
-            } else {
-                Date::new((y, m, d), &context, field)
-            },
-            "Failed to create encrypted date",
-        );
-        if mode == "no_query" {
-            res.make_unqueryable();
-        }
-
-        RString::new_utf8(&maybe_raise(serde_json::to_string(&res), "Failed to JSONify ciphertext"))
-    },
-    fn enquo_field_decrypt_date(ciphertext_obj: RString, context_obj: RString) -> AnyObject {
-        let ct = ciphertext_obj.to_str_unchecked();
-        let context = context_obj.to_vec_u8_unchecked();
-
-        let field = rbself.get_data(&*FIELD_WRAPPER);
-
-        let e_value: Date =
-            maybe_raise(serde_json::from_str(ct), "Failed to deserialize ciphertext");
-
-        let (y, m, d) = maybe_raise(
-            e_value.decrypt(&context, field),
-            "Failed to decrypt date value",
-        );
-        let klass = Class::from_existing("Date");
-        let args: [AnyObject; 3] = [
-            Integer::from(y as i32).into(),
-            Integer::from(m as i32).into(),
-            Integer::from(d as i32).into(),
-        ];
-        klass.protect_send("new", &args).unwrap()
-    }
-    fn enquo_field_encrypt_text(
-        text_obj: RString,
-        context_obj: RString,
-        mode_obj: Symbol,
-        order_code_len_obj: Integer
-    ) -> RString {
-        let text = text_obj.to_str();
-        let context = context_obj.to_vec_u8_unchecked();
-        let mode = mode_obj.to_str();
-
-        let field = rbself.get_data(&*FIELD_WRAPPER);
-
-        let mut res = maybe_raise(
-            if mode == "unsafe" {
-                Text::new_with_unsafe_parts(
-                    text,
-                    &context,
-                    field,
-                    None,
-                )
-            } else if mode == "orderable" {
-                let order_code_len = order_code_len_obj.to_i64() as u8;
-                Text::new_with_unsafe_parts(
-                    text,
-                    &context,
-                    field,
-                    Some(order_code_len),
-                )
-            } else {
-                Text::new(text, &context, field)
+    r.map_err(|e| {
+        magnus::Error::new(
+            ex_class,
+            match &s {
+                None => e.to_string(),
+                Some(s) => format!("{s}: {e}"),
             },
-            "Failed to create encrypted date",
-        );
-        if mode == "no_query" {
-            maybe_raise(res.make_unqueryable(), "Failed to make ciphertext unqueryable");
-        }
-
-        RString::new_utf8(&maybe_raise(serde_json::to_string(&res), "Failed to JSONify ciphertext"))
-    },
-    fn enquo_field_decrypt_text(ciphertext_obj: RString, context_obj: RString) -> RString {
-        let ct = ciphertext_obj.to_str_unchecked();
-        let context = context_obj.to_vec_u8_unchecked();
-
-        let field = rbself.get_data(&*FIELD_WRAPPER);
-
-        let e_value: Text =
-            maybe_raise(serde_json::from_str(ct), "Failed to deserialize ciphertext");
-
-        let s = maybe_raise(e_value.decrypt(&context, field), "Failed to decrypt text value");
-
-        RString::new_utf8(&s)
-    },
-    fn enquo_field_encrypt_text_length_query(
-        len_obj: Integer
-    ) -> RString {
-        let len = len_obj.to_u32();
-
-        let field = rbself.get_data(&*FIELD_WRAPPER);
-
-        let v_set = maybe_raise(Text::query_length(len, field), "Failed to encrypt length as value set");
-        RString::new_utf8(&maybe_raise(serde_json::to_string(&v_set), "Failed to JSONify value set"))
-    }
-);
-
-#[allow(non_snake_case)]
-#[no_mangle]
-pub extern "C" fn Init_enquo() {
-    Module::from_existing("Enquo").define(|topmod| {
-        topmod
-            .define_nested_class("Root", None)
-            .define(|rootklass| {
-                rootklass.singleton_class().def_private(
-                    "_new_from_static_root_key",
-                    enquo_root_new_from_static_root_key,
-                );
-                rootklass.def_private("_field", enquo_root_field);
-            });
-        topmod
-            .define_nested_class("Field", None)
-            .define(|fieldklass| {
-                fieldklass.def_private("_encrypt_boolean", enquo_field_encrypt_boolean);
-                fieldklass.def_private("_decrypt_boolean", enquo_field_decrypt_boolean);
-                fieldklass.def_private("_encrypt_i64", enquo_field_encrypt_i64);
-                fieldklass.def_private("_decrypt_i64", enquo_field_decrypt_i64);
-                fieldklass.def_private("_encrypt_date", enquo_field_encrypt_date);
-                fieldklass.def_private("_decrypt_date", enquo_field_decrypt_date);
-                fieldklass.def_private("_encrypt_text", enquo_field_encrypt_text);
-                fieldklass.def_private("_decrypt_text", enquo_field_decrypt_text);
-                fieldklass.def_private(
-                    "_encrypt_text_length_query",
-                    enquo_field_encrypt_text_length_query,
-                );
-            });
-        topmod.define_nested_module("RootKey").define(|rkmod| {
-            rkmod
-                .define_nested_class("Static", None)
-                .define(|statickeyklass| {
-                    statickeyklass
-                        .singleton_class()
-                        .def_private("_new", enquo_root_key_static_new);
-                });
-        });
-    });
+        )
+    })
 }

data/ext/enquo/src/root.rs

@@ -0,0 +1,39 @@
+use magnus::{class, function, method, prelude::*, RModule};
+use std::ops::Deref;
+
+use crate::{field::Field, maybe_raise, root_key::RootKey};
+
+#[magnus::wrap(class = "Enquo::Root")]
+struct Root(enquo_core::Root);
+
+impl Deref for Root {
+    type Target = enquo_core::Root;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Root {
+    fn new(k: &RootKey) -> Result<Self, magnus::Error> {
+        Ok(Self(maybe_raise(
+            enquo_core::Root::new(k.deref().clone()),
+            None,
+        )?))
+    }
+
+    fn field(&self, relation: String, name: String) -> Result<Field, magnus::Error> {
+        Ok(Field(maybe_raise(
+            self.0.field(relation.as_bytes(), name.as_bytes()),
+            None,
+        )?))
+    }
+}
+
+pub fn init(base: &RModule) -> Result<(), magnus::Error> {
+    let class = base.define_class("Root", class::object())?;
+
+    class.define_singleton_method("new", function!(Root::new, 1))?;
+    class.define_method("field", method!(Root::field, 2))?;
+    Ok(())
+}

data/ext/enquo/src/root_key.rs

@@ -0,0 +1,67 @@
+use enquo_core::{key_provider, key_provider::KeyProvider};
+use magnus::{class, encoding, exception, function, prelude::*, RModule};
+use std::ops::Deref;
+use std::sync::Arc;
+
+#[magnus::wrap(class = "Enquo::RootKey")]
+pub struct RootKey(Arc<dyn KeyProvider>);
+
+impl Deref for RootKey {
+    type Target = Arc<dyn KeyProvider>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+fn new_static_root_key(k_str: magnus::RString) -> Result<RootKey, magnus::Error> {
+    let encindex = k_str.enc_get();
+
+    let k: &[u8] = &if encindex == encoding::Index::ascii8bit() {
+        if k_str.len() == 32 {
+            Ok(unsafe { (*k_str.as_slice()).to_vec() })
+        } else {
+            Err(magnus::Error::new(
+                exception::arg_error(),
+                "binary key string must be exactly 32 bytes long".to_string(),
+            ))
+        }
+    } else if encindex == encoding::Index::utf8() || encindex == encoding::Index::usascii() {
+        if k_str.len() == 64 {
+            Ok(unsafe {
+                hex::decode(k_str.as_slice()).map_err(|e| {
+                    magnus::Error::new(
+                        exception::arg_error(),
+                        format!("hex key must only contain valid hex characters: {e}"),
+                    )
+                })?
+            })
+        } else {
+            Err(magnus::Error::new(
+                exception::arg_error(),
+                format!(
+                    "hex key string must be exactly 64 characters long (got {} characters)",
+                    k_str.len()
+                ),
+            ))
+        }
+    } else {
+        Err(magnus::Error::new(
+            exception::encoding_error(),
+            "key string must be encoded as BINARY or UTF-8".to_string(),
+        ))
+    }?;
+
+    Ok(RootKey(Arc::new(key_provider::Static::new(k))))
+}
+
+pub fn init(base: &RModule) -> Result<(), magnus::Error> {
+    let base_class = base.define_class("RootKey", class::object())?;
+
+    {
+        let class = base_class.define_class("Static", base_class)?;
+        class.define_singleton_method("new", function!(new_static_root_key, 1))?;
+    }
+
+    Ok(())
+}

data/lib/enquo.rb

@@ -1,3 +1,5 @@
+require "date"
+
 module Enquo
 	class Error < StandardError; end
 end
@@ -12,7 +14,3 @@ rescue LoadError
 		raise LoadError, "Failed to load enquo.#{RbConfig::CONFIG["DLEXT"]}; either it hasn't been built, or was built incorrectly for your system"
 	end
 end
-
-require_relative "./enquo/root"
-require_relative "./enquo/root_key"
-require_relative "./enquo/field"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enquo-core
 version: !ruby/object:Gem::Version
-  version: 0.7.0.2.gb37f667
+  version: 0.7.0.5.gb281772
 platform: x86_64-linux
 authors:
 - Matt Palmer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-14 00:00:00.000000000 Z
+date: 2023-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -170,7 +170,10 @@ files:
 - ext/enquo/Cargo.lock
 - ext/enquo/Cargo.toml
 - ext/enquo/extconf.rb
+- ext/enquo/src/field.rs
 - ext/enquo/src/lib.rs
+- ext/enquo/src/root.rs
+- ext/enquo/src/root_key.rs
 - lib/2.7/enquo.so
 - lib/3.0/enquo.so
 - lib/3.1/enquo.so
@@ -178,10 +181,6 @@ files:
 - lib/enquo-core.rb
 - lib/enquo.rb
 - lib/enquo.so
-- lib/enquo/field.rb
-- lib/enquo/root.rb
-- lib/enquo/root_key.rb
-- lib/enquo/root_key/static.rb
 - lib/enquo_core.rb
 homepage: https://enquo.org/active_enquo
 licenses: []

data/lib/enquo/field.rb

@@ -1,173 +0,0 @@
-require "date"
-
-module Enquo
-	class Field
-		def self.new(*_)
-			raise RuntimeError, "Enquo::Field cannot be instantiated directly; use Enquo::Crypto#field instead"
-		end
-
-		def encrypt_boolean(b, ctx, safety: true, no_query: false)
-			unless b.is_a?(TrueClass) || b.is_a?(FalseClass)
-				raise ArgumentError, "Enquo::Field#encrypt_boolean can only encrypt booleans (got an instance of #{b.class})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_encrypt_boolean(b, ctx, no_query ? :no_query : safety == :unsafe ? :unsafe : :default)
-		end
-
-		def decrypt_boolean(data, ctx)
-			unless data.is_a?(String)
-				raise ArgumentError, "Enquo::Field#decrypt_boolean can only decrypt from a string (got an instance of #{data.class})"
-			end
-
-			unless data.encoding == Encoding::UTF_8 && data.valid_encoding?
-				raise ArgumentError, "Enquo::Field#decrypt_boolean can only decrypt validly-encoded UTF-8 strings (got #{data.encoding})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_decrypt_boolean(data, ctx)
-		end
-
-		def encrypt_i64(i, ctx, safety: true, no_query: false)
-			unless i.is_a?(Integer)
-				raise ArgumentError, "Enquo::Field#encrypt_i64 can only encrypt integers (got an instance of #{i.class})"
-			end
-
-			unless i >= -2 ** 63 && i < 2 ** 63
-				raise RangeError, "Enquo::Field#encrypt_i64 can only encrypt integers between -2^63 and 2^63-1 (got #{i})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_encrypt_i64(i, ctx, no_query ? :no_query : safety == :unsafe ? :unsafe : :default)
-		end
-
-		def decrypt_i64(data, ctx)
-			unless data.is_a?(String)
-				raise ArgumentError, "Enquo::Field#decrypt_i64 can only decrypt from a string (got an instance of #{data.class})"
-			end
-
-			unless data.encoding == Encoding::UTF_8 && data.valid_encoding?
-				raise ArgumentError, "Enquo::Field#decrypt_i64 can only decrypt validly-encoded UTF-8 strings (got #{data.encoding})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_decrypt_i64(data, ctx)
-		end
-
-		def encrypt_date(d, ctx, safety: true, no_query: false)
-			unless d.is_a?(Date)
-				raise ArgumentError, "Enquo::Field#encrypt_date can only encrypt Dates (got an instance of #{d.class})"
-			end
-
-			unless d.year >= -2 ** 15 && d.year < 2 ** 15 - 1
-				raise RangeError, "Enquo::Field#encrypt_date can only encrypt dates where the year is between -32,768 and 32,767 (got #{d.year})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_encrypt_date(d.year, d.month, d.day, ctx, no_query ? :no_query : safety == :unsafe ? :unsafe : :default)
-		end
-
-		def decrypt_date(data, ctx)
-			unless data.is_a?(String)
-				raise ArgumentError, "Enquo::Field#decrypt_date can only decrypt from a string (got an instance of #{data.class})"
-			end
-
-			unless data.encoding == Encoding::UTF_8 && data.valid_encoding?
-				raise ArgumentError, "Enquo::Field#decrypt_date can only decrypt validly-encoded UTF-8 strings (got #{data.encoding})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_decrypt_date(data, ctx)
-		end
-
-		def encrypt_text(t, ctx, safety: true, no_query: false, order_prefix_length: nil)
-			unless t.is_a?(String)
-				raise ArgumentError, "Enquo::Field#encrypt_string can only encrypt Strings (got an instance of #{t.class})"
-			end
-
-			unless [Encoding::UTF_8, Encoding::US_ASCII].include?(t.encoding)
-				raise ArgumentError, "Enquo::Field#encrypt_string can only encrypt UTF-8 strings (got a string encoding of #{t.encoding})"
-			end
-
-			unless t.valid_encoding?
-				raise ArgumentError, "Enquo::Field#encrypt_string can only encrypt validly-encoded strings"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			unless order_prefix_length.nil?
-				unless safety == :unsafe
-					raise ArgumentError, "Ordering is only supported when the text field is marked unsafe"
-				end
-
-				unless order_prefix_length.is_a?(Integer)
-					raise ArgumentError, "Ordering prefix length must be an integer (got an instance of #{order_prefix_length.class})"
-				end
-
-				unless (1..255).include?(order_prefix_length)
-					raise ArgumentError, "Ordering prefix length must be between 1 and 255 inclusive (got #{order_prefix_length})"
-				end
-			end
-
-			mode = if no_query
-				:no_query
-			elsif !order_prefix_length.nil?
-				:orderable
-			elsif safety == :unsafe
-				:unsafe
-			else
-				:default
-			end
-
-			_encrypt_text(t, ctx, mode, order_prefix_length)
-		end
-
-		def decrypt_text(data, ctx)
-			unless data.is_a?(String)
-				raise ArgumentError, "Enquo::Field#decrypt_text can only decrypt from a string (got an instance of #{data.class})"
-			end
-
-			unless data.encoding == Encoding::UTF_8 && data.valid_encoding?
-				raise ArgumentError, "Enquo::Field#decrypt_date can only decrypt validly-encoded UTF-8 strings (got #{data.encoding})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_decrypt_text(data, ctx)
-		end
-
-		def encrypt_text_length_query(len)
-			unless len.is_a?(Integer)
-				raise ArgumentError, "Enquo::Field#encrypt_text_length_query can only encrypt integers (got an instance of #{len.class})"
-			end
-
-			unless len >= 0 && len < 2 ** 32
-				raise ArgumentError, "Enquo::Field#encrypt_text_length_query can only encrypt integers between 0 and 2^32-1 (got #{len})"
-			end
-
-			_encrypt_text_length_query(len)
-		end
-	end
-end