Commit ea13edca authored by Hubert Chathi's avatar Hubert Chathi

don't use variable length or zero-length arrays in test files

as some compilers don't handle that
parent 157c0fa6
......@@ -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);
......
......@@ -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);
......
This diff is collapsed.
......@@ -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);
......
This diff is collapsed.
#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);
}
......
#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];
......
......@@ -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()
);
......
......@@ -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]++;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment