diff options
author | Hubert Chathi <hubert@uhoreg.ca> | 2019-04-22 10:12:42 -0400 |
---|---|---|
committer | Hubert Chathi <hubert@uhoreg.ca> | 2019-04-22 10:12:42 -0400 |
commit | ea13edcae00cc4ab1805e85322e73b7aa2faba7a (patch) | |
tree | 1960e726574ebcb8ce52230c0cc86ecce4833f91 | |
parent | 157c0fa67e1ccdaac5a66983004dab8e978f2b4f (diff) |
don't use variable length or zero-length arrays in test files
as some compilers don't handle that
-rw-r--r-- | tests/test_base64.cpp | 8 | ||||
-rw-r--r-- | tests/test_crypto.cpp | 14 | ||||
-rw-r--r-- | tests/test_group_session.cpp | 152 | ||||
-rw-r--r-- | tests/test_message.cpp | 2 | ||||
-rw-r--r-- | tests/test_olm.cpp | 366 | ||||
-rw-r--r-- | tests/test_olm_decrypt.cpp | 16 | ||||
-rw-r--r-- | tests/test_olm_sha256.cpp | 6 | ||||
-rw-r--r-- | tests/test_pk.cpp | 65 | ||||
-rw-r--r-- | tests/test_ratchet.cpp | 73 |
9 files changed, 353 insertions, 349 deletions
diff --git a/tests/test_base64.cpp b/tests/test_base64.cpp index c95e3c9..6f80acf 100644 --- a/tests/test_base64.cpp +++ b/tests/test_base64.cpp @@ -14,7 +14,7 @@ std::size_t input_length = sizeof(input) - 1; std::size_t output_length = olm::encode_base64_length(input_length); assert_equals(std::size_t(15), output_length); -std::uint8_t output[output_length]; +std::uint8_t output[15]; olm::encode_base64(input, input_length, output); assert_equals(expected_output, output, output_length); } @@ -29,7 +29,7 @@ std::size_t input_length = sizeof(input) - 1; std::size_t output_length = ::_olm_encode_base64_length(input_length); assert_equals(std::size_t(15), output_length); -std::uint8_t output[output_length]; +std::uint8_t output[15]; output_length = ::_olm_encode_base64(input, input_length, output); assert_equals(std::size_t(15), output_length); assert_equals(expected_output, output, output_length); @@ -45,7 +45,7 @@ std::size_t input_length = sizeof(input) - 1; std::size_t output_length = olm::decode_base64_length(input_length); assert_equals(std::size_t(11), output_length); -std::uint8_t output[output_length]; +std::uint8_t output[11]; olm::decode_base64(input, input_length, output); assert_equals(expected_output, output, output_length); } @@ -60,7 +60,7 @@ std::size_t input_length = sizeof(input) - 1; std::size_t output_length = ::_olm_decode_base64_length(input_length); assert_equals(std::size_t(11), output_length); -std::uint8_t output[output_length]; +std::uint8_t output[11]; output_length = ::_olm_decode_base64(input, input_length, output); assert_equals(std::size_t(11), output_length); assert_equals(expected_output, output, output_length); diff --git a/tests/test_crypto.cpp b/tests/test_crypto.cpp index 7dad892..5da742c 100644 --- a/tests/test_crypto.cpp +++ b/tests/test_crypto.cpp @@ -146,7 +146,10 @@ assert_equals(input, actual, length); TestCase test_case("SHA 256 Test Case 1"); -std::uint8_t input[0] = {}; +// we want to take the hash of the empty string, but MSVC doesn't like +// allocating 0 bytes, so allocate one item, but pass a length of zero to +// sha256 +std::uint8_t input[1] = {0}; std::uint8_t expected[32] = { 0xE3, 0xB0, 0xC4, 0x42, 0x98, 0xFC, 0x1C, 0x14, @@ -157,7 +160,7 @@ std::uint8_t expected[32] = { std::uint8_t actual[32]; -_olm_crypto_sha256(input, sizeof(input), actual); +_olm_crypto_sha256(input, 0, actual); assert_equals(expected, actual, 32); @@ -167,7 +170,10 @@ assert_equals(expected, actual, 32); TestCase test_case("HMAC Test Case 1"); -std::uint8_t input[0] = {}; +// we want to take the hash of the empty string, but MSVC doesn't like +// allocating 0 bytes, so allocate one item, but pass a length of zero to +// hmac_sha256 +std::uint8_t input[1] = {0}; std::uint8_t expected[32] = { 0xb6, 0x13, 0x67, 0x9a, 0x08, 0x14, 0xd9, 0xec, @@ -178,7 +184,7 @@ std::uint8_t expected[32] = { std::uint8_t actual[32]; -_olm_crypto_hmac_sha256(input, sizeof(input), input, sizeof(input), actual); +_olm_crypto_hmac_sha256(input, 0, input, 0, actual); assert_equals(expected, actual, 32); diff --git a/tests/test_group_session.cpp b/tests/test_group_session.cpp index 63241d5..19b7761 100644 --- a/tests/test_group_session.cpp +++ b/tests/test_group_session.cpp @@ -16,6 +16,7 @@ #include "olm/outbound_group_session.h" #include "unittest.hh" +#include <vector> int main() { @@ -23,33 +24,32 @@ 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); + std::vector<uint8_t> memory(size); + OlmOutboundGroupSession *session = olm_outbound_group_session(memory.data()); size_t pickle_length = olm_pickle_outbound_group_session_length(session); - uint8_t pickle1[pickle_length]; + std::vector<uint8_t> pickle1(pickle_length); size_t res = olm_pickle_outbound_group_session( - session, "secret_key", 10, pickle1, pickle_length + session, "secret_key", 10, pickle1.data(), pickle_length ); assert_equals(pickle_length, res); - uint8_t pickle2[pickle_length]; - memcpy(pickle2, pickle1, pickle_length); + std::vector<uint8_t> pickle2(pickle1); - uint8_t buffer2[size]; - OlmOutboundGroupSession *session2 = olm_outbound_group_session(buffer2); + std::vector<uint8_t> buffer2(size); + OlmOutboundGroupSession *session2 = olm_outbound_group_session(buffer2.data()); res = olm_unpickle_outbound_group_session( - session2, "secret_key", 10, pickle2, pickle_length + session2, "secret_key", 10, pickle2.data(), pickle_length ); assert_not_equals((size_t)-1, res); assert_equals(pickle_length, olm_pickle_outbound_group_session_length(session2)); res = olm_pickle_outbound_group_session( - session2, "secret_key", 10, pickle2, pickle_length + session2, "secret_key", 10, pickle2.data(), pickle_length ); assert_equals(pickle_length, res); - assert_equals(pickle1, pickle2, pickle_length); + assert_equals(pickle1.data(), pickle2.data(), pickle_length); } @@ -57,32 +57,31 @@ int main() { 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); + std::vector<uint8_t> memory(size); + OlmInboundGroupSession *session = olm_inbound_group_session(memory.data()); size_t pickle_length = olm_pickle_inbound_group_session_length(session); - uint8_t pickle1[pickle_length]; + std::vector<uint8_t> pickle1(pickle_length); size_t res = olm_pickle_inbound_group_session( - session, "secret_key", 10, pickle1, pickle_length + session, "secret_key", 10, pickle1.data(), pickle_length ); assert_equals(pickle_length, res); - uint8_t pickle2[pickle_length]; - memcpy(pickle2, pickle1, pickle_length); + std::vector<uint8_t> pickle2(pickle1); - uint8_t buffer2[size]; - OlmInboundGroupSession *session2 = olm_inbound_group_session(buffer2); + std::vector<uint8_t> buffer2(size); + OlmInboundGroupSession *session2 = olm_inbound_group_session(buffer2.data()); res = olm_unpickle_inbound_group_session( - session2, "secret_key", 10, pickle2, pickle_length + session2, "secret_key", 10, pickle2.data(), pickle_length ); assert_not_equals((size_t)-1, res); assert_equals(pickle_length, olm_pickle_inbound_group_session_length(session2)); res = olm_pickle_inbound_group_session( - session2, "secret_key", 10, pickle2, pickle_length + session2, "secret_key", 10, pickle2.data(), pickle_length ); - assert_equals(pickle1, pickle2, pickle_length); + assert_equals(pickle1.data(), pickle2.data(), pickle_length); } { @@ -99,8 +98,8 @@ int main() { /* build the outbound session */ size_t size = olm_outbound_group_session_size(); - uint8_t memory[size]; - OlmOutboundGroupSession *session = olm_outbound_group_session(memory); + std::vector<uint8_t> memory(size); + OlmOutboundGroupSession *session = olm_outbound_group_session(memory.data()); assert_equals((size_t)160, olm_init_outbound_group_session_random_length(session)); @@ -111,8 +110,8 @@ int main() { 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); + std::vector<uint8_t> session_key(session_key_len); + olm_outbound_group_session_key(session, session_key.data(), session_key_len); /* encode the message */ uint8_t plaintext[] = "Message"; @@ -121,57 +120,56 @@ int main() { size_t msglen = olm_group_encrypt_message_length( session, plaintext_length); - uint8_t msg[msglen]; + std::vector<uint8_t> msg(msglen); res = olm_group_encrypt(session, plaintext, plaintext_length, - msg, msglen); + msg.data(), 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]; + std::vector<uint8_t> inbound_session_memory(size); OlmInboundGroupSession *inbound_session = - olm_inbound_group_session(inbound_session_memory); + olm_inbound_group_session(inbound_session_memory.data()); assert_equals(0, olm_inbound_group_session_is_verified(inbound_session)); res = olm_init_inbound_group_session( - inbound_session, session_key, session_key_len); + inbound_session, session_key.data(), session_key_len); assert_equals((size_t)0, res); assert_equals(1, olm_inbound_group_session_is_verified(inbound_session)); /* Check the session ids */ size_t out_session_id_len = olm_outbound_group_session_id_length(session); - uint8_t out_session_id[out_session_id_len]; + std::vector<uint8_t> out_session_id(out_session_id_len); assert_equals(out_session_id_len, olm_outbound_group_session_id( - session, out_session_id, out_session_id_len + session, out_session_id.data(), out_session_id_len )); size_t in_session_id_len = olm_inbound_group_session_id_length( inbound_session ); - uint8_t in_session_id[in_session_id_len]; + std::vector<uint8_t> in_session_id(in_session_id_len); assert_equals(in_session_id_len, olm_inbound_group_session_id( - inbound_session, in_session_id, in_session_id_len + inbound_session, in_session_id.data(), in_session_id_len )); assert_equals(in_session_id_len, out_session_id_len); - assert_equals(out_session_id, in_session_id, in_session_id_len); + assert_equals(out_session_id.data(), in_session_id.data(), in_session_id_len); /* 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]; + std::vector<uint8_t> msgcopy(msg); + size = olm_group_decrypt_max_plaintext_length(inbound_session, msgcopy.data(), msglen); + std::vector<uint8_t> plaintext_buf(size); uint32_t message_index; - res = olm_group_decrypt(inbound_session, msg, msglen, - plaintext_buf, size, &message_index); + res = olm_group_decrypt(inbound_session, msg.data(), msglen, + plaintext_buf.data(), size, &message_index); assert_equals(plaintext_length, res); - assert_equals(plaintext, plaintext_buf, res); + assert_equals(plaintext, plaintext_buf.data(), res); assert_equals(message_index, uint32_t(0)); } @@ -192,9 +190,9 @@ int main() { /* init first inbound group session, and decrypt */ std::size_t size = olm_inbound_group_session_size(); - uint8_t session_memory1[size]; + std::vector<uint8_t> session_memory1(size); OlmInboundGroupSession *session1 = - olm_inbound_group_session(session_memory1); + olm_inbound_group_session(session_memory1.data()); assert_equals(0, olm_inbound_group_session_is_verified(session1)); std::size_t res = olm_init_inbound_group_session( @@ -205,24 +203,24 @@ int main() { /* olm_group_decrypt_max_plaintext_length destroys the input so we have to copy it. */ - uint8_t msgcopy[msglen]; - memcpy(msgcopy, message, msglen); - size = olm_group_decrypt_max_plaintext_length(session1, msgcopy, msglen); - uint8_t plaintext_buf[size]; + std::vector<uint8_t> msgcopy(msglen); + memcpy(msgcopy.data(), message, msglen); + size = olm_group_decrypt_max_plaintext_length(session1, msgcopy.data(), msglen); + std::vector<uint8_t> plaintext_buf(size); uint32_t message_index; - memcpy(msgcopy, message, msglen); + memcpy(msgcopy.data(), message, msglen); res = olm_group_decrypt( - session1, msgcopy, msglen, plaintext_buf, size, &message_index + session1, msgcopy.data(), msglen, plaintext_buf.data(), size, &message_index ); assert_equals((std::size_t)7, res); - assert_equals((const uint8_t *)"Message", plaintext_buf, res); + assert_equals((const uint8_t *)"Message", plaintext_buf.data(), res); assert_equals(uint32_t(0), message_index); /* export the keys */ size = olm_export_inbound_group_session_length(session1); - uint8_t export_memory[size]; + std::vector<uint8_t> export_memory(size); res = olm_export_inbound_group_session( - session1, export_memory, size, 0 + session1, export_memory.data(), size, 0 ); assert_equals(size, res); @@ -231,25 +229,25 @@ int main() { /* import the keys into another inbound group session */ size = olm_inbound_group_session_size(); - uint8_t session_memory2[size]; + std::vector<uint8_t> session_memory2(size); OlmInboundGroupSession *session2 = - olm_inbound_group_session(session_memory2); + olm_inbound_group_session(session_memory2.data()); res = olm_import_inbound_group_session( - session2, export_memory, sizeof(export_memory) + session2, export_memory.data(), export_memory.size() ); assert_equals((size_t)0, res); assert_equals(0, olm_inbound_group_session_is_verified(session2)); /* decrypt the message with the new session */ - memcpy(msgcopy, message, msglen); - size = olm_group_decrypt_max_plaintext_length(session2, msgcopy, msglen); - uint8_t plaintext_buf2[size]; - memcpy(msgcopy, message, msglen); + memcpy(msgcopy.data(), message, msglen); + size = olm_group_decrypt_max_plaintext_length(session2, msgcopy.data(), msglen); + std::vector<uint8_t> plaintext_buf2(size); + memcpy(msgcopy.data(), message, msglen); res = olm_group_decrypt( - session2, msgcopy, msglen, plaintext_buf2, size, &message_index + session2, msgcopy.data(), msglen, plaintext_buf2.data(), size, &message_index ); assert_equals((std::size_t)7, res); - assert_equals((const uint8_t *)"Message", plaintext_buf2, res); + assert_equals((const uint8_t *)"Message", plaintext_buf2.data(), res); assert_equals(uint32_t(0), message_index); assert_equals(1, olm_inbound_group_session_is_verified(session2)); } @@ -274,9 +272,9 @@ int main() { /* build the inbound session */ size_t size = olm_inbound_group_session_size(); - uint8_t inbound_session_memory[size]; + std::vector<uint8_t> inbound_session_memory(size); OlmInboundGroupSession *inbound_session = - olm_inbound_group_session(inbound_session_memory); + olm_inbound_group_session(inbound_session_memory.data()); size_t res = olm_init_inbound_group_session( inbound_session, session_key, sizeof(session_key)-1 @@ -287,36 +285,36 @@ int main() { /* olm_group_decrypt_max_plaintext_length destroys the input so we have to copy it. */ - uint8_t msgcopy[msglen]; - memcpy(msgcopy, message, msglen); + std::vector<uint8_t> msgcopy(msglen); + memcpy(msgcopy.data(), message, msglen); size = olm_group_decrypt_max_plaintext_length( - inbound_session, msgcopy, msglen + inbound_session, msgcopy.data(), msglen ); - memcpy(msgcopy, message, msglen); - uint8_t plaintext_buf[size]; + memcpy(msgcopy.data(), message, msglen); + std::vector<uint8_t> plaintext_buf(size); uint32_t message_index; res = olm_group_decrypt( - inbound_session, msgcopy, msglen, plaintext_buf, size, &message_index + inbound_session, msgcopy.data(), msglen, plaintext_buf.data(), size, &message_index ); assert_equals(message_index, uint32_t(0)); assert_equals(plaintext_length, res); - assert_equals(plaintext, plaintext_buf, res); + assert_equals(plaintext, plaintext_buf.data(), res); /* now twiddle the signature */ message[msglen-1] = 'E'; - memcpy(msgcopy, message, msglen); + memcpy(msgcopy.data(), message, msglen); assert_equals( size, olm_group_decrypt_max_plaintext_length( - inbound_session, msgcopy, msglen + inbound_session, msgcopy.data(), msglen ) ); - memcpy(msgcopy, message, msglen); + memcpy(msgcopy.data(), message, msglen); res = olm_group_decrypt( - inbound_session, msgcopy, msglen, - plaintext_buf, size, &message_index + inbound_session, msgcopy.data(), msglen, + plaintext_buf.data(), size, &message_index ); assert_equals((size_t)-1, res); assert_equals( diff --git a/tests/test_message.cpp b/tests/test_message.cpp index 25693f5..fa2d0cc 100644 --- a/tests/test_message.cpp +++ b/tests/test_message.cpp @@ -49,7 +49,7 @@ TestCase test_case("Message encode test"); std::size_t length = olm::encode_message_length(1, 10, 10, 8); assert_equals(std::size_t(35), length); -std::uint8_t output[length]; +std::uint8_t output[35]; olm::MessageWriter writer; olm::encode_message(writer, 3, 1, 10, 10, output); diff --git a/tests/test_olm.cpp b/tests/test_olm.cpp index b24cd90..ab7d816 100644 --- a/tests/test_olm.cpp +++ b/tests/test_olm.cpp @@ -4,6 +4,7 @@ #include <cstddef> #include <cstdint> #include <cstring> +#include <vector> struct MockRandom { MockRandom(std::uint8_t tag, std::uint8_t offset = 0) @@ -36,35 +37,34 @@ TestCase test_case("Pickle account test"); MockRandom mock_random('P'); -std::uint8_t account_buffer[::olm_account_size()]; -::OlmAccount *account = ::olm_account(account_buffer); -std::uint8_t random[::olm_create_account_random_length(account)]; -mock_random(random, sizeof(random)); -::olm_create_account(account, random, sizeof(random)); -std::uint8_t ot_random[::olm_account_generate_one_time_keys_random_length( +std::vector<std::uint8_t> account_buffer(::olm_account_size()); +::OlmAccount *account = ::olm_account(account_buffer.data()); +std::vector<std::uint8_t> random(::olm_create_account_random_length(account)); +mock_random(random.data(), random.size()); +::olm_create_account(account, random.data(), random.size()); +std::vector<std::uint8_t> ot_random(::olm_account_generate_one_time_keys_random_length( account, 42 -)]; -mock_random(ot_random, sizeof(ot_random)); -::olm_account_generate_one_time_keys(account, 42, ot_random, sizeof(ot_random)); + )); +mock_random(ot_random.data(), ot_random.size()); +::olm_account_generate_one_time_keys(account, 42, ot_random.data(), ot_random.size()); std::size_t pickle_length = ::olm_pickle_account_length(account); -std::uint8_t pickle1[pickle_length]; -std::size_t res = ::olm_pickle_account(account, "secret_key", 10, pickle1, pickle_length); +std::vector<std::uint8_t> pickle1(pickle_length); +std::size_t res = ::olm_pickle_account(account, "secret_key", 10, pickle1.data(), pickle_length); assert_equals(pickle_length, res); -std::uint8_t pickle2[pickle_length]; -std::memcpy(pickle2, pickle1, pickle_length); +std::vector<std::uint8_t> pickle2(pickle1); -std::uint8_t account_buffer2[::olm_account_size()]; -::OlmAccount *account2 = ::olm_account(account_buffer2); +std::vector<std::uint8_t> account_buffer2(::olm_account_size()); +::OlmAccount *account2 = ::olm_account(account_buffer2.data()); assert_not_equals(std::size_t(-1), ::olm_unpickle_account( - account2, "secret_key", 10, pickle2, pickle_length + account2, "secret_key", 10, pickle2.data(), pickle_length )); assert_equals(pickle_length, ::olm_pickle_account_length(account2)); -res = ::olm_pickle_account(account2, "secret_key", 10, pickle2, pickle_length); +res = ::olm_pickle_account(account2, "secret_key", 10, pickle2.data(), pickle_length); assert_equals(pickle_length, res); -assert_equals(pickle1, pickle2, pickle_length); +assert_equals(pickle1.data(), pickle2.data(), pickle_length); } @@ -79,8 +79,8 @@ assert_equals(pickle1, pickle2, pickle_length); "K/A/8TOu9iK2hDFszy6xETiousHnHgh2ZGbRUh4pQx+YMm8ZdNZeRnwFGLnrWyf9" "O5TmXua1FcU"; - std::uint8_t account_buffer[::olm_account_size()]; - ::OlmAccount *account = ::olm_account(account_buffer); + std::vector<std::uint8_t> account_buffer(::olm_account_size()); + ::OlmAccount *account = ::olm_account(account_buffer.data()); assert_equals( std::size_t(-1), ::olm_unpickle_account( @@ -99,47 +99,46 @@ assert_equals(pickle1, pickle2, pickle_length); TestCase test_case("Pickle session test"); MockRandom mock_random('P'); -std::uint8_t account_buffer[::olm_account_size()]; -::OlmAccount *account = ::olm_account(account_buffer); -std::uint8_t random[::olm_create_account_random_length(account)]; -mock_random(random, sizeof(random)); -::olm_create_account(account, random, sizeof(random)); +std::vector<std::uint8_t> account_buffer(::olm_account_size()); +::OlmAccount *account = ::olm_account(account_buffer.data()); +std::vector<std::uint8_t> random(::olm_create_account_random_length(account)); +mock_random(random.data(), random.size()); +::olm_create_account(account, random.data(), random.size()); -std::uint8_t session_buffer[::olm_session_size()]; -::OlmSession *session = ::olm_session(session_buffer); +std::vector<std::uint8_t> session_buffer(::olm_session_size()); +::OlmSession *session = ::olm_session(session_buffer.data()); std::uint8_t identity_key[32]; std::uint8_t one_time_key[32]; mock_random(identity_key, sizeof(identity_key)); mock_random(one_time_key, sizeof(one_time_key)); -std::uint8_t random2[::olm_create_outbound_session_random_length(session)]; -mock_random(random2, sizeof(random2)); +std::vector<std::uint8_t> random2(::olm_create_outbound_session_random_length(session)); +mock_random(random2.data(), random2.size()); ::olm_create_outbound_session( session, account, identity_key, sizeof(identity_key), one_time_key, sizeof(one_time_key), - random2, sizeof(random2) + random2.data(), random2.size() ); std::size_t pickle_length = ::olm_pickle_session_length(session); -std::uint8_t pickle1[pickle_length]; -std::size_t res = ::olm_pickle_session(session, "secret_key", 10, pickle1, pickle_length); +std::vector<std::uint8_t> pickle1(pickle_length); +std::size_t res = ::olm_pickle_session(session, "secret_key", 10, pickle1.data(), pickle_length); assert_equals(pickle_length, res); -std::uint8_t pickle2[pickle_length]; -std::memcpy(pickle2, pickle1, pickle_length); +std::vector<std::uint8_t> pickle2(pickle1); -std::uint8_t session_buffer2[::olm_session_size()]; -::OlmSession *session2 = ::olm_session(session_buffer2); +std::vector<std::uint8_t> session_buffer2(::olm_session_size()); +::OlmSession *session2 = ::olm_session(session_buffer2.data()); assert_not_equals(std::size_t(-1), ::olm_unpickle_session( - session2, "secret_key", 10, pickle2, pickle_length + session2, "secret_key", 10, pickle2.data(), pickle_length )); assert_equals(pickle_length, ::olm_pickle_session_length(session2)); -res = ::olm_pickle_session(session2, "secret_key", 10, pickle2, pickle_length); +res = ::olm_pickle_session(session2, "secret_key", 10, pickle2.data(), pickle_length); assert_equals(pickle_length, res); -assert_equals(pickle1, pickle2, pickle_length); +assert_equals(pickle1.data(), pickle2.data(), pickle_length); } { /** Loopback test */ @@ -148,145 +147,143 @@ TestCase test_case("Loopback test"); MockRandom mock_random_a('A', 0x00); MockRandom mock_random_b('B', 0x80); -std::uint8_t a_account_buffer[::olm_account_size()]; -::OlmAccount *a_account = ::olm_account(a_account_buffer); -std::uint8_t a_random[::olm_create_account_random_length(a_account)]; -mock_random_a(a_random, sizeof(a_random)); -::olm_create_account(a_account, a_random, sizeof(a_random)); - -std::uint8_t b_account_buffer[::olm_account_size()]; -::OlmAccount *b_account = ::olm_account(b_account_buffer); -std::uint8_t b_random[::olm_create_account_random_length(b_account)]; -mock_random_b(b_random, sizeof(b_random)); -::olm_create_account(b_account, b_random, sizeof(b_random)); -std::uint8_t o_random[::olm_account_generate_one_time_keys_random_length( +std::vector<std::uint8_t> a_account_buffer(::olm_account_size()); +::OlmAccount *a_account = ::olm_account(a_account_buffer.data()); +std::vector<std::uint8_t> a_random(::olm_create_account_random_length(a_account)); +mock_random_a(a_random.data(), a_random.size()); +::olm_create_account(a_account, a_random.data(), a_random.size()); + +std::vector<std::uint8_t> b_account_buffer(::olm_account_size()); +::OlmAccount *b_account = ::olm_account(b_account_buffer.data()); +std::vector<std::uint8_t> b_random(::olm_create_account_random_length(b_account)); +mock_random_b(b_random.data(), b_random.size()); +::olm_create_account(b_account, b_random.data(), b_random.size()); +std::vector<std::uint8_t> o_random(::olm_account_generate_one_time_keys_random_length( b_account, 42 -)]; -mock_random_b(o_random, sizeof(o_random)); -::olm_account_generate_one_time_keys(b_account, 42, o_random, sizeof(o_random)); - -std::uint8_t a_id_keys[::olm_account_identity_keys_length(a_account)]; -::olm_account_identity_keys(a_account, a_id_keys, sizeof(a_id_keys)); - -std::uint8_t b_id_keys[::olm_account_identity_keys_length(b_account)]; -std::uint8_t b_ot_keys[::olm_account_one_time_keys_length(b_account)]; -::olm_account_identity_keys(b_account, b_id_keys, sizeof(b_id_keys)); -::olm_account_one_time_keys(b_account, b_ot_keys, sizeof(b_ot_keys)); - -std::uint8_t a_session_buffer[::olm_session_size()]; -::OlmSession *a_session = ::olm_session(a_session_buffer); -std::uint8_t a_rand[::olm_create_outbound_session_random_length(a_session)]; -mock_random_a(a_rand, sizeof(a_rand)); +)); +mock_random_b(o_random.data(), o_random.size()); +::olm_account_generate_one_time_keys(b_account, 42, o_random.data(), o_random.size()); + +std::vector<std::uint8_t> a_id_keys(::olm_account_identity_keys_length(a_account)); +::olm_account_identity_keys(a_account, a_id_keys.data(), a_id_keys.size()); + +std::vector<std::uint8_t> b_id_keys(::olm_account_identity_keys_length(b_account)); +std::vector<std::uint8_t> b_ot_keys(::olm_account_one_time_keys_length(b_account)); +::olm_account_identity_keys(b_account, b_id_keys.data(), b_id_keys.size()); +::olm_account_one_time_keys(b_account, b_ot_keys.data(), b_ot_keys.size()); + +std::vector<std::uint8_t> a_session_buffer(::olm_session_size()); +::OlmSession *a_session = ::olm_session(a_session_buffer.data()); +std::vector<std::uint8_t> a_rand(::olm_create_outbound_session_random_length(a_session)); +mock_random_a(a_rand.data(), a_rand.size()); assert_not_equals(std::size_t(-1), ::olm_create_outbound_session( a_session, a_account, - b_id_keys + 15, 43, // B's curve25519 identity key - b_ot_keys + 25, 43, // B's curve25519 one time key - a_rand, sizeof(a_rand) + b_id_keys.data() + 15, 43, // B's curve25519 identity key + b_ot_keys.data() + 25, 43, // B's curve25519 one time key + a_rand.data(), a_rand.size() )); std::uint8_t plaintext[] = "Hello, World"; -std::uint8_t message_1[::olm_encrypt_message_length(a_session, 12)]; -std::uint8_t a_message_random[::olm_encrypt_random_length(a_session)]; -mock_random_a(a_message_random, sizeof(a_message_random)); +std::vector<std::uint8_t> message_1(::olm_encrypt_message_length(a_session, 12)); +std::vector<std::uint8_t> a_message_random(::olm_encrypt_random_length(a_session)); +mock_random_a(a_message_random.data(), 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, sizeof(a_message_random), - message_1, sizeof(message_1) + a_message_random.data(), a_message_random.size(), + message_1.data(), message_1.size() )); -std::uint8_t tmp_message_1[sizeof(message_1)]; -std::memcpy(tmp_message_1, message_1, sizeof(message_1)); -std::uint8_t b_session_buffer[::olm_account_size()]; -::OlmSession *b_session = ::olm_session(b_session_buffer); +std::vector<std::uint8_t> tmp_message_1(message_1); +std::vector<std::uint8_t> b_session_buffer(::olm_account_size()); +::OlmSession *b_session = ::olm_session(b_session_buffer.data()); ::olm_create_inbound_session( - b_session, b_account, tmp_message_1, sizeof(message_1) + b_session, b_account, tmp_message_1.data(), message_1.size() ); // Check that the inbound session matches the message it was created from. -std::memcpy(tmp_message_1, message_1, sizeof(message_1)); +std::memcpy(tmp_message_1.data(), message_1.data(), message_1.size()); assert_equals(std::size_t(1), ::olm_matches_inbound_session( b_session, - tmp_message_1, sizeof(message_1) + tmp_message_1.data(), message_1.size() )); // Check that the inbound session matches the key this message is supposed // to be from. -std::memcpy(tmp_message_1, message_1, sizeof(message_1)); +std::memcpy(tmp_message_1.data(), message_1.data(), message_1.size()); assert_equals(std::size_t(1), ::olm_matches_inbound_session_from( b_session, - a_id_keys + 15, 43, // A's curve125519 identity key. - tmp_message_1, sizeof(message_1) + a_id_keys.data() + 15, 43, // A's curve125519 identity key. + tmp_message_1.data(), message_1.size() )); // Check that the inbound session isn't from a different user. -std::memcpy(tmp_message_1, message_1, sizeof(message_1)); +std::memcpy(tmp_message_1.data(), message_1.data(), message_1.size()); assert_equals(std::size_t(0), ::olm_matches_inbound_session_from( b_session, - b_id_keys + 15, 43, // B's curve25519 identity key. - tmp_message_1, sizeof(message_1) + b_id_keys.data() + 15, 43, // B's curve25519 identity key. + tmp_message_1.data(), message_1.size() )); // Check that we can decrypt the message. -std::memcpy(tmp_message_1, message_1, sizeof(message_1)); -std::uint8_t plaintext_1[::olm_decrypt_max_plaintext_length( - b_session, 0, tmp_message_1, sizeof(message_1) -)]; -std::memcpy(tmp_message_1, message_1, sizeof(message_1)); +std::memcpy(tmp_message_1.data(), message_1.data(), message_1.size()); +std::vector<std::uint8_t> plaintext_1(::olm_decrypt_max_plaintext_length( + b_session, 0, tmp_message_1.data(), message_1.size() +)); +std::memcpy(tmp_message_1.data(), message_1.data(), message_1.size()); assert_equals(std::size_t(12), ::olm_decrypt( b_session, 0, - tmp_message_1, sizeof(message_1), - plaintext_1, sizeof(plaintext_1) + tmp_message_1.data(), message_1.size(), + plaintext_1.data(), plaintext_1.size() )); -assert_equals(plaintext, plaintext_1, 12); +assert_equals(plaintext, plaintext_1.data(), 12); -std::uint8_t message_2[::olm_encrypt_message_length(b_session, 12)]; -std::uint8_t b_message_random[::olm_encrypt_random_length(b_session)]; -mock_random_b(b_message_random, sizeof(b_message_random)); +std::vector<std::uint8_t> message_2(::olm_encrypt_message_length(b_session, 12)); +std::vector<std::uint8_t> b_message_random(::olm_encrypt_random_length(b_session)); +mock_random_b(b_message_random.data(), b_message_random.size()); assert_equals(std::size_t(1), ::olm_encrypt_message_type(b_session)); assert_not_equals(std::size_t(-1), ::olm_encrypt( b_session, plaintext, 12, - b_message_random, sizeof(b_message_random), - message_2, sizeof(message_2) + b_message_random.data(), b_message_random.size(), + message_2.data(), message_2.size() )); -std::uint8_t tmp_message_2[sizeof(message_2)]; -std::memcpy(tmp_message_2, message_2, sizeof(message_2)); -std::uint8_t plaintext_2[::olm_decrypt_max_plaintext_length( - a_session, 1, tmp_message_2, sizeof(message_2) -)]; -std::memcpy(tmp_message_2, message_2, sizeof(message_2)); +std::vector<std::uint8_t> tmp_message_2(message_2); +std::vector<std::uint8_t> plaintext_2(::olm_decrypt_max_plaintext_length( + a_session, 1, tmp_message_2.data(), message_2.size() +)); +std::memcpy(tmp_message_2.data(), message_2.data(), message_2.size()); assert_equals(std::size_t(12), ::olm_decrypt( a_session, 1, - tmp_message_2, sizeof(message_2), - plaintext_2, sizeof(plaintext_2) + tmp_message_2.data(), message_2.size(), + plaintext_2.data(), plaintext_2.size() )); -assert_equals(plaintext, plaintext_2, 12); +assert_equals(plaintext, plaintext_2.data(), 12); -std::memcpy(tmp_message_2, message_2, sizeof(message_2)); +std::memcpy(tmp_message_2.data(), message_2.data(), message_2.size()); assert_equals(std::size_t(-1), ::olm_decrypt( a_session, 1, - tmp_message_2, sizeof(message_2), - plaintext_2, sizeof(plaintext_2) + tmp_message_2.data(), message_2.size(), + plaintext_2.data(), plaintext_2.size() )); -std::uint8_t a_session_id[::olm_session_id_length(a_session)]; +std::vector<std::uint8_t> a_session_id(::olm_session_id_length(a_session)); assert_not_equals(std::size_t(-1), ::olm_session_id( - a_session, a_session_id, sizeof(a_session_id) + a_session, a_session_id.data(), a_session_id.size() )); -std::uint8_t b_session_id[::olm_session_id_length(b_session)]; +std::vector<std::uint8_t> b_session_id(::olm_session_id_length(b_session)); assert_not_equals(std::size_t(-1), ::olm_session_id( - b_session, b_session_id, sizeof(b_session_id) + b_session, b_session_id.data(), b_session_id.size() )); -assert_equals(sizeof(a_session_id), sizeof(b_session_id)); -assert_equals(a_session_id, b_session_id, sizeof(b_session_id)); +assert_equals(a_session_id.size(), b_session_id.size()); +assert_equals(a_session_id.data(), b_session_id.data(), b_session_id.size()); } @@ -296,107 +293,104 @@ TestCase test_case("More messages test"); MockRandom mock_random_a('A', 0x00); MockRandom mock_random_b('B', 0x80); -std::uint8_t a_account_buffer[::olm_account_size()]; -::OlmAccount *a_account = ::olm_account(a_account_buffer); -std::uint8_t a_random[::olm_create_account_random_length(a_account)]; -mock_random_a(a_random, sizeof(a_random)); -::olm_create_account(a_account, a_random, sizeof(a_random)); - -std::uint8_t b_account_buffer[::olm_account_size()]; -::OlmAccount *b_account = ::olm_account(b_account_buffer); -std::uint8_t b_random[::olm_create_account_random_length(b_account)]; -mock_random_b(b_random, sizeof(b_random)); -::olm_create_account(b_account, b_random, sizeof(b_random)); -std::uint8_t o_random[::olm_account_generate_one_time_keys_random_length( +std::vector<std::uint8_t> a_account_buffer(::olm_account_size()); +::OlmAccount *a_account = ::olm_account(a_account_buffer.data()); +std::vector<std::uint8_t> a_random(::olm_create_account_random_length(a_account)); +mock_random_a(a_random.data(), a_random.size()); +::olm_create_account(a_account, a_random.data(), a_random.size()); + +std::vector<std::uint8_t> b_account_buffer(::olm_account_size()); +::OlmAccount *b_account = ::olm_account(b_account_buffer.data()); +std::vector<std::uint8_t> b_random(::olm_create_account_random_length(b_account)); +mock_random_b(b_random.data(), b_random.size()); +::olm_create_account(b_account, b_random.data(), b_random.size()); +std::vector<std::uint8_t> o_random(::olm_account_generate_one_time_keys_random_length( b_account, 42 -)]; -mock_random_b(o_random, sizeof(o_random)); -::olm_account_generate_one_time_keys(b_account, 42, o_random, sizeof(o_random)); - -std::uint8_t b_id_keys[::olm_account_identity_keys_length(b_account)]; -std::uint8_t b_ot_keys[::olm_account_one_time_keys_length(b_account)]; -::olm_account_identity_keys(b_account, b_id_keys, sizeof(b_id_keys)); -::olm_account_one_time_keys(b_account, b_ot_keys, sizeof(b_ot_keys)); - -std::uint8_t a_session_buffer[::olm_session_size()]; -::OlmSession *a_session = ::olm_session(a_session_buffer); -std::uint8_t a_rand[::olm_create_outbound_session_random_length(a_session)]; -mock_random_a(a_rand, sizeof(a_rand)); +)); +mock_random_b(o_random.data(), o_random.size()); +::olm_account_generate_one_time_keys(b_account, 42, o_random.data(), o_random.size()); + +std::vector<std::uint8_t> b_id_keys(::olm_account_identity_keys_length(b_account)); +std::vector<std::uint8_t> b_ot_keys(::olm_account_one_time_keys_length(b_account)); +::olm_account_identity_keys(b_account, b_id_keys.data(), b_id_keys.size()); +::olm_account_one_time_keys(b_account, b_ot_keys.data(), b_ot_keys.size()); + +std::vector<std::uint8_t> a_session_buffer(::olm_session_size()); +::OlmSession *a_session = ::olm_session(a_session_buffer.data()); +std::vector<std::uint8_t> a_rand(::olm_create_outbound_session_random_length(a_session)); +mock_random_a(a_rand.data(), 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, sizeof(a_rand) + b_id_keys.data() + 15, 43, + b_ot_keys.data() + 25, 43, + a_rand.data(), a_rand.size() )); std::uint8_t plaintext[] = "Hello, World"; -std::uint8_t message_1[::olm_encrypt_message_length(a_session, 12)]; -std::uint8_t a_message_random[::olm_encrypt_random_length(a_session)]; -mock_random_a(a_message_random, sizeof(a_message_random)); +std::vector<std::uint8_t> message_1(::olm_encrypt_message_length(a_session, 12)); +std::vector<std::uint8_t> a_message_random(::olm_encrypt_random_length(a_session)); +mock_random_a(a_message_random.data(), 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, sizeof(a_message_random), - message_1, sizeof(message_1) + a_message_random.data(), a_message_random.size(), + message_1.data(), message_1.size() )); -std::uint8_t tmp_message_1[sizeof(message_1)]; -std::memcpy(tmp_message_1, message_1, sizeof(message_1)); -std::uint8_t b_session_buffer[::olm_account_size()]; -::OlmSession *b_session = ::olm_session(b_session_buffer); +std::vector<std::uint8_t> tmp_message_1(message_1); +std::vector<std::uint8_t> b_session_buffer(::olm_account_size()); +::OlmSession *b_session = ::olm_session(b_session_buffer.data()); ::olm_create_inbound_session( - b_session, b_account, tmp_message_1, sizeof(message_1) + b_session, b_account, tmp_message_1.data(), message_1.size() ); -std::memcpy(tmp_message_1, message_1, sizeof(message_1)); -std::uint8_t plaintext_1[::olm_decrypt_max_plaintext_length( - b_session, 0, tmp_message_1, sizeof(message_1) -)]; -std::memcpy(tmp_message_1, message_1, sizeof(message_1)); +std::memcpy(tmp_message_1.data(), message_1.data(), message_1.size()); +std::vector<std::uint8_t> plaintext_1(::olm_decrypt_max_plaintext_length( + b_session, 0, tmp_message_1.data(), message_1.size() +)); +std::memcpy(tmp_message_1.data(), message_1.data(), message_1.size()); assert_equals(std::size_t(12), ::olm_decrypt( b_session, 0, - tmp_message_1, sizeof(message_1), - plaintext_1, sizeof(plaintext_1) + tmp_message_1.data(), message_1.size(), + plaintext_1.data(), plaintext_1.size() )); for (unsigned i = 0; i < 8; ++i) { { - std::uint8_t msg_a[::olm_encrypt_message_length(a_session, 12)]; - std::uint8_t rnd_a[::olm_encrypt_random_length(a_session)]; - mock_random_a(rnd_a, sizeof(rnd_a)); + std::vector<std::uint8_t> msg_a(::olm_encrypt_message_length(a_session, 12)); + std::vector<std::uint8_t> rnd_a(::olm_encrypt_random_length(a_session)); + mock_random_a(rnd_a.data(), 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, sizeof(rnd_a), msg_a, sizeof(msg_a) + a_session, plaintext, 12, rnd_a.data(), rnd_a.size(), msg_a.data(), msg_a.size() )); - std::uint8_t tmp_a[sizeof(msg_a)]; - std::memcpy(tmp_a, msg_a, sizeof(msg_a)); - std::uint8_t out_a[::olm_decrypt_max_plaintext_length( - b_session, type_a, tmp_a, sizeof(tmp_a) - )]; - std::memcpy(tmp_a, msg_a, sizeof(msg_a)); + std::vector<std::uint8_t> tmp_a(msg_a); + std::vector<std::uint8_t> out_a(::olm_decrypt_max_plaintext_length( + b_session, type_a, tmp_a.data(), tmp_a.size() + )); + std::memcpy(tmp_a.data(), msg_a.data(), sizeof(msg_a)); assert_equals(std::size_t(12), ::olm_decrypt( - b_session, type_a, msg_a, sizeof(msg_a), out_a, sizeof(out_a) + b_session, type_a, msg_a.data(), msg_a.size(), out_a.data(), out_a.size() )); } { - std::uint8_t msg_b[::olm_encrypt_message_length(b_session, 12)]; - std::uint8_t rnd_b[::olm_encrypt_random_length(b_session)]; - mock_random_b(rnd_b, sizeof(rnd_b)); + std::vector<std::uint8_t> msg_b(::olm_encrypt_message_length(b_session, 12)); + std::vector<std::uint8_t> rnd_b(::olm_encrypt_random_length(b_session)); + mock_random_b(rnd_b.data(), 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, sizeof(rnd_b), msg_b, sizeof(msg_b) + b_session, plaintext, 12, rnd_b.data(), rnd_b.size(), msg_b.data(), msg_b.size() )); - std::uint8_t tmp_b[sizeof(msg_b)]; - std::memcpy(tmp_b, msg_b, sizeof(msg_b)); - std::uint8_t out_b[::olm_decrypt_max_plaintext_length( - a_session, type_b, tmp_b, sizeof(tmp_b) - )]; - std::memcpy(tmp_b, msg_b, sizeof(msg_b)); + std::vector<std::uint8_t> tmp_b(msg_b); + std::vector<std::uint8_t> out_b(::olm_decrypt_max_plaintext_length( + a_session, type_b, tmp_b.data(), tmp_b.size() + )); + std::memcpy(tmp_b.data(), msg_b.data(), msg_b.size()); assert_equals(std::size_t(12), ::olm_decrypt( - a_session, type_b, msg_b, sizeof(msg_b), out_b, sizeof(out_b) + a_session, type_b, msg_b.data(), msg_b.size(), out_b.data(), out_b.size() )); } } diff --git a/tests/test_olm_decrypt.cpp b/tests/test_olm_decrypt.cpp index 4a1fb97..0c8feb8 100644 --- a/tests/test_olm_decrypt.cpp +++ b/tests/test_olm_decrypt.cpp @@ -1,6 +1,8 @@ #include "olm/olm.h" #include "unittest.hh" +#include <vector> + struct test_case { const char *msghex; const char *expected_error; @@ -37,14 +39,14 @@ void decode_hex( } 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::vector<std::uint8_t> session_memory(olm_session_size()); + ::OlmSession * session = ::olm_session(session_memory.data()); - std::uint8_t pickled[strlen(session_data)]; - ::memcpy(pickled, session_data, sizeof(pickled)); + std::vector<std::uint8_t> pickled(strlen(session_data)); + ::memcpy(pickled.data(), session_data, pickled.size()); assert_not_equals( ::olm_error(), - ::olm_unpickle_session(session, "", 0, pickled, sizeof(pickled)) + ::olm_unpickle_session(session, "", 0, pickled.data(), pickled.size()) ); std::size_t message_length = strlen(test_case->msghex) / 2; @@ -67,12 +69,12 @@ void decrypt_case(int message_type, const test_case * test_case) { assert_not_equals(::olm_error(), max_length); - uint8_t plaintext[max_length]; + std::vector<uint8_t> plaintext(max_length); decode_hex(test_case->msghex, message, message_length); olm_decrypt( session, message_type, message, message_length, - plaintext, max_length + plaintext.data(), max_length ); free(message); } diff --git a/tests/test_olm_sha256.cpp b/tests/test_olm_sha256.cpp index c6d0242..d76e592 100644 --- a/tests/test_olm_sha256.cpp +++ b/tests/test_olm_sha256.cpp @@ -1,13 +1,15 @@ #include "olm/olm.h" #include "unittest.hh" +#include <vector> + int main() { { TestCase("Olm sha256 test"); -std::uint8_t utility_buffer[::olm_utility_size()]; -::OlmUtility * utility = ::olm_utility(utility_buffer); +std::vector<std::uint8_t> utility_buffer(::olm_utility_size()); +::OlmUtility * utility = ::olm_utility(utility_buffer.data()); assert_equals(std::size_t(43), ::olm_sha256_length(utility)); std::uint8_t output[43]; diff --git a/tests/test_pk.cpp b/tests/test_pk.cpp index abdbda0..7679096 100644 --- a/tests/test_pk.cpp +++ b/tests/test_pk.cpp @@ -5,6 +5,7 @@ #include "unittest.hh" #include <iostream> +#include <vector> int main() { @@ -13,8 +14,8 @@ int main() { 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::vector<std::uint8_t> decryption_buffer(olm_pk_decryption_size()); +OlmPkDecryption *decryption = olm_pk_decryption(decryption_buffer.data()); std::uint8_t alice_private[32] = { 0x77, 0x07, 0x6D, 0x0A, 0x73, 0x18, 0xA5, 0x7D, @@ -34,25 +35,25 @@ std::uint8_t bob_private[32] = { const std::uint8_t *bob_public = (std::uint8_t *) "3p7bfXt9wbTTW2HC7OQ1Nz+DQ8hbeGdNrfx+FG+IK08"; -std::uint8_t pubkey[::olm_pk_key_length()]; +std::vector<std::uint8_t> pubkey(::olm_pk_key_length()); olm_pk_key_from_private( decryption, - pubkey, sizeof(pubkey), + pubkey.data(), pubkey.size(), alice_private, sizeof(alice_private) ); -assert_equals(alice_public, pubkey, olm_pk_key_length()); +assert_equals(alice_public, pubkey.data(), 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); +std::vector<std::uint8_t> encryption_buffer(olm_pk_encryption_size()); +OlmPkEncryption *encryption = olm_pk_encryption(encryption_buffer.data()); -olm_pk_encryption_set_recipient_key(encryption, pubkey, sizeof(pubkey)); +olm_pk_encryption_set_recipient_key(encryption, pubkey.data(), pubkey.size()); const size_t plaintext_length = 14; const std::uint8_t *plaintext = (std::uint8_t *) "This is a test"; @@ -60,27 +61,27 @@ 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()]; +std::vector<std::uint8_t> output_buffer(olm_pk_mac_length(encryption)); +std::vector<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), + output_buffer.data(), output_buffer.size(), + ephemeral_key.data(), ephemeral_key.size(), bob_private, sizeof(bob_private) ); -assert_equals(bob_public, ephemeral_key, olm_pk_key_length()); +assert_equals(bob_public, ephemeral_key.data(), 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), + ephemeral_key.data(), ephemeral_key.size(), + output_buffer.data(), output_buffer.size(), ciphertext_buffer, ciphertext_length, plaintext_buffer, max_plaintext_length ); @@ -96,8 +97,8 @@ free(plaintext_buffer); TestCase test_case("Public Key Decryption pickling"); -std::uint8_t decryption_buffer[olm_pk_decryption_size()]; -OlmPkDecryption *decryption = olm_pk_decryption(decryption_buffer); +std::vector<std::uint8_t> decryption_buffer(olm_pk_decryption_size()); +OlmPkDecryption *decryption = olm_pk_decryption(decryption_buffer.data()); std::uint8_t alice_private[32] = { 0x77, 0x07, 0x6D, 0x0A, 0x73, 0x18, 0xA5, 0x7D, @@ -108,37 +109,37 @@ std::uint8_t alice_private[32] = { const std::uint8_t *alice_public = (std::uint8_t *) "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmoK"; -std::uint8_t pubkey[olm_pk_key_length()]; +std::vector<std::uint8_t> pubkey(olm_pk_key_length()); olm_pk_key_from_private( decryption, - pubkey, sizeof(pubkey), + pubkey.data(), pubkey.size(), 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)]; +std::vector<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) + pickle_buffer.data(), pickle_buffer.size() ); -assert_equals(expected_pickle, pickle_buffer, olm_pickle_pk_decryption_length(decryption)); +assert_equals(expected_pickle, pickle_buffer.data(), olm_pickle_pk_decryption_length(decryption)); olm_clear_pk_decryption(decryption); -memset(pubkey, 0, olm_pk_key_length()); +memset(pubkey.data(), 0, olm_pk_key_length()); olm_unpickle_pk_decryption( decryption, PICKLE_KEY, strlen((char *)PICKLE_KEY), - pickle_buffer, sizeof(pickle_buffer), - pubkey, sizeof(pubkey) + pickle_buffer.data(), pickle_buffer.size(), + pubkey.data(), pubkey.size() ); -assert_equals(alice_public, pubkey, olm_pk_key_length()); +assert_equals(alice_public, pubkey.data(), olm_pk_key_length()); char *ciphertext = strdup("ntk49j/KozVFtSqJXhCejg"); const char *mac = "zpzU6BkZcNI"; @@ -168,8 +169,8 @@ free(plaintext_buffer); TestCase test_case("Public Key Signing"); -std::uint8_t signing_buffer[olm_pk_signing_size()]; -OlmPkSigning *signing = olm_pk_signing(signing_buffer); +std::vector<std::uint8_t> signing_buffer(olm_pk_signing_size()); +OlmPkSigning *signing = olm_pk_signing(signing_buffer.data()); std::uint8_t seed[32] = { 0x77, 0x07, 0x6D, 0x0A, 0x73, 0x18, 0xA5, 0x7D, @@ -180,11 +181,11 @@ std::uint8_t seed[32] = { //const std::uint8_t *pub_key = (std::uint8_t *) "hSDwCYkwp1R0i33ctD73Wg2/Og0mOBr066SpjqqbTmoK"; -char pubkey[olm_pk_signing_public_key_length() + 1]; +std::vector<char> pubkey(olm_pk_signing_public_key_length() + 1); olm_pk_signing_key_from_seed( signing, - pubkey, sizeof(pubkey), + pubkey.data(), pubkey.size() - 1, seed, sizeof(seed) ); @@ -205,7 +206,7 @@ size_t result; result = ::olm_ed25519_verify( utility, - pubkey, olm_pk_signing_public_key_length(), + pubkey.data(), olm_pk_signing_public_key_length(), message, strlen(message), sig_buffer, olm_pk_signature_length() ); @@ -216,7 +217,7 @@ sig_buffer[5] = 'm'; result = ::olm_ed25519_verify( utility, - pubkey, olm_pk_signing_public_key_length(), + pubkey.data(), olm_pk_signing_public_key_length(), message, strlen(message), sig_buffer, olm_pk_signature_length() ); diff --git a/tests/test_ratchet.cpp b/tests/test_ratchet.cpp index fb60ba9..0408429 100644 --- a/tests/test_ratchet.cpp +++ b/tests/test_ratchet.cpp @@ -16,6 +16,7 @@ #include "olm/cipher.h" #include "unittest.hh" +#include <vector> int main() { @@ -57,23 +58,23 @@ std::size_t encrypt_length, decrypt_length; random_length = alice.encrypt_random_length(); assert_equals(std::size_t(0), random_length); - std::uint8_t message[message_length]; + std::vector<std::uint8_t> message(message_length); encrypt_length = alice.encrypt( plaintext, plaintext_length, NULL, 0, - message, message_length + message.data(), message_length ); assert_equals(message_length, encrypt_length); - output_length = bob.decrypt_max_plaintext_length(message, message_length); - std::uint8_t output[output_length]; + output_length = bob.decrypt_max_plaintext_length(message.data(), message_length); + std::vector<std::uint8_t> output(output_length); decrypt_length = bob.decrypt( - message, message_length, - output, output_length + message.data(), message_length, + output.data(), output_length ); assert_equals(plaintext_length, decrypt_length); - assert_equals(plaintext, output, decrypt_length); + assert_equals(plaintext, output.data(), decrypt_length); } @@ -83,24 +84,24 @@ std::size_t encrypt_length, decrypt_length; random_length = bob.encrypt_random_length(); assert_equals(std::size_t(32), random_length); - std::uint8_t message[message_length]; + std::vector<std::uint8_t> message(message_length); std::uint8_t random[] = "This is a random 32 byte string."; encrypt_length = bob.encrypt( plaintext, plaintext_length, random, 32, - message, message_length + message.data(), message_length ); assert_equals(message_length, encrypt_length); - output_length = alice.decrypt_max_plaintext_length(message, message_length); - std::uint8_t output[output_length]; + output_length = alice.decrypt_max_plaintext_length(message.data(), message_length); + std::vector<std::uint8_t> output(output_length); decrypt_length = alice.decrypt( - message, message_length, - output, output_length + message.data(), message_length, + output.data(), output_length ); assert_equals(plaintext_length, decrypt_length); - assert_equals(plaintext, output, decrypt_length); + assert_equals(plaintext, output.data(), decrypt_length); } } /* Send/receive message test case */ @@ -130,12 +131,12 @@ std::size_t encrypt_length, decrypt_length; random_length = alice.encrypt_random_length(); assert_equals(std::size_t(0), random_length); - std::uint8_t message_1[message_1_length]; + std::vector<std::uint8_t> message_1(message_1_length); std::uint8_t random[] = "This is a random 32 byte string."; encrypt_length = alice.encrypt( plaintext_1, plaintext_1_length, random, 32, - message_1, message_1_length + message_1.data(), message_1_length ); assert_equals(message_1_length, encrypt_length); @@ -143,36 +144,36 @@ std::size_t encrypt_length, decrypt_length; random_length = alice.encrypt_random_length(); assert_equals(std::size_t(0), random_length); - std::uint8_t message_2[message_2_length]; + std::vector<std::uint8_t> message_2(message_2_length); encrypt_length = alice.encrypt( plaintext_2, plaintext_2_length, NULL, 0, - message_2, message_2_length + message_2.data(), message_2_length ); assert_equals(message_2_length, encrypt_length); output_length = bob.decrypt_max_plaintext_length( - message_2, message_2_length + message_2.data(), message_2_length ); - std::uint8_t output_1[output_length]; + std::vector<std::uint8_t> output_1(output_length); decrypt_length = bob.decrypt( - message_2, message_2_length, - output_1, output_length + message_2.data(), message_2_length, + output_1.data(), output_length ); assert_equals(plaintext_2_length, decrypt_length); - assert_equals(plaintext_2, output_1, decrypt_length); + assert_equals(plaintext_2, output_1.data(), decrypt_length); output_length = bob.decrypt_max_plaintext_length( - message_1, message_1_length + message_1.data(), message_1_length ); - std::uint8_t output_2[output_length]; + std::vector<std::uint8_t> output_2(output_length); decrypt_length = bob.decrypt( - message_1, message_1_length, - output_2, output_length + message_1.data(), message_1_length, + output_2.data(), output_length ); assert_equals(plaintext_1_length, decrypt_length); - assert_equals(plaintext_1, output_2, decrypt_length); + assert_equals(plaintext_1, output_2.data(), decrypt_length); } } /* Out of order test case */ @@ -193,24 +194,24 @@ std::uint8_t random[] = "This is a random 32 byte string"; for (unsigned i = 0; i < 8; ++i) { { - std::uint8_t msg[alice.encrypt_output_length(sizeof(plaintext))]; + std::vector<std::uint8_t> msg(alice.encrypt_output_length(sizeof(plaintext))); alice.encrypt( - plaintext, 15, random, 32, msg, sizeof(msg) + plaintext, 15, random, 32, msg.data(), msg.size() ); - std::uint8_t output[bob.decrypt_max_plaintext_length(msg, sizeof(msg))]; + std::vector<std::uint8_t> output(bob.decrypt_max_plaintext_length(msg.data(), msg.size())); assert_equals( - std::size_t(15), bob.decrypt(msg, sizeof(msg), output, sizeof(output)) + std::size_t(15), bob.decrypt(msg.data(), msg.size(), output.data(), output.size()) ); } random[31]++; { - std::uint8_t msg[bob.encrypt_output_length(sizeof(plaintext))]; + std::vector<std::uint8_t> msg(bob.encrypt_output_length(sizeof(plaintext))); bob.encrypt( - plaintext, 15, random, 32, msg, sizeof(msg) + plaintext, 15, random, 32, msg.data(), msg.size() ); - std::uint8_t output[alice.decrypt_max_plaintext_length(msg, sizeof(msg))]; + std::vector<std::uint8_t> output(alice.decrypt_max_plaintext_length(msg.data(), msg.size())); assert_equals( - std::size_t(15), alice.decrypt(msg, sizeof(msg), output, sizeof(output)) + std::size_t(15), alice.decrypt(msg.data(), msg.size(), output.data(), output.size()) ); } random[31]++; |