capbac 0.3.0 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9aea3202cf722c59f88ff0cc3ac473c5d70d05727bf2887a9665ff554552fa02
-  data.tar.gz: e0a1ea74ed0b853ccb8e3619015bd599f4f20ea30f8c9eb4caadf331dbfc979f
+  metadata.gz: 81c1db17c50ca3dce7a76f825fb981bcd347b3c0b0d194718e3d74ada60a8cd9
+  data.tar.gz: c193c44fb1693f57fa4b4e6e00bb7935b28c86ba53578b5e8d55b62b2d625388
 SHA512:
-  metadata.gz: 1ea6fb01de7bd48e299b32602b2ee276bbed2581c2e75fb724deba69f776386edb05b61e6492867152d97bb02989b894145dee0a8bf6d94bdd301d60ee181f55
-  data.tar.gz: f1a7f43fbfb3df31dc1272edd15f74b27c3b29fcf83c4b765290f976a5eec5e07f3c1cdfb63772f1e6fe4813f1df3eea0fb224b6bda2ae80697f60e22732b4c2
+  metadata.gz: e4f381fc3571fe2ae1a3f8f7fc1a710a0425909cb5c5fb292392a7380361b8c23e95f0145a80291717175cc55548669a345b394c1866b0079669c4870105a274
+  data.tar.gz: dfab7513a193b11f048843bd43edc19f12f497073a39841995f5adca6abb83fafe2ecd9766a5e25c4f7d887388fd791f42c5504e6f78517b861a69dbea389d1c

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "capbac-ruby"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Kirill Chernyshov <delaguardo@gmail.com>"]
 edition = "2018"
 
@@ -8,10 +8,10 @@ edition = "2018"
 crate-type = ["cdylib"]
 
 [dependencies]
-rutie = "0.6.1"
+rutie = "0.8.0"
 url = "2.1"
 openssl = "0.10"
 ring = "0.16.15"
 lazy_static = "1"
 protobuf = "2.16.2"
-capbac = "0.2.1"
+capbac = "0.3.0"

data/lib/capbac/version.rb

@@ -1,3 +1,3 @@
 module CapBAC
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.4.4'.freeze
 end

data/src/lib.rs

@@ -1,25 +1,68 @@
-#[macro_use] extern crate rutie;
-#[macro_use] extern crate lazy_static;
+#[macro_use]
+extern crate rutie;
+#[macro_use]
+extern crate lazy_static;
 
-use rutie::{Module, Class, RString, Object, AnyObject, Array,
-            Fixnum, Hash, Symbol, VM, Boolean, GC, VerifiedObject};
 use capbac::{CertificateBlueprint, InvokeBlueprint};
