self_crypto 0.0.8 → 0.0.10

data/ext/self_crypto/pk_signing.c

@@ -1,102 +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_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

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

data/lib/self_crypto/sas.rb

@@ -1,28 +0,0 @@
-require_relative './sas_data'
-
-class SelfCrypto::SAS
-  METHODS = %i[decimal emoji]
-
-  def generate(method, info)
-    method = method.to_sym
-    raise ArgumentError, "Unknown SAS method: #{method}" unless METHODS.include? method
-
-    send method, info
-  end
-
-  protected
-
-  def decimal(info)
-    bytes = generate_bytes(5, info)
-    bits = bytes.unpack1('B39')
-    grouped = bits.chars.each_slice(13).map &:join
-    grouped.map {|s| s.to_i(2) + 1000}
-  end
-
-  def emoji(info)
-    bytes = generate_bytes(6, info)
-    bits = bytes.unpack1('B42')
-    grouped = bits.chars.each_slice(6).map &:join
-    grouped.map {|s| EMOJI_TABLE[s.to_i(2)]}.join
-  end
-end

data/lib/self_crypto/sas_data.rb

@@ -1,71 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-class SelfCrypto::SAS
-  EMOJI_TABLE = {
-    0 => '🐶',
-    1 => '🐱',
-    2 => '🦁',
-    3 => '🐎',
-    4 => '🦄',
-    5 => '🐷',
-    6 => '🐘',
-    7 => '🐰',
-    8 => '🐼',
-    9 => '🐓',
-    10 => '🐧',
-    11 => '🐢',
-    12 => '🐟',
-    13 => '🐙',
-    14 => '🦋',
-    15 => '🌷',
-    16 => '🌳',
-    17 => '🌵',
-    18 => '🍄',
-    19 => '🌏',
-    20 => '🌙',
-    21 => '☁',
-    22 => '🔥',
-    23 => '🍌',
-    24 => '🍎',
-    25 => '🍓',
-    26 => '🌽',
-    27 => '🍕',
-    28 => '🎂',
-    29 => '❤',
-    30 => '😀',
-    31 => '🤖',
-    32 => '🎩',
-    33 => '👓',
-    34 => '🔧',
-    35 => '🎅',
-    36 => '👍',
-    37 => '☂',
-    38 => '⌛',
-    39 => '⏰',
-    40 => '🎁',
-    41 => '💡',
-    42 => '📕',
-    43 => '✏',
-    44 => '📎',
-    45 => '✂',
-    46 => '🔒',
-    47 => '🔑',
-    48 => '🔨',
-    49 => '☎',
-    50 => '🏁',
-    51 => '🚂',
-    52 => '🚲',
-    53 => '✈',
-    54 => '🚀',
-    55 => '🏆',
-    56 => '⚽',
-    57 => '🎸',
-    58 => '🎺',
-    59 => '🔔',
-    60 => '⚓',
-    61 => '🎧',
-    62 => '📁',
-    63 => '📌'
-  }
-end

data/test/examples/test_bob_no_answer.rb

@@ -1,62 +0,0 @@
-require 'minitest/autorun'
-require 'self_crypto'
-
-class TestExchange < Minitest::Test
-
-  include SelfCrypto
-
-  # Alice -> Bob
-  # Alice -> Bob
-  #
-  def test_bob_no_answer
-
-    alice = Account.new
-    bob = Account.new
-
-    # Alice wants to send a message to Bob
-    alice_msg = "hi bob"
-
-    # Bob generates a one-time-key
-    bob.gen_otk
-
-    # Alice must have Bob's identity and one-time-key to make a session
-    alice_session = alice.outbound_session(bob.ik['curve25519'], bob.otk['curve25519'].values.first)
-
-    # Bob marks all one-time-keys as published
-    bob.mark_otk
-
-    # Alice can encrypt
-    encrypted = alice_session.encrypt(alice_msg)
-    assert_instance_of PreKeyMessage, encrypted
-
-    # Bob can create a session from this first message
-    bob_session = bob.inbound_session(encrypted)
-
-    # Bob can now update his list of marked otk (since he knows one has been used)
-    bob.update_otk(bob_session)
-
-    # Bob can decrypt Alice's message
-    bob_msg = bob_session.decrypt(encrypted)
-
-    assert_equal alice_msg, bob_msg
-
-    # At this point Bob has received but Alice hasn't
-    assert bob_session.has_received?
-    refute alice_session.has_received?
-
-    ###
-
-    # Alice sends another message before reply from Bob
-    alice_msg = "BOB!"
-
-    encrypted = alice_session.encrypt(alice_msg)
-    assert_instance_of PreKeyMessage, encrypted
-
-    # Bob needs to check if this is the same session or a new one
-    same_session = bob_session.will_receive? encrypted
-
-    assert same_session
-
-  end
-
-end

data/test/examples/test_exchange.rb

@@ -1,60 +0,0 @@
-require 'minitest/autorun'
-require 'self_crypto'
-
-class TestExchange < Minitest::Test
-
-  include SelfCrypto
-
-  # Alice -> Bob
-  # Alice <- Bob
-  def test_exchange
-
-    alice = Account.new
-    bob = Account.new
-
-    # Alice wants to send a message to Bob
-    alice_msg = "hi bob"
-
-    # Bob generates a one-time-key
-    bob.gen_otk
-
-    # Alice must have Bob's identity and one-time-key to make a session
-    alice_session = alice.outbound_session(bob.ik['curve25519'], bob.otk['curve25519'].values.first)
-
-    # Bob marks all one-time-keys as published
-    bob.mark_otk
-
-    # Alice can encrypt
-    encrypted = alice_session.encrypt(alice_msg)
-    assert_instance_of PreKeyMessage, encrypted
-
-    # Bob can create a session from this first message
-    bob_session = bob.inbound_session(encrypted)
-
-    # Bob can now update his list of marked otk (since he knows one has been used)
-    bob.update_otk(bob_session)
-
-    # Bob can decrypt Alice's message
-    bob_msg = bob_session.decrypt(encrypted)
-
-    assert_equal alice_msg, bob_msg
-
-    # At this point Bob has received but Alice hasn't
-    assert bob_session.has_received?
-    refute alice_session.has_received?
-
-    ####
-
-    # Bob can send messages back to Alice
-    bob_msg = "hi alice"
-
-    encrypted = bob_session.encrypt(bob_msg)
-    assert_instance_of Message, encrypted
-
-    alice_msg = alice_session.decrypt(encrypted)
-
-    assert_equal alice_msg, bob_msg
-
-  end
-
-end