enquo-core 0.1.0

data/ext/enquo/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "enquo"
+version = "0.0.0"
+edition = "2021"
+
+[dependencies]
+enquo-core = { path = "../../../rust" }
+lazy_static = "1.0"
+serde_json = "1.0"
+rb-sys = "0.8"
+rutie = { git = "https://github.com/mpalmer/rutie", branch = "rb_sys" }
+
+[lib]
+crate-type = ["cdylib"]

data/ext/enquo/extconf.rb

@@ -0,0 +1,4 @@
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("enquo/enquo")

data/ext/enquo/src/lib.rs

@@ -0,0 +1,139 @@
+#[macro_use]
+extern crate rutie;
+
+use enquo_core::{Field, Root, I64};
+use rutie::{Class, Integer, Module, Object, RString, VerifiedObject, VM};
+
+class!(EnquoRoot);
+class!(EnquoRootKeyStatic);
+class!(EnquoField);
+
+type StaticRootKey = Vec<u8>;
+
+wrappable_struct!(Root<'static>, RootWrapper, ROOT_WRAPPER);
+wrappable_struct!(StaticRootKey, StaticRootKeyWrapper, STATIC_ROOT_KEY_WRAPPER);
+wrappable_struct!(Field, FieldWrapper, FIELD_WRAPPER);
+
+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),
+        )
+    })
+    .unwrap()
+}
+
+methods!(
+    EnquoRoot,
+    rbself,
+    fn enquo_root_new_from_static_root_key(root_key_obj: EnquoRootKeyStatic) -> EnquoRoot {
+        let root_key = root_key_obj.unwrap();
+        // Not so needless after all, Clippy...
+        #[allow(clippy::needless_borrow)]
+        let rk = root_key.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: RString, name: RString) -> EnquoField {
+        let root = rbself.get_data(&*ROOT_WRAPPER);
+
+        let field = maybe_raise(
+            root.field(
+                &relation.unwrap().to_vec_u8_unchecked(),
+                &name.unwrap().to_vec_u8_unchecked(),
+            ),
+            "Failed to create Enquo::Field",
+        );
+
+        let klass = Module::from_existing("Enquo").get_nested_class("Field");
+        klass.wrap_data(field, &*FIELD_WRAPPER)
+    }
+);
+
+methods!(
+    EnquoRootKeyStatic,
+    _rbself,
+    fn enquo_root_key_static_new(root_key: RString) -> EnquoRootKeyStatic {
+        let k = root_key.unwrap().to_vec_u8_unchecked();
+        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"
+    }
+}
+
+methods!(
+    EnquoField,
+    rbself,
+    fn enquo_field_encrypt_i64(value: Integer, context: RString) -> RString {
+        let i = value.unwrap().to_i64();
+        let field = rbself.get_data(&*FIELD_WRAPPER);
+
+        let res = maybe_raise(
+            field.i64(i, &context.unwrap().to_vec_u8_unchecked()),
+            "Failed to create encrypted i64",
+        );
+        RString::new_utf8(&serde_json::to_string(&res).unwrap())
+    },
+    fn enquo_field_decrypt_i64(ciphertext: RString, context: RString) -> Integer {
+        let ct_r = ciphertext.unwrap();
+        let ct = ct_r.to_str_unchecked();
+        let e_value: I64 =
+            maybe_raise(serde_json::from_str(ct), "Failed to deserialize ciphertext");
+
+        let field = rbself.get_data(&*FIELD_WRAPPER);
+
+        let value = maybe_raise(
+            e_value.decrypt(&context.unwrap().to_vec_u8_unchecked(), field),
+            "Failed to decrypt i64 value",
+        );
+        Integer::from(value)
+    }
+);
+
+#[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_i64", enquo_field_encrypt_i64);
+                fieldklass.def_private("_decrypt_i64", enquo_field_decrypt_i64);
+            });
+        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/lib/enquo/field.rb

@@ -0,0 +1,39 @@
+module Enquo
+	class Field
+		def self.new(*_)
+			raise RuntimeError, "Enquo::Field cannot be instantiated directly; use Enquo::Crypto#field instead"
+		end
+
+		def encrypt_i64(i, ctx)
+			unless i.is_a?(Integer)
+				raise ArgumentError, "Enquo::Field#encrypt_i64 can only encrypt integers"
+			end
+
+			unless i >= -2 ** 63 || i < 2 ** 63
+				raise ArgumentError, "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 a #{ctx.class})"
+			end
+
+			_encrypt_i64(i, ctx)
+		end
+
+		def decrypt_i64(data, ctx)
+			unless data.is_a?(String)
+				raise ArgumentError, "Enquo::Field#decrypt_i64 can only decrypt from a string (got #{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 a #{ctx.class})"
+			end
+
+			_decrypt_i64(data, ctx)
+		end
+	end
+end

data/lib/enquo/root.rb

@@ -0,0 +1,24 @@
+module Enquo
+	class Root
+		def self.new(key)
+			case key
+			when RootKey::Static
+				_new_from_static_root_key(key)
+			else
+				raise ArgumentError, "key must be a root key provider object (got a #{key.class})"
+			end
+		end
+
+		def field(relation, name)
+			if relation.is_a?(Symbol)
+				relation = relation.to_s
+			end
+
+			if name.is_a?(Symbol)
+				name = name.to_s
+			end
+
+			_field(relation, name)
+		end
+	end
+end

data/lib/enquo/root_key/static.rb

@@ -0,0 +1,27 @@
+module Enquo
+	module RootKey
+		class Static
+			def self.new(k)
+            unless k.is_a?(String)
+               raise ArgumentError, "An Enquo static root key must be passed a string"
+            end
+
+            key = if k.encoding == Encoding::BINARY
+               unless k.bytesize == 32
+                  raise ArgumentError, "An Enquo static root key must be a 32 byte binary string"
+               end
+
+               k
+            else
+               unless k =~ /\A\h{64}\z/
+                  raise ArgumentError, "An Enquo static root key must be a 64 byte hex string"
+               end
+
+               [k].pack("H*")
+            end
+
+				_new(key)
+			end
+		end
+	end
+end

data/lib/enquo/root_key.rb

@@ -0,0 +1 @@
+require_relative "./root_key/static"

data/lib/enquo.rb

@@ -0,0 +1,18 @@
+module Enquo
+	class Error < StandardError; end
+end
+
+begin
+	RUBY_VERSION =~ /(\d+\.\d+)/
+	require_relative "./#{$1}/enquo"
+rescue LoadError
+	begin
+		require_relative "./enquo.#{RbConfig::CONFIG["DLEXT"]}"
+	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

@@ -0,0 +1,198 @@
+--- !ruby/object:Gem::Specification
+name: enquo-core
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matt Palmer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: github-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler-dock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- matt@enquo.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- enquo-core.gemspec
+- ext/enquo/.gitignore
+- ext/enquo/Cargo.lock
+- ext/enquo/Cargo.toml
+- ext/enquo/extconf.rb
+- ext/enquo/src/lib.rs
+- lib/enquo.rb
+- lib/enquo/field.rb
+- lib/enquo/root.rb
+- lib/enquo/root_key.rb
+- lib/enquo/root_key/static.rb
+homepage: https://enquo.org/active_enquo
+licenses: []
+metadata:
+  homepage_uri: https://enquo.org/active_enquo
+  source_code_uri: https://github.com/enquo/enquo-core
+  changelog_uri: https://github.com/enquo/enquo-core/releases
+  bug_tracker_uri: https://github.com/enquo/enquo-core/issues
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Core library for encrypted querying operations
+test_files: []