enveloperb 0.1.2-x86_64-linux → 0.1.4-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e91c3431752cf11579e997eab0cf22f781270083365185c3650261c2692844fb
-  data.tar.gz: aa6bc449d349dd533ef4d3ae1e1f66a4ea37e7f9400cdac5405f75b80efbef91
+  metadata.gz: c783aeda24e29352ee837e44e082310ff6679e235a3f66861ff73267a29af7cb
+  data.tar.gz: b2af145d653968417b5f9ad7618ca8419473494ea69dfc78d9bf187e572eefe7
 SHA512:
-  metadata.gz: 8e49f7e046080b0c766d13ab0f5616af5305ac008a092ef6112146a925b0cd888aa0b5915dbe199d9aa0d25d6342432ac4e4a5d44cfd5396778d12218bb4c095
-  data.tar.gz: ea9826c9e2b125c4f599ce2c21b50a1ad47ca2d2506d9606a796440d9036c6dde141be9341e1772b09ac9d03ad35e3ee455bf6d79fe047e53cb3433ffd93b7b4
+  metadata.gz: 1298feeaffa939f9652519d194dca45de664f0fd270a00cad1c863605b101ec59bd6493550492411645ffdcfb7c31d53dabc17952f29691c962573ebbc5f2d20
+  data.tar.gz: a9708a5ff1bd0ffcbd63d6b3a0c74a6d5c88375c85358c66278328a70bb3abab74e6074f51f2993c8f127eba347153a2321794a22a33d81fbb383ec7d6859aa0

data/README.md

@@ -19,24 +19,22 @@ Except for testing purposes, it is not common to use envelope encryption in situ
 
 # Installation
 
-In order to build the `enveloperb` gem, you must have Rust 1.31.0 or later installed.
-On an ARM-based platform, you must use Rust nightly, for SIMD intrinsics support.
+For the most common platforms, we provide "native" gems (which have the shared object that provides the cryptographic primitives pre-compiled).
+At present, we provide native gems for:
 
-With that available, you should be able to install it like any other gem:
+* Linux `x86_64` and `aarch64`
+* macOS `x86_64` and `arm64`
 
-    gem install enveloperb
+On these platforms, you can just install the `enveloperb` gem via your preferred method, and it should "just work".
+If it doesn't, please [report that as a bug](https://github.com/cipherstash/enveloperb/issues).
 
-There's also the wonders of [the Gemfile](http://bundler.io):
+For other platforms, you will need to install the source gem, which requires that you have Rust 1.31.0 or later installed.
+On ARM-based platforms, you must use Rust nightly, for SIMD intrinsics support.
 
-    gem 'enveloperb'
+## Installing from Git
 
-If you're the sturdy type that likes to run from git:
-
-    bundle install
-    rake install
-
-Or, if you've eschewed the convenience of Rubygems entirely, then you
-presumably know what to do already.
+If you have a burning need to install directly from a checkout of the git repository, you can do so by running `bundle install && rake install`.
+As this is a source-based installation, you will need to have Rust installed, as described above.
 
 
 # Usage

data/enveloperb.gemspec

@@ -24,10 +24,9 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = ">= 2.7.0"
 
-  s.add_runtime_dependency "rutie", "~> 0.0.4"
+  s.add_runtime_dependency 'fiddle', '~> 1.1'
 
   s.add_development_dependency 'bundler'
-  s.add_development_dependency 'gem-compiler'
   s.add_development_dependency 'github-release'
   s.add_development_dependency 'guard-rspec'
   s.add_development_dependency 'rake', '~> 10.4', '>= 10.4.2'

data/lib/enveloperb.rb

@@ -1,7 +1,13 @@
-require "rutie"
+require "fiddle"
 
-module Enveloperb
-  Rutie.new(:enveloperb).init 'Init_enveloperb', __dir__
+begin
+  Fiddle::Function.new(Fiddle.dlopen("#{__dir__}/#{RbConfig::CONFIG["ruby_version"]}/libenveloperb.#{RbConfig::CONFIG["SOEXT"]}")["Init_libenveloperb"], [], Fiddle::TYPE_VOIDP).call
+rescue Fiddle::DLError
+  begin
+    Fiddle::Function.new(Fiddle.dlopen("#{__dir__}/libenveloperb.#{RbConfig::CONFIG["SOEXT"]}")["Init_libenveloperb"], [], Fiddle::TYPE_VOIDP).call
+  rescue Fiddle::DLError
+    raise LoadError, "Failed to initialize libenveloperb.#{RbConfig::CONFIG["SOEXT"]}; either it hasn't been built, or was built incorrectly for your system"
+  end
 end
 
 require_relative "./enveloperb/encrypted_record"

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: enveloperb
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: x86_64-linux
 authors:
 - Matt Palmer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-29 00:00:00.000000000 Z
+date: 2022-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rutie
+  name: fiddle
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.4
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.4
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: gem-compiler
-  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
@@ -179,24 +165,14 @@ extra_rdoc_files: []
 files:
 - CODE_OF_CONDUCT.md
 - CONTRIBUTING.md
-- Cargo.toml
 - LICENCE
 - README.md
 - enveloperb.gemspec
-- ext/Rakefile
+- lib/2.7.0/libenveloperb.so
 - lib/enveloperb.rb
 - lib/enveloperb/awskms.rb
 - lib/enveloperb/encrypted_record.rb
 - lib/enveloperb/simple.rb
-- src/lib.rs
-- target/release/deps/libasync_trait-d616c5275efb3885.so
-- target/release/deps/libenveloperb.so
-- target/release/deps/libfutures_macro-0f8ad5ae6e34b161.so
-- target/release/deps/libpin_project_internal-ef8d149cf28b24bc.so
-- target/release/deps/libserde_derive-3653e4229ae528ef.so
-- target/release/deps/libthiserror_impl-c49e7233e0f6f247.so
-- target/release/deps/libtracing_attributes-ae844bddcb3f978b.so
-- target/release/libenveloperb.so
 homepage: https://github.com/cipherstash/enveloperb
 licenses: []
 metadata: {}

data/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "enveloperb"
-version = "0.0.0"
-edition = "2021"
-
-[dependencies]
-enveloper = { git = "https://github.com/cipherstash/enveloper", branch = "main" }
-lazy_static = "^0.2.2"
-rutie = "0.8.4"
-tokio = { version = "^1.17.0", features = [ "rt-multi-thread" ] }
-aws-config = "0.10.1"
-aws-sdk-kms = "0.10.1"
-aws-types = { version = "0.10.1", features = [ "hardcoded-credentials" ] }
-
-[lib]
-name = "enveloperb"
-crate-type = ["cdylib"]

data/ext/Rakefile

@@ -1,5 +0,0 @@
-task :build do
-  sh "cargo build --release"
-end
-
-task default: :build

data/src/lib.rs

