self_crypto 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 34537603a575a2b32c468b332dd83e91ba2516c8c09984fb99d8f55910cdb680
+  data.tar.gz: 5e3a683e167fcdb4126bed5de9282d4d4e5c694ef54158d4dacd146b8d180d8e
+SHA512:
+  metadata.gz: d0133166300cd4f784af606550459c670bdc0dde4a6db1a74e70fd0dcba36baae7a1e50604d923d0f0da25b3b59378d4418f0c671dadd1eb931faff780958be4
+  data.tar.gz: 498ad6f393d8683d9250ce56957d09d026283449a3964e3f5193a0ad1512bfce887eb67c75a99a8ded80768de075289b728328b18e494de4e15ac0d0ee248385

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rake/testtask'
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new  do |ext|
+  ext.name = "self_crypto"
+  ext.ext_dir = "ext/self_crypto"
+  ext.lib_dir = "lib/self_crypto"
+end
+
+task :test => :compile
+
+Rake::TestTask.new do |t|
+  t.name = :test
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+  t.verbose = true
+end
+
+task :default => :test

data/ext/self_crypto/account.c

@@ -0,0 +1,292 @@
+#include "sodium.h"
+#include "self_olm/olm.h"
+#include "self_crypto.h"
+
+static VALUE last_error(VALUE self)
+{
+    OlmAccount *this;
+    Data_Get_Struct(self, OlmAccount, this);
+
+    return rb_funcall(rb_eval_string("SelfCrypto::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, seed, 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")));
+    seed = rb_hash_aref(opts, ID2SYM(rb_intern("seed")));
+
+    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));
+        }
+    }
+    if(seed != Qnil){
+        if(olm_create_account_derrived_keys(this, RSTRING_PTR(seed), RSTRING_LEN(seed)) == 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_size(VALUE self)
+{
+    OlmAccount *this;
+    Data_Get_Struct(self, OlmAccount, this);
+
+    return SIZET2NUM(olm_account_one_time_keys_length(this));
+}
+
+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);
+
+    // add an additional byte to stop this from overflowing
+    if((ptr = malloc(size+1)) == 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("SelfCrypto::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("SelfCrypto::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("SelfCrypto");
+    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, "one_time_keys_size", one_time_keys_size, 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/self_crypto/extconf.rb

@@ -0,0 +1,15 @@
+require 'mkmf'
+
+$CFLAGS = " -std=c99"
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+pkg_config('self_olm')
+pkg_config('self_omemo')
+pkg_config("sodium")
+
+abort "Missing sodium" unless have_library("sodium")
+abort "Missing omemo" unless have_library("self_omemo")
+abort "Missing olm" unless have_library("self_olm")
+
+create_makefile('self_crypto/self_crypto')

data/ext/self_crypto/omemo.c

@@ -0,0 +1,170 @@
+#include "sodium.h"
+#include "self_olm/olm.h"
+#include "self_omemo.h"
+#include "self_crypto.h"
+
+static VALUE initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE identity;
+    GroupSession *this;
+
+    Data_Get_Struct(self, GroupSession, this);
+
+    (void)rb_scan_args(argc, argv, "1", &identity);
+
+    if(identity != Qnil){
+        if(rb_obj_is_kind_of(identity, rb_cString) != Qtrue){
+            rb_raise(rb_eTypeError, "identity must be kind of String");
+        }
+    }
+
+    omemo_set_identity(this, RSTRING_PTR(identity));
+
+    return self;
+}
+
+static VALUE add_participant(VALUE self, VALUE identity, VALUE session)
+{
+    GroupSession *this;
+    OlmSession *s;
+
+    Data_Get_Struct(self, GroupSession, this);
+    Data_Get_Struct(session, OlmSession, s);
+
+    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_instance_of(session, rb_eval_string("SelfCrypto::Session")) != Qtrue &&
+       rb_obj_is_instance_of(session, rb_eval_string("SelfCrypto::InboundSession")) != Qtrue &&
+       rb_obj_is_instance_of(session, rb_eval_string("SelfCrypto::OutboundSession")) != Qtrue
+     ){
+        rb_raise(rb_eTypeError, "session must be an instance of SelfCrypto::Session, SelfCrypto::InboundSession or SelfCrypto::OutboundSession");
+    }
+
+    omemo_add_group_participant(this, RSTRING_PTR(identity), s);
+
+    return identity;
+}
+
+static VALUE encrypt(VALUE self, VALUE plaintext)
+{
+    GroupSession *this;
+    VALUE ciphertext;
+    void *ptr;
+    size_t ciphertext_sz;
+
+    Data_Get_Struct(self, GroupSession, this);
+
+    if(rb_obj_is_kind_of(plaintext, rb_eval_string("String")) != Qtrue){
+        rb_raise(rb_eTypeError, "plaintext must be kind of String");
+    }
+
+    ciphertext_sz = omemo_encrypted_size(this, RSTRING_LEN(plaintext));
+
+    if (ciphertext_sz == 0) {
+        rb_raise(rb_eTypeError, "could not get size of encrypted message");
+    }
+
+    if((ptr = malloc(ciphertext_sz)) == NULL){
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+
+    ciphertext_sz = omemo_encrypt(
+        this,
+        RSTRING_PTR(plaintext),
+        RSTRING_LEN(plaintext),
+        ptr,
+        ciphertext_sz
+    );
+
+    if(ciphertext_sz == 0) {
+        free(ptr);
+        rb_raise(rb_eTypeError, "failed to encrypt");
+    }
+
+    ciphertext = rb_funcall(rb_eval_string("SelfCrypto::GroupMessage"), rb_intern("new"), 1, rb_str_new(ptr, ciphertext_sz));
+
+    free(ptr);
+
+    return ciphertext;
+}
+
+static VALUE decrypt(VALUE self, VALUE sender, VALUE ciphertext)
+{
+    GroupSession *this;
+    VALUE plaintext;
+    void *ptr;
+    size_t plaintext_sz;
+
+    Data_Get_Struct(self, GroupSession, this);
+
+    if(rb_obj_is_kind_of(sender, rb_eval_string("String")) != Qtrue){
+        rb_raise(rb_eTypeError, "sender must be kind of String");
+    }
+
+    if(rb_obj_is_kind_of(ciphertext, rb_eval_string("String")) != Qtrue){
+        rb_raise(rb_eTypeError, "ciphertext must be kind of String");
+    }
+
+    plaintext_sz = omemo_decrypted_size(this, RSTRING_PTR(ciphertext), RSTRING_LEN(ciphertext));
+
+    if (plaintext_sz == 0) {
+        rb_raise(rb_eTypeError, "could not get size of decrypted message");
+    }
+
+    if((ptr = malloc(plaintext_sz)) == NULL){
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+
+    plaintext_sz = omemo_decrypt(
+        this,
+        RSTRING_PTR(sender),
+        ptr,
+        plaintext_sz,
+        RSTRING_PTR(ciphertext),
+        RSTRING_LEN(ciphertext)
+    );
+
+    if(plaintext_sz == 0) {
+        free(ptr);
+        rb_raise(rb_eTypeError, "failed to decrypt");
+    }
+
+    plaintext = rb_str_new(ptr, plaintext_sz);
+
+    free(ptr);
+
+    return plaintext;
+}
+
+static void _free(void *ptr)
+{
+    omemo_destroy_group_session(ptr);
+}
+
+static VALUE _alloc(VALUE klass)
+{
+    GroupSession *this;
+    VALUE self;
+
+    self = Data_Wrap_Struct(klass, 0, _free, omemo_create_group_session());
+
+    Data_Get_Struct(self, GroupSession, this);
+
+    return self;
+}
+
+void group_session_init()
+{
+    VALUE cRubyOLM = rb_define_module("SelfCrypto");
+    VALUE cGroupSession = rb_define_class_under(cRubyOLM, "GroupSession", rb_cObject);
+
+    rb_define_alloc_func(cGroupSession, _alloc);
+
+    rb_define_method(cGroupSession, "initialize", initialize, -1);
+    rb_define_method(cGroupSession, "add_participant", add_participant, 2);
+    rb_define_method(cGroupSession, "encrypt", encrypt, 1);
+    rb_define_method(cGroupSession, "decrypt", decrypt, 2);
+}