self_crypto 0.0.7 → 0.0.10

data/ext/self_crypto/utility.c

@@ -1,89 +1,199 @@
-#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));
+    if (size == Qnil) {
+        rb_raise(rb_eStandardError, "must specify a size");
+    }
+
+    if ((nonce = malloc(NUM2SIZET(size))) == NULL) {
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
+
+    self_randombytes_buf(nonce, NUM2SIZET(size));
+
+    VALUE n = rb_str_new(nonce, NUM2SIZET(size));
+
+    free(nonce);
+
+    return n;
 }
 
-static VALUE ed25519_verify(VALUE self, VALUE data, VALUE key, VALUE signature)
-{
-    VALUE retval = Qtrue;
-    OlmUtility *this;
-    Data_Get_Struct(self, OlmUtility, this);
+static VALUE aead_xchacha20poly1305_ietf_nonce(VALUE self) {
+    void * nonce;
 
-    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()){
+    if ((nonce = malloc(self_crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)) == NULL) {
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
+    }
 
-        retval = Qfalse;
+    self_randombytes_buf(nonce, self_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;
+
+    if ((key = malloc(self_crypto_aead_xchacha20poly1305_ietf_KEYBYTES)) == NULL) {
+        rb_raise(rb_eNoMemError, "%s()", __FUNCTION__);
     }
 
-    return retval;
+    self_crypto_aead_xchacha20poly1305_ietf_keygen(key);
+
+    VALUE k = rb_str_new(key, self_crypto_aead_xchacha20poly1305_ietf_KEYBYTES);
+
+    free(key);
+
+    return k;
 }
 
-static VALUE ed25519_pk_to_curve25519(VALUE self, VALUE ed25519_pk)
-{
+static VALUE aead_xchacha20poly1305_ietf_encrypt(VALUE self, VALUE key, VALUE nonce, VALUE plaintext) {
+    void * ciphertext;
+    unsigned long long ciphertext_len;
+
+    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__);
+    }
+
+    self_crypto_aead_xchacha20poly1305_ietf_encrypt(
+        ciphertext, 
+        (uint64_t *) &ciphertext_len,
+        RSTRING_PTR(plaintext),
+        RSTRING_LEN(plaintext),
+        NULL,
+        0,
+        NULL,
+        RSTRING_PTR(nonce),
+        RSTRING_PTR(key)
+    );
+
+    VALUE ct = rb_str_new(ciphertext, ciphertext_len);
+
+    free(ciphertext);
+
+    return ct;
+}
+
+static VALUE aead_xchacha20poly1305_ietf_decrypt(VALUE self, VALUE key, VALUE nonce, VALUE ciphertext) {
+    void * plaintext;
+    unsigned long long plaintext_len;
+
+    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 = self_crypto_aead_xchacha20poly1305_ietf_decrypt(
+        plaintext,
+        (uint64_t *) &plaintext_len,
+        NULL,
+        RSTRING_PTR(ciphertext),
+        RSTRING_LEN(ciphertext),
+        NULL,
+        0,
+        RSTRING_PTR(nonce),
+        RSTRING_PTR(key)
+    );
+
+    if (status != 0) {
+        rb_raise(rb_eStandardError, "could not authenticate encrypted message");
+    }
+
+    VALUE pt = rb_str_new(plaintext, plaintext_len);
+
+    free(plaintext);
+
+    return pt;
+}
+
+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);
@@ -95,49 +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/group_message.rb

@@ -1,3 +1,5 @@
+# Copyright 2020 Self Group Ltd. All Rights Reserved.
+
 require 'base64'
 
 module SelfCrypto

data/lib/self_crypto/group_session.rb

@@ -1,3 +1,5 @@
+# Copyright 2020 Self Group Ltd. All Rights Reserved.
+
 require 'base64'
 
 module SelfCrypto

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/utility.rb

@@ -1,3 +1,5 @@
+# Copyright 2020 Self Group Ltd. All Rights Reserved.
+
 module SelfCrypto
 
   module Util

data/lib/self_crypto/version.rb

@@ -1,5 +1,7 @@
+# Copyright 2020 Self Group Ltd. All Rights Reserved.
+
 module SelfCrypto
 
-  VERSION="0.0.7"
+  VERSION="0.0.10"
 
 end

data/lib/self_crypto.rb

@@ -1,3 +1,5 @@
+# Copyright 2020 Self Group Ltd. All Rights Reserved.
+
 require 'self_crypto/version'
 require 'self_crypto/self_crypto'
 require 'self_crypto/account'
@@ -7,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

data/test/spec/test_util.rb

@@ -14,4 +14,16 @@ describe "Util" do
     it("should convert"){ _(account.ik['curve25519']).must_equal curve25519_pk }
   end
 
+  describe "xchacha20_poly1305_itef" do
+    message = "something"
+
+    key = SelfCrypto::Util.aead_xchacha20poly1305_ietf_keygen
+    nonce = SelfCrypto::Util.aead_xchacha20poly1305_ietf_nonce
+
+    ct = SelfCrypto::Util.aead_xchacha20poly1305_ietf_encrypt(key, nonce, message)
+    pt = SelfCrypto::Util.aead_xchacha20poly1305_ietf_decrypt(key, nonce, ct)
+
+    it('should decrypt'){ _(pt).must_equal message}
+  end
+
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: self_crypto
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.10
 platform: ruby
 authors:
 - Tom Bevan
 - Cameron Harper
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-21 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.1.2
-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_exchange.rb
-- test/examples/test_bob_no_answer.rb
-- test/spec/test_util.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);
-}