-use url::Url;
-use openssl::pkey::{PKey, Public};
-use openssl::ec::EcKey;
-use protobuf::{Message};
-use std::fmt;
-
-use ring::{
-    rand,
-    signature::{self, KeyPair, EcdsaKeyPair},
+use openssl::{
+    ec::{EcKey},
+    pkey::{PKey, Public},
+};
+use protobuf::Message;
+use rutie::{
+    AnyObject, Boolean, Class, Encoding, Fixnum, Hash, Module, Object, RString, Symbol,
+    VerifiedObject, GC, VM, Array,
 };
+use std::{fmt, str};
+use url::Url;
+
+class!(ASCIIRString);
+
+impl VerifiedObject for ASCIIRString {
+    fn is_correct_type<T: Object>(object: &T) -> bool {
+        object
+            .class()
+            .ancestors()
+            .iter()
+            .any(|class| *class == Class::from_existing("String"))
+    }
+
+    fn error_message() -> &'static str {
+        "Error converting to ASCII String"
+    }
+}
+
+impl From<ASCIIRString> for Vec<u8> {
+    fn from(rstring: ASCIIRString) -> Self {
+        let bytes = rstring
+            .protect_send("bytes", &[])
+            .map_err(VM::raise_ex)
+            .unwrap()
+            .try_convert_to::<Array>()
+            .map_err(VM::raise_ex)
+            .unwrap();
+
+        let mut res = Vec::new();
+
+        for n in bytes.into_iter() {
+            let n = n.try_convert_to::<Fixnum>()
+                .map_err(|e| VM::raise_ex(e))
+                .unwrap();
+
+            res.push(n.to_i64() as u8);
+        }
+        res
+    }
+}
 
 class!(URI);
 
 impl VerifiedObject for URI {
     fn is_correct_type<T: Object>(object: &T) -> bool {
-        object.class().ancestors().iter()
+        object
+            .class()
+            .ancestors()
+            .iter()
             .any(|class| *class == Class::from_existing("URI"))
     }
 
@@ -30,108 +73,98 @@ impl VerifiedObject for URI {
 
 impl fmt::Display for URI {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let s = self.send("to_s", &vec![]).try_convert_to::<RString>().unwrap().to_string();
+        let s = self
+            .protect_send("to_s", &[])
+            .map_err(VM::raise_ex)
+            .unwrap()
+            .try_convert_to::<RString>()
+            .map_err(VM::raise_ex)
+            .unwrap()
+            .to_string();
         write!(f, "{}", s)
     }
 }
 
 impl From<&Url> for URI {
     fn from(url: &Url) -> Self {
-        Class::from_existing("URI").send("parse", &vec![RString::new_utf8(&url.clone().to_string()).to_any_object()]).try_convert_to::<URI>().unwrap()
+        let args = [RString::new_utf8(&url.clone().to_string()).to_any_object()];
+        Class::from_existing("URI")
+            .protect_send("parse", &args)
+            .map_err(VM::raise_ex)
+            .unwrap()
+            .try_convert_to::<URI>()
+            .map_err(VM::raise_ex)
+            .unwrap()
     }
 }
 
 impl From<URI> for Url {
     fn from(uri: URI) -> Self {
-        Url::parse(&uri.to_string()).unwrap()
+        Url::parse(&uri.to_string())
+            .map_err(|_e| {
+                VM::raise(
+                    Class::from_existing("URI").get_nested_class("InvalidURIError"),
+                    &format!("bad URI(is not URI?): {}", uri.to_string()),
+                )
+            })
+            .unwrap()
     }
 }
 
+// TODO CertificateBlueprint -> Result<CertificateBlueprint, Error>
 fn options_to_cert_blueprint(options: Hash) -> CertificateBlueprint {
     let subject = options
         .at(&Symbol::new("subject"))
-        .try_convert_to::<URI>();
+        .try_convert_to::<URI>()
+        .map_err(VM::raise_ex)
+        .unwrap();
 
-    if let Err(ref _error) = subject {
-        VM::raise(Class::from_existing("ArgumentError"), "Subject must be an instance of URI");
-    }
-
-    let subject = Url::from(subject.unwrap());
+    let subject = Url::from(subject);
 
     let capability = options
         .at(&Symbol::new("capability"))
-        .try_convert_to::<RString>();
-
-    if let Err(ref _error) = capability {
-        VM::raise(Class::from_existing("ArgumentError"), "Capability must be a string");
-    }
-
-    let capability = capability
-        .unwrap().to_string()
+        .try_convert_to::<RString>()
+        .map_err(VM::raise_ex)
+        .unwrap()
+        .to_string()
         .into_bytes();
 
     let exp = match options.at(&Symbol::new("exp")).try_convert_to::<Fixnum>() {
         Ok(x) => Some(x.to_i64() as u64),
-        _ => None
+        _ => None,
     };
 
     CertificateBlueprint {
         subject,
         capability,
-        exp
-    }
-}
-
-fn array_to_cert(array: Array) -> capbac::proto::Certificate {
-    let mut cert_content: Vec<u8> = Vec::new();
-    for n in array.into_iter() {
-        let n = n.try_convert_to::<Fixnum>();
-
-        if let Err(ref error) = n {
-            VM::raise(error.class(), &error.to_string());
-        }
-
-        cert_content.push(n.unwrap().to_i64() as u8);
+        exp,
     }
-    let mut cert = capbac::proto::Certificate::new();
-    cert.merge_from_bytes(&cert_content).unwrap();
-    cert
 }
 
 fn options_to_invoke_blueprint(options: Hash) -> InvokeBlueprint {
-
     let cert_content = options
         .at(&Symbol::new("cert"))
-        .try_convert_to::<Array>();
+        .try_convert_to::<ASCIIRString>()
+        .map_err(VM::raise_ex)
+        .unwrap();
 
-    if let Err(ref _error) = cert_content {
-        VM::raise(Class::from_existing("ArgumentError"), "Certificate must be an array");
-    }
-
-    let cert = array_to_cert(cert_content.unwrap());
+    let mut cert = capbac::proto::Certificate::new();
+    cert.merge_from_bytes(&Vec::from(cert_content)).unwrap();
 
     let action = options
         .at(&Symbol::new("action"))
-        .try_convert_to::<RString>();
-
-    if let Err(ref _error) = action {
-        VM::raise(Class::from_existing("ArgumentError"), "Action must be a string");
-    }
-
-    let action = action
-        .unwrap().to_string()
+        .try_convert_to::<RString>()
+        .map_err(VM::raise_ex)
+        .unwrap()
+        .to_string()
         .into_bytes();
 
     let exp = match options.at(&Symbol::new("exp")).try_convert_to::<Fixnum>() {
         Ok(x) => Some(x.to_i64() as u64),
-        _ => None
+        _ => None,
     };
 
-    InvokeBlueprint {
-        cert,
-        action,
-        exp
-    }
+    InvokeBlueprint { cert, action, exp }
 }
 
 wrappable_struct!(capbac::Holder, HolderWrapper, HOLDER_WRAPPER);
@@ -142,87 +175,74 @@ methods!(
     Holder,
     itself,
 
-    fn ruby_holder_new(me: URI, sk: Array) -> AnyObject {
-        if let Err(ref error) = me {
-            VM::raise(error.class(), &error.to_string());
-        }
-
-        if let Err(ref error) = sk {
-            VM::raise(error.class(), &error.to_string());
-        }
-
-        let me = Url::parse(&me.unwrap().to_string());
-
-        if let Err(ref error) = me {
-            VM::raise(Class::from_existing("ArgumentError"), &error.to_string())
-        }
-
-        let mut sk_content: Vec<u8> = Vec::new();
-        for n in sk.unwrap().into_iter() {
-            let n = n.try_convert_to::<Fixnum>();
-
-            if let Err(ref error) = n {
-                VM::raise(error.class(), &error.to_string());
-            }
-
-            sk_content.push(n.unwrap().to_i64() as u8);
-        }
-
-        let holder = capbac::Holder::new(me.unwrap(), PKey::private_key_from_pkcs8(&sk_content).unwrap().ec_key().unwrap());
+    fn ruby_holder_new(me: URI, sk: RString) -> AnyObject {
+        let ruby_me = me.map_err(VM::raise_ex).unwrap().to_string();
+
+        let ruby_sk = sk
+            .map_err(VM::raise_ex)
+            .unwrap()
+            .to_string_unchecked();
+
+        let me = Url::parse(&ruby_me)
+            .map_err(|e| VM::raise(Class::from_existing("ArgumentError"), &e.to_string()))
+            .unwrap();
+        let sk = PKey::private_key_from_pem(&ruby_sk.as_bytes())
+            .map_err(|e| {
+                VM::raise(
+                    Class::from_existing("ArgumentError"),
+                    &format!("Wrong secret key formar (not pkcs8?) ({})", e.to_string()),
+                )
+            })
+            .unwrap()
+            .ec_key()
+            .map_err(|e| {
+                VM::raise(
+                    Class::from_existing("ArgumentError"),
+                    &format!("Can't extract EC key ({})", e.to_string()),
+                )
+            })
+            .unwrap();
+
+        let holder = capbac::Holder::new(me, sk);
 
         Class::from_existing("CapBAC")
             .get_nested_class("Holder")
             .wrap_data(holder, &*HOLDER_WRAPPER)
     }
 
-    fn ruby_holder_forge(options: Hash) -> Array {
-        if let Err(ref _error) = options {
-            VM::raise(Class::from_existing("ArgumentError"), "Options must be a hash");
-        }
-
-        let options = options_to_cert_blueprint(options.unwrap());
-
+    fn ruby_holder_forge(options: Hash) -> RString {
+        let ruby_options = options.map_err(VM::raise_ex).unwrap();
+        let options = options_to_cert_blueprint(ruby_options);
         let holder = itself.get_data(&*HOLDER_WRAPPER);
+
         let cert = holder.forge(options).unwrap();
 
-        let mut res = Array::new();
-        for item in cert.write_to_bytes().unwrap().iter() {
-            res.push(Fixnum::new(i64::from(*item)));
-        };
-        res
+        RString::from_bytes(&cert.write_to_bytes().unwrap(), &Encoding::us_ascii())
     }
 
-    fn ruby_holder_delegate(cert: Array, options: Hash) -> Array {
-        if let Err(ref _error) = options {
-            VM::raise(Class::from_existing("ArgumentError"), "Options must be a hash");
-        }
-
-        let options = options_to_cert_blueprint(options.unwrap());
+    fn ruby_holder_delegate(cert: ASCIIRString, options: Hash) -> RString {
+        let ruby_options = options.map_err(VM::raise_ex).unwrap();
+        let options = options_to_cert_blueprint(ruby_options);
         let holder = itself.get_data(&*HOLDER_WRAPPER);
-        let cert = array_to_cert(cert.unwrap());
+
+        let cert_content = Vec::from(cert.map_err(VM::raise_ex).unwrap());
+
+        let mut cert = capbac::proto::Certificate::new();
+        cert.merge_from_bytes(&cert_content).unwrap();
 
         let cert = holder.delegate(cert, options).unwrap();
-        let mut res = Array::new();
-        for item in cert.write_to_bytes().unwrap().iter() {
-            res.push(Fixnum::new(i64::from(*item)));
-        };
-        res
-    }
 
-    fn ruby_holder_invoke(options: Hash) -> Array {
-        if let Err(ref _error) = options {
-            VM::raise(Class::from_existing("ArgumentError"), "Options must be a hash");
-        }
+        RString::from_bytes(&cert.write_to_bytes().unwrap(), &Encoding::us_ascii())
+    }
 
-        let options = options_to_invoke_blueprint(options.unwrap());
+    fn ruby_holder_invoke(options: Hash) -> RString {
+        let ruby_options = options.map_err(VM::raise_ex).unwrap();
+        let options = options_to_invoke_blueprint(ruby_options);
         let holder = itself.get_data(&*HOLDER_WRAPPER);
 
         let invocation = holder.invoke(options).unwrap();
-        let mut res = Array::new();
-        for item in invocation.write_to_bytes().unwrap().iter() {
-            res.push(Fixnum::new(i64::from(*item)));
-        };
-        res
+
+        RString::from_bytes(&invocation.write_to_bytes().unwrap(), &Encoding::us_ascii())
     }
 );
 
@@ -235,7 +255,7 @@ impl IntValidator {
     fn new(trust_checker: AnyObject, pubs: AnyObject) -> Self {
         IntValidator {
             trust_checker,
-            pubs
+            pubs,
         }
     }
 }
@@ -244,30 +264,36 @@ impl capbac::TrustChecker for IntValidator {
     fn is_trusted(&self, id: &Url) -> bool {
         let args = vec![URI::from(id).to_any_object()];
         self.trust_checker
-            .send("trusted?", &args)
+            .protect_send("trusted?", &args)
+            .map_err(VM::raise_ex)
+            .unwrap()
             .try_convert_to::<Boolean>()
-            .unwrap_or(Boolean::new(false))
+            .unwrap_or_else(|_| Boolean::new(false))
             .to_bool()
     }
 }
 
 impl capbac::Pubs for IntValidator {
     fn get(&self, id: &Url) -> Option<EcKey<Public>> {
-        let res = self.pubs.send("get", &vec![URI::from(id).to_any_object()]).try_convert_to::<Array>();
-        if let Err(ref _error) = res {
-            return None
-        }
-        let mut pk_content: Vec<u8> = Vec::new();
-        for n in res.unwrap().into_iter() {
-            let n = n.try_convert_to::<Fixnum>();
-
-            if let Err(ref error) = n {
-                VM::raise(error.class(), &error.to_string());
+        let args = [URI::from(id).to_any_object()];
+        let res = self
+            .pubs
+            .protect_send("get", &args)
+            .map_err(VM::raise_ex)
+            .unwrap()
+            .try_convert_to::<RString>();
+
+        match res {
+            Ok(pk) => {
+                Some(
+                    PKey::public_key_from_pem(&pk.to_string_unchecked().as_bytes())
+                        .unwrap()
+                        .ec_key()
+                        .unwrap(),
+                )
             }
-
-            pk_content.push(n.unwrap().to_i64() as u8);
+            Err(_) => None
         }
-        Some(PKey::public_key_from_der(&pk_content).unwrap().ec_key().unwrap())
     }
 }
 
@@ -290,56 +316,48 @@ methods!(
             .wrap_data(validator, &*INT_VALIDATOR_WRAPPER)
     }
 
-    fn ruby_validator_validate_cert(cert: Array, now: Fixnum) -> Boolean {
-        if let Err(ref error) = cert {
-            VM::raise(error.class(), &error.to_string());
-        }
-
-        if let Err(ref error) = now {
-            VM::raise(error.class(), &error.to_string());
-        }
-
-        let mut cert_content: Vec<u8> = Vec::new();
-        for n in cert.unwrap().into_iter() {
-            let n = n.try_convert_to::<Fixnum>();
+    fn ruby_validator_validate_cert(cert: RString, now: Fixnum) -> Boolean {
+        let ruby_cert = cert
+            .map_err(VM::raise_ex)
+            .unwrap()
+            .to_string_unchecked();
 
-            if let Err(ref error) = n {
-                VM::raise(error.class(), &error.to_string());
-            }
-
-            cert_content.push(n.unwrap().to_i64() as u8);
-        }
         let mut cert = capbac::proto::Certificate::new();
-        cert.merge_from_bytes(&cert_content).unwrap();
+        cert.merge_from_bytes(&ruby_cert.as_bytes()).unwrap();
 
-        let now = now.unwrap().to_i64() as u64;
+        let now = now.map_err(VM::raise_ex).unwrap().to_i64() as u64;
 
         let x = itself.get_data(&*INT_VALIDATOR_WRAPPER);
         let validator = capbac::Validator::new(x, x);
 
         match validator.validate_cert(&cert, now) {
             Result::Ok(_) => Boolean::new(true),
-            Err(x) =>  {
+            Err(x) => {
                 let capbac_class = Class::from_existing("CapBAC");
                 match x {
-                    capbac::ValidateError::Malformed { .. } => {
-                        VM::raise(capbac_class.get_nested_class("Malformed"), &format!("{}", x))
-                    },
+                    capbac::ValidateError::Malformed { .. } => VM::raise(
+                        capbac_class.get_nested_class("Malformed"),
+                        &format!("{}", x),
+                    ),
                     capbac::ValidateError::BadURL { .. } => {
                         VM::raise(capbac_class.get_nested_class("BadURL"), &format!("{}", x))
-                    },
-                    capbac::ValidateError::UnknownPub { .. } => {
-                        VM::raise(capbac_class.get_nested_class("UnknownPub"), &format!("{}", x))
-                    },
-                    capbac::ValidateError::BadIssuer { .. } => {
-                        VM::raise(capbac_class.get_nested_class("BadIssuer"), &format!("{}", x))
-                    },
-                    capbac::ValidateError::BadInvoker { .. } => {
-                        VM::raise(capbac_class.get_nested_class("BadInvoker"), &format!("{}", x))
-                    },
-                    capbac::ValidateError::Untrusted { .. } => {
-                        VM::raise(capbac_class.get_nested_class("Untrusted"), &format!("{}", x))
-                    },
+                    }
+                    capbac::ValidateError::UnknownPub { .. } => VM::raise(
+                        capbac_class.get_nested_class("UnknownPub"),
+                        &format!("{}", x),
+                    ),
+                    capbac::ValidateError::BadIssuer { .. } => VM::raise(
+                        capbac_class.get_nested_class("BadIssuer"),
+                        &format!("{}", x),
+                    ),
+                    capbac::ValidateError::BadInvoker { .. } => VM::raise(
+                        capbac_class.get_nested_class("BadInvoker"),
+                        &format!("{}", x),
+                    ),
+                    capbac::ValidateError::Untrusted { .. } => VM::raise(
+                        capbac_class.get_nested_class("Untrusted"),
+                        &format!("{}", x),
+                    ),
                     capbac::ValidateError::Expired => {
                         VM::raise(capbac_class.get_nested_class("Expired"), &format!("{}", x))
                     }
@@ -352,56 +370,50 @@ methods!(
         }
     }
 
-    fn ruby_validator_validate_invocation(invocation: Array, now: Fixnum) -> Boolean {
-        if let Err(ref error) = invocation {
-            VM::raise(error.class(), &error.to_string());
-        }
+    fn ruby_validator_validate_invocation(invocation: RString, now: Fixnum) -> Boolean {
+        let ruby_invocation = invocation
+            .map_err(VM::raise_ex)
+            .unwrap()
+            .to_string_unchecked();
 
-        if let Err(ref error) = now {
-            VM::raise(error.class(), &error.to_string());
-        }
-
-        let mut invocation_content: Vec<u8> = Vec::new();
-        for n in invocation.unwrap().into_iter() {
-            let n = n.try_convert_to::<Fixnum>();
-
-            if let Err(ref error) = n {
-                VM::raise(error.class(), &error.to_string());
-            }
-
-            invocation_content.push(n.unwrap().to_i64() as u8);
-        }
         let mut invocation = capbac::proto::Invocation::new();
-        invocation.merge_from_bytes(&invocation_content).unwrap();
+        invocation
+            .merge_from_bytes(&ruby_invocation.as_bytes())
+            .unwrap();
 
-        let now = now.unwrap().to_i64() as u64;
+        let now = now.map_err(VM::raise_ex).unwrap().to_i64() as u64;
 
         let x = itself.get_data(&*INT_VALIDATOR_WRAPPER);
         let validator = capbac::Validator::new(x, x);
 
         match validator.validate_invocation(&invocation, now) {
             Result::Ok(_) => Boolean::new(true),
-            Err(x) =>  {
+            Err(x) => {
                 let capbac_class = Class::from_existing("CapBAC");
                 match x {
-                    capbac::ValidateError::Malformed { .. } => {
-                        VM::raise(capbac_class.get_nested_class("Malformed"), &format!("{}", x))
-                    },
+                    capbac::ValidateError::Malformed { .. } => VM::raise(
+                        capbac_class.get_nested_class("Malformed"),
+                        &format!("{}", x),
+                    ),
                     capbac::ValidateError::BadURL { .. } => {
                         VM::raise(capbac_class.get_nested_class("BadURL"), &format!("{}", x))
-                    },
-                    capbac::ValidateError::UnknownPub { .. } => {
-                        VM::raise(capbac_class.get_nested_class("UnknownPub"), &format!("{}", x))
-                    },
-                    capbac::ValidateError::BadIssuer { .. } => {
-                        VM::raise(capbac_class.get_nested_class("BadIssuer"), &format!("{}", x))
-                    },
-                    capbac::ValidateError::BadInvoker { .. } => {
-                        VM::raise(capbac_class.get_nested_class("BadInvoker"), &format!("{}", x))
-                    },
-                    capbac::ValidateError::Untrusted { .. } => {
-                        VM::raise(capbac_class.get_nested_class("Untrusted"), &format!("{}", x))
-                    },
+                    }
+                    capbac::ValidateError::UnknownPub { .. } => VM::raise(
+                        capbac_class.get_nested_class("UnknownPub"),
+                        &format!("{}", x),
+                    ),
+                    capbac::ValidateError::BadIssuer { .. } => VM::raise(
+                        capbac_class.get_nested_class("BadIssuer"),
+                        &format!("{}", x),
+                    ),
+                    capbac::ValidateError::BadInvoker { .. } => VM::raise(
+                        capbac_class.get_nested_class("BadInvoker"),
+                        &format!("{}", x),
+                    ),
+                    capbac::ValidateError::Untrusted { .. } => VM::raise(
+                        capbac_class.get_nested_class("Untrusted"),
+                        &format!("{}", x),
+                    ),
                     capbac::ValidateError::Expired => {
                         VM::raise(capbac_class.get_nested_class("Expired"), &format!("{}", x))
                     }
@@ -412,34 +424,6 @@ methods!(
                 Boolean::new(false)
             }
         }
-
-    }
-);
-
-class!(KeyGen);
-
-methods!(
-    KeyGen,
-    itself,
-
-    fn ruby_generate_keypair() -> Hash {
-        let rng = rand::SystemRandom::new();
-        let key_pair = EcdsaKeyPair::generate_pkcs8(&signature::ECDSA_P256_SHA256_FIXED_SIGNING, &rng).unwrap();
-        let mut sk = Array::new();
-        for item in key_pair.as_ref().iter() {
-            sk.push(Fixnum::new(i64::from(*item)));
-        };
-
-        let key_pair = EcdsaKeyPair::from_pkcs8(&signature::ECDSA_P256_SHA256_FIXED_SIGNING, &key_pair.as_ref()).unwrap();
-        let mut pk = Array::new();
-        for item in key_pair.public_key().as_ref().iter() {
-            pk.push(Fixnum::new(i64::from(*item)));
-        };
-
-        let mut res = Hash::new();
-        res.store(Symbol::new("sk"), sk);
-        res.store(Symbol::new("pk"), pk);
-        res
     }
 );
 
@@ -454,14 +438,12 @@ pub extern "C" fn Init_capbac() {
             itself.def("invoke", ruby_holder_invoke);
         });
 
-        itself.define_nested_class("Validator", None).define(|itself| {
-            itself.def_self("new", ruby_validator_new);
-            itself.def("validate_cert", ruby_validator_validate_cert);
-            itself.def("validate_invocation", ruby_validator_validate_invocation);
-        });
-
-        itself.define_nested_class("KeyPair", None).define(|itself| {
-            itself.def("generate!", ruby_generate_keypair);
-        });
+        itself
+            .define_nested_class("Validator", None)
+            .define(|itself| {
+                itself.def_self("new", ruby_validator_new);
+                itself.def("validate_cert", ruby_validator_validate_cert);
+                itself.def("validate_invocation", ruby_validator_validate_invocation);
+            });
     });
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capbac
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.4
 platform: ruby
 authors:
 - Kirill Chernyshov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-22 00:00:00.000000000 Z
+date: 2020-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thermite