self_crypto 0.0.1

data/ext/self_crypto/pk.c

@@ -0,0 +1,15 @@
+#include "self_olm/pk.h"
+#include "self_crypto.h"
+
+void pk_encryption_init(VALUE cSelfCryptoPK);
+void pk_decryption_init(VALUE cSelfCryptoPK);
+void pk_signing_init(VALUE cSelfCryptoPK);
+
+void pk_init(void) {
+    VALUE cSelfCrypto = rb_define_module("SelfCrypto");
+    VALUE cSelfCryptoPK = rb_define_module_under(cSelfCrypto, "PK");
+
+    pk_encryption_init(cSelfCryptoPK);
+    pk_decryption_init(cSelfCryptoPK);
+    pk_signing_init(cSelfCryptoPK);
+}

data/ext/self_crypto/pk_decryption.c

@@ -0,0 +1,129 @@
+#include <ruby.h>
+#include <stdlib.h>
+#include <self_olm/pk.h>
+#include <self_olm/olm.h>
+#include "self_crypto.h"
+
+static void _free(void *ptr) {
+    olm_clear_pk_decryption(ptr);
+    free(ptr);
+}
+
+static size_t _size(const void *ptr __attribute__((unused))) {
+    return olm_pk_decryption_size();
+}
+
+static const rb_data_type_t olm_pk_decryption_type = {
+        .wrap_struct_name = "olm_pk_decryption",
+        .function = {
+                .dmark = NULL,
+                .dfree = _free,
+                .dsize = _size,
+                .reserved = {NULL}
+        },
+        .data = NULL,
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE _alloc(VALUE klass) {
+    void *memory = malloc_or_raise(olm_pk_decryption_size());
+    return TypedData_Wrap_Struct(klass, &olm_pk_decryption_type, olm_pk_decryption(memory));
+}
+
+static VALUE initialize(int argc, VALUE *argv, VALUE self) {
+    OlmPkDecryption *this;
+    size_t publicKeyLen;
+    char *publicKeyPtr;
+    VALUE privateKey;
+    TypedData_Get_Struct(self, OlmPkDecryption, &olm_pk_decryption_type, this);
+
+    rb_scan_args(argc, argv, "01", &privateKey);
+
+    if (NIL_P(privateKey)) {
+        privateKey = get_random(olm_pk_private_key_length());
+    } else {
+        Check_Type(privateKey, T_STRING);
+        if (RSTRING_LEN(privateKey) != olm_pk_private_key_length()) {
+            rb_raise(rb_eval_string("ArgumentError"), "private_key has wrong size (must be %lu)", olm_pk_private_key_length());
+        }
+    }
+
+    publicKeyLen = olm_pk_key_length();
+    publicKeyPtr = malloc_or_raise(publicKeyLen);
+
+    if (olm_pk_key_from_private(this,
+            publicKeyPtr, publicKeyLen,
+            RSTRING_PTR(privateKey), RSTRING_LEN(privateKey)) == olm_error()) {
+        free(publicKeyPtr);
+        raise_olm_error(olm_pk_decryption_last_error(this));
+    }
+
+    rb_iv_set(self, "@public_key", rb_str_new(publicKeyPtr, publicKeyLen));
+    free(publicKeyPtr);
+
+    return self;
+}
+
+static VALUE pk_decrypt(VALUE self, VALUE pkMessage) {
+    OlmPkDecryption *this;
+    size_t plaintextLen;
+    char *plaintextPtr;
+    VALUE ephemeral, mac, ciphertext, retval;
+    TypedData_Get_Struct(self, OlmPkDecryption, &olm_pk_decryption_type, this);
+
+    ephemeral = rb_funcall(pkMessage, rb_intern("ephemeral_key"), 0);
+    Check_Type(ephemeral, T_STRING);
+    mac = rb_funcall(pkMessage, rb_intern("mac"), 0);
+    Check_Type(mac, T_STRING);
+    ciphertext = rb_funcall(pkMessage, rb_intern("cipher_text"), 0);
+    Check_Type(ciphertext, T_STRING);
+
+    plaintextLen = olm_pk_max_plaintext_length(this, RSTRING_LEN(ciphertext));
+    plaintextPtr = malloc_or_raise(plaintextLen);
+
+    plaintextLen = olm_pk_decrypt(this,
+                       RSTRING_PTR(ephemeral), RSTRING_LEN(ephemeral),
+                       RSTRING_PTR(mac), RSTRING_LEN(mac),
+                       RSTRING_PTR(ciphertext), RSTRING_LEN(ciphertext),
+                       plaintextPtr, plaintextLen);
+    if (plaintextLen == olm_error()) {
+        free(plaintextPtr);
+        raise_olm_error(olm_pk_decryption_last_error(this));
+    }
+
+    retval = rb_str_new(plaintextPtr, plaintextLen);
+    free(plaintextPtr);
+
+    return retval;
+}
+
+static VALUE private_key(VALUE self) {
+    OlmPkDecryption *this;
+    size_t privkeyLen;
+    char *privkeyPtr;
+    VALUE retval;
+    TypedData_Get_Struct(self, OlmPkDecryption, &olm_pk_decryption_type, this);
+
+    privkeyLen = olm_pk_private_key_length();
+    privkeyPtr = malloc_or_raise(privkeyLen);
+
+    if (olm_pk_get_private_key(this, privkeyPtr, privkeyLen) == olm_error()) {
+        free(privkeyPtr);
+        raise_olm_error(olm_pk_decryption_last_error(this));
+    }
+
+    retval = rb_str_new(privkeyPtr, privkeyLen);
+    free(privkeyPtr);
+    return retval;
+}
+
+void pk_decryption_init(VALUE cSelfCryptoPK) {
+    VALUE cDecryption = rb_define_class_under(cSelfCryptoPK, "Decryption", rb_cData);
+
+    rb_define_alloc_func(cDecryption, _alloc);
+
+    rb_define_attr(cDecryption, "public_key", 1, 0);
+    rb_define_method(cDecryption, "initialize", initialize, -1);
+    rb_define_method(cDecryption, "decrypt", pk_decrypt, 1);
+    rb_define_method(cDecryption, "private_key", private_key, 0);
+}

data/ext/self_crypto/pk_encryption.c

@@ -0,0 +1,93 @@
+#include <ruby.h>
+#include <stdlib.h>
+#include <self_olm/pk.h>
+#include <self_olm/olm.h>
+#include "self_crypto.h"
+
+static void _free(void *ptr) {
+    olm_clear_pk_encryption(ptr);
+    free(ptr);
+}
+
+static size_t _size(const void *ptr __attribute__((unused))) {
+    return olm_pk_encryption_size();
+}
+
+static const rb_data_type_t olm_pk_encryption_type = {
+        .wrap_struct_name = "olm_pk_encryption",
+        .function = {
+                .dmark = NULL,
+                .dfree = _free,
+                .dsize = _size,
+                .reserved = {NULL}
+        },
+        .data = NULL,
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE _alloc(VALUE klass) {
+    void *memory = malloc_or_raise(olm_pk_encryption_size());
+    return TypedData_Wrap_Struct(klass, &olm_pk_encryption_type, olm_pk_encryption(memory));
+}
+
+static VALUE initialize(VALUE self, VALUE recipientKey) {
+    OlmPkEncryption *this;
+    TypedData_Get_Struct(self, OlmPkEncryption, &olm_pk_encryption_type, this);
+    Check_Type(recipientKey, T_STRING);
+
+    if (olm_pk_encryption_set_recipient_key(this,
+            RSTRING_PTR(recipientKey), RSTRING_LEN(recipientKey)) == olm_error()) {
+        raise_olm_error(olm_pk_encryption_last_error(this));
+    }
+
+    return self;
+}
+
+static VALUE pk_encrypt(VALUE self, VALUE plaintext) {
+    OlmPkEncryption *this;
+    size_t ciphertextLen, macLen, ephemeralLen, randomLen;
+    char *ciphertextPtr, *macPtr, *ephemeralPtr;
+    VALUE retval;
+    TypedData_Get_Struct(self, OlmPkEncryption, &olm_pk_encryption_type, this);
+    Check_Type(plaintext, T_STRING);
+
+    ciphertextLen = olm_pk_ciphertext_length(this, RSTRING_LEN(plaintext));
+    ciphertextPtr = malloc_or_raise(ciphertextLen);
+    macLen = olm_pk_mac_length(this);
+    macPtr = malloc_or_raise(macLen);
+    ephemeralLen = olm_pk_key_length();
+    ephemeralPtr = malloc_or_raise(ephemeralLen);
+    randomLen = olm_pk_encrypt_random_length(this);
+
+    if (olm_pk_encrypt(this,
+            RSTRING_PTR(plaintext), RSTRING_LEN(plaintext),
+            ciphertextPtr, ciphertextLen,
+            macPtr, macLen,
+            ephemeralPtr, ephemeralLen,
+            RSTRING_PTR(get_random(randomLen)), randomLen) == olm_error()) {
+        free(ephemeralPtr);
+        free(macPtr);
+        free(ciphertextPtr);
+        raise_olm_error(olm_pk_encryption_last_error(this));
+    }
+
+    retval = rb_funcall(rb_eval_string("SelfCrypto::PK::Message"), rb_intern("new"), 3,
+            rb_str_new(ciphertextPtr, ciphertextLen),
+            rb_str_new(macPtr, macLen),
+            rb_str_new(ephemeralPtr, ephemeralLen));
+
+    free(ephemeralPtr);
+    free(macPtr);
+    free(ciphertextPtr);
+
+    return retval;
+}
+
+void pk_encryption_init(VALUE cSelfCryptoPK) {
+    VALUE cEncryption = rb_define_class_under(cSelfCryptoPK, "Encryption", rb_cData);
+
+    rb_define_alloc_func(cEncryption, _alloc);
+
+    rb_define_method(cEncryption, "initialize", initialize, 1);
+    rb_define_method(cEncryption, "encrypt", pk_encrypt, 1);
+}

data/ext/self_crypto/pk_signing.c

@@ -0,0 +1,102 @@
+#include <ruby.h>
+#include <stdlib.h>
+#include <self_olm/pk.h>
+#include <self_olm/olm.h>
+#include "self_crypto.h"
+
+static void _free(void *ptr) {
+    olm_clear_pk_signing(ptr);
+    free(ptr);
+}
+
+static size_t _size(const void *ptr __attribute__((unused))) {
+    return olm_pk_signing_size();
+}
+
+static const rb_data_type_t olm_pk_signing_type = {
+        .wrap_struct_name = "olm_pk_signing",
+        .function = {
+                .dmark = NULL,
+                .dfree = _free,
+                .dsize = _size,
+                .reserved = {NULL}
+        },
+        .data = NULL,
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE _alloc(VALUE klass) {
+    void *memory = malloc_or_raise(olm_pk_signing_size());
+    return TypedData_Wrap_Struct(klass, &olm_pk_signing_type, olm_pk_signing(memory));
+}
+
+static VALUE initialize(int argc, VALUE *argv, VALUE self) {
+    OlmPkSigning *this;
+    size_t publicKeyLen;
+    char *publicKeyPtr;
+    VALUE privateKey;
+    TypedData_Get_Struct(self, OlmPkSigning, &olm_pk_signing_type, this);
+
+    rb_scan_args(argc, argv, "01", &privateKey);
+
+    if (NIL_P(privateKey)) {
+        privateKey = get_random(olm_pk_signing_seed_length());
+    } else {
+        Check_Type(privateKey, T_STRING);
+        if (RSTRING_LEN(privateKey) != olm_pk_signing_seed_length()) {
+            rb_raise(rb_eval_string("ArgumentError"), "private_key has wrong size (must be %lu)", olm_pk_signing_seed_length());
+        }
+    }
+
+    publicKeyLen = olm_pk_signing_public_key_length();
+    publicKeyPtr = malloc_or_raise(publicKeyLen);
+
+    if (olm_pk_signing_key_from_seed(this,
+                                publicKeyPtr, publicKeyLen,
+                                RSTRING_PTR(privateKey), RSTRING_LEN(privateKey)) == olm_error()) {
+        free(publicKeyPtr);
+        raise_olm_error(olm_pk_signing_last_error(this));
+    }
+
+    rb_iv_set(self, "@public_key", rb_str_new(publicKeyPtr, publicKeyLen));
+    rb_iv_set(self, "@private_key", privateKey);
+    free(publicKeyPtr);
+
+    return self;
+}
+
+static VALUE sign(VALUE self, VALUE message) {
+    OlmPkSigning *this;
+    size_t signatureLen;
+    char *signaturePtr;
+    VALUE retval;
+    TypedData_Get_Struct(self, OlmPkSigning, &olm_pk_signing_type, this);
+
+    Check_Type(message, T_STRING);
+
+    signatureLen = olm_pk_signature_length();
+    signaturePtr = malloc_or_raise(signatureLen);
+
+    if (olm_pk_sign(this,
+            RSTRING_PTR(message), RSTRING_LEN(message),
+            signaturePtr, signatureLen) == olm_error()) {
+        free(signaturePtr);
+        raise_olm_error(olm_pk_signing_last_error(this));
+    }
+
+    retval = rb_str_new(signaturePtr, signatureLen);
+    free(signaturePtr);
+    return retval;
+}
+
+void pk_signing_init(VALUE cSelfCryptoPK) {
+    VALUE cSigning = rb_define_class_under(cSelfCryptoPK, "Signing", rb_cData);
+
+    rb_define_alloc_func(cSigning, _alloc);
+
+    rb_define_attr(cSigning, "public_key", 1, 0);
+    rb_define_attr(cSigning, "private_key", 1, 0);
+
+    rb_define_method(cSigning, "initialize", initialize, -1);
+    rb_define_method(cSigning, "sign", sign, 1);
+}

data/ext/self_crypto/sas.c

@@ -0,0 +1,190 @@
+#include <ruby.h>
+#include <stdlib.h>
+#include <self_olm/olm.h>
+#include <self_olm/sas.h>
+#include "self_crypto.h"
+
+static VALUE set_other_pubkey(VALUE self, VALUE other_public_key);
+
+static void _free(void *ptr) {
+    olm_clear_sas(ptr);
+    free(ptr);
+}
+
+static size_t _size(const void *ptr __attribute__((unused))) {
+    return olm_sas_size();
+}
+
+static const rb_data_type_t olm_sas_type = {
+        .wrap_struct_name = "olm_sas",
+        .function = {
+                .dmark = NULL,
+                .dfree = _free,
+                .dsize = _size,
+                .reserved = {NULL}
+        },
+        .data = NULL,
+        .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE _alloc(VALUE klass) {
+    void *memory = malloc_or_raise(olm_sas_size());
+    return TypedData_Wrap_Struct(klass, &olm_sas_type, olm_sas(memory));
+}
+
+static void _ensure_other_pubkey(VALUE self) {
+    if (NIL_P(rb_iv_get(self, "@other_public_key"))) {
+        rb_raise(rb_eRuntimeError, "other_public_key must be set");
+    }
+}
+
+static VALUE initialize(int argc, VALUE *argv, VALUE self) {
+    OlmSAS *this;
+    VALUE random;
+    VALUE other_pubkey;
+    TypedData_Get_Struct(self, OlmSAS, &olm_sas_type, this);
+
+    rb_scan_args(argc, argv, "01", &other_pubkey);
+
+    random = get_random(olm_create_sas_random_length(this));
+    if (olm_create_sas(this, RSTRING_PTR(random), RSTRING_LEN(random)) == olm_error()) {
+        raise_olm_error(olm_sas_last_error(this));
+    }
+
+    // Make sure @other_public_key is set
+    rb_iv_set(self, "@other_public_key", Qnil);
+
+    if (!NIL_P(other_pubkey)) {
+        set_other_pubkey(self, other_pubkey);
+    }
+
+    return self;
+}
+
+static VALUE set_other_pubkey(VALUE self, VALUE other_public_key) {
+    OlmSAS *this;
+    TypedData_Get_Struct(self, OlmSAS, &olm_sas_type, this);
+    Check_Type(other_public_key, T_STRING);
+
+    if (RSTRING_LEN(other_public_key) != olm_sas_pubkey_length(this)) {
+        rb_raise(rb_eval_string("ArgumentError"), "other_public_key has wrong size (must be %lu)", olm_sas_pubkey_length(this));
+    }
+
+    // olm_sas_set_their_key trashes other_public_key, and rb_str_dup only creates a shallow copy.
+    VALUE other_public_key_dup = rb_str_new(RSTRING_PTR(other_public_key), RSTRING_LEN(other_public_key));
+    if (olm_sas_set_their_key(this, RSTRING_PTR(other_public_key_dup), RSTRING_LEN(other_public_key_dup)) == olm_error()) {
+        raise_olm_error(olm_sas_last_error(this));
+    }
+
+    rb_iv_set(self, "@other_public_key", other_public_key);
+    return other_public_key;
+}
+
+static VALUE get_public_key(VALUE self) {
+    OlmSAS *this;
+    size_t public_key_len;
+    char *public_key;
+    VALUE retval;
+    TypedData_Get_Struct(self, OlmSAS, &olm_sas_type, this);
+
+    public_key_len = olm_sas_pubkey_length(this);
+    public_key = malloc_or_raise(public_key_len);
+
+    if (olm_sas_get_pubkey(this, public_key, public_key_len) == olm_error()) {
+        free(public_key);
+        raise_olm_error(olm_sas_last_error(this));
+    }
+
+    retval = rb_str_new(public_key, public_key_len);
+    free(public_key);
+    return retval;
+}
+
+static VALUE generate_bytes(VALUE self, VALUE count, VALUE info) {
+    OlmSAS *this;
+    size_t output_len;
+    char *output;
+    VALUE retval;
+    TypedData_Get_Struct(self, OlmSAS, &olm_sas_type, this);
+    Check_Type(count, T_FIXNUM);
+    Check_Type(info, T_STRING);
+
+    output_len = NUM2ULONG(count);
+    output = malloc_or_raise(output_len);
+
+    if (olm_sas_generate_bytes(this, RSTRING_PTR(info), RSTRING_LEN(info), output, output_len) == olm_error()) {
+        free(output);
+        raise_olm_error(olm_sas_last_error(this));
+    }
+
+    retval = rb_str_new(output, output_len);
+    free(output);
+    // Return raw byte string here, higher abstraction in Ruby
+    return retval;
+}
+
+static VALUE calculate_mac(VALUE self, VALUE message, VALUE info) {
+    OlmSAS *this;
+    size_t mac_len;
+    char *mac;
+    VALUE retval;
+    TypedData_Get_Struct(self, OlmSAS, &olm_sas_type, this);
+    Check_Type(message, T_STRING);
+    Check_Type(info, T_STRING);
+
+    mac_len = olm_sas_mac_length(this);
+    mac = malloc_or_raise(mac_len);
+
+    if (olm_sas_calculate_mac(this,
+                              RSTRING_PTR(message), RSTRING_LEN(message),
+                              RSTRING_PTR(info), RSTRING_LEN(info),
+                              mac, mac_len) == olm_error()) {
+        free(mac);
+        raise_olm_error(olm_sas_last_error(this));
+    }
+
+    retval = rb_str_new(mac, mac_len);
+    free(mac);
+    return retval;
+}
+
+static VALUE calculate_mac_long_kdf(VALUE self, VALUE message, VALUE info) {
+    OlmSAS *this;
+    size_t mac_len;
+    char *mac;
+    VALUE retval;
+    TypedData_Get_Struct(self, OlmSAS, &olm_sas_type, this);
+    Check_Type(message, T_STRING);
+    Check_Type(info, T_STRING);
+
+    mac_len = olm_sas_mac_length(this);
+    mac = malloc_or_raise(mac_len);
+
+    if (olm_sas_calculate_mac_long_kdf(this,
+                              RSTRING_PTR(message), RSTRING_LEN(message),
+                              RSTRING_PTR(info), RSTRING_LEN(info),
+                              mac, mac_len) == olm_error()) {
+        free(mac);
+        raise_olm_error(olm_sas_last_error(this));
+    }
+
+    retval = rb_str_new(mac, mac_len);
+    free(mac);
+    return retval;
+}
+
+void sas_init(void) {
+    VALUE cSelfCrypto = rb_define_module("SelfCrypto");
+    VALUE cSAS = rb_define_class_under(cSelfCrypto, "SAS", rb_cData);
+
+    rb_define_alloc_func(cSAS, _alloc);
+
+    rb_define_attr(cSAS, "other_public_key", 1, 0);
+    rb_define_method(cSAS, "other_public_key=", set_other_pubkey, 1);
+
+    rb_define_method(cSAS, "initialize", initialize, -1);
+    rb_define_method(cSAS, "public_key", get_public_key, 0);
+    rb_define_method(cSAS, "generate_bytes", generate_bytes, 2);
+    rb_define_method(cSAS, "calculate_mac", calculate_mac, 2);
+    rb_define_method(cSAS, "calculate_mac_long_kdf", calculate_mac_long_kdf, 2);
+}