self_crypto 0.0.8 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3db3da86cb87d90e72ce0f69a682872a8e2b092b9828e67d1a7641b1952fed59
-  data.tar.gz: e3319c2d1c8f34854500f4f4d723007b89d9c1ac312ae6d271c74d953c22548d
+  metadata.gz: 31cc22c6b9dd88e85087d810252d8c27ffe3519794f3bcc9508b518c45e169d8
+  data.tar.gz: fce33b4e5a82e3733a271cb7f7d6550f3689e93f0f80a1b4c8976f30f5115f7d
 SHA512:
-  metadata.gz: cb42f2dd7f586324bd638583c89a867b1858ae4d2da836f15392f851eb36e624f59648c71f5f0fff12fce922cca1b18f37fe2e6019bfda72131af60fa855e3b3
-  data.tar.gz: 770c20da2afea5e5dbd1cf8291584640b1ce1db395bbe916a340c67b429aa1998acfb3aa0d0f56f0f0e05bcd13bd27ef995fcf6866bebb8917c1e80051fcff79
+  metadata.gz: a4ba1661748742d3b5bdb3f563b71ca88ab646e1c05bfdf7578ff2943a672b592455a8ec039457069f2b7ac88b951344415a2349a20545b7a9683d8f13a92d2b
+  data.tar.gz: ab7e3453c2d122c5fb68eca9d9c5606c3184626765fed83baac4166e2d76fb0cfad15c9776e42513a034a04d9526d1f3020675fdb4c85aad4d624d6b85935254

data/ext/self_crypto/account.c

@@ -1,130 +1,154 @@
-#include "sodium.h"
-#include "self_olm/olm.h"
+#include "self_omemo.h"
 #include "self_crypto.h"
 
-static VALUE last_error(VALUE self)
-{
-    OlmAccount *this;
+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)));
+    return rb_funcall(rb_eval_string("SelfCrypto::OlmError"), rb_intern("from_string"), 1, rb_str_new2(self_olm_account_last_error(this)));
 }
 
-static VALUE initialize(int argc, VALUE *argv, VALUE self)
-{
+static VALUE initialize(int argc, VALUE * argv, VALUE self) {
     VALUE pickle, password, seed, opts;
     size_t size;
-    OlmAccount *this;
+    OlmAccount * this;
+
     Data_Get_Struct(self, OlmAccount, this);
 
-    (void)rb_scan_args(argc, argv, "0:", &opts);
+    (void) rb_scan_args(argc, argv, "0:", & opts);
 
-    opts = (opts == Qnil) ? rb_hash_new(): 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){
-
+    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){
-
+    if (password != Qnil) {
+        if (rb_obj_is_kind_of(password, rb_cString) != Qtrue) {
             rb_raise(rb_eTypeError, "password must be kind of String");
         }
-    }
-    else{
-
+    } 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 (pickle != Qnil) {
+        if (self_olm_unpickle_account(this, RSTRING_PTR(password), RSTRING_LEN(password), RSTRING_PTR(dup_string(pickle)), RSTRING_LEN(pickle)) == -1) {
+            raise_olm_error(self_olm_account_last_error(this));
+        }
+    } else if (seed != Qnil) {
+        uint8_t *ed25519_pk = malloc_or_raise(self_crypto_sign_publickeybytes());
+        uint8_t *ed25519_sk = malloc_or_raise(self_crypto_sign_secretkeybytes());
+        uint8_t *curve25519_pk = malloc_or_raise(self_crypto_sign_publickeybytes()); // equivalent to crypto_scalarmult_curve25519_BYTES
+        uint8_t *curve25519_sk = malloc_or_raise(self_crypto_sign_publickeybytes()); // equivalent to crypto_scalarmult_curve25519_BYTES
+        size_t status = self_crypto_sign_seed_keypair(
+            ed25519_pk,
+            ed25519_sk,
+            RSTRING_PTR(seed)
+        );
+
+        if (status != 0) {
+            raise_olm_error("could not generate key from seed");
         }
-    } else 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));
+
+        status = self_crypto_sign_ed25519_pk_to_curve25519(
+            curve25519_pk,
+            ed25519_pk
+        );
+
+        if (status != 0) {
+            raise_olm_error("could not convert ed25519 public key to curve25519");
+        }
+
+        status = self_crypto_sign_ed25519_sk_to_curve25519(
+            curve25519_sk,
+            ed25519_sk
+        );
+
+        if (status != 0) {
+            raise_olm_error("could not convert ed25519 secret key to curve25519");
+        } 
+
+        status = self_olm_import_account(
+            this,
+            ed25519_sk,
+            ed25519_pk,
+            curve25519_sk,
+            curve25519_pk
+        );
+
+        if (status == -1) {
+            raise_olm_error(self_olm_account_last_error(this));
         }
     } else {
-        size = olm_create_account_random_length(this);
+        size = self_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));
+        if (self_olm_create_account(this, RSTRING_PTR(get_random(size)), size) == -1) {
+            raise_olm_error(self_olm_account_last_error(this));
         }
     }
 
     return self;
 }
 
