Merge branch 'rav/more_group_chat/1'

3 files changed, 343 insertions, 1 deletions

diff --git a/tests/test_group_session.cpp b/tests/test_group_session.cpp
new file mode 100644
index 0000000..4a82154
--- /dev/null
+++ b/tests/test_group_session.cpp
@@ -0,0 +1,151 @@
+/* Copyright 2016 OpenMarket Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "olm/inbound_group_session.h"
+#include "olm/outbound_group_session.h"
+#include "unittest.hh"
+
+
+int main() {
+
+{
+    TestCase test_case("Pickle outbound group session");
+
+    size_t size = olm_outbound_group_session_size();
+    uint8_t memory[size];
+    OlmOutboundGroupSession *session = olm_outbound_group_session(memory);
+
+    size_t pickle_length = olm_pickle_outbound_group_session_length(session);
+    uint8_t pickle1[pickle_length];
+    olm_pickle_outbound_group_session(session,
+                                      "secret_key", 10,
+                                      pickle1, pickle_length);
+    uint8_t pickle2[pickle_length];
+    memcpy(pickle2, pickle1, pickle_length);
+
+    uint8_t buffer2[size];
+    OlmOutboundGroupSession *session2 = olm_outbound_group_session(buffer2);
+    size_t res = olm_unpickle_outbound_group_session(session2,
+                                                     "secret_key", 10,
+                                                     pickle2, pickle_length);
+    assert_not_equals((size_t)-1, res);
+    assert_equals(pickle_length,
+                  olm_pickle_outbound_group_session_length(session2));
+    olm_pickle_outbound_group_session(session2,
+                                      "secret_key", 10,
+                                      pickle2, pickle_length);
+
+    assert_equals(pickle1, pickle2, pickle_length);
+}
+
+
+{
+    TestCase test_case("Pickle inbound group session");
+
+    size_t size = olm_inbound_group_session_size();
+    uint8_t memory[size];
+    OlmInboundGroupSession *session = olm_inbound_group_session(memory);
+
+    size_t pickle_length = olm_pickle_inbound_group_session_length(session);
+    uint8_t pickle1[pickle_length];
+    olm_pickle_inbound_group_session(session,
+                                     "secret_key", 10,
+                                     pickle1, pickle_length);
+    uint8_t pickle2[pickle_length];
+    memcpy(pickle2, pickle1, pickle_length);
+
+    uint8_t buffer2[size];
+    OlmInboundGroupSession *session2 = olm_inbound_group_session(buffer2);
+    size_t res = olm_unpickle_inbound_group_session(session2,
+                                                    "secret_key", 10,
+                                                    pickle2, pickle_length);
+    assert_not_equals((size_t)-1, res);
+    assert_equals(pickle_length,
+                  olm_pickle_inbound_group_session_length(session2));
+    olm_pickle_inbound_group_session(session2,
+                                      "secret_key", 10,
+                                      pickle2, pickle_length);
+
+    assert_equals(pickle1, pickle2, pickle_length);
+}
+
+
+{
+    TestCase test_case("Group message send/receive");
+
+    uint8_t random_bytes[] =
+        "0123456789ABDEF0123456789ABCDEF"
+        "0123456789ABDEF0123456789ABCDEF"
+        "0123456789ABDEF0123456789ABCDEF"
+        "0123456789ABDEF0123456789ABCDEF"
+        "0123456789ABDEF0123456789ABCDEF";
+
+
+    /* build the outbound session */
+    size_t size = olm_outbound_group_session_size();
+    uint8_t memory[size];
+    OlmOutboundGroupSession *session = olm_outbound_group_session(memory);
+
+    assert_equals((size_t)132,
+                  olm_init_outbound_group_session_random_length(session));
+
+    size_t res = olm_init_outbound_group_session(
+        session, random_bytes, sizeof(random_bytes));
+    assert_equals((size_t)0, res);
+
+    assert_equals(0U, olm_outbound_group_session_message_index(session));
+    size_t session_key_len = olm_outbound_group_session_key_length(session);
+    uint8_t session_key[session_key_len];
+    olm_outbound_group_session_key(session, session_key, session_key_len);
+
+
+    /* encode the message */
+    uint8_t plaintext[] = "Message";
+    size_t plaintext_length = sizeof(plaintext) - 1;
+
+    size_t msglen = olm_group_encrypt_message_length(
+        session, plaintext_length);
+
+    uint8_t msg[msglen];
+    res = olm_group_encrypt(session, plaintext, plaintext_length,
+                            msg, msglen);
+    assert_equals(msglen, res);
+    assert_equals(1U, olm_outbound_group_session_message_index(session));
+
+
+    /* build the inbound session */
+    size = olm_inbound_group_session_size();
+    uint8_t inbound_session_memory[size];
+    OlmInboundGroupSession *inbound_session =
+        olm_inbound_group_session(inbound_session_memory);
+
+    res = olm_init_inbound_group_session(
+        inbound_session, 0U, session_key, session_key_len);
+    assert_equals((size_t)0, res);
+
+    /* decode the message */
+
+    /* olm_group_decrypt_max_plaintext_length destroys the input so we have to
+       copy it. */
+    uint8_t msgcopy[msglen];
+    memcpy(msgcopy, msg, msglen);
+    size = olm_group_decrypt_max_plaintext_length(inbound_session, msgcopy, msglen);
+    uint8_t plaintext_buf[size];
+    res = olm_group_decrypt(inbound_session, msg, msglen,
+                            plaintext_buf, size);
+    assert_equals(plaintext_length, res);
+    assert_equals(plaintext, plaintext_buf, res);
+}
+
+}
diff --git a/tests/test_megolm.cpp b/tests/test_megolm.cpp
new file mode 100644
index 0000000..3048fa3
--- /dev/null
+++ b/tests/test_megolm.cpp
@@ -0,0 +1,134 @@
+/* Copyright 2016 OpenMarket Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "olm/megolm.h"
+#include "olm/memory.hh"
+
+#include "unittest.hh"
+
+
+int main() {
+
+std::uint8_t random_bytes[] =
+    "0123456789ABCDEF0123456789ABCDEF"
+    "0123456789ABCDEF0123456789ABCDEF"
+    "0123456789ABCDEF0123456789ABCDEF"
+    "0123456789ABCDEF0123456789ABCDEF";
+
+{
+    TestCase test_case("Megolm::advance");
+
+    Megolm mr;
+
+    megolm_init(&mr, random_bytes, 0);
+    // single-step advance
+    megolm_advance(&mr);
+    const std::uint8_t expected1[] = {
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+        0xba, 0x9c, 0xd9, 0x55, 0x74, 0x1d, 0x1c, 0x16, 0x23, 0x23, 0xec, 0x82, 0x5e, 0x7c, 0x5c, 0xe8,
+        0x89, 0xbb, 0xb4, 0x23, 0xa1, 0x8f, 0x23, 0x82, 0x8f, 0xb2, 0x09, 0x0d, 0x6e, 0x2a, 0xf8, 0x6a
+    };
+    assert_equals(1U, mr.counter);
+    assert_equals(expected1, megolm_get_data(&mr), MEGOLM_RATCHET_LENGTH);
+
+    // repeat with complex advance
+    megolm_init(&mr, random_bytes, 0);
+    megolm_advance_to(&mr, 1);
+    assert_equals(1U, mr.counter);
+    assert_equals(expected1, megolm_get_data(&mr), MEGOLM_RATCHET_LENGTH);
+
+    megolm_advance_to(&mr, 0x1000000);
+    const std::uint8_t expected2[] = {
+        0x54, 0x02, 0x2d, 0x7d, 0xc0, 0x29, 0x8e, 0x16, 0x37, 0xe2, 0x1c, 0x97, 0x15, 0x30, 0x92, 0xf9,
+        0x33, 0xc0, 0x56, 0xff, 0x74, 0xfe, 0x1b, 0x92, 0x2d, 0x97, 0x1f, 0x24, 0x82, 0xc2, 0x85, 0x9c,
+        0x70, 0x04, 0xc0, 0x1e, 0xe4, 0x9b, 0xd6, 0xef, 0xe0, 0x07, 0x35, 0x25, 0xaf, 0x9b, 0x16, 0x32,
+        0xc5, 0xbe, 0x72, 0x6d, 0x12, 0x34, 0x9c, 0xc5, 0xbd, 0x47, 0x2b, 0xdc, 0x2d, 0xf6, 0x54, 0x0f,
+        0x31, 0x12, 0x59, 0x11, 0x94, 0xfd, 0xa6, 0x17, 0xe5, 0x68, 0xc6, 0x83, 0x10, 0x1e, 0xae, 0xcd,
+        0x7e, 0xdd, 0xd6, 0xde, 0x1f, 0xbc, 0x07, 0x67, 0xae, 0x34, 0xda, 0x1a, 0x09, 0xa5, 0x4e, 0xab,
+        0xba, 0x9c, 0xd9, 0x55, 0x74, 0x1d, 0x1c, 0x16, 0x23, 0x23, 0xec, 0x82, 0x5e, 0x7c, 0x5c, 0xe8,
+        0x89, 0xbb, 0xb4, 0x23, 0xa1, 0x8f, 0x23, 0x82, 0x8f, 0xb2, 0x09, 0x0d, 0x6e, 0x2a, 0xf8, 0x6a,
+    };
+    assert_equals(0x1000000U, mr.counter);
+    assert_equals(expected2, megolm_get_data(&mr), MEGOLM_RATCHET_LENGTH);
+
+    megolm_advance_to(&mr, 0x1041506);
+    const std::uint8_t expected3[] = {
+        0x54, 0x02, 0x2d, 0x7d, 0xc0, 0x29, 0x8e, 0x16, 0x37, 0xe2, 0x1c, 0x97, 0x15, 0x30, 0x92, 0xf9,
+        0x33, 0xc0, 0x56, 0xff, 0x74, 0xfe, 0x1b, 0x92, 0x2d, 0x97, 0x1f, 0x24, 0x82, 0xc2, 0x85, 0x9c,
+        0x55, 0x58, 0x8d, 0xf5, 0xb7, 0xa4, 0x88, 0x78, 0x42, 0x89, 0x27, 0x86, 0x81, 0x64, 0x58, 0x9f,
+        0x36, 0x63, 0x44, 0x7b, 0x51, 0xed, 0xc3, 0x59, 0x5b, 0x03, 0x6c, 0xa6, 0x04, 0xc4, 0x6d, 0xcd,
+        0x5c, 0x54, 0x85, 0x0b, 0xfa, 0x98, 0xa1, 0xfd, 0x79, 0xa9, 0xdf, 0x1c, 0xbe, 0x8f, 0xc5, 0x68,
+        0x19, 0x37, 0xd3, 0x0c, 0x85, 0xc8, 0xc3, 0x1f, 0x7b, 0xb8, 0x28, 0x81, 0x6c, 0xf9, 0xff, 0x3b,
+        0x95, 0x6c, 0xbf, 0x80, 0x7e, 0x65, 0x12, 0x6a, 0x49, 0x55, 0x8d, 0x45, 0xc8, 0x4a, 0x2e, 0x4c,
+        0xd5, 0x6f, 0x03, 0xe2, 0x44, 0x16, 0xb9, 0x8e, 0x1c, 0xfd, 0x97, 0xc2, 0x06, 0xaa, 0x90, 0x7a
+    };
+    assert_equals(0x1041506U, mr.counter);
+    assert_equals(expected3, megolm_get_data(&mr), MEGOLM_RATCHET_LENGTH);
+}
+
+{
+    TestCase test_case("Megolm::advance wraparound");
+
+    Megolm mr1, mr2;
+
+    megolm_init(&mr1, random_bytes, 0xffffffffUL);
+    megolm_advance_to(&mr1, 0x1000000);
+    assert_equals(0x1000000U, mr1.counter);
+
+    megolm_init(&mr2, random_bytes, 0);
+    megolm_advance_to(&mr2, 0x2000000);
+    assert_equals(0x2000000U, mr2.counter);
+
+    assert_equals(megolm_get_data(&mr2), megolm_get_data(&mr1), MEGOLM_RATCHET_LENGTH);
+}
+
+{
+    TestCase test_case("Megolm::advance overflow by one");
+
+    Megolm mr1, mr2;
+
+    megolm_init(&mr1, random_bytes, 0xffffffffUL);
+    megolm_advance_to(&mr1, 0x0);
+    assert_equals(0x0U, mr1.counter);
+
+    megolm_init(&mr2, random_bytes, 0xffffffffUL);
+    megolm_advance(&mr2);
+    assert_equals(0x0U, mr2.counter);
+
+    assert_equals(megolm_get_data(&mr2), megolm_get_data(&mr1), MEGOLM_RATCHET_LENGTH);
+}
+
+{
+    TestCase test_case("Megolm::advance overflow");
+
+    Megolm mr1, mr2;
+
+    megolm_init(&mr1, random_bytes, 0x1UL);
+    megolm_advance_to(&mr1, 0x80000000UL);
+    megolm_advance_to(&mr1, 0x0);
+    assert_equals(0x0U, mr1.counter);
+
+    megolm_init(&mr2, random_bytes, 0x1UL);
+    megolm_advance_to(&mr2, 0x0UL);
+    assert_equals(0x0U, mr2.counter);
+
+    assert_equals(megolm_get_data(&mr2), megolm_get_data(&mr1), MEGOLM_RATCHET_LENGTH);
+}
+
+}
diff --git a/tests/test_message.cpp b/tests/test_message.cpp
index ff14649..30c10a0 100644
--- a/tests/test_message.cpp
+++ b/tests/test_message.cpp
@@ -1,4 +1,4 @@
-/* Copyright 2015 OpenMarket Ltd
+/* Copyright 2015-2016 OpenMarket Ltd
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -62,4 +62,61 @@ assert_equals(message2, output, 35);
 
 } /* Message encode test */
 
+
+{ /* group message encode test */
+
+    TestCase test_case("Group message encode test");
+
+    const uint8_t session_id[] = "sessionid";
+    size_t session_id_len = 9;
+
+    size_t length = _olm_encode_group_message_length(
+        session_id_len, 200, 10, 8);
+    size_t expected_length = 1 + (2+session_id_len) + (1+2) + (2+10) + 8;
+    assert_equals(expected_length, length);
+
+    uint8_t output[50];
+    uint8_t *ciphertext_ptr;
+
+    _olm_encode_group_message(
+        3,
+        session_id, session_id_len,
+        200, // counter
+        10,  // ciphertext length
+        output,
+        &ciphertext_ptr
+    );
+
+    uint8_t expected[] =
+        "\x03"
+        "\x0A\x09sessionid"
+        "\x10\xC8\x01"
+        "\x1A\x0A";
+
+    assert_equals(expected, output, sizeof(expected)-1);
+    assert_equals(output+sizeof(expected)-1, ciphertext_ptr);
+} /* group message encode test */
+
+{
+    TestCase test_case("Group message decode test");
+
+    struct _OlmDecodeGroupMessageResults results;
+    std::uint8_t message[] =
+        "\x03"
+        "\x0A\x09sessionid"
+        "\x10\xC8\x01"
+        "\x1A\x0A" "ciphertext"
+        "hmacsha2";
+
+    const uint8_t expected_session_id[] = "sessionid";
+
+    _olm_decode_group_message(message, sizeof(message)-1, 8, &results);
+    assert_equals(std::uint8_t(3), results.version);
+    assert_equals(std::size_t(9), results.session_id_length);
+    assert_equals(expected_session_id, results.session_id, 9);
+    assert_equals(1, results.has_message_index);
+    assert_equals(std::uint32_t(200), results.message_index);
+    assert_equals(std::size_t(10), results.ciphertext_length);
+    assert_equals(ciphertext, results.ciphertext, 10);
+} /* group message decode test */
 }