self_crypto 0.0.1

data/ext/self_crypto/self_crypto.c

@@ -0,0 +1,68 @@
+#include <ruby.h>
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "sodium.h"
+#include "self_olm/olm.h"
+#include "self_omemo.h"
+
+void account_init(void);
+void session_init(void);
+void utility_init(void);
+void group_session_init(void);
+void pk_init(void);
+void sas_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_self_crypto(void)
+{
+    rb_require("openssl");
+    rb_require("json");
+    rb_require("self_crypto/olm_error");
+
+    rb_define_singleton_method(rb_eval_string("SelfCrypto"), "olm_version", get_olm_version, 0);
+
+    account_init();
+    session_init();
+    group_session_init();
+    utility_init();
+    pk_init();
+    sas_init();
+}
+
+void raise_olm_error(const char *error)
+{
+    rb_funcall(rb_eval_string("SelfCrypto::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));
+}
+
+void* malloc_or_raise(size_t len) {
+    void * ptr = malloc(len);
+    if (ptr == NULL) {
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+    return ptr;
+}

data/ext/self_crypto/self_crypto.h

@@ -0,0 +1,15 @@
+#ifndef SELF_CRYPTO_H
+#define SELF_CRYPTO_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);
+
+void* malloc_or_raise(size_t len) __attribute__((malloc));
+
+#endif

data/ext/self_crypto/session.c

@@ -0,0 +1,363 @@
+#include "self_olm/olm.h"
+#include "self_crypto.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("SelfCrypto::Account")) != Qtrue){
+
+        rb_raise(rb_eTypeError, "account must be an instance of SelfCrypto::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("SelfCrypto::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("SelfCrypto::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("SelfCrypto::PreKeyMessage");
+    }
+    else if(olm_encrypt_message_type(this) == OLM_MESSAGE_TYPE_MESSAGE){
+
+        retval = rb_eval_string("SelfCrypto::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("SelfCrypto::Message")) == Qtrue){
+
+        type = OLM_MESSAGE_TYPE_MESSAGE;
+    }
+    else if(rb_obj_is_kind_of(cipher, rb_eval_string("SelfCrypto::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("SelfCrypto");
+    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);
+}

data/ext/self_crypto/utility.c

@@ -0,0 +1,143 @@
+#include "self_olm/olm.h"
+#include "self_crypto.h"
+#include "sodium.h"
+
+static VALUE last_error(VALUE self)
+{
+    OlmUtility *this;
+    Data_Get_Struct(self, OlmUtility, this);
+
+    return rb_str_new2(olm_utility_last_error(this));
+}
+
+static VALUE ed25519_verify(VALUE self, VALUE data, VALUE key, VALUE signature)
+{
+    VALUE retval = Qtrue;
+    OlmUtility *this;
+    Data_Get_Struct(self, OlmUtility, this);
+
+    if(olm_ed25519_verify(this, RSTRING_PTR(key), RSTRING_LEN(key), RSTRING_PTR(data), RSTRING_LEN(data), RSTRING_PTR(dup_string(signature)), RSTRING_LEN(signature)) == olm_error()){
+
+        retval = Qfalse;
+    }
+
+    return retval;
+}
+
+static VALUE ed25519_pk_to_curve25519(VALUE self, VALUE ed25519_pk)
+{
+    VALUE curve25519_sk;
+    void  *pk_ptr, *dec_ptr, *enc_ptr;
+    size_t pk_sz, dec_sz, enc_sz, success;
+
+    if(rb_obj_is_kind_of(ed25519_pk, rb_eval_string("String")) != Qtrue){
+        rb_raise(rb_eTypeError, "ed25519_pk must be kind of String");
+    }
+
+    pk_sz = crypto_sign_publickeybytes();
+
+    if((dec_ptr = malloc(pk_sz)) == NULL){
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+
+    success = sodium_base642bin(
+        dec_ptr,
+        pk_sz,
+        RSTRING_PTR(ed25519_pk),
+        RSTRING_LEN(ed25519_pk),
+        NULL,
+        &dec_sz,
+        NULL,
+        sodium_base64_VARIANT_ORIGINAL_NO_PADDING
+    );
+
+    if(success != 0) {
+        free(dec_ptr);
+        rb_raise(rb_eTypeError, "could not convert ed25519 public key");
+    }
+
+    if((pk_ptr = malloc(pk_sz)) == NULL){
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+
+    success = crypto_sign_ed25519_pk_to_curve25519(
+        pk_ptr,
+        dec_ptr
+    );
+
+    free(dec_ptr);
+
+    if(success != 0) {
+        free(pk_ptr);
+        rb_raise(rb_eTypeError, "could not convert ed25519 public key");
+    }
+
+    enc_sz = sodium_base64_ENCODED_LEN(pk_sz, sodium_base64_VARIANT_ORIGINAL_NO_PADDING);
+
+    if((enc_ptr = malloc(enc_sz)) == NULL){
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+
+    sodium_bin2base64(
+        enc_ptr,
+        enc_sz,
+        pk_ptr,
+        pk_sz,
+        sodium_base64_VARIANT_ORIGINAL_NO_PADDING
+    );
+
+    free(pk_ptr);
+
+    curve25519_sk = rb_str_new(enc_ptr, enc_sz);
+
+    free(enc_ptr);
+
+    return curve25519_sk;
+}
+
+static VALUE sha256(VALUE self, VALUE data)
+{
+    size_t size;
+    OlmUtility *this;
+    Data_Get_Struct(self, OlmUtility, this);
+
+    size = olm_sha256_length(this);
+    uint8_t buf[size];
+
+    (void)olm_sha256(this, RSTRING_PTR(data), RSTRING_LEN(data), buf, size);
+
+    return rb_str_new(buf, size);
+}
+
+static void _free(void *ptr)
+{
+    olm_clear_utility(ptr);
+    free(ptr);
+}
+
+static VALUE _alloc(VALUE klass)
+{
+    OlmUtility *this;
+    VALUE self;
+
+    self = Data_Wrap_Struct(klass, 0, _free, calloc(1, olm_utility_size()));
+
+    Data_Get_Struct(self, OlmUtility, this);
+
+    (void)olm_utility((void *)this);
+
+    return self;
+}
+
+void utility_init(void)
+{
+    VALUE cRubyOLM = rb_define_module("SelfCrypto");
+    VALUE cUtil = rb_define_module_under(cRubyOLM, "Util");
+    VALUE cUtility = rb_define_class_under(cRubyOLM, "Utility", rb_cObject);
+
+    rb_define_alloc_func(cUtility, _alloc);
+
+    rb_define_method(cUtility, "sha256", sha256, 1);
+    rb_define_method(cUtility, "ed25519_verify", ed25519_verify, 3);
+    rb_define_module_function(cUtil, "ed25519_pk_to_curve25519", ed25519_pk_to_curve25519, 1);
+}