-static VALUE identity_keys(VALUE self)
-{
-    OlmAccount *this;
+static VALUE identity_keys(VALUE self) {
+    OlmAccount * this;
     size_t size;
     Data_Get_Struct(self, OlmAccount, this);
 
-    size = olm_account_identity_keys_length(this);
+    size = self_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));
+    if (self_olm_account_identity_keys(this, buf, size) != size) {
+        raise_olm_error(self_olm_account_last_error(this));
     }
 
-    return rb_funcall(rb_eval_string("JSON"), rb_intern("parse"), 1, rb_str_new((char *)buf, size));
+    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)
-{
+static VALUE generate_one_time_keys(VALUE self, VALUE number) {
     size_t size;
-    OlmAccount *this;
+    OlmAccount * this;
     Data_Get_Struct(self, OlmAccount, this);
 
-    size = olm_account_generate_one_time_keys_random_length(this, NUM2SIZET(number));
+    size = self_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));
+    if (self_olm_account_generate_one_time_keys(this, NUM2SIZET(number), RSTRING_PTR(get_random(size)), size) == -1) {
+        raise_olm_error(self_olm_account_last_error(this));
     }
 
     return self;
 }
 
-static VALUE one_time_keys_size(VALUE self)
-{
-    OlmAccount *this;
+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));
+    return SIZET2NUM(self_olm_account_one_time_keys_length(this));
 }
 
