ruby_olm 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 17da5166e2138afc190196d6edf41f5e9e7c9f3b00f7924112fa6490c87f955e
+  data.tar.gz: 0c5b08a346d82fcfa3f6388b6ba208a7a42d83fe9949b3ae4ced863aceaa28bc
+SHA512:
+  metadata.gz: 679c54ffda79d6b8639fa3e0a18e25b2c514ccc26879c0981539d794f0bcafec7e54b8477e9621452e47d16eec27ed0b151843923e60278988f6556468c34e76
+  data.tar.gz: 3866781b6aae4957b6cd5fd7d3c30c35a7af5dafb55b94fbc359d6122581adc65310c6f6f7de776edcaaf7272fba3f77b984a4e775888d32d2f962bbdaed6123

data/ext/ruby_olm/ext_lib_olm/ext_account.c

@@ -0,0 +1,274 @@
+#include "olm/olm.h"
+#include "ext_lib_olm.h"
+
+static VALUE last_error(VALUE self)
+{
+    OlmAccount *this;
+    Data_Get_Struct(self, OlmAccount, this);
+    
+    return rb_funcall(rb_eval_string("RubyOlm::OlmError"), rb_intern("from_string"), 1, rb_str_new2(olm_account_last_error(this)));
+}
+
+static VALUE initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE pickle, password, opts;
+    size_t size;
+    OlmAccount *this;
+    Data_Get_Struct(self, OlmAccount, this);
+    
+    (void)rb_scan_args(argc, argv, "0:", &opts);
+
+    opts = (opts == Qnil) ? rb_hash_new(): opts;
+        
+    pickle = rb_hash_aref(opts, ID2SYM(rb_intern("pickle")));
+    password = rb_hash_aref(opts, ID2SYM(rb_intern("password")));
+
+    if(pickle != Qnil){
+
+        if(rb_obj_is_kind_of(pickle, rb_cString) != Qtrue){
+            
+            rb_raise(rb_eTypeError, "pickle must be kind of String");
+        }
+    }
+    
+    if(password != Qnil){
+        
+        if(rb_obj_is_kind_of(password, rb_cString) != Qtrue){
+            
+            rb_raise(rb_eTypeError, "password must be kind of String");
+        }
+    }
+    else{
+        
+        password = rb_str_new2("");
+    }
+    
+    if(pickle != Qnil){    
+        
+        if(olm_unpickle_account(this, RSTRING_PTR(password), RSTRING_LEN(password), RSTRING_PTR(dup_string(pickle)), RSTRING_LEN(pickle)) == olm_error()){
+            
+            raise_olm_error(olm_account_last_error(this));
+        }
+    }
+    else{
+        
+        size = olm_create_account_random_length(this);
+        
+        if(olm_create_account(this, RSTRING_PTR(get_random(size)), size) == olm_error()){
+            
+            raise_olm_error(olm_account_last_error(this));
+        }
+    }
+    
+    return self;
+}
+
+static VALUE identity_keys(VALUE self)
+{
+    OlmAccount *this;
+    size_t size;
+    Data_Get_Struct(self, OlmAccount, this);
+    
+    size = olm_account_identity_keys_length(this);
+    uint8_t buf[size];
+    
+    if(olm_account_identity_keys(this, buf, size) != size){
+        
+        raise_olm_error(olm_account_last_error(this));
+    }
+    
+    return rb_funcall(rb_eval_string("JSON"), rb_intern("parse"), 1, rb_str_new((char *)buf, size));    
+}
+
+static VALUE generate_one_time_keys(VALUE self, VALUE number)
+{
+    size_t size;
+    OlmAccount *this;
+    Data_Get_Struct(self, OlmAccount, this);
+    
+    size = olm_account_generate_one_time_keys_random_length(this, NUM2SIZET(number));        
+    
+    if(olm_account_generate_one_time_keys(this, NUM2SIZET(number), RSTRING_PTR(get_random(size)), size) == olm_error()){
+        
+        raise_olm_error(olm_account_last_error(this));
+    }
+    
+    return self;
+}
+
+static VALUE one_time_keys(VALUE self)
+{
+    VALUE retval;
+    size_t size;
+    void *ptr;    
+    OlmAccount *this;
+    Data_Get_Struct(self, OlmAccount, this);
+    
+    size = olm_account_one_time_keys_length(this);
+    
+    if((ptr = malloc(size)) == NULL){
+        
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+    
+    if(olm_account_one_time_keys(this, ptr, size) != size){
+        
+        free(ptr);
+        raise_olm_error(olm_account_last_error(this));
+    }
+    
+    retval = rb_funcall(rb_eval_string("JSON"), rb_intern("parse"), 1, rb_str_new(ptr, size));
+    
+    free(ptr);
+    
+    return retval;
+}
+
+static VALUE sign(VALUE self, VALUE message)
+{
+    VALUE retval;
+    size_t size;
+    void *ptr;    
+    OlmAccount *this;
+    Data_Get_Struct(self, OlmAccount, this);
+    
+    size = olm_account_signature_length(this);
+    
+    if((ptr = malloc(size)) == NULL){
+        
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+    
+    if(olm_account_sign(this, RSTRING_PTR(message), RSTRING_LEN(message), ptr, size) == olm_error()){
+        
+        free(ptr);
+        raise_olm_error(olm_account_last_error(this));
+    }
+    
+    retval = rb_str_new(ptr, size);
+    
+    free(ptr);
+    
+    return retval;
+}
+
+static VALUE mark_keys_as_published(VALUE self)
+{
+    OlmAccount *this;
+    Data_Get_Struct(self, OlmAccount, this);
+    
+    (void)olm_account_mark_keys_as_published(this);
+    
+    return self; 
+}
+
+static VALUE max_number_of_one_time_keys(VALUE self)
+{
+    OlmAccount *this;
+    Data_Get_Struct(self, OlmAccount, this);
+    
+    return SIZET2NUM(olm_account_max_number_of_one_time_keys(this));
+}
+
+static VALUE remove_one_time_keys(VALUE self, VALUE session)
+{
+    OlmAccount *this;
+    Data_Get_Struct(self, OlmAccount, this);
+    
+    OlmSession *s;
+    Data_Get_Struct(session, OlmSession, s);
+    
+    if(olm_remove_one_time_keys(this, s) == olm_error()){
+        
+        raise_olm_error(olm_account_last_error(this));
+    }
+       
+    return self;
+}
+
+static VALUE outbound_session(VALUE self, VALUE identity_key, VALUE pre_key)
+{
+    return rb_funcall(rb_eval_string("RubyOlm::OutboundSession"), rb_intern("new"), 3, self, identity_key, pre_key);    
+}
+
+static VALUE inbound_session(int argc, VALUE *argv, VALUE self)
+{
+    VALUE args[] = {self, Qnil, Qnil};
+    
+    (void)rb_scan_args(argc, argv, "11", &args[1], &args[2]);
+    
+    return rb_class_new_instance(sizeof(args)/sizeof(*args), args, rb_eval_string("RubyOlm::InboundSession"));
+}
+
+static VALUE to_pickle(int argc, VALUE *argv, VALUE self)
+{
+    VALUE password, retval;
+    OlmAccount *this;
+    void *ptr;
+    size_t size;
+    Data_Get_Struct(self, OlmAccount, this);
+    
+    (void)rb_scan_args(argc, argv, "01", &password);
+    
+    password = (password == Qnil) ? rb_str_new2("") : password;
+   
+    size = olm_pickle_account_length(this);
+   
+    if((ptr = malloc(size)) == NULL){
+        
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+    
+    if(olm_pickle_account(this, RSTRING_PTR(password), RSTRING_LEN(password), ptr, size) != size){
+        
+        free(ptr);
+        raise_olm_error(olm_account_last_error(this));
+    } 
+    
+    retval = rb_str_new(ptr, size);
+    
+    free(ptr);
+    
+    return retval;
+}
+
+static void _free(void *ptr)
+{    
+    olm_clear_account(ptr);
+    free(ptr);
+}
+
+static VALUE _alloc(VALUE klass)
+{
+    OlmAccount *this;    
+    VALUE self;
+    
+    self = Data_Wrap_Struct(klass, 0, _free, calloc(1, olm_account_size())); 
+    
+    Data_Get_Struct(self, OlmAccount, this);   
+    
+    (void)olm_account((void *)this);
+    
+    return self;
+}
+
+void account_init(void)
+{
+    VALUE cRubyOLM = rb_define_module("RubyOlm");    
+    VALUE cAccount = rb_define_class_under(cRubyOLM, "Account", rb_cObject);
+    
+    rb_define_alloc_func(cAccount, _alloc);
+    
+    rb_define_method(cAccount, "initialize", initialize, -1);
+    rb_define_method(cAccount, "identity_keys", identity_keys, 0);
+    rb_define_method(cAccount, "one_time_keys", one_time_keys, 0);
+    rb_define_method(cAccount, "generate_one_time_keys", generate_one_time_keys, 1);
+    rb_define_method(cAccount, "last_error", last_error, 0);
+    rb_define_method(cAccount, "sign", sign, 1);
+    rb_define_method(cAccount, "mark_keys_as_published", mark_keys_as_published, 0);
+    rb_define_method(cAccount, "max_number_of_one_time_keys", max_number_of_one_time_keys, 0);
+    rb_define_method(cAccount, "remove_one_time_keys", remove_one_time_keys, 1);
+    rb_define_method(cAccount, "outbound_session", outbound_session, 2);
+    rb_define_method(cAccount, "inbound_session", inbound_session, -1);
+    rb_define_method(cAccount, "to_pickle", to_pickle, -1);
+}

data/ext/ruby_olm/ext_lib_olm/ext_lib_olm.c

@@ -0,0 +1,51 @@
+#include <ruby.h>
+#include <assert.h>
+#include <stdbool.h>
+
+#include "olm/olm.h"
+
+void account_init(void);
+void session_init(void);
+void utility_init(void);
+
+static VALUE get_olm_version(VALUE self)
+{
+    char buffer[20U];
+    uint8_t major = 0U;
+    uint8_t minor = 0U;
+    uint8_t patch = 0U;
+    
+    olm_get_library_version(&major, &minor, &patch);
+    
+    snprintf(buffer, sizeof(buffer), "%u.%u.%u", major, minor, patch);
+    
+    return rb_str_new2(buffer);
+}
+
+void Init_ext_lib_olm(void)
+{
+    rb_require("openssl");
+    rb_require("json");    
+    rb_require("ruby_olm/olm_error");
+
+    rb_define_singleton_method(rb_eval_string("RubyOlm"), "olm_version", get_olm_version, 0);
+
+    account_init();
+    session_init();
+    utility_init();
+}
+
+void raise_olm_error(const char *error)
+{
+    rb_funcall(rb_eval_string("RubyOlm::OlmError"), rb_intern("raise_from_string"), 1, rb_str_new2(error));
+}
+
+VALUE get_random(size_t size)
+{
+    return rb_funcall(rb_eval_string("OpenSSL::Random"), rb_intern("random_bytes"), 1, SIZET2NUM(size));
+}
+
+VALUE dup_string(VALUE str)
+{
+    return rb_str_new(RSTRING_PTR(str), RSTRING_LEN(str));
+}

data/ext/ruby_olm/ext_lib_olm/ext_lib_olm.h

@@ -0,0 +1,13 @@
+#ifndef EXT_LIB_OLM_H
+#define EXT_LIB_OLM_H
+
+#include <ruby.h>
+
+/* convert error string to exception and raise it */
+void raise_olm_error(const char *error);
+VALUE get_random(size_t size);
+
+/* necessary to avoid copy-on-write weirdness */
+VALUE dup_string(VALUE str);
+
+#endif

data/ext/ruby_olm/ext_lib_olm/ext_session.c

@@ -0,0 +1,363 @@
+#include "olm/olm.h"
+#include "ext_lib_olm.h"
+
+static VALUE last_error(VALUE self)
+{
+    OlmSession *this;
+    Data_Get_Struct(self, OlmSession, this);
+    
+    return rb_str_new2(olm_session_last_error(this));
+}
+        
+static VALUE initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE pickle, password;
+    OlmSession *this;
+    Data_Get_Struct(self, OlmSession, this);
+    
+    (void)rb_scan_args(argc, argv, "11", &pickle, &password);
+
+    if(rb_obj_is_kind_of(pickle, rb_cString) != Qtrue){
+        
+        rb_raise(rb_eTypeError, "pickle must be kind of String");
+    }
+    
+    if(password != Qnil){
+        
+        if(rb_obj_is_kind_of(password, rb_cString) != Qtrue){
+            
+            rb_raise(rb_eTypeError, "password must be kind of String");
+        }
+    }
+    else{
+        
+        password = rb_str_new2("");
+    }
+
+    if(olm_unpickle_session(this, RSTRING_PTR(password), RSTRING_LEN(password), RSTRING_PTR(dup_string(pickle)), RSTRING_LEN(pickle)) == olm_error()){
+    
+        raise_olm_error(olm_session_last_error(this));     
+    }
+
+    return self;
+}
+
+static VALUE initialize_outbound(VALUE self, VALUE account, VALUE identity, VALUE one_time_key)
+{    
+    size_t size;
+    OlmSession *this;
+    OlmAccount *a;
+    
+    Data_Get_Struct(self, OlmSession, this);
+    Data_Get_Struct(account, OlmAccount, a);
+ 
+    size = olm_create_outbound_session_random_length(this);
+    
+    if(rb_obj_is_instance_of(account, rb_eval_string("RubyOlm::Account")) != Qtrue){
+    
+        rb_raise(rb_eTypeError, "account must be an instance of RubyOlm::Account");
+    }
+    if(rb_obj_is_kind_of(identity, rb_eval_string("String")) != Qtrue){
+    
+        rb_raise(rb_eTypeError, "identity must be kind of String");
+    }
+    if(rb_obj_is_kind_of(one_time_key, rb_eval_string("String")) != Qtrue){
+    
+        rb_raise(rb_eTypeError, "one_time_key must be kind of String");
+    }
+    
+    if(olm_create_outbound_session(this, a,
+            RSTRING_PTR(identity), RSTRING_LEN(identity),
+            RSTRING_PTR(one_time_key), RSTRING_LEN(one_time_key),
+            RSTRING_PTR(get_random(size)), size
+            ) == olm_error()){
+        raise_olm_error(olm_session_last_error(this));
+    }
+    
+    return self;
+}
+
+static VALUE initialize_inbound(int argc, VALUE *argv, VALUE self)
+{    
+    VALUE account, one_time_message, identity;
+    
+    identity = Qnil;
+    
+    (void)rb_scan_args(argc, argv, "21", &account, &one_time_message, &identity);
+    
+    OlmSession *this;
+    Data_Get_Struct(self, OlmSession, this);
+    
+    OlmAccount *a;
+    Data_Get_Struct(account, OlmAccount, a);
+    
+    if(rb_obj_is_kind_of(one_time_message, rb_eval_string("RubyOlm::PreKeyMessage")) != Qtrue){
+        
+        rb_raise(rb_eTypeError, "one_time_message must be kind of PreKeyMessage");
+    }
+    
+    one_time_message = rb_funcall(one_time_message, rb_intern("to_s"), 0);
+    
+    if(identity == Qnil){
+
+        if(olm_create_inbound_session(this, a,
+                RSTRING_PTR(dup_string(one_time_message)), RSTRING_LEN(one_time_message)
+                ) == olm_error()){
+            raise_olm_error(olm_session_last_error(this));
+        }
+    }
+    else{
+        
+        if(olm_create_inbound_session_from(this, a,
+                RSTRING_PTR(identity), RSTRING_LEN(identity),
+                RSTRING_PTR(dup_string(one_time_message)), RSTRING_LEN(one_time_message)
+                ) == olm_error()){
+            raise_olm_error(olm_session_last_error(this));
+        }
+    }
+    
+    return self;
+}
+
+static VALUE has_received_message(VALUE self)
+{
+    OlmSession *this;
+    Data_Get_Struct(self, OlmSession, this);
+    
+    return (olm_session_has_received_message(this) == 0) ? Qfalse : Qtrue;
+}
+
+static VALUE get_session_id(VALUE self)
+{
+    OlmSession *this;
+    Data_Get_Struct(self, OlmSession, this);
+    
+    size_t size = olm_session_id_length(this);
+    uint8_t buf[size];
+    
+    if(olm_session_id(this, buf, size) != size){
+        
+        raise_olm_error(olm_session_last_error(this));
+    }
+    
+    return rb_str_new((char *)buf, size);    
+}
+
+static VALUE will_receive(int argc, VALUE *argv, VALUE self)
+{
+    VALUE one_time_message, identity;
+    size_t result;
+    OlmSession *this;
+    Data_Get_Struct(self, OlmSession, this);
+
+    identity = Qnil;
+
+    (void)rb_scan_args(argc, argv, "11", &one_time_message, &identity);
+
+    if(rb_obj_is_kind_of(one_time_message, rb_eval_string("RubyOlm::PreKeyMessage")) != Qtrue){
+        
+        rb_raise(rb_eTypeError, "one_time_message must be kind of PreKeyMessage");
+    }
+
+    one_time_message = rb_funcall(one_time_message, rb_intern("to_s"), 0);
+
+    if(identity == Qnil){
+    
+        result = olm_matches_inbound_session(this, 
+                RSTRING_PTR(dup_string(one_time_message)), RSTRING_LEN(one_time_message)
+        );
+    }
+    else{
+        
+        result = olm_matches_inbound_session_from(this, 
+                RSTRING_PTR(identity), RSTRING_LEN(identity),
+                RSTRING_PTR(dup_string(one_time_message)), RSTRING_LEN(one_time_message)
+        );
+    }
+    
+    if(result == olm_error()){
+        
+        raise_olm_error(olm_session_last_error(this));
+    }
+    
+    return (result == 1) ? Qtrue : Qfalse;
+}
+
+static VALUE message_type(VALUE self)
+{
+    OlmSession *this;
+    VALUE retval;
+    Data_Get_Struct(self, OlmSession, this);
+    
+    if(olm_encrypt_message_type(this) == OLM_MESSAGE_TYPE_PRE_KEY){
+        
+        retval = rb_eval_string("RubyOlm::PreKeyMessage");
+    }
+    else if(olm_encrypt_message_type(this) == OLM_MESSAGE_TYPE_MESSAGE){
+        
+        retval = rb_eval_string("RubyOlm::Message");
+    }
+    else{
+        
+        rb_bug("olm_encrypt_message_type()");
+    }
+    
+    return retval;
+}
+
+static VALUE encrypt(VALUE self, VALUE plain)
+{
+    size_t cipher_size, random_size;
+    void *ptr;
+    OlmSession *this;
+    VALUE retval, type;
+    Data_Get_Struct(self, OlmSession, this);
+    
+    cipher_size = olm_encrypt_message_length(this, RSTRING_LEN(plain));
+    random_size = olm_encrypt_random_length(this);
+    
+    if((ptr = malloc(cipher_size)) == NULL){
+        
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+    
+    type = message_type(self);
+    
+    if(olm_encrypt(this, RSTRING_PTR(plain), RSTRING_LEN(plain),
+            RSTRING_PTR(get_random(random_size)), random_size,
+            ptr, cipher_size
+            ) == olm_error()){
+        free(ptr);
+        raise_olm_error(olm_session_last_error(this));
+    }
+    
+    retval = rb_funcall(type, rb_intern("new"), 1, rb_str_new(ptr, cipher_size));
+    
+    free(ptr);
+    
+    return retval;
+}
+
+static VALUE decrypt(VALUE self, VALUE cipher)
+{
+    size_t plain_size, plain_max, type;
+    void *ptr;
+    OlmSession *this;
+    VALUE retval, data;
+    Data_Get_Struct(self, OlmSession, this);
+    
+    if(rb_obj_is_kind_of(cipher, rb_eval_string("RubyOlm::Message")) == Qtrue){
+        
+        type = OLM_MESSAGE_TYPE_MESSAGE;
+    }
+    else if(rb_obj_is_kind_of(cipher, rb_eval_string("RubyOlm::PreKeyMessage")) == Qtrue){
+        
+        type = OLM_MESSAGE_TYPE_PRE_KEY;
+    }
+    else{
+        
+        rb_raise(rb_eTypeError, "cipher must be kind of Message or PreKeyMessage");
+    }
+    
+    data = rb_funcall(cipher, rb_intern("to_s"), 0);
+    
+    if((plain_max = olm_decrypt_max_plaintext_length(this, type, RSTRING_PTR(dup_string(data)), RSTRING_LEN(data))) == olm_error()){
+        
+        raise_olm_error(olm_session_last_error(this));
+    } 
+    
+    /* size of output will be less than size of input */
+    if((ptr = malloc(plain_max)) == NULL){
+        
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+    
+    if((plain_size = olm_decrypt(this, 
+            type,
+            RSTRING_PTR(dup_string(data)), RSTRING_LEN(data),  
+            ptr, plain_max)) == olm_error())
+    {
+        free(ptr);
+        raise_olm_error(olm_session_last_error(this));
+    }
+    
+    retval = rb_str_new(ptr, plain_size);
+    
+    free(ptr);
+    
+    return retval;
+}
+
+static VALUE to_pickle(int argc, VALUE *argv, VALUE self)
+{
+    VALUE password, retval;
+    OlmSession *this;
+    void *ptr;
+    size_t size;
+    Data_Get_Struct(self, OlmSession, this);
+    
+    (void)rb_scan_args(argc, argv, "01", &password);
+    
+    password = (password == Qnil) ? rb_str_new2("") : password;
+   
+    size = olm_pickle_session_length(this);
+   
+    if((ptr = malloc(size)) == NULL){
+        
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+    
+    if(olm_pickle_session(this, RSTRING_PTR(password), RSTRING_LEN(password), ptr, size) != size){
+        
+        free(ptr);
+        raise_olm_error(olm_session_last_error(this));
+    } 
+    
+    retval = rb_str_new(ptr, size);
+    
+    free(ptr);
+    
+    return retval;
+}
+
+static void _free(void *ptr)
+{    
+    olm_clear_session(ptr);
+    free(ptr);
+}
+
+static VALUE _alloc(VALUE klass)
+{
+    OlmSession *this;    
+    VALUE self;
+    
+    self = Data_Wrap_Struct(klass, 0, _free, calloc(1, olm_session_size())); 
+    
+    Data_Get_Struct(self, OlmSession, this);   
+    
+    (void)olm_session((void *)this);
+    
+    return self;
+}
+
+void session_init(void)
+{
+    VALUE cRubyOLM = rb_define_module("RubyOlm");    
+    VALUE cSession = rb_define_class_under(cRubyOLM, "Session", rb_cObject);
+    VALUE cSessionOut = rb_define_class_under(cRubyOLM, "OutboundSession", cSession);
+    VALUE cSessionIn = rb_define_class_under(cRubyOLM, "InboundSession", cSession);
+    
+    rb_define_alloc_func(cSession, _alloc);
+    
+    rb_define_method(cSessionOut, "initialize", initialize_outbound, 3);    
+    rb_define_method(cSessionIn, "initialize", initialize_inbound, -1);    
+    
+    rb_define_method(cSession, "initialize", initialize, -1);    
+    rb_define_method(cSession, "id", get_session_id, 0);    
+    rb_define_method(cSession, "last_error", last_error, 0);    
+    rb_define_method(cSession, "has_received_message", has_received_message, 0);    
+    rb_define_method(cSession, "encrypt", encrypt, 1);    
+    rb_define_method(cSession, "decrypt", decrypt, 1);
+    rb_define_method(cSession, "to_pickle", to_pickle, -1);
+    rb_define_method(cSession, "will_receive?", will_receive, -1);
+}