@@ -1,195 +0,0 @@
-#[macro_use]
-extern crate rutie;
-
-#[macro_use]
-extern crate lazy_static;
-
-// I have deliberately not used more-specific symbols inside the aws_* crates because the
-// names are quite generic, and in the near future when we have more providers, we'll
-// almost certainly end up with naming clashes.
-use aws_config;
-use aws_sdk_kms;
-use aws_types;
-use enveloper::{EncryptedRecord, EnvelopeCipher, KMSKeyProvider, SimpleKeyProvider};
-use std::borrow::Cow;
-use tokio::runtime::Runtime;
-use rutie::{Class, Encoding, Hash, Module, Object, RString, Symbol, VerifiedObject, VM};
-
-module!(Enveloperb);
-class!(EnveloperbSimple);
-class!(EnveloperbAWSKMS);
-class!(EnveloperbEncryptedRecord);
-
-impl VerifiedObject for EnveloperbEncryptedRecord {
-    fn is_correct_type<T: Object>(object: &T) -> bool {
-        let klass = Module::from_existing("Enveloperb").get_nested_class("EncryptedRecord");
-        klass.case_equals(object)
-    }
-
-    fn error_message() -> &'static str {
-        "Error converting to Enveloperb::EncryptedRecord"
-    }
-}
-
-pub struct SimpleCipher {
-    cipher: EnvelopeCipher<SimpleKeyProvider>,
-    runtime: Runtime,
-}
-
-pub struct AWSKMSCipher {
-    cipher: EnvelopeCipher<KMSKeyProvider>,
-    runtime: Runtime,
-}
-
-wrappable_struct!(SimpleCipher, SimpleCipherWrapper, SIMPLE_CIPHER_WRAPPER);
-wrappable_struct!(AWSKMSCipher, AWSKMSCipherWrapper, AWSKMS_CIPHER_WRAPPER);
-wrappable_struct!(EncryptedRecord, EncryptedRecordWrapper, ENCRYPTED_RECORD_WRAPPER);
-
-methods!(
-    EnveloperbSimple,
-    rbself,
-
-    fn enveloperb_simple_new(rbkey: RString) -> EnveloperbSimple {
-        let mut key: [u8; 16] = Default::default();
-
-        key.clone_from_slice(rbkey.unwrap().to_bytes_unchecked());
-
-        let provider = SimpleKeyProvider::init(key);
-        let cipher = EnvelopeCipher::init(provider);
-
-        let klass = Module::from_existing("Enveloperb").get_nested_class("Simple");
-        return klass.wrap_data(SimpleCipher{ cipher: cipher, runtime: Runtime::new().unwrap() }, &*SIMPLE_CIPHER_WRAPPER);
-    }
-
-    fn enveloperb_simple_encrypt(rbtext: RString) -> EnveloperbEncryptedRecord {
-        let cipher = rbself.get_data(&*SIMPLE_CIPHER_WRAPPER);
-        let er_r = cipher.runtime.block_on(async {
-            cipher.cipher.encrypt(rbtext.unwrap().to_bytes_unchecked()).await
-        });
-        let er = er_r.map_err(|e| VM::raise(Class::from_existing("RuntimeError"), &format!("Failed to perform encryption: {:?}", e))).unwrap();
-
-        let klass = Module::from_existing("Enveloperb").get_nested_class("EncryptedRecord");
-        return klass.wrap_data(er, &*ENCRYPTED_RECORD_WRAPPER);
-    }
-
-    fn enveloperb_simple_decrypt(rbrecord: EnveloperbEncryptedRecord) -> RString {
-        let cipher = rbself.get_data(&*SIMPLE_CIPHER_WRAPPER);
-        let e_record = rbrecord.unwrap();
-        let record = e_record.get_data(&*ENCRYPTED_RECORD_WRAPPER);
-
-        let vec_r = cipher.runtime.block_on(async {
-            cipher.cipher.decrypt(record).await
-        });
-        let vec = vec_r.map_err(|e| VM::raise(Class::from_existing("RuntimeError"), &format!("Failed to perform decryption: {:?}", e))).unwrap();
-
-        return RString::from_bytes(&vec, &Encoding::find("BINARY").unwrap());
-    }
-);
-
-methods!(
-    EnveloperbAWSKMS,
-    rbself,
-
-    fn enveloperb_awskms_new(rbkey: RString, rbcreds: Hash) -> EnveloperbAWSKMS {
-        let raw_creds = rbcreds.unwrap();
-        let rt = Runtime::new().unwrap();
-
-        let kmsclient_config = if raw_creds.at(&Symbol::new("access_key_id")).is_nil() {
-            rt.block_on(async {
-                aws_config::load_from_env().await
-            })
-        } else {
-            let rbregion = raw_creds.at(&Symbol::new("region")).try_convert_to::<RString>().unwrap();
-            let region   = Some(aws_types::region::Region::new(rbregion.to_str().to_owned()));
-
-            let rbkey_id = raw_creds.at(&Symbol::new("access_key_id")).try_convert_to::<RString>().unwrap();
-            let key_id   = rbkey_id.to_str();
-
-            let rbsecret = raw_creds.at(&Symbol::new("secret_access_key")).try_convert_to::<RString>().unwrap();
-            let secret   = rbsecret.to_str();
-
-            let token = match raw_creds.at(&Symbol::new("session_token")).try_convert_to::<RString>() {
-                Ok(str) => Some(str.to_string()),
-                Err(_)  => None
-            };
-
-            let aws_creds = aws_types::Credentials::from_keys(key_id, secret, token);
-            let creds_provider = aws_types::credentials::SharedCredentialsProvider::new(aws_creds);
-
-            aws_types::sdk_config::SdkConfig::builder().region(region).credentials_provider(creds_provider).build()
-        };
-
-        let kmsclient = aws_sdk_kms::Client::new(&kmsclient_config);
-        let provider = KMSKeyProvider::new(kmsclient, rbkey.unwrap().to_string());
-        let cipher = EnvelopeCipher::init(provider);
-
-        let klass = Module::from_existing("Enveloperb").get_nested_class("AWSKMS");
-        return klass.wrap_data(AWSKMSCipher{ cipher: cipher, runtime: rt }, &*AWSKMS_CIPHER_WRAPPER);
-    }
-
-    fn enveloperb_awskms_encrypt(rbtext: RString) -> EnveloperbEncryptedRecord {
-        let cipher = rbself.get_data(&*AWSKMS_CIPHER_WRAPPER);
-        let er_r = cipher.runtime.block_on(async {
-            cipher.cipher.encrypt(rbtext.unwrap().to_bytes_unchecked()).await
-        });
-        let er = er_r.map_err(|e| VM::raise(Class::from_existing("RuntimeError"), &format!("Failed to perform encryption: {:?}", e))).unwrap();
-
-        let klass = Module::from_existing("Enveloperb").get_nested_class("EncryptedRecord");
-        return klass.wrap_data(er, &*ENCRYPTED_RECORD_WRAPPER);
-    }
-
-    fn enveloperb_awskms_decrypt(rbrecord: EnveloperbEncryptedRecord) -> RString {
-        let cipher = rbself.get_data(&*AWSKMS_CIPHER_WRAPPER);
-        let e_record = rbrecord.unwrap();
-        let record = e_record.get_data(&*ENCRYPTED_RECORD_WRAPPER);
-
-        let vec_r = cipher.runtime.block_on(async {
-            cipher.cipher.decrypt(record).await
-        });
-        let vec = vec_r.map_err(|e| VM::raise(Class::from_existing("RuntimeError"), &format!("Failed to perform decryption: {:?}", e))).unwrap();
-
-        return RString::from_bytes(&vec, &Encoding::find("BINARY").unwrap());
-    }
-);
-
-methods!(
-    EnveloperbEncryptedRecord,
-    rbself,
-
-    fn enveloperb_encrypted_record_new(serialized_record: RString) -> EnveloperbEncryptedRecord {
-        let s = serialized_record.unwrap().to_vec_u8_unchecked();
-        let ct = EncryptedRecord::from_vec(s).map_err(|e| VM::raise(Class::from_existing("ArgumentError"), &format!("Failed to decode encrypted record: {:?}", e))).unwrap();
-
-        let klass = Module::from_existing("Enveloperb").get_nested_class("EncryptedRecord");
-        return klass.wrap_data(ct, &*ENCRYPTED_RECORD_WRAPPER);
-    }
-
-    fn enveloperb_encrypted_record_serialize() -> RString {
-        let record = rbself.get_data(&*ENCRYPTED_RECORD_WRAPPER);
-
-        return RString::from_bytes(&record.to_vec().map_err(|e| VM::raise(Class::from_existing("RuntimeError"), &format!("Failed to encode encrypted record: {:?}", e))).unwrap(), &Encoding::find("BINARY").unwrap());
-    }
-);
-
-#[allow(non_snake_case)]
-#[no_mangle]
-pub extern "C" fn Init_enveloperb() {
-    Module::from_existing("Enveloperb").define(|envmod| {
-        envmod.define_nested_class("Simple", None).define(|klass| {
-            klass.singleton_class().def_private("_new", enveloperb_simple_new);
-            klass.def_private("_encrypt", enveloperb_simple_encrypt);
-            klass.def_private("_decrypt", enveloperb_simple_decrypt);
-        });
-
-        envmod.define_nested_class("AWSKMS", None).define(|klass| {
-            klass.singleton_class().def_private("_new", enveloperb_awskms_new);
-            klass.def_private("_encrypt", enveloperb_awskms_encrypt);
-            klass.def_private("_decrypt", enveloperb_awskms_decrypt);
-        });
-
-        envmod.define_nested_class("EncryptedRecord", None).define(|klass| {
-            klass.singleton_class().def_private("_new", enveloperb_encrypted_record_new);
-            klass.def_private("_serialize", enveloperb_encrypted_record_serialize);
-        });
-    });
-}