-static VALUE one_time_keys(VALUE self)
-{
+static VALUE one_time_keys(VALUE self) {
     VALUE retval;
     size_t size;
-    void *ptr;
-    OlmAccount *this;
+    void * ptr;
+    OlmAccount * this;
     Data_Get_Struct(self, OlmAccount, this);
 
-    size = olm_account_one_time_keys_length(this);
+    size = self_olm_account_one_time_keys_length(this);
 
     // add an additional byte to stop this from overflowing
-    if((ptr = malloc(size+1)) == NULL){
-
+    if ((ptr = malloc(size + 1)) == NULL) {
         rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
     }
 
-    if(olm_account_one_time_keys(this, ptr, size) != size){
-
+    if (self_olm_account_one_time_keys(this, ptr, size) != size) {
         free(ptr);
-        raise_olm_error(olm_account_last_error(this));
+        raise_olm_error(self_olm_account_last_error(this));
     }
 
     retval = rb_funcall(rb_eval_string("JSON"), rb_intern("parse"), 1, rb_str_new(ptr, size));
@@ -134,25 +158,22 @@ static VALUE one_time_keys(VALUE self)
     return retval;
 }
 
-static VALUE sign(VALUE self, VALUE message)
-{
+static VALUE sign(VALUE self, VALUE message) {
     VALUE retval;
     size_t size;
-    void *ptr;
-    OlmAccount *this;
+    void * ptr;
+    OlmAccount * this;
     Data_Get_Struct(self, OlmAccount, this);
 
-    size = olm_account_signature_length(this);
-
-    if((ptr = malloc(size)) == NULL){
+    size = self_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()){
-
+    if (self_olm_account_sign(this, RSTRING_PTR(message), RSTRING_LEN(message), ptr, size) == -1) {
         free(ptr);
-        raise_olm_error(olm_account_last_error(this));
+        raise_olm_error(self_olm_account_last_error(this));
     }
 
     retval = rb_str_new(ptr, size);
@@ -162,77 +183,72 @@ static VALUE sign(VALUE self, VALUE message)
     return retval;
 }
 
-static VALUE mark_keys_as_published(VALUE self)
-{
-    OlmAccount *this;
+static VALUE mark_keys_as_published(VALUE self) {
+    OlmAccount * this;
     Data_Get_Struct(self, OlmAccount, this);
 
-    (void)olm_account_mark_keys_as_published(this);
+    (void) self_olm_account_mark_keys_as_published(this);
 
     return self;
 }
 
-static VALUE max_number_of_one_time_keys(VALUE self)
-{
-    OlmAccount *this;
+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));
+    return SIZET2NUM(self_olm_account_max_number_of_one_time_keys(this));
 }
 
-static VALUE remove_one_time_keys(VALUE self, VALUE session)
-{
-    OlmAccount *this;
+static VALUE remove_one_time_keys(VALUE self, VALUE session) {
+    OlmAccount * this;
     Data_Get_Struct(self, OlmAccount, this);
 
-    OlmSession *s;
+    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));
+    if (self_olm_remove_one_time_keys(this, s) == -1) {
+        raise_olm_error(self_olm_account_last_error(this));
     }
 
     return self;
 }
 
-static VALUE outbound_session(VALUE self, VALUE identity_key, VALUE pre_key)
-{
+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};
+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]);
+    (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"));
+    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)
-{
+static VALUE to_pickle(int argc, VALUE * argv, VALUE self) {
     VALUE password, retval;
-    OlmAccount *this;
-    void *ptr;
+    OlmAccount * this;
+    void * ptr;
     size_t size;
     Data_Get_Struct(self, OlmAccount, this);
 
-    (void)rb_scan_args(argc, argv, "01", &password);
+    (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){
+    size = self_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){
-
+    if (self_olm_pickle_account(this, RSTRING_PTR(password), RSTRING_LEN(password), ptr, size) != size) {
         free(ptr);
-        raise_olm_error(olm_account_last_error(this));
+        raise_olm_error(self_olm_account_last_error(this));
     }
 
     retval = rb_str_new(ptr, size);
@@ -242,28 +258,18 @@ static VALUE to_pickle(int argc, VALUE *argv, VALUE self)
     return retval;
 }
 
-static void _free(void *ptr)
-{
-    olm_clear_account(ptr);
+static void _free(void * 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);
+static VALUE _alloc(VALUE klass) {
+    void *account_buf = calloc(1, self_olm_account_size());
+    OlmAccount *account = self_olm_account(account_buf);
 
-    (void)olm_account((void *)this);
-
-    return self;
+    return Data_Wrap_Struct(klass, 0, _free, account);
 }
 
-void account_init(void)
-{
+void account_init(void) {
     VALUE cRubyOLM = rb_define_module("SelfCrypto");
     VALUE cAccount = rb_define_class_under(cRubyOLM, "Account", rb_cObject);
 
@@ -282,4 +288,4 @@ void account_init(void)
     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

@@ -4,12 +4,10 @@ $CFLAGS = " -std=c99"
 
 RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
 
-pkg_config('self_olm')
+pkg_config('stdc++')
 pkg_config('self_omemo')
-pkg_config("sodium")
 
-abort "Missing sodium" unless have_library("sodium")
+abort "Missing stdc++" unless have_library("stdc++")
 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

@@ -1,79 +1,74 @@
 // Copyright 2020 Self Group Ltd. All Rights Reserved.
 
-#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)
-{
+static VALUE initialize(int argc, VALUE * argv, VALUE self) {
     VALUE identity;
-    GroupSession *this;
+    GroupSession * this;
 
     Data_Get_Struct(self, GroupSession, this);
 
-    (void)rb_scan_args(argc, argv, "1", &identity);
+    (void) rb_scan_args(argc, argv, "1", & identity);
 
-    if(identity != Qnil){
-        if(rb_obj_is_kind_of(identity, rb_cString) != Qtrue){
+    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));
+    self_omemo_set_identity(this, RSTRING_PTR(identity));
 
     return self;
 }
 
-static VALUE add_participant(VALUE self, VALUE identity, VALUE session)
-{
-    GroupSession *this;
-    OlmSession *s;
+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){
+    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
-     ){
+    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);
+    self_omemo_add_group_participant(this, RSTRING_PTR(identity), s);
 
     return identity;
 }
 
-static VALUE group_encrypt(VALUE self, VALUE plaintext)
-{
-    GroupSession *this;
+static VALUE group_encrypt(VALUE self, VALUE plaintext) {
+    GroupSession * this;
     VALUE ciphertext;
-    void *ptr;
+    void * ptr;
     size_t ciphertext_sz;
 
     Data_Get_Struct(self, GroupSession, this);
 
-    if(rb_obj_is_kind_of(plaintext, rb_eval_string("String")) != Qtrue){
+    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));
+    ciphertext_sz = self_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){
+    if ((ptr = malloc(ciphertext_sz)) == NULL) {
         rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
     }
 
-    ciphertext_sz = omemo_encrypt(
+    ciphertext_sz = self_omemo_encrypt(
         this,
         RSTRING_PTR(plaintext),
         RSTRING_LEN(plaintext),
@@ -81,7 +76,7 @@ static VALUE group_encrypt(VALUE self, VALUE plaintext)
         ciphertext_sz
     );
 
-    if(ciphertext_sz == 0) {
+    if (ciphertext_sz == 0) {
         free(ptr);
         rb_raise(rb_eTypeError, "failed to encrypt");
     }
@@ -93,34 +88,33 @@ static VALUE group_encrypt(VALUE self, VALUE plaintext)
     return ciphertext;
 }
 
-static VALUE group_decrypt(VALUE self, VALUE sender, VALUE ciphertext)
-{
-    GroupSession *this;
+static VALUE group_decrypt(VALUE self, VALUE sender, VALUE ciphertext) {
+    GroupSession * this;
     VALUE plaintext;
-    void *ptr;
+    void * ptr;
     size_t plaintext_sz;
 
     Data_Get_Struct(self, GroupSession, this);
 
-    if(rb_obj_is_kind_of(sender, rb_eval_string("String")) != Qtrue){
+    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){
+    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));
+    plaintext_sz = self_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){
+    if ((ptr = malloc(plaintext_sz)) == NULL) {
         rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
     }
 
-    plaintext_sz = omemo_decrypt(
+    plaintext_sz = self_omemo_decrypt(
         this,
         RSTRING_PTR(sender),
         ptr,
@@ -129,7 +123,7 @@ static VALUE group_decrypt(VALUE self, VALUE sender, VALUE ciphertext)
         RSTRING_LEN(ciphertext)
     );
 
-    if(plaintext_sz == 0) {
+    if (plaintext_sz == 0) {
         free(ptr);
         rb_raise(rb_eTypeError, "failed to decrypt");
     }
@@ -141,25 +135,22 @@ static VALUE group_decrypt(VALUE self, VALUE sender, VALUE ciphertext)
     return plaintext;
 }
 
-static void _free(void *ptr)
-{
-    omemo_destroy_group_session(ptr);
+static void _free(void * ptr) {
+    self_omemo_destroy_group_session(ptr);
 }
 
-static VALUE _alloc(VALUE klass)
-{
-    GroupSession *this;
+static VALUE _alloc(VALUE klass) {
+    GroupSession * this;
     VALUE self;
 
-    self = Data_Wrap_Struct(klass, 0, _free, omemo_create_group_session());
+    self = Data_Wrap_Struct(klass, 0, _free, self_omemo_create_group_session());
 
     Data_Get_Struct(self, GroupSession, this);
 
     return self;
 }
 
-void group_session_init()
-{
+void group_session_init() {
     VALUE cRubyOLM = rb_define_module("SelfCrypto");
     VALUE cGroupSession = rb_define_class_under(cRubyOLM, "GroupSession", rb_cObject);
 
@@ -169,4 +160,4 @@ void group_session_init()
     rb_define_method(cGroupSession, "add_participant", add_participant, 2);
     rb_define_method(cGroupSession, "encrypt", group_encrypt, 1);
     rb_define_method(cGroupSession, "decrypt", group_decrypt, 2);
-}
+}