self_crypto 0.0.8 → 0.0.10

data/ext/self_crypto/utility.c

@@ -1,38 +1,18 @@
-#include "self_olm/olm.h"
+#include "self_omemo.h"
 #include "self_crypto.h"
-#include "sodium.h"
 
-static VALUE last_error(VALUE self)
-{
-    OlmUtility *this;
-    Data_Get_Struct(self, OlmUtility, this);
+static VALUE random_bytes(VALUE self, VALUE size) {
+    void * nonce;
 
-    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;
+    if (size == Qnil) {
+        rb_raise(rb_eStandardError, "must specify a size");
     }
 
-    return retval;
-}
-
-static VALUE random_bytes(VALUE self, VALUE size)
-{
-    void *nonce;
-
-    if((nonce = malloc(NUM2SIZET(size))) == NULL){
+    if ((nonce = malloc(NUM2SIZET(size))) == NULL) {
         rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
     }
 
-    randombytes_buf(nonce, NUM2SIZET(size));
+    self_randombytes_buf(nonce, NUM2SIZET(size));
 
     VALUE n = rb_str_new(nonce, NUM2SIZET(size));
 
@@ -41,52 +21,61 @@ static VALUE random_bytes(VALUE self, VALUE size)
     return n;
 }
 
-static VALUE aead_xchacha20poly1305_ietf_nonce(VALUE self)
-{
-    void *nonce;
+static VALUE aead_xchacha20poly1305_ietf_nonce(VALUE self) {
+    void * nonce;
 
-    if((nonce = malloc(crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)) == NULL){
+    if ((nonce = malloc(self_crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)) == NULL) {
         rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
     }
 
-    randombytes_buf(nonce, crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
+    self_randombytes_buf(nonce, self_crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
 
-    VALUE n = rb_str_new(nonce, crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
+    VALUE n = rb_str_new(nonce, self_crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
 
     free(nonce);
 
     return n;
 }
 
-static VALUE aead_xchacha20poly1305_ietf_keygen(VALUE self)
-{
-    void *key;
+static VALUE aead_xchacha20poly1305_ietf_keygen(VALUE self) {
+    void * key;
 
-    if((key = malloc(crypto_aead_xchacha20poly1305_ietf_KEYBYTES)) == NULL){
+    if ((key = malloc(self_crypto_aead_xchacha20poly1305_ietf_KEYBYTES)) == NULL) {
         rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
     }
 
-    crypto_aead_xchacha20poly1305_ietf_keygen(key);
+    self_crypto_aead_xchacha20poly1305_ietf_keygen(key);
 
-    VALUE k = rb_str_new(key, crypto_aead_xchacha20poly1305_ietf_KEYBYTES);
+    VALUE k = rb_str_new(key, self_crypto_aead_xchacha20poly1305_ietf_KEYBYTES);
 
     free(key);
 
     return k;
 }
 
-static VALUE aead_xchacha20poly1305_ietf_encrypt(VALUE self, VALUE key, VALUE nonce, VALUE plaintext)
-{
-    void *ciphertext;
+static VALUE aead_xchacha20poly1305_ietf_encrypt(VALUE self, VALUE key, VALUE nonce, VALUE plaintext) {
+    void * ciphertext;
     unsigned long long ciphertext_len;
 
-    if((ciphertext = malloc(RSTRING_LEN(plaintext) + crypto_aead_xchacha20poly1305_ietf_ABYTES)) == NULL){
+    if (key == Qnil) {
+        rb_raise(rb_eStandardError, "must specify a key");
+    }
+
+    if (nonce == Qnil) {
+        rb_raise(rb_eStandardError, "must specify a nonce");
+    }
+
+    if (plaintext == Qnil) {
+        rb_raise(rb_eStandardError, "must specify plaintext");
+    }
+
+    if ((ciphertext = malloc(RSTRING_LEN(plaintext) + self_crypto_aead_xchacha20poly1305_ietf_ABYTES)) == NULL) {
         rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
     }
 
-    crypto_aead_xchacha20poly1305_ietf_encrypt(
-        ciphertext,
-        &ciphertext_len,
+    self_crypto_aead_xchacha20poly1305_ietf_encrypt(
+        ciphertext, 
+        (uint64_t *) &ciphertext_len,
         RSTRING_PTR(plaintext),
         RSTRING_LEN(plaintext),
         NULL,
@@ -103,18 +92,29 @@ static VALUE aead_xchacha20poly1305_ietf_encrypt(VALUE self, VALUE key, VALUE no
     return ct;
 }
 
-static VALUE aead_xchacha20poly1305_ietf_decrypt(VALUE self, VALUE key, VALUE nonce, VALUE ciphertext)
-{
-    void *plaintext;
+static VALUE aead_xchacha20poly1305_ietf_decrypt(VALUE self, VALUE key, VALUE nonce, VALUE ciphertext) {
+    void * plaintext;
     unsigned long long plaintext_len;
 
-    if((plaintext = malloc(RSTRING_LEN(ciphertext))) == NULL){
+    if (key == Qnil) {
+        rb_raise(rb_eStandardError, "must specify a key");
+    }
+
+    if (nonce == Qnil) {
+        rb_raise(rb_eStandardError, "must specify a nonce");
+    }
+
+    if (ciphertext == Qnil) {
+        rb_raise(rb_eStandardError, "must specify ciphertext");
+    }
+
+    if ((plaintext = malloc(RSTRING_LEN(ciphertext))) == NULL) {
         rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
     }
 
-    int status = crypto_aead_xchacha20poly1305_ietf_decrypt(
+    int status = self_crypto_aead_xchacha20poly1305_ietf_decrypt(
         plaintext,
-        &plaintext_len,
+        (uint64_t *) &plaintext_len,
         NULL,
         RSTRING_PTR(ciphertext),
         RSTRING_LEN(ciphertext),
@@ -135,66 +135,65 @@ static VALUE aead_xchacha20poly1305_ietf_decrypt(VALUE self, VALUE key, VALUE no
     return pt;
 }
 
-static VALUE ed25519_pk_to_curve25519(VALUE self, VALUE ed25519_pk)
-{
+static VALUE ed25519_pk_to_curve25519(VALUE self, VALUE ed25519_pk) {
     VALUE curve25519_sk;
-    void  *pk_ptr, *dec_ptr, *enc_ptr;
+    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){
+    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();
+    pk_sz = self_crypto_sign_publickeybytes();
 
-    if((dec_ptr = malloc(pk_sz)) == NULL){
+    if ((dec_ptr = malloc(pk_sz)) == NULL) {
         rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
     }
 
-    success = sodium_base642bin(
+    success = self_base642bin(
         dec_ptr,
         pk_sz,
         RSTRING_PTR(ed25519_pk),
         RSTRING_LEN(ed25519_pk),
+        NULL, &
+        dec_sz,
         NULL,
-        &dec_sz,
-        NULL,
-        sodium_base64_VARIANT_URLSAFE_NO_PADDING
+        self_base64_VARIANT_URLSAFE_NO_PADDING
     );
 
-    if(success != 0) {
+    if (success != 0) {
         free(dec_ptr);
         rb_raise(rb_eTypeError, "could not decode ed25519 public key");
     }
 
-    if((pk_ptr = malloc(pk_sz)) == NULL){
+    if ((pk_ptr = malloc(pk_sz)) == NULL) {
         rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
     }
 
-    success = crypto_sign_ed25519_pk_to_curve25519(
+    success = self_crypto_sign_ed25519_pk_to_curve25519(
         pk_ptr,
         dec_ptr
     );
 
     free(dec_ptr);
 
-    if(success != 0) {
+    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);
+    enc_sz = self_base64_ENCODED_LEN(pk_sz, self_base64_VARIANT_ORIGINAL_NO_PADDING);
 
-    if((enc_ptr = malloc(enc_sz)) == NULL){
+    if ((enc_ptr = malloc(enc_sz)) == NULL) {
         rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
     }
 
-    sodium_bin2base64(
+    self_bin2base64(
         enc_ptr,
         enc_sz,
         pk_ptr,
         pk_sz,
-        sodium_base64_VARIANT_ORIGINAL_NO_PADDING
+        self_base64_VARIANT_ORIGINAL_NO_PADDING
     );
 
     free(pk_ptr);
@@ -206,54 +205,18 @@ static VALUE ed25519_pk_to_curve25519(VALUE self, VALUE ed25519_pk)
     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);
+static void _free(void * 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)
-{
+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);
     rb_define_module_function(cUtil, "random_bytes", random_bytes, 1);
     rb_define_module_function(cUtil, "aead_xchacha20poly1305_ietf_keygen", aead_xchacha20poly1305_ietf_keygen, 0);
     rb_define_module_function(cUtil, "aead_xchacha20poly1305_ietf_nonce", aead_xchacha20poly1305_ietf_nonce, 0);
     rb_define_module_function(cUtil, "aead_xchacha20poly1305_ietf_encrypt", aead_xchacha20poly1305_ietf_encrypt, 3);
     rb_define_module_function(cUtil, "aead_xchacha20poly1305_ietf_decrypt", aead_xchacha20poly1305_ietf_decrypt, 3);
-}
+}

data/lib/self_crypto/session.rb

@@ -9,8 +9,6 @@ module SelfCrypto
       Session.new(pickle, password)
     end
 
-    alias_method :has_received?, :has_received_message
-
   end
 
 end

data/lib/self_crypto/version.rb

@@ -2,6 +2,6 @@
 
 module SelfCrypto
 
-  VERSION="0.0.8"
+  VERSION="0.0.10"
 
 end

data/lib/self_crypto.rb

@@ -9,7 +9,6 @@ require 'self_crypto/olm_message'
 require 'self_crypto/message'
 require 'self_crypto/group_message'
 require 'self_crypto/pre_key_message'
-require 'self_crypto/sas'
 require 'self_crypto/utility'
 
 module SelfCrypto

data/test/spec/test_account.rb

@@ -77,34 +77,6 @@ describe "Account" do
 
     end
 
-    describe "#inbound_session" do
-
-      let(:remote_session){ remote.outbound_session(account.ik['curve25519'], account.otk['curve25519'].values.first) }
-      let(:remote_message){ remote_session.encrypt("hello") }
-
-      it("creates session") { _(account.inbound_session(remote_message)).must_be_kind_of SelfCrypto::Session }
-
-    end
-
-    describe "#inbound_session from known remote" do
-
-      let(:remote_session){ remote.outbound_session(account.ik['curve25519'], account.otk['curve25519'].values.first) }
-      let(:remote_message){ remote_session.encrypt("hello") }
-
-      it("creates session") { _(account.inbound_session(remote_message, remote.ik['curve25519'])).must_be_kind_of SelfCrypto::Session }
-
-    end
-
-    describe "#inbound_session from pickled account" do
-
-      let(:remote_session){ remote.outbound_session(account.ik['curve25519'], account.otk['curve25519'].values.first) }
-      let(:remote_message){ remote_session.encrypt("hello") }
-      let(:pickled_account){ account.to_pickle("test") }
-      let(:unpickled_account){ SelfCrypto::Account.from_pickle(pickled_account, "test") }
-      it("creates session") { _(unpickled_account.inbound_session(remote_message, remote.ik['curve25519'])).must_be_kind_of SelfCrypto::Session }
-
-    end
-
   end
 
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: self_crypto
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.10
 platform: ruby
 authors:
 - Tom Bevan
 - Cameron Harper
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-12 00:00:00.000000000 Z
+date: 2023-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -67,7 +67,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email: ops@selfid.net
 executables: []
 extensions:
@@ -78,11 +78,6 @@ files:
 - ext/self_crypto/account.c
 - ext/self_crypto/extconf.rb
 - ext/self_crypto/omemo.c
-- ext/self_crypto/pk.c
-- ext/self_crypto/pk_decryption.c
-- ext/self_crypto/pk_encryption.c
-- ext/self_crypto/pk_signing.c
-- ext/self_crypto/sas.c
 - ext/self_crypto/self_crypto.c
 - ext/self_crypto/self_crypto.h
 - ext/self_crypto/session.c
@@ -95,13 +90,9 @@ files:
 - lib/self_crypto/olm_error.rb
 - lib/self_crypto/olm_message.rb
 - lib/self_crypto/pre_key_message.rb
-- lib/self_crypto/sas.rb
-- lib/self_crypto/sas_data.rb
 - lib/self_crypto/session.rb
 - lib/self_crypto/utility.rb
 - lib/self_crypto/version.rb
-- test/examples/test_bob_no_answer.rb
-- test/examples/test_exchange.rb
 - test/spec/test_account.rb
 - test/spec/test_util.rb
 - test/unit/test_account_methods.rb
@@ -109,7 +100,7 @@ homepage: https://github.com/aldgate-ventures/self-crypto-ruby
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -124,13 +115,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.5
-signing_key: 
+rubygems_version: 3.3.15
+signing_key:
 specification_version: 4
 summary: Group end to end encryption for self
 test_files:
-- test/unit/test_account_methods.rb
-- test/examples/test_bob_no_answer.rb
-- test/examples/test_exchange.rb
 - test/spec/test_account.rb
 - test/spec/test_util.rb
+- test/unit/test_account_methods.rb

data/ext/self_crypto/pk.c

@@ -1,15 +0,0 @@
-#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

@@ -1,129 +0,0 @@
-#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

@@ -1,93 +0,0 @@
-#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);
-}