capbac 0.2.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88589fad2be4f62d09eea046bd902057b259be959578d08c67e35a5d1b9877a0
-  data.tar.gz: e7e7be8ba72bb20186cbfe2babfa742451aa514100e04e3097acb7b2dac3b2f6
+  metadata.gz: 6b7076bd32f529211ece0a6a16efe8c1fc37ad412241f1c10392cd1bdd722f4c
+  data.tar.gz: 9d1d9bde2412d98785d964e774a91378d00fa70a662d6e66775c2813f34f0170
 SHA512:
-  metadata.gz: e05d719e53998961edb131743604d86a1dc2b8e9e7671258cc54ee8e6ddaf0bf958215ab51d8370198abc6ae7e00ac57fd7df387269db844b328bab90bb121e0
-  data.tar.gz: 3a6356425474be7a70af3be13e65dcdc05a644f3cf2e0734ae4f2758208f484424b2976271de58ff7facb010c0eb6143a1288eb9717812aded00b3eefb763560
+  metadata.gz: 227eb36d3513826e5dd9f5771958dd9b833903cb8181cb7e6d15889e0932ad21f8ea5303fc49e33b2bf5aa255237c1ae99214de09ed37a2dab947268021ddd20
+  data.tar.gz: 7c6de742856e11d91071e602538a28cd217490bcfa469ad5f09c677f9d5e9abb4964cc7243fe3b863f2988e9fab74248928612a5dbfc40a3ee77305cc8e184ac

data/Cargo.toml

@@ -8,9 +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"
-capbac = "0.2.0"
+protobuf = "2.16.2"
+capbac = "0.2.1"

data/lib/capbac/version.rb

@@ -1,3 +1,3 @@
 module CapBAC
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.4.2'.freeze
 end

data/src/lib.rs

@@ -1,20 +1,72 @@
-#[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 openssl::{
+    ec::EcKey,
+    pkey::{PKey, Public},
+};
+use protobuf::Message;
+use ring::{
+    rand,
+    signature::{self, EcdsaKeyPair, KeyPair},
+};
+use rutie::{
+    AnyObject, Boolean, Class, Encoding, Fixnum, Hash, Module, Object, RString, Symbol,
+    VerifiedObject, GC, VM, Array,
+};
+use std::{fmt, str};
 use url::Url;
-use openssl::pkey::{PKey, Public};
-use openssl::ec::EcKey;
-use protobuf::{Message};
-use std::fmt;
+
+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"))
     }
 
@@ -25,108 +77,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>();
-
-    if let Err(ref _error) = subject {
-        VM::raise(Class::from_existing("ArgumentError"), "Subject must be an instance of URI");
-    }
+        .try_convert_to::<URI>()
+        .map_err(VM::raise_ex)
+        .unwrap();
 
-    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
+        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);
-    }
-    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>();
-
-    if let Err(ref _error) = cert_content {
-        VM::raise(Class::from_existing("ArgumentError"), "Certificate must be an array");
-    }
+        .try_convert_to::<ASCIIRString>()
+        .map_err(VM::raise_ex)
+        .unwrap();
 
-    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);
@@ -137,87 +179,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_pkcs8(&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())
     }
 );
 
@@ -230,7 +259,7 @@ impl IntValidator {
     fn new(trust_checker: AnyObject, pubs: AnyObject) -> Self {
         IntValidator {
             trust_checker,
-            pubs
+            pubs,
         }
     }
 }
@@ -239,30 +268,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_der(&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())
     }
 }
 
@@ -285,56 +320,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>();
-
-            if let Err(ref error) = n {
-                VM::raise(error.class(), &error.to_string());
-            }
+    fn ruby_validator_validate_cert(cert: RString, now: Fixnum) -> Boolean {
+        let ruby_cert = cert
+            .map_err(VM::raise_ex)
+            .unwrap()
+            .to_string_unchecked();
 
-            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))
                     }
@@ -347,56 +374,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());
-        }
-
-        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>();
+    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) = 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))
                     }
@@ -407,7 +428,40 @@ 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 sk = key_pair.as_ref();
+
+        let key_pair = EcdsaKeyPair::from_pkcs8(
+            &signature::ECDSA_P256_SHA256_FIXED_SIGNING,
+            &key_pair.as_ref(),
+        )
+        .unwrap();
+        let pk = key_pair.public_key().as_ref();
+
+        let mut res = Hash::new();
+        res.store(
+            Symbol::new("sk"),
+            RString::from_bytes(&sk, &Encoding::us_ascii()),
+        );
+        res.store(
+            Symbol::new("pk"),
+            RString::from_bytes(&pk, &Encoding::us_ascii()),
+        );
+        res
     }
 );
 
@@ -422,10 +476,18 @@ 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("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);
+            });
     });
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capbac
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Kirill Chernyshov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-15 00:00:00.000000000 Z
+date: 2020-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thermite
@@ -110,6 +110,7 @@ files:
 - lib/capbac/pubs.rb
 - lib/capbac/trust_checker.rb
 - lib/capbac/version.rb
+- lib/capbac_ruby.so
 - src/lib.rs
 homepage: http://capbac.org
 licenses: