ruby_olm 0.1.1

data/ext/ruby_olm/ext_lib_olm/olm/tests/test_olm_decrypt.cpp

@@ -0,0 +1,90 @@
+#include "olm/olm.h"
+#include "unittest.hh"
+
+struct test_case {
+    const char *msghex;
+    const char *expected_error;
+};
+
+const test_case test_cases[] = {
+    { "41776f", "BAD_MESSAGE_FORMAT" },
+    { "7fff6f0101346d671201", "BAD_MESSAGE_FORMAT" },
+    { "ee776f41496f674177804177778041776f6716670a677d6f670a67c2677d", "BAD_MESSAGE_FORMAT" },
+    { "e9e9c9c1e9e9c9e9c9c1e9e9c9c1", "BAD_MESSAGE_FORMAT" },
+};
+
+
+const char * session_data =
+    "E0p44KO2y2pzp9FIjv0rud2wIvWDi2dx367kP4Fz/9JCMrH+aG369HGymkFtk0+PINTLB9lQRt"
+    "ohea5d7G/UXQx3r5y4IWuyh1xaRnojEZQ9a5HRZSNtvmZ9NY1f1gutYa4UtcZcbvczN8b/5Bqg"
+    "e16cPUH1v62JKLlhoAJwRkH1wU6fbyOudERg5gdXA971btR+Q2V8GKbVbO5fGKL5phmEPVXyMs"
+    "rfjLdzQrgjOTxN8Pf6iuP+WFPvfnR9lDmNCFxJUVAdLIMnLuAdxf1TGcS+zzCzEE8btIZ99mHF"
+    "dGvPXeH8qLeNZA";
+
+void decode_hex(
+    const char * input,
+    std::uint8_t * output, std::size_t output_length
+) {
+    std::uint8_t * end = output + output_length;
+    while (output != end) {
+        char high = *(input++);
+        char low = *(input++);
+        if (high >= 'a') high -= 'a' - ('9' + 1);
+        if (low >= 'a') low -= 'a' - ('9' + 1);
+        uint8_t value = ((high - '0') << 4) | (low - '0');
+        *(output++) = value;
+    }
+}
+
+void decrypt_case(int message_type, const test_case * test_case) {
+    std::uint8_t session_memory[olm_session_size()];
+    ::OlmSession * session = ::olm_session(session_memory);
+
+    std::uint8_t pickled[strlen(session_data)];
+    ::memcpy(pickled, session_data, sizeof(pickled));
+    assert_not_equals(
+        ::olm_error(),
+        ::olm_unpickle_session(session, "", 0, pickled, sizeof(pickled))
+    );
+
+    std::size_t message_length = strlen(test_case->msghex) / 2;
+    std::uint8_t * message = (std::uint8_t *) ::malloc(message_length);
+    decode_hex(test_case->msghex, message, message_length);
+
+    size_t max_length = olm_decrypt_max_plaintext_length(
+        session, message_type, message, message_length
+    );
+
+    if (test_case->expected_error) {
+        assert_equals(::olm_error(), max_length);
+        assert_equals(
+            std::string(test_case->expected_error),
+            std::string(::olm_session_last_error(session))
+        );
+        free(message);
+        return;
+    }
+
+    assert_not_equals(::olm_error(), max_length);
+
+    uint8_t plaintext[max_length];
+    decode_hex(test_case->msghex, message, message_length);
+    olm_decrypt(
+        session, message_type,
+        message, message_length,
+        plaintext, max_length
+    );
+    free(message);
+}
+
+
+int main() {
+{
+TestCase my_test("Olm decrypt test");
+
+for (unsigned int i = 0; i < sizeof(test_cases)/ sizeof(test_cases[0]); ++i) {
+    decrypt_case(0, &test_cases[i]);
+}
+
+}
+}

data/ext/ruby_olm/ext_lib_olm/olm/tests/test_olm_sha256.cpp

@@ -0,0 +1,20 @@
+#include "olm/olm.h"
+#include "unittest.hh"
+
+int main() {
+{
+TestCase("Olm sha256 test");
+
+
+std::uint8_t utility_buffer[::olm_utility_size()];
+::OlmUtility * utility = ::olm_utility(utility_buffer);
+
+assert_equals(std::size_t(43), ::olm_sha256_length(utility));
+std::uint8_t output[43];
+::olm_sha256(utility, "Hello, World", 12, output, 43);
+
+std::uint8_t expected_output[] = "A2daxT/5zRU1zMffzfosRYxSGDcfQY3BNvLRmsH76KU";
+assert_equals(output, expected_output, 43);
+
+}
+}

data/ext/ruby_olm/ext_lib_olm/olm/tests/test_olm_signature.cpp

@@ -0,0 +1,81 @@
+#include "olm/olm.h"
+#include "unittest.hh"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+struct MockRandom {
+    MockRandom(std::uint8_t tag, std::uint8_t offset = 0)
+        : tag(tag), current(offset) {}
+    void operator()(
+        void * buf, std::size_t length
+    ) {
+        std::uint8_t * bytes = (std::uint8_t *) buf;
+        while (length > 32) {
+            bytes[0] = tag;
+            std::memset(bytes + 1, current, 31);
+            length -= 32;
+            bytes += 32;
+            current += 1;
+        }
+        if (length) {
+            bytes[0] = tag;
+            std::memset(bytes + 1, current, length - 1);
+            current += 1;
+        }
+    }
+    std::uint8_t tag;
+    std::uint8_t current;
+};
+
+std::uint8_t * check_malloc(std::size_t size) {
+    if (size == std::size_t(-1)) {
+        assert_not_equals(std::size_t(-1), size);
+    }
+    return (std::uint8_t *)::malloc(size);
+}
+
+
+int main() {
+
+{ /** Signing Test */
+TestCase test_case("Signing test");
+
+MockRandom mock_random_a('A', 0x00);
+
+void * account_buffer = check_malloc(::olm_account_size());
+::OlmAccount * account = ::olm_account(account_buffer);
+
+std::size_t random_size = ::olm_create_account_random_length(account);
+void * random = check_malloc(random_size);
+mock_random_a(random, random_size);
+::olm_create_account(account, random, random_size);
+::free(random);
+
+std::size_t message_size = 12;
+void * message = check_malloc(message_size);
+::memcpy(message, "Hello, World", message_size);
+
+std::size_t signature_size = ::olm_account_signature_length(account);
+void * signature = check_malloc(signature_size);
+assert_not_equals(std::size_t(-1), ::olm_account_sign(
+    account, message, message_size, signature, signature_size
+));
+
+std::size_t id_keys_size = ::olm_account_identity_keys_length(account);
+std::uint8_t * id_keys = (std::uint8_t *) check_malloc(id_keys_size);
+assert_not_equals(std::size_t(-1), ::olm_account_identity_keys(
+    account, id_keys, id_keys_size
+));
+
+void * utility_buffer = check_malloc(::olm_utility_size());
+::OlmUtility * utility = ::olm_utility(utility_buffer);
+
+assert_not_equals(std::size_t(-1), ::olm_ed25519_verify(
+    utility, id_keys + 71, 43, message, message_size, signature, signature_size
+));
+
+}
+
+}

data/ext/ruby_olm/ext_lib_olm/olm/tests/test_olm_using_malloc.cpp

@@ -0,0 +1,210 @@
+#include "olm/olm.h"
+#include "unittest.hh"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+struct MockRandom {
+    MockRandom(std::uint8_t tag, std::uint8_t offset = 0)
+        : tag(tag), current(offset) {}
+    void operator()(
+        void * buf, std::size_t length
+    ) {
+        std::uint8_t * bytes = (std::uint8_t *) buf;
+        while (length > 32) {
+            bytes[0] = tag;
+            std::memset(bytes + 1, current, 31);
+            length -= 32;
+            bytes += 32;
+            current += 1;
+        }
+        if (length) {
+            bytes[0] = tag;
+            std::memset(bytes + 1, current, length - 1);
+            current += 1;
+        }
+    }
+    std::uint8_t tag;
+    std::uint8_t current;
+};
+
+std::uint8_t * check_malloc(std::size_t size) {
+    if (size == std::size_t(-1)) {
+        assert_not_equals(std::size_t(-1), size);
+    }
+    return (std::uint8_t *)::malloc(size);
+}
+
+int main() {
+
+{ /** More messages test */
+
+TestCase test_case("More messages test");
+MockRandom mock_random_a('A', 0x00);
+MockRandom mock_random_b('B', 0x80);
+
+void * a_account_buffer = check_malloc(::olm_account_size());
+::OlmAccount *a_account = ::olm_account(a_account_buffer);
+
+std::size_t a_random_size = ::olm_create_account_random_length(a_account);
+void * a_random = check_malloc(a_random_size);
+mock_random_a(a_random, a_random_size);
+::olm_create_account(a_account, a_random, a_random_size);
+free(a_random);
+
+void * b_account_buffer = check_malloc(::olm_account_size());
+::OlmAccount *b_account = ::olm_account(b_account_buffer);
+
+std::size_t b_random_size = ::olm_create_account_random_length(b_account);
+void * b_random = check_malloc(b_random_size);
+mock_random_b(b_random, b_random_size);
+::olm_create_account(b_account, b_random, b_random_size);
+free(b_random);
+
+std::size_t o_random_size = ::olm_account_generate_one_time_keys_random_length(
+    b_account, 42
+);
+void * o_random = check_malloc(o_random_size);
+mock_random_b(o_random, o_random_size);
+::olm_account_generate_one_time_keys(b_account, 42, o_random, o_random_size);
+free(o_random);
+
+
+std::size_t b_id_keys_size = ::olm_account_identity_keys_length(b_account);
+std::size_t b_ot_keys_size = ::olm_account_one_time_keys_length(b_account);
+std::uint8_t * b_id_keys = (std::uint8_t *) check_malloc(b_id_keys_size);
+std::uint8_t * b_ot_keys = (std::uint8_t *) check_malloc(b_ot_keys_size);
+::olm_account_identity_keys(b_account, b_id_keys, b_id_keys_size);
+::olm_account_one_time_keys(b_account, b_ot_keys, b_ot_keys_size);
+
+void * a_session_buffer = check_malloc(::olm_session_size());
+::OlmSession *a_session = ::olm_session(a_session_buffer);
+
+std::size_t a_rand_size = ::olm_create_outbound_session_random_length(a_session);
+void * a_rand = check_malloc(a_rand_size);
+mock_random_a(a_rand, a_rand_size);
+assert_not_equals(std::size_t(-1), ::olm_create_outbound_session(
+    a_session, a_account,
+    b_id_keys + 15, 43,
+    b_ot_keys + 25, 43,
+    a_rand, a_rand_size
+));
+free(b_id_keys);
+free(b_ot_keys);
+free(a_rand);
+
+void * plaintext = malloc(12);
+::memcpy(plaintext, "Hello, World", 12);
+
+std::size_t message_1_size = ::olm_encrypt_message_length(a_session, 12);
+void * message_1 = check_malloc(message_1_size);
+std::size_t a_message_random_size = ::olm_encrypt_random_length(a_session);
+void * a_message_random = check_malloc(a_message_random_size);
+mock_random_a(a_message_random, a_message_random_size);
+assert_equals(std::size_t(0), ::olm_encrypt_message_type(a_session));
+assert_not_equals(std::size_t(-1), ::olm_encrypt(
+    a_session,
+    plaintext, 12,
+    a_message_random, a_message_random_size,
+    message_1, message_1_size
+));
+free(a_message_random);
+
+void * tmp_message_1 = check_malloc(message_1_size);
+std::memcpy(tmp_message_1, message_1, message_1_size);
+
+void * b_session_buffer = check_malloc(olm_account_size());
+::OlmSession *b_session = ::olm_session(b_session_buffer);
+::olm_create_inbound_session(
+    b_session, b_account, tmp_message_1, message_1_size
+);
+
+std::memcpy(tmp_message_1, message_1, message_1_size);
+
+std::size_t plaintext_1_size = ::olm_decrypt_max_plaintext_length(
+    b_session, 0, tmp_message_1, message_1_size
+);
+void * plaintext_1 = check_malloc(plaintext_1_size);
+std::memcpy(tmp_message_1, message_1, message_1_size);
+assert_equals(std::size_t(12), ::olm_decrypt(
+    b_session, 0,
+    tmp_message_1, message_1_size,
+    plaintext_1, plaintext_1_size
+));
+free(tmp_message_1);
+free(plaintext_1);
+free(message_1);
+
+assert_not_equals(
+    std::size_t(-1), ::olm_remove_one_time_keys(b_account, b_session)
+);
+
+for (unsigned i = 0; i < 8; ++i) {
+    {
+    std::size_t msg_a_size = ::olm_encrypt_message_length(a_session, 12);
+    std::size_t rnd_a_size = ::olm_encrypt_random_length(a_session);
+    void * msg_a = check_malloc(msg_a_size);
+    void * rnd_a = check_malloc(rnd_a_size);
+    mock_random_a(rnd_a, rnd_a_size);
+    std::size_t type_a = ::olm_encrypt_message_type(a_session);
+    assert_not_equals(std::size_t(-1), ::olm_encrypt(
+        a_session, plaintext, 12, rnd_a, rnd_a_size, msg_a, msg_a_size
+    ));
+    free(rnd_a);
+
+    void * tmp_a = check_malloc(msg_a_size);
+    std::memcpy(tmp_a, msg_a, msg_a_size);
+    std::size_t out_a_size = ::olm_decrypt_max_plaintext_length(
+        b_session, type_a, tmp_a, msg_a_size
+    );
+    void * out_a = check_malloc(out_a_size);
+    std::memcpy(tmp_a, msg_a, msg_a_size);
+    assert_equals(std::size_t(12), ::olm_decrypt(
+        b_session, type_a, tmp_a, msg_a_size, out_a, out_a_size
+    ));
+    free(tmp_a);
+    free(msg_a);
+    free(out_a);
+    }
+    {
+    std::size_t msg_b_size = ::olm_encrypt_message_length(b_session, 12);
+    std::size_t rnd_b_size = ::olm_encrypt_random_length(b_session);
+    void * msg_b = check_malloc(msg_b_size);
+    void * rnd_b = check_malloc(rnd_b_size);
+    mock_random_b(rnd_b, rnd_b_size);
+    std::size_t type_b = ::olm_encrypt_message_type(b_session);
+    assert_not_equals(std::size_t(-1), ::olm_encrypt(
+            b_session, plaintext, 12, rnd_b, rnd_b_size, msg_b, msg_b_size
+    ));
+    free(rnd_b);
+
+    void * tmp_b = check_malloc(msg_b_size);
+    std::memcpy(tmp_b, msg_b, msg_b_size);
+    std::size_t out_b_size = ::olm_decrypt_max_plaintext_length(
+            a_session, type_b, tmp_b, msg_b_size
+    );
+    void * out_b = check_malloc(out_b_size);
+    std::memcpy(tmp_b, msg_b, msg_b_size);
+    assert_equals(std::size_t(12), ::olm_decrypt(
+            a_session, type_b, msg_b, msg_b_size, out_b, out_b_size
+    ));
+    free(tmp_b);
+    free(msg_b);
+    free(out_b);
+    }
+}
+::olm_clear_account(a_account);
+::olm_clear_account(b_account);
+::olm_clear_session(a_session);
+::olm_clear_session(b_session);
+
+free(a_account_buffer);
+free(b_account_buffer);
+free(a_session_buffer);
+free(b_session_buffer);
+free(plaintext);
+
+}
+
+}

data/ext/ruby_olm/ext_lib_olm/olm/tests/test_pk.cpp

@@ -0,0 +1,166 @@
+#include "olm/pk.h"
+#include "olm/crypto.h"
+#include "olm/olm.h"
+
+#include "unittest.hh"
+
+#include <iostream>
+
+int main() {
+
+
+{ /* Encryption Test Case 1 */
+
+TestCase test_case("Public Key Encryption/Decryption Test Case 1");
+
+std::uint8_t decryption_buffer[olm_pk_decryption_size()];
+OlmPkDecryption *decryption = olm_pk_decryption(decryption_buffer);
+
+std::uint8_t alice_private[32] = {
+    0x77, 0x07, 0x6D, 0x0A, 0x73, 0x18, 0xA5, 0x7D,
+    0x3C, 0x16, 0xC1, 0x72, 0x51, 0xB2, 0x66, 0x45,
+    0xDF, 0x4C, 0x2F, 0x87, 0xEB, 0xC0, 0x99, 0x2A,
+    0xB1, 0x77, 0xFB, 0xA5, 0x1D, 0xB9, 0x2C, 0x2A
+};
+
+const std::uint8_t *alice_public = (std::uint8_t *) "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmo";
+
+std::uint8_t bob_private[32] = {
+    0x5D, 0xAB, 0x08, 0x7E, 0x62, 0x4A, 0x8A, 0x4B,
+    0x79, 0xE1, 0x7F, 0x8B, 0x83, 0x80, 0x0E, 0xE6,
+    0x6F, 0x3B, 0xB1, 0x29, 0x26, 0x18, 0xB6, 0xFD,
+    0x1C, 0x2F, 0x8B, 0x27, 0xFF, 0x88, 0xE0, 0xEB
+};
+
+const std::uint8_t *bob_public = (std::uint8_t *) "3p7bfXt9wbTTW2HC7OQ1Nz+DQ8hbeGdNrfx+FG+IK08";
+
+std::uint8_t pubkey[::olm_pk_key_length()];
+
+olm_pk_key_from_private(
+    decryption,
+    pubkey, sizeof(pubkey),
+    alice_private, sizeof(alice_private)
+);
+
+assert_equals(alice_public, pubkey, olm_pk_key_length());
+
+uint8_t *alice_private_back_out = (uint8_t *)malloc(olm_pk_private_key_length());
+olm_pk_get_private_key(decryption, alice_private_back_out, olm_pk_private_key_length());
+assert_equals(alice_private, alice_private_back_out, olm_pk_private_key_length());
+free(alice_private_back_out);
+
+std::uint8_t encryption_buffer[olm_pk_encryption_size()];
+OlmPkEncryption *encryption = olm_pk_encryption(encryption_buffer);
+
+olm_pk_encryption_set_recipient_key(encryption, pubkey, sizeof(pubkey));
+
+const size_t plaintext_length = 14;
+const std::uint8_t *plaintext = (std::uint8_t *) "This is a test";
+
+size_t ciphertext_length = olm_pk_ciphertext_length(encryption, plaintext_length);
+std::uint8_t *ciphertext_buffer = (std::uint8_t *) malloc(ciphertext_length);
+
+std::uint8_t output_buffer[olm_pk_mac_length(encryption)];
+std::uint8_t ephemeral_key[olm_pk_key_length()];
+
+olm_pk_encrypt(
+    encryption,
+    plaintext, plaintext_length,
+    ciphertext_buffer, ciphertext_length,
+    output_buffer, sizeof(output_buffer),
+    ephemeral_key, sizeof(ephemeral_key),
+    bob_private, sizeof(bob_private)
+);
+
+assert_equals(bob_public, ephemeral_key, olm_pk_key_length());
+
+size_t max_plaintext_length = olm_pk_max_plaintext_length(decryption, ciphertext_length);
+std::uint8_t *plaintext_buffer = (std::uint8_t *) malloc(max_plaintext_length);
+
+olm_pk_decrypt(
+    decryption,
+    ephemeral_key, sizeof(ephemeral_key),
+    output_buffer, sizeof(output_buffer),
+    ciphertext_buffer, ciphertext_length,
+    plaintext_buffer, max_plaintext_length
+);
+
+assert_equals(plaintext, plaintext_buffer, plaintext_length);
+
+free(ciphertext_buffer);
+free(plaintext_buffer);
+
+}
+
+{ /* Encryption Test Case 1 */
+
+TestCase test_case("Public Key Decryption pickling");
+
+std::uint8_t decryption_buffer[olm_pk_decryption_size()];
+OlmPkDecryption *decryption = olm_pk_decryption(decryption_buffer);
+
+std::uint8_t alice_private[32] = {
+    0x77, 0x07, 0x6D, 0x0A, 0x73, 0x18, 0xA5, 0x7D,
+    0x3C, 0x16, 0xC1, 0x72, 0x51, 0xB2, 0x66, 0x45,
+    0xDF, 0x4C, 0x2F, 0x87, 0xEB, 0xC0, 0x99, 0x2A,
+    0xB1, 0x77, 0xFB, 0xA5, 0x1D, 0xB9, 0x2C, 0x2A
+};
+
+const std::uint8_t *alice_public = (std::uint8_t *) "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmoK";
+
+std::uint8_t pubkey[olm_pk_key_length()];
+
+olm_pk_key_from_private(
+    decryption,
+    pubkey, sizeof(pubkey),
+    alice_private, sizeof(alice_private)
+);
+
+const uint8_t *PICKLE_KEY=(uint8_t *)"secret_key";
+std::uint8_t pickle_buffer[olm_pickle_pk_decryption_length(decryption)];
+const uint8_t *expected_pickle = (uint8_t *) "qx37WTQrjZLz5tId/uBX9B3/okqAbV1ofl9UnHKno1eipByCpXleAAlAZoJgYnCDOQZDQWzo3luTSfkF9pU1mOILCbbouubs6TVeDyPfgGD9i86J8irHjA";
+
+olm_pickle_pk_decryption(
+    decryption,
+    PICKLE_KEY, strlen((char *)PICKLE_KEY),
+    pickle_buffer, sizeof(pickle_buffer)
+);
+assert_equals(expected_pickle, pickle_buffer, olm_pickle_pk_decryption_length(decryption));
+
+olm_clear_pk_decryption(decryption);
+
+memset(pubkey, 0, olm_pk_key_length());
+
+olm_unpickle_pk_decryption(
+    decryption,
+    PICKLE_KEY, strlen((char *)PICKLE_KEY),
+    pickle_buffer, sizeof(pickle_buffer),
+    pubkey, sizeof(pubkey)
+);
+
+assert_equals(alice_public, pubkey, olm_pk_key_length());
+
+char *ciphertext = strdup("ntk49j/KozVFtSqJXhCejg");
+const char *mac = "zpzU6BkZcNI";
+const char *ephemeral_key = "3p7bfXt9wbTTW2HC7OQ1Nz+DQ8hbeGdNrfx+FG+IK08";
+
+size_t max_plaintext_length = olm_pk_max_plaintext_length(decryption, strlen(ciphertext));
+std::uint8_t *plaintext_buffer = (std::uint8_t *) malloc(max_plaintext_length);
+
+olm_pk_decrypt(
+    decryption,
+    ephemeral_key, strlen(ephemeral_key),
+    mac, strlen(mac),
+    ciphertext, strlen(ciphertext),
+    plaintext_buffer, max_plaintext_length
+);
+
+const std::uint8_t *plaintext = (std::uint8_t *) "This is a test";
+
+assert_equals(plaintext, plaintext_buffer, strlen((const char *)plaintext));
+
+free(ciphertext);
+free(plaintext_buffer);
+
+}
+}