wbrawner/openssl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Convert more tests

Browse source 
ct_test,evp_extra_test,wpackettest,packettest
Add strncmp TEST wrappers
And make some style/consistency fixes to ct_test
Silence travis; gcc bug?

Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3234)
This commit is contained in:
Rich Salz 2017-04-18 16:33:15 -04:00
parent f3ab6c16c4
commit adcd8e37db
7 changed files with 635 additions and 843 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
test/build.info
View file

@ -151,7 +151,7 @@ IF[{- !$disabled{tests} -}]
INCLUDE[evp_test]=../include
DEPEND[evp_test]=../libcrypto
SOURCE[evp_extra_test]=evp_extra_test.c
SOURCE[evp_extra_test]=evp_extra_test.c testutil.c test_main.c
INCLUDE[evp_extra_test]=../include
DEPEND[evp_extra_test]=../libcrypto
@ -191,7 +191,7 @@ IF[{- !$disabled{tests} -}]
INCLUDE[bad_dtls_test]=../include
DEPEND[bad_dtls_test]=../libcrypto ../libssl
SOURCE[packettest]=packettest.c
SOURCE[packettest]=packettest.c testutil.c test_main.c
INCLUDE[packettest]=../include
DEPEND[packettest]=../libcrypto

228
test/ct_test.c
View file

@ -60,29 +60,21 @@ typedef struct ct_test_fixture {
static CT_TEST_FIXTURE set_up(const char *const test_case_name)
{
CT_TEST_FIXTURE fixture;
int setup_ok = 1;
int ok = 0;
memset(&fixture, 0, sizeof(fixture));
fixture.test_case_name = test_case_name;
fixture.epoch_time_in_ms = 1473269626000; /* Sep 7 17:33:46 2016 GMT */
fixture.ctlog_store = CTLOG_STORE_new();
if (fixture.ctlog_store == NULL) {
setup_ok = 0;
fprintf(stderr, "Failed to create a new CT log store\n");
if (!TEST_ptr(fixture.ctlog_store = CTLOG_STORE_new())
|| !TEST_int_eq(
CTLOG_STORE_load_default_file(fixture.ctlog_store), 1))
goto end;
}
if (CTLOG_STORE_load_default_file(fixture.ctlog_store) != 1) {
setup_ok = 0;
fprintf(stderr, "Failed to load CT log list\n");
goto end;
}
ok = 1;
end:
if (!setup_ok) {
if (!ok) {
CTLOG_STORE_free(fixture.ctlog_store);
TEST_error("Failed to setup");
exit(EXIT_FAILURE);
}
return fixture;
@ -96,19 +88,18 @@ static void tear_down(CT_TEST_FIXTURE fixture)
static char *mk_file_path(const char *dir, const char *file)
{
char *full_file = NULL;
size_t full_file_l = 0;
const char *sep = "";
#ifndef OPENSSL_SYS_VMS
sep = "/";
const char *sep = "/";
#else
const char *sep = "";
#endif
size_t len = strlen(dir) + strlen(sep) + strlen(file) + 1;
char *full_file = OPENSSL_zalloc(len);
full_file_l = strlen(dir) + strlen(sep) + strlen(file) + 1;
full_file = OPENSSL_zalloc(full_file_l);
if (full_file != NULL) {
OPENSSL_strlcpy(full_file, dir, full_file_l);
OPENSSL_strlcat(full_file, sep, full_file_l);
OPENSSL_strlcat(full_file, file, full_file_l);
OPENSSL_strlcpy(full_file, dir, len);
OPENSSL_strlcat(full_file, sep, len);
OPENSSL_strlcat(full_file, file, len);
}
return full_file;
@ -121,65 +112,54 @@ static X509 *load_pem_cert(const char *dir, const char *file)
if (file_path != NULL) {
BIO *cert_io = BIO_new_file(file_path, "r");
OPENSSL_free(file_path);
if (cert_io != NULL)
cert = PEM_read_bio_X509(cert_io, NULL, NULL, NULL);
BIO_free(cert_io);
}
OPENSSL_free(file_path);
return cert;
}
static int read_text_file(const char *dir, const char *file,
char *buffer, int buffer_length)
{
int result = -1;
int len = -1;
char *file_path = mk_file_path(dir, file);
if (file_path != NULL) {
BIO *file_io = BIO_new_file(file_path, "r");
OPENSSL_free(file_path);
if (file_io != NULL) {
result = BIO_read(file_io, buffer, buffer_length);
BIO_free(file_io);
}
if (file_io != NULL)
len = BIO_read(file_io, buffer, buffer_length);
BIO_free(file_io);
}
return result;
OPENSSL_free(file_path);
return len;
}
static int compare_sct_list_printout(STACK_OF(SCT) *sct,
const char *expected_output)
const char *expected_output)
{
BIO *text_buffer = NULL;
char *actual_output = NULL;
int result = 1;
int result = 0;
text_buffer = BIO_new(BIO_s_mem());
if (text_buffer == NULL) {
fprintf(stderr, "Unable to allocate buffer\n");
if (!TEST_ptr(text_buffer = BIO_new(BIO_s_mem())))
goto end;
}
SCT_LIST_print(sct, text_buffer, 0, "\n", NULL);
/* Append null terminator because we're about to use the buffer contents
* as a string. */
if (BIO_write(text_buffer, "\0", 1) != 1) {
fprintf(stderr, "Failed to append null terminator to SCT text\n");
/* Append \0 because we're about to use the buffer contents as a string. */
if (!TEST_true(BIO_write(text_buffer, "\0", 1)))
goto end;
}
BIO_get_mem_data(text_buffer, &actual_output);
result = strcmp(actual_output, expected_output);
if (result != 0) {
fprintf(stderr,
"Expected SCT printout:\n%s\nActual SCT printout:\n%s\n",
expected_output, actual_output);
}
if (!TEST_str_eq(actual_output, expected_output))
goto end;
result = 1;
end:
BIO_free(text_buffer);
@ -191,55 +171,41 @@ static int compare_extension_printout(X509_EXTENSION *extension,
{
BIO *text_buffer = NULL;
char *actual_output = NULL;
int result = 1;
int result = 0;
text_buffer = BIO_new(BIO_s_mem());
if (text_buffer == NULL) {
fprintf(stderr, "Unable to allocate buffer\n");
if (!TEST_ptr(text_buffer = BIO_new(BIO_s_mem()))
|| !TEST_true(X509V3_EXT_print(text_buffer, extension,
X509V3_EXT_DEFAULT, 0)))
goto end;
}
if (!X509V3_EXT_print(text_buffer, extension, X509V3_EXT_DEFAULT, 0)) {
fprintf(stderr, "Failed to print extension\n");
/* Append \0 because we're about to use the buffer contents as a string. */
if (!TEST_true(BIO_write(text_buffer, "\0", 1)))
goto end;
}
/* Append null terminator because we're about to use the buffer contents
* as a string. */
if (BIO_write(text_buffer, "\0", 1) != 1) {
fprintf(stderr,
"Failed to append null terminator to extension text\n");
goto end;
}
BIO_get_mem_data(text_buffer, &actual_output);
result = strcmp(actual_output, expected_output);
if (!TEST_str_eq(actual_output, expected_output))
goto end;
if (result != 0) {
fprintf(stderr,
"Expected SCT printout:\n%s\nActual SCT printout:\n%s\n",
expected_output, actual_output);
}
result = 1;
end:
BIO_free(text_buffer);
return result;
}
static int assert_validity(CT_TEST_FIXTURE fixture,
STACK_OF(SCT) *scts,
CT_POLICY_EVAL_CTX *policy_ctx) {
static int assert_validity(CT_TEST_FIXTURE fixture, STACK_OF(SCT) *scts,
CT_POLICY_EVAL_CTX *policy_ctx)
{
int invalid_sct_count = 0;
int valid_sct_count = 0;
int i;
if (SCT_LIST_validate(scts, policy_ctx) < 0) {
fprintf(stderr, "Error verifying SCTs\n");
if (!TEST_int_ge(SCT_LIST_validate(scts, policy_ctx), 0))
return 0;
}
for (i = 0; i < sk_SCT_num(scts); ++i) {
SCT *sct_i = sk_SCT_value(scts, i);
switch (SCT_get_validation_status(sct_i)) {
case SCT_VALIDATION_STATUS_VALID:
++valid_sct_count;
@ -256,18 +222,12 @@ static int assert_validity(CT_TEST_FIXTURE fixture,
}
}
if (valid_sct_count != fixture.expected_valid_sct_count) {
if (!TEST_int_eq(valid_sct_count, fixture.expected_valid_sct_count)) {
int unverified_sct_count = sk_SCT_num(scts) -
invalid_sct_count - valid_sct_count;
invalid_sct_count - valid_sct_count;
fprintf(stderr,
"%d SCTs failed verification\n"
"%d SCTs passed verification (%d expected)\n"
"%d SCTs were unverified\n",
invalid_sct_count,
valid_sct_count,
fixture.expected_valid_sct_count,
unverified_sct_count);
TEST_info("%d SCTs failed, %d SCTs unverified",
invalid_sct_count, unverified_sct_count);
return 0;
}
@ -291,12 +251,8 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
expected_sct_text,
CT_TEST_MAX_FILE_SIZE - 1);
if (sct_text_len < 0) {
fprintf(stderr, "Test data file not found: %s\n",
fixture.sct_text_file);
if (!TEST_int_ge(sct_text_len, 0))
goto end;
}
expected_sct_text[sct_text_len] = '\0';
}
@ -308,25 +264,17 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
if (fixture.certificate_file != NULL) {
int sct_extension_index;
X509_EXTENSION *sct_extension = NULL;
cert = load_pem_cert(fixture.certs_dir, fixture.certificate_file);
if (cert == NULL) {
fprintf(stderr, "Unable to load certificate: %s\n",
fixture.certificate_file);
if (!TEST_ptr(cert = load_pem_cert(fixture.certs_dir,
fixture.certificate_file)))
goto end;
}
CT_POLICY_EVAL_CTX_set1_cert(ct_policy_ctx, cert);
if (fixture.issuer_file != NULL) {
issuer = load_pem_cert(fixture.certs_dir, fixture.issuer_file);
if (issuer == NULL) {
fprintf(stderr, "Unable to load issuer certificate: %s\n",
fixture.issuer_file);
if (!TEST_ptr(issuer = load_pem_cert(fixture.certs_dir,
fixture.issuer_file)))
goto end;
}
CT_POLICY_EVAL_CTX_set1_issuer(ct_policy_ctx, issuer);
}
@ -334,17 +282,13 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
X509_get_ext_by_NID(cert, NID_ct_precert_scts, -1);
sct_extension = X509_get_ext(cert, sct_extension_index);
if (fixture.expected_sct_count > 0) {
if (sct_extension == NULL) {
fprintf(stderr, "SCT extension not found in: %s\n",
fixture.certificate_file);
if (!TEST_ptr(sct_extension))
goto end;
}
if (fixture.sct_text_file
&& compare_extension_printout(sct_extension,
expected_sct_text)) {
&& !compare_extension_printout(sct_extension,
expected_sct_text))
goto end;
}
if (fixture.test_validity) {
int i;
@ -353,30 +297,24 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
for (i = 0; i < sk_SCT_num(scts); ++i) {
SCT *sct_i = sk_SCT_value(scts, i);
if (!SCT_set_source(sct_i, SCT_SOURCE_X509V3_EXTENSION)) {
fprintf(stderr,
"Error setting SCT source to X509v3 extension\n");
if (!TEST_true(SCT_set_source(sct_i,
SCT_SOURCE_X509V3_EXTENSION)))
goto end;
}
}
if (!assert_validity(fixture, scts, ct_policy_ctx))
goto end;
}
} else if (sct_extension != NULL) {
fprintf(stderr,
"Expected no SCTs, but found SCT extension in: %s\n",
fixture.certificate_file);
} else if (!TEST_ptr_null(sct_extension)) {
goto end;
}
}
if (fixture.tls_sct_list != NULL) {
const unsigned char *p = fixture.tls_sct_list;
if (o2i_SCT_LIST(&scts, &p, fixture.tls_sct_list_len) == NULL) {
fprintf(stderr, "Failed to decode SCTs from TLS format\n");
if (!TEST_ptr(o2i_SCT_LIST(&scts, &p, fixture.tls_sct_list_len)))
goto end;
}
if (fixture.test_validity && cert != NULL) {
if (!assert_validity(fixture, scts, ct_policy_ctx))
@ -384,17 +322,14 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
}
if (fixture.sct_text_file
&& compare_sct_list_printout(scts, expected_sct_text)) {
&& !compare_sct_list_printout(scts, expected_sct_text)) {
goto end;
}
tls_sct_list_len = i2o_SCT_LIST(scts, &tls_sct_list);
if (tls_sct_list_len != fixture.tls_sct_list_len ||
memcmp(fixture.tls_sct_list, tls_sct_list, tls_sct_list_len) != 0) {
fprintf(stderr,
"Failed to encode SCTs into TLS format correctly\n");
if (!TEST_mem_eq(fixture.tls_sct_list, fixture.tls_sct_list_len,
tls_sct_list, tls_sct_list_len))
goto end;
}
}
success = 1;
@ -520,15 +455,11 @@ static int test_encode_tls_sct()
SETUP_CT_TEST_FIXTURE();
fixture.sct_list = sk_SCT_new_null();
sct = SCT_new_from_base64(SCT_VERSION_V1, log_id,
CT_LOG_ENTRY_TYPE_X509, timestamp,
extensions, signature);
if (!TEST_ptr(sct = SCT_new_from_base64(SCT_VERSION_V1, log_id,
CT_LOG_ENTRY_TYPE_X509, timestamp,
extensions, signature)))
if (sct == NULL) {
tear_down(fixture);
fprintf(stderr, "Failed to create SCT from base64-encoded test data\n");
return 0;
}
sk_SCT_push(fixture.sct_list, sct);
fixture.sct_dir = ct_dir;
@ -548,11 +479,8 @@ static int test_default_ct_policy_eval_ctx_time_is_now()
1000;
const time_t time_tolerance = 600; /* 10 minutes */
if (fabs(difftime(time(NULL), default_time)) > time_tolerance) {
fprintf(stderr,
"Default CT_POLICY_EVAL_CTX time is not approximately now.\n");
if (!TEST_uint_le(fabs(difftime(time(NULL), default_time)), time_tolerance))
goto end;
}
success = 1;
end:
@ -562,13 +490,10 @@ end:
int test_main(int argc, char *argv[])
{
int result = 0;
char *tmp_env;
tmp_env = getenv("CT_DIR");
ct_dir = OPENSSL_strdup(tmp_env != NULL ? tmp_env : "ct");
tmp_env = getenv("CERTS_DIR");
certs_dir = OPENSSL_strdup(tmp_env != NULL ? tmp_env : "certs");
if ((ct_dir = getenv("CT_DIR")) == NULL)
ct_dir = "ct";
if ((certs_dir = getenv("CERTS_DIR")) == NULL)
certs_dir = "certs";
ADD_TEST(test_no_scts_in_certificate);
ADD_TEST(test_one_sct_in_certificate);
@ -580,12 +505,7 @@ int test_main(int argc, char *argv[])
ADD_TEST(test_encode_tls_sct);
ADD_TEST(test_default_ct_policy_eval_ctx_time_is_now);
result = run_tests(argv[0]);
OPENSSL_free(ct_dir);
OPENSSL_free(certs_dir);
return result;
return run_tests(argv[0]);
}
#else
int test_main(int argc, char *argv[])

182
test/evp_extra_test.c
View file

@ -15,6 +15,8 @@
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/x509.h>
#include "testutil.h"
#include "test_main.h"
/*
* kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
@ -186,6 +188,18 @@ static const unsigned char kExampleBadECKeyDER[] = {
};
#endif
typedef struct APK_DATA_st {
const unsigned char *kder;
size_t size;
int evptype;
} APK_DATA;
static APK_DATA keydata[] = {
{kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER), EVP_PKEY_RSA},
{kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA},
{kExampleECKeyDER, sizeof(kExampleECKeyDER), EVP_PKEY_EC}
};
static EVP_PKEY *load_example_rsa_key(void)
{
EVP_PKEY *ret = NULL;
@ -193,19 +207,17 @@ static EVP_PKEY *load_example_rsa_key(void)
EVP_PKEY *pkey = NULL;
RSA *rsa = NULL;
if (!d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))) {
if (!TEST_true(d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))))
return NULL;
}
pkey = EVP_PKEY_new();
if (pkey == NULL || !EVP_PKEY_set1_RSA(pkey, rsa)) {
goto out;
}
if (!TEST_ptr(pkey = EVP_PKEY_new())
|| !TEST_true(EVP_PKEY_set1_RSA(pkey, rsa)))
goto end;
ret = pkey;
pkey = NULL;
out:
end:
EVP_PKEY_free(pkey);
RSA_free(rsa);
@ -218,48 +230,37 @@ static int test_EVP_DigestSignInit(void)
EVP_PKEY *pkey = NULL;
unsigned char *sig = NULL;
size_t sig_len = 0;
EVP_MD_CTX *md_ctx, *md_ctx_verify;
EVP_MD_CTX *md_ctx, *md_ctx_verify = NULL;
md_ctx = EVP_MD_CTX_new();
md_ctx_verify = EVP_MD_CTX_new();
if (md_ctx == NULL || md_ctx_verify == NULL)
if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
|| !TEST_ptr(md_ctx_verify = EVP_MD_CTX_new())
|| !TEST_ptr(pkey = load_example_rsa_key()))
goto out;
pkey = load_example_rsa_key();
if (pkey == NULL ||
!EVP_DigestSignInit(md_ctx, NULL, EVP_sha256(), NULL, pkey) ||
!EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))) {
if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
|| !TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
goto out;
}
/* Determine the size of the signature. */
if (!EVP_DigestSignFinal(md_ctx, NULL, &sig_len)) {
if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len))
|| !TEST_size_t_eq(sig_len, (size_t)EVP_PKEY_size(pkey)))
goto out;
}
/* Sanity check for testing. */
if (sig_len != (size_t)EVP_PKEY_size(pkey)) {
fprintf(stderr, "sig_len mismatch\n");
goto out;
}
sig = OPENSSL_malloc(sig_len);
if (sig == NULL || !EVP_DigestSignFinal(md_ctx, sig, &sig_len)) {
if (!TEST_ptr(sig = OPENSSL_malloc(sig_len))
|| !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
goto out;
}
/* Ensure that the signature round-trips. */
if (!EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sha256(), NULL, pkey)
|| !EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))
|| !EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)) {
if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sha256(),
NULL, pkey))
|| !TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify,
kMsg, sizeof(kMsg)))
|| !TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
goto out;
}
ret = 1;
out:
if (!ret) {
ERR_print_errors_fp(stderr);
}
EVP_MD_CTX_free(md_ctx);
EVP_MD_CTX_free(md_ctx_verify);
EVP_PKEY_free(pkey);
@ -272,56 +273,44 @@ static int test_EVP_DigestVerifyInit(void)
{
int ret = 0;
EVP_PKEY *pkey = NULL;
EVP_MD_CTX *md_ctx;
EVP_MD_CTX *md_ctx = NULL;
md_ctx = EVP_MD_CTX_new();
pkey = load_example_rsa_key();
if (pkey == NULL ||
!EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey) ||
!EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)) ||
!EVP_DigestVerifyFinal(md_ctx, kSignature, sizeof(kSignature))) {
if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
|| !TEST_ptr(pkey = load_example_rsa_key()))
goto out;
if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
|| !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
|| !TEST_true(EVP_DigestVerifyFinal(md_ctx, kSignature,
sizeof(kSignature))))
goto out;
}
ret = 1;
out:
if (!ret) {
ERR_print_errors_fp(stderr);
}
EVP_MD_CTX_free(md_ctx);
EVP_PKEY_free(pkey);
return ret;
}
static int test_d2i_AutoPrivateKey(const unsigned char *input,
size_t input_len, int expected_id)
static int test_d2i_AutoPrivateKey(int i)
{
int ret = 0;
const unsigned char *p;
EVP_PKEY *pkey = NULL;
const APK_DATA *ak = &keydata[i];
const unsigned char *input = ak->kder;
size_t input_len = ak->size;
int expected_id = ak->evptype;
p = input;
pkey = d2i_AutoPrivateKey(NULL, &p, input_len);
if (pkey == NULL || p != input + input_len) {
fprintf(stderr, "d2i_AutoPrivateKey failed\n");
if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
|| !TEST_ptr_eq(p, input + input_len)
|| !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
goto done;
}
if (EVP_PKEY_id(pkey) != expected_id) {
fprintf(stderr, "Did not decode expected type\n");
goto done;
}
ret = 1;
done:
if (!ret) {
ERR_print_errors_fp(stderr);
}
EVP_PKEY_free(pkey);
return ret;
}
@ -335,18 +324,16 @@ static int test_EVP_PKCS82PKEY(void)
PKCS8_PRIV_KEY_INFO *p8inf = NULL;
EVP_PKEY *pkey = NULL;
p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp, sizeof(kExampleBadECKeyDER));
if (!p8inf || derp != kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)) {
fprintf(stderr, "Failed to parse key\n");
if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
sizeof(kExampleBadECKeyDER))))
goto done;
}
pkey = EVP_PKCS82PKEY(p8inf);
if (pkey) {
fprintf(stderr, "Imported invalid EC key\n");
if (!TEST_ptr_eq(derp,
kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
goto done;
if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
goto done;
}
ret = 1;
@ -358,52 +345,13 @@ static int test_EVP_PKCS82PKEY(void)
}
#endif
int main(void)
void register_tests(void)
{
CRYPTO_set_mem_debug(1);
CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
if (!test_EVP_DigestSignInit()) {
fprintf(stderr, "EVP_DigestSignInit failed\n");
return 1;
}
if (!test_EVP_DigestVerifyInit()) {
fprintf(stderr, "EVP_DigestVerifyInit failed\n");
return 1;
}
if (!test_d2i_AutoPrivateKey(kExampleRSAKeyDER, sizeof(kExampleRSAKeyDER),
EVP_PKEY_RSA)) {
fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyDER) failed\n");
return 1;
}
if (!test_d2i_AutoPrivateKey
(kExampleRSAKeyPKCS8, sizeof(kExampleRSAKeyPKCS8), EVP_PKEY_RSA)) {
fprintf(stderr, "d2i_AutoPrivateKey(kExampleRSAKeyPKCS8) failed\n");
return 1;
}
ADD_TEST(test_EVP_DigestSignInit);
ADD_TEST(test_EVP_DigestVerifyInit);
ADD_ALL_TESTS(test_d2i_AutoPrivateKey,
sizeof(keydata) / sizeof(keydata[0]));
#ifndef OPENSSL_NO_EC
if (!test_d2i_AutoPrivateKey(kExampleECKeyDER, sizeof(kExampleECKeyDER),
EVP_PKEY_EC)) {
fprintf(stderr, "d2i_AutoPrivateKey(kExampleECKeyDER) failed\n");
return 1;
}
if (!test_EVP_PKCS82PKEY()) {
fprintf(stderr, "test_EVP_PKCS82PKEY failed\n");
return 1;
}
ADD_TEST(test_EVP_PKCS82PKEY);
#endif
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
if (CRYPTO_mem_leaks_fp(stderr) <= 0)
return 1;
#endif
printf("PASS\n");
return 0;
}

543
test/packettest.c
View file

@ -8,328 +8,311 @@
*/
#include "../ssl/packet_locl.h"
#include "testutil.h"
#include "test_main.h"
#define BUF_LEN 255
static int test_PACKET_remaining(unsigned char buf[BUF_LEN])
static unsigned char smbuf[BUF_LEN];
static int test_PACKET_remaining()
{
PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| PACKET_remaining(&pkt) != BUF_LEN
|| !PACKET_forward(&pkt, BUF_LEN - 1)
|| PACKET_remaining(&pkt) != 1
|| !PACKET_forward(&pkt, 1)
|| PACKET_remaining(&pkt) != 0) {
fprintf(stderr, "test_PACKET_remaining() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
|| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
|| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
|| !TEST_size_t_eq(PACKET_remaining(&pkt), 1)
|| !TEST_true(PACKET_forward(&pkt, 1))
|| !TEST_size_t_eq(PACKET_remaining(&pkt), 0)))
return 0;
}
return 1;
}
static int test_PACKET_end(unsigned char buf[BUF_LEN])
static int test_PACKET_end()
{
PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| PACKET_remaining(&pkt) != BUF_LEN
|| PACKET_end(&pkt) != buf + BUF_LEN
|| !PACKET_forward(&pkt, BUF_LEN - 1)
|| PACKET_end(&pkt) != buf + BUF_LEN
|| !PACKET_forward(&pkt, 1)
|| PACKET_end(&pkt) != buf + BUF_LEN) {
fprintf(stderr, "test_PACKET_end() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
|| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
|| !TEST_ptr_ne(PACKET_end(&pkt), smbuf + BUF_LEN)
|| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
|| !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)
|| !TEST_true(PACKET_forward(&pkt, 1))
|| !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)))
return 0;
}
return 1;
}
static int test_PACKET_get_1(unsigned char buf[BUF_LEN])
static int test_PACKET_get_1()
{
unsigned int i;
PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_get_1(&pkt, &i)
|| i != 0x02
|| !PACKET_forward(&pkt, BUF_LEN - 2)
|| !PACKET_get_1(&pkt, &i)
|| i != 0xfe
|| PACKET_get_1(&pkt, &i)) {
fprintf(stderr, "test_PACKET_get_1() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !TEST_true(PACKET_get_1(&pkt, &i))
|| !TEST_uint_eq(i, 0x02)
|| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 2))
|| !TEST_true(PACKET_get_1(&pkt, &i))
|| !TEST_uint_eq(i, 0xfe)
|| !TEST_false(PACKET_get_1(&pkt, &i)))
return 0;
}
return 1;
}
static int test_PACKET_get_4(unsigned char buf[BUF_LEN])
static int test_PACKET_get_4()
{
unsigned long i;
PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_get_4(&pkt, &i)
|| i != 0x08060402UL
|| !PACKET_forward(&pkt, BUF_LEN - 8)
|| !PACKET_get_4(&pkt, &i)
|| i != 0xfefcfaf8UL
|| PACKET_get_4(&pkt, &i)) {
fprintf(stderr, "test_PACKET_get_4() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !TEST_true(PACKET_get_4(&pkt, &i))
|| !TEST_ulong_eq(i, 0x08060402UL)
|| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
|| !TEST_true(PACKET_get_4(&pkt, &i))
|| !TEST_ulong_eq(i, 0xfefcfaf8UL)
|| !TEST_false(PACKET_get_4(&pkt, &i)))
return 0;
}
return 1;
}
static int test_PACKET_get_net_2(unsigned char buf[BUF_LEN])
static int test_PACKET_get_net_2()
{
unsigned int i;
PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_get_net_2(&pkt, &i)
|| i != 0x0204
|| !PACKET_forward(&pkt, BUF_LEN - 4)
|| !PACKET_get_net_2(&pkt, &i)
|| i != 0xfcfe
|| PACKET_get_net_2(&pkt, &i)) {
fprintf(stderr, "test_PACKET_get_net_2() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !TEST_true(PACKET_get_net_2(&pkt, &i))
|| !TEST_uint_eq(i, 0x0204)
|| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 4))
|| !TEST_true(PACKET_get_net_2(&pkt, &i))
|| !TEST_uint_eq(i, 0xfcfe)
|| !TEST_false(PACKET_get_net_2(&pkt, &i)))
return 0;
}
return 1;
}
static int test_PACKET_get_net_3(unsigned char buf[BUF_LEN])
static int test_PACKET_get_net_3()
{
unsigned long i;
PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_get_net_3(&pkt, &i)
|| i != 0x020406UL
|| !PACKET_forward(&pkt, BUF_LEN - 6)
|| !PACKET_get_net_3(&pkt, &i)
|| i != 0xfafcfeUL
|| PACKET_get_net_3(&pkt, &i)) {
fprintf(stderr, "test_PACKET_get_net_3() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !TEST_true(PACKET_get_net_3(&pkt, &i))
|| !TEST_ulong_eq(i, 0x020406UL)
|| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 6))
|| !TEST_true(PACKET_get_net_3(&pkt, &i))
|| !TEST_ulong_eq(i, 0xfafcfeUL)
|| !TEST_false(PACKET_get_net_3(&pkt, &i)))
return 0;
}
return 1;
}
static int test_PACKET_get_net_4(unsigned char buf[BUF_LEN])
static int test_PACKET_get_net_4()
{
unsigned long i;
PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_get_net_4(&pkt, &i)
|| i != 0x02040608UL
|| !PACKET_forward(&pkt, BUF_LEN - 8)
|| !PACKET_get_net_4(&pkt, &i)
|| i != 0xf8fafcfeUL
|| PACKET_get_net_4(&pkt, &i)) {
fprintf(stderr, "test_PACKET_get_net_4() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !TEST_true(PACKET_get_net_4(&pkt, &i))
|| !TEST_ulong_eq(i, 0x02040608UL)
|| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
|| !TEST_true(PACKET_get_net_4(&pkt, &i))
|| !TEST_ulong_eq(i, 0xf8fafcfeUL)
|| !TEST_false(PACKET_get_net_4(&pkt, &i)))
return 0;
}
return 1;
}
static int test_PACKET_get_sub_packet(unsigned char buf[BUF_LEN])
static int test_PACKET_get_sub_packet()
{
PACKET pkt, subpkt;
unsigned long i;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_get_sub_packet(&pkt, &subpkt, 4)
|| !PACKET_get_net_4(&subpkt, &i)
|| i != 0x02040608UL
|| PACKET_remaining(&subpkt)
|| !PACKET_forward(&pkt, BUF_LEN - 8)
|| !PACKET_get_sub_packet(&pkt, &subpkt, 4)
|| !PACKET_get_net_4(&subpkt, &i)
|| i != 0xf8fafcfeUL
|| PACKET_remaining(&subpkt)
|| PACKET_get_sub_packet(&pkt, &subpkt, 4)) {
fprintf(stderr, "test_PACKET_get_sub_packet() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
|| !TEST_true(PACKET_get_net_4(&subpkt, &i))
|| !TEST_ulong_eq(i, 0x02040608UL)
|| !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
|| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
|| !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
|| !TEST_true(PACKET_get_net_4(&subpkt, &i))
|| !TEST_ulong_eq(i, 0xf8fafcfeUL)
|| !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
|| !TEST_false(PACKET_get_sub_packet(&pkt, &subpkt, 4)))
return 0;
}
return 1;
}
static int test_PACKET_get_bytes(unsigned char buf[BUF_LEN])
static int test_PACKET_get_bytes()
{
const unsigned char *bytes;
PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_get_bytes(&pkt, &bytes, 4)
|| bytes[0] != 2 || bytes[1] != 4
|| bytes[2] != 6 || bytes[3] != 8
|| PACKET_remaining(&pkt) != BUF_LEN -4
|| !PACKET_forward(&pkt, BUF_LEN - 8)
|| !PACKET_get_bytes(&pkt, &bytes, 4)
|| bytes[0] != 0xf8 || bytes[1] != 0xfa
|| bytes[2] != 0xfc || bytes[3] != 0xfe
|| PACKET_remaining(&pkt)) {
fprintf(stderr, "test_PACKET_get_bytes() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
|| !TEST_uchar_eq(bytes[0], 2)
|| !TEST_uchar_eq(bytes[1], 4)
|| !TEST_uchar_eq(bytes[2], 6)
|| !TEST_uchar_eq(bytes[3], 8)
|| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN -4)
|| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
|| !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
|| !TEST_uchar_eq(bytes[0], 0xf8)
|| !TEST_uchar_eq(bytes[1], 0xfa)
|| !TEST_uchar_eq(bytes[2], 0xfc)
|| !TEST_uchar_eq(bytes[3], 0xfe)
|| !TEST_false(PACKET_remaining(&pkt)))
return 0;
}
return 1;
}
static int test_PACKET_copy_bytes(unsigned char buf[BUF_LEN])
static int test_PACKET_copy_bytes()
{
unsigned char bytes[4];
PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_copy_bytes(&pkt, bytes, 4)
|| bytes[0] != 2 || bytes[1] != 4
|| bytes[2] != 6 || bytes[3] != 8
|| PACKET_remaining(&pkt) != BUF_LEN - 4
|| !PACKET_forward(&pkt, BUF_LEN - 8)
|| !PACKET_copy_bytes(&pkt, bytes, 4)
|| bytes[0] != 0xf8 || bytes[1] != 0xfa
|| bytes[2] != 0xfc || bytes[3] != 0xfe
|| PACKET_remaining(&pkt)) {
fprintf(stderr, "test_PACKET_copy_bytes() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
|| !TEST_char_eq(bytes[0], 2)
|| !TEST_char_eq(bytes[1], 4)
|| !TEST_char_eq(bytes[2], 6)
|| !TEST_char_eq(bytes[3], 8)
|| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN - 4)
|| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
|| !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
|| !TEST_uchar_eq(bytes[0], 0xf8)
|| !TEST_uchar_eq(bytes[1], 0xfa)
|| !TEST_uchar_eq(bytes[2], 0xfc)
|| !TEST_uchar_eq(bytes[3], 0xfe)
|| !TEST_false(PACKET_remaining(&pkt)))
return 0;
}
return 1;
}
static int test_PACKET_copy_all(unsigned char buf[BUF_LEN])
static int test_PACKET_copy_all()
{
unsigned char tmp[BUF_LEN];
PACKET pkt;
size_t len;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_copy_all(&pkt, tmp, BUF_LEN, &len)
|| len != BUF_LEN
|| memcmp(buf, tmp, BUF_LEN) != 0
|| PACKET_remaining(&pkt) != BUF_LEN
|| PACKET_copy_all(&pkt, tmp, BUF_LEN - 1, &len)) {
fprintf(stderr, "test_PACKET_copy_bytes() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !TEST_true(PACKET_copy_all(&pkt, tmp, BUF_LEN, &len))
|| !TEST_size_t_eq(len, BUF_LEN)
|| !TEST_mem_eq(smbuf, BUF_LEN, tmp, BUF_LEN)
|| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
|| !TEST_false(PACKET_copy_all(&pkt, tmp, BUF_LEN - 1, &len)))
return 0;
}
return 1;
}
static int test_PACKET_memdup(unsigned char buf[BUF_LEN])
static int test_PACKET_memdup()
{
unsigned char *data = NULL;
size_t len;
PACKET pkt;
int result = 0;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_memdup(&pkt, &data, &len)
|| len != BUF_LEN
|| memcmp(data, PACKET_data(&pkt), len)
|| !PACKET_forward(&pkt, 10)
|| !PACKET_memdup(&pkt, &data, &len)
|| len != BUF_LEN - 10
|| memcmp(data, PACKET_data(&pkt), len)) {
fprintf(stderr, "test_PACKET_memdup() failed\n");
OPENSSL_free(data);
return 0;
}
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !TEST_true(PACKET_memdup(&pkt, &data, &len))
|| !TEST_size_t_eq(len, BUF_LEN)
|| !TEST_mem_eq(data, len, PACKET_data(&pkt), len)
|| !TEST_true(PACKET_forward(&pkt, 10))
|| !TEST_true(PACKET_memdup(&pkt, &data, &len))
|| !TEST_size_t_eq(len, BUF_LEN - 10)
|| !TEST_mem_eq(data, len, PACKET_data(&pkt), len))
goto end;
result = 1;
end:
OPENSSL_free(data);
return 1;
return result;
}
static int test_PACKET_strndup()
{
char buf[10], buf2[10];
char buf1[10], buf2[10];
char *data = NULL;
PACKET pkt;
int result = 0;
memset(buf, 'x', 10);
memset(buf1, 'x', 10);
memset(buf2, 'y', 10);
buf2[5] = '\0';
if ( !PACKET_buf_init(&pkt, (unsigned char*)buf, 10)
|| !PACKET_strndup(&pkt, &data)
|| strlen(data) != 10
|| strncmp(data, buf, 10)
|| !PACKET_buf_init(&pkt, (unsigned char*)buf2, 10)
|| !PACKET_strndup(&pkt, &data)
|| strlen(data) != 5
|| strcmp(data, buf2)) {
fprintf(stderr, "test_PACKET_strndup failed\n");
OPENSSL_free(data);
return 0;
}
if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
|| !TEST_true(PACKET_strndup(&pkt, &data))
|| !TEST_size_t_eq(strlen(data), 10)
|| !TEST_strn_eq(data, buf1, 10)
|| !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
|| !TEST_true(PACKET_strndup(&pkt, &data))
|| !TEST_size_t_eq(strlen(data), 5)
|| !TEST_str_eq(data, buf2))
goto end;
result = 1;
end:
OPENSSL_free(data);
return 1;
return result;
}
static int test_PACKET_contains_zero_byte()
{
char buf[10], buf2[10];
char buf1[10], buf2[10];
PACKET pkt;
memset(buf, 'x', 10);
memset(buf1, 'x', 10);
memset(buf2, 'y', 10);
buf2[5] = '\0';
if ( !PACKET_buf_init(&pkt, (unsigned char*)buf, 10)
|| PACKET_contains_zero_byte(&pkt)
|| !PACKET_buf_init(&pkt, (unsigned char*)buf2, 10)
|| !PACKET_contains_zero_byte(&pkt)) {
fprintf(stderr, "test_PACKET_contains_zero_byte failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
|| !TEST_false(PACKET_contains_zero_byte(&pkt))
|| !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
|| !TEST_true(PACKET_contains_zero_byte(&pkt)))
return 0;
}
return 1;
}
static int test_PACKET_forward(unsigned char buf[BUF_LEN])
static int test_PACKET_forward()
{
const unsigned char *byte;
PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_forward(&pkt, 1)
|| !PACKET_get_bytes(&pkt, &byte, 1)
|| byte[0] != 4
|| !PACKET_forward(&pkt, BUF_LEN - 3)
|| !PACKET_get_bytes(&pkt, &byte, 1)
|| byte[0] != 0xfe) {
fprintf(stderr, "test_PACKET_forward() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !TEST_true(PACKET_forward(&pkt, 1))
|| !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
|| !TEST_uchar_eq(byte[0], 4)
|| !TEST_true(PACKET_forward(&pkt, BUF_LEN - 3))
|| !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
|| !TEST_uchar_eq(byte[0], 0xfe))
return 0;
}
return 1;
}
static int test_PACKET_buf_init()
{
unsigned char buf[BUF_LEN];
unsigned char buf1[BUF_LEN];
PACKET pkt;
/* Also tests PACKET_remaining() */
if ( !PACKET_buf_init(&pkt, buf, 4)
|| PACKET_remaining(&pkt) != 4
|| !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| PACKET_remaining(&pkt) != BUF_LEN
|| PACKET_buf_init(&pkt, buf, -1)) {
fprintf(stderr, "test_PACKET_buf_init() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, buf1, 4))
|| !TEST_size_t_eq(PACKET_remaining(&pkt), 4)
|| !TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
|| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
|| !TEST_false(PACKET_buf_init(&pkt, buf1, -1)))
return 0;
}
return 1;
}
@ -339,135 +322,119 @@ static int test_PACKET_null_init()
PACKET pkt;
PACKET_null_init(&pkt);
if ( PACKET_remaining(&pkt) != 0
|| PACKET_forward(&pkt, 1)) {
fprintf(stderr, "test_PACKET_null_init() failed\n");
if (!TEST_size_t_eq(PACKET_remaining(&pkt), 0)
|| !TEST_false(PACKET_forward(&pkt, 1)))
return 0;
}
return 1;
}
static int test_PACKET_equal(unsigned char buf[BUF_LEN])
static int test_PACKET_equal()
{
PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, 4)
|| !PACKET_equal(&pkt, buf, 4)
|| PACKET_equal(&pkt, buf + 1, 4)
|| !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_equal(&pkt, buf, BUF_LEN)
|| PACKET_equal(&pkt, buf, BUF_LEN - 1)
|| PACKET_equal(&pkt, buf, BUF_LEN + 1)
|| PACKET_equal(&pkt, buf, 0)) {
fprintf(stderr, "test_PACKET_equal() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, smbuf, 4))
|| !TEST_true(PACKET_equal(&pkt, smbuf, 4))
|| !TEST_false(PACKET_equal(&pkt, smbuf + 1, 4))
|| !TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !TEST_true(PACKET_equal(&pkt, smbuf, BUF_LEN))
|| !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN - 1))
|| !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN + 1))
|| !TEST_false(PACKET_equal(&pkt, smbuf, 0)))
return 0;
}
return 1;
}
static int test_PACKET_get_length_prefixed_1()
{
unsigned char buf[BUF_LEN];
unsigned char buf1[BUF_LEN];
const size_t len = 16;
unsigned int i;
PACKET pkt, short_pkt, subpkt;
PACKET pkt, short_pkt, subpkt = {0};
buf[0] = len;
for (i = 1; i < BUF_LEN; i++) {
buf[i] = (i * 2) & 0xff;
}
buf1[0] = len;
for (i = 1; i < BUF_LEN; i++)
buf1[i] = (i * 2) & 0xff;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_buf_init(&short_pkt, buf, len)
|| !PACKET_get_length_prefixed_1(&pkt, &subpkt)
|| PACKET_remaining(&subpkt) != len
|| !PACKET_get_net_2(&subpkt, &i)
|| i != 0x0204
|| PACKET_get_length_prefixed_1(&short_pkt, &subpkt)
|| PACKET_remaining(&short_pkt) != len) {
fprintf(stderr, "test_PACKET_get_length_prefixed_1() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
|| !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
|| !TEST_true(PACKET_get_length_prefixed_1(&pkt, &subpkt))
|| !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
|| !TEST_true(PACKET_get_net_2(&subpkt, &i))
|| !TEST_uint_eq(i, 0x0204)
|| !TEST_false(PACKET_get_length_prefixed_1(&short_pkt, &subpkt))
|| !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
return 0;
}
return 1;
}
static int test_PACKET_get_length_prefixed_2()
{
unsigned char buf[1024];
unsigned char buf1[1024];
const size_t len = 516; /* 0x0204 */
unsigned int i;
PACKET pkt, short_pkt, subpkt;
PACKET pkt, short_pkt, subpkt = {0};
for (i = 1; i <= 1024; i++) {
buf[i-1] = (i * 2) & 0xff;
}
for (i = 1; i <= 1024; i++)
buf1[i - 1] = (i * 2) & 0xff;
if ( !PACKET_buf_init(&pkt, buf, 1024)
|| !PACKET_buf_init(&short_pkt, buf, len)
|| !PACKET_get_length_prefixed_2(&pkt, &subpkt)
|| PACKET_remaining(&subpkt) != len
|| !PACKET_get_net_2(&subpkt, &i)
|| i != 0x0608
|| PACKET_get_length_prefixed_2(&short_pkt, &subpkt)
|| PACKET_remaining(&short_pkt) != len) {
fprintf(stderr, "test_PACKET_get_length_prefixed_2() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
|| !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
|| !TEST_true(PACKET_get_length_prefixed_2(&pkt, &subpkt))
|| !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
|| !TEST_true(PACKET_get_net_2(&subpkt, &i))
|| !TEST_uint_eq(i, 0x0608)
|| !TEST_false(PACKET_get_length_prefixed_2(&short_pkt, &subpkt))
|| !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
return 0;
}
return 1;
}
static int test_PACKET_get_length_prefixed_3()
{
unsigned char buf[1024];
unsigned char buf1[1024];
const size_t len = 516; /* 0x000204 */
unsigned int i;
PACKET pkt, short_pkt, subpkt;
PACKET pkt, short_pkt, subpkt = {0};
for (i = 0; i < 1024; i++) {
buf[i] = (i * 2) & 0xff;
}
for (i = 0; i < 1024; i++)
buf1[i] = (i * 2) & 0xff;
if ( !PACKET_buf_init(&pkt, buf, 1024)
|| !PACKET_buf_init(&short_pkt, buf, len)
|| !PACKET_get_length_prefixed_3(&pkt, &subpkt)
|| PACKET_remaining(&subpkt) != len
|| !PACKET_get_net_2(&subpkt, &i)
|| i != 0x0608
|| PACKET_get_length_prefixed_3(&short_pkt, &subpkt)
|| PACKET_remaining(&short_pkt) != len) {
fprintf(stderr, "test_PACKET_get_length_prefixed_3() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
|| !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
|| !TEST_true(PACKET_get_length_prefixed_3(&pkt, &subpkt))
|| !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
|| !TEST_true(PACKET_get_net_2(&subpkt, &i))
|| !TEST_uint_eq(i, 0x0608)
|| !TEST_false(PACKET_get_length_prefixed_3(&short_pkt, &subpkt))
|| !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
return 0;
}
return 1;
}
static int test_PACKET_as_length_prefixed_1()
{
unsigned char buf[BUF_LEN];
unsigned char buf1[BUF_LEN];
const size_t len = 16;
unsigned int i;
PACKET pkt, exact_pkt, subpkt;
buf[0] = len;
for (i = 1; i < BUF_LEN; i++) {
buf[i] = (i * 2) & 0xff;
}
buf1[0] = len;
for (i = 1; i < BUF_LEN; i++)
buf1[i] = (i * 2) & 0xff;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN)
|| !PACKET_buf_init(&exact_pkt, buf, len + 1)
|| PACKET_as_length_prefixed_1(&pkt, &subpkt)
|| PACKET_remaining(&pkt) != BUF_LEN
|| !PACKET_as_length_prefixed_1(&exact_pkt, &subpkt)
|| PACKET_remaining(&exact_pkt) != 0
|| PACKET_remaining(&subpkt) != len) {
fprintf(stderr, "test_PACKET_as_length_prefixed_1() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
|| !TEST_true(PACKET_buf_init(&exact_pkt, buf1, len + 1))
|| !TEST_false(PACKET_as_length_prefixed_1(&pkt, &subpkt))
|| !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
|| !TEST_true(PACKET_as_length_prefixed_1(&exact_pkt, &subpkt)
|| !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
|| !TEST_size_t_eq(PACKET_remaining(&subpkt), len)))
return 0;
}
return 1;
}
@ -479,59 +446,49 @@ static int test_PACKET_as_length_prefixed_2()
unsigned int i;
PACKET pkt, exact_pkt, subpkt;
for (i = 1; i <= 1024; i++) {
for (i = 1; i <= 1024; i++)
buf[i-1] = (i * 2) & 0xff;
}
if ( !PACKET_buf_init(&pkt, buf, 1024)
|| !PACKET_buf_init(&exact_pkt, buf, len + 2)
|| PACKET_as_length_prefixed_2(&pkt, &subpkt)
|| PACKET_remaining(&pkt) != 1024
|| !PACKET_as_length_prefixed_2(&exact_pkt, &subpkt)
|| PACKET_remaining(&exact_pkt) != 0
|| PACKET_remaining(&subpkt) != len) {
fprintf(stderr, "test_PACKET_as_length_prefixed_2() failed\n");
if (!TEST_true(PACKET_buf_init(&pkt, buf, 1024))
|| !TEST_true(PACKET_buf_init(&exact_pkt, buf, len + 2))
|| !TEST_false(PACKET_as_length_prefixed_2(&pkt, &subpkt))
|| !TEST_size_t_eq(PACKET_remaining(&pkt), 1024)
|| !TEST_true(PACKET_as_length_prefixed_2(&exact_pkt, &subpkt))
|| !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
|| !TEST_size_t_eq(PACKET_remaining(&subpkt), len))
return 0;
}
return 1;
}
int main(int argc, char **argv)
void register_tests(void)
{
unsigned char buf[BUF_LEN];
unsigned int i;
for (i=1; i<=BUF_LEN; i++) {
buf[i-1] = (i * 2) & 0xff;
}
i = 0;
for (i = 1; i <= BUF_LEN; i++)
smbuf[i - 1] = (i * 2) & 0xff;
if ( !test_PACKET_buf_init()
|| !test_PACKET_null_init()
|| !test_PACKET_remaining(buf)
|| !test_PACKET_end(buf)
|| !test_PACKET_equal(buf)
|| !test_PACKET_get_1(buf)
|| !test_PACKET_get_4(buf)
|| !test_PACKET_get_net_2(buf)
|| !test_PACKET_get_net_3(buf)
|| !test_PACKET_get_net_4(buf)
|| !test_PACKET_get_sub_packet(buf)
|| !test_PACKET_get_bytes(buf)
|| !test_PACKET_copy_bytes(buf)
|| !test_PACKET_copy_all(buf)
|| !test_PACKET_memdup(buf)
|| !test_PACKET_strndup()
|| !test_PACKET_contains_zero_byte()
|| !test_PACKET_forward(buf)
|| !test_PACKET_get_length_prefixed_1()
|| !test_PACKET_get_length_prefixed_2()
|| !test_PACKET_get_length_prefixed_3()
|| !test_PACKET_as_length_prefixed_1()
|| !test_PACKET_as_length_prefixed_2()) {
return 1;
}
printf("PASS\n");
return 0;
ADD_TEST(test_PACKET_buf_init);
ADD_TEST(test_PACKET_null_init);
ADD_TEST(test_PACKET_remaining);
ADD_TEST(test_PACKET_end);
ADD_TEST(test_PACKET_equal);
ADD_TEST(test_PACKET_get_1);
ADD_TEST(test_PACKET_get_4);
ADD_TEST(test_PACKET_get_net_2);
ADD_TEST(test_PACKET_get_net_3);
ADD_TEST(test_PACKET_get_net_4);
ADD_TEST(test_PACKET_get_sub_packet);
ADD_TEST(test_PACKET_get_bytes);
ADD_TEST(test_PACKET_copy_bytes);
ADD_TEST(test_PACKET_copy_all);
ADD_TEST(test_PACKET_memdup);
ADD_TEST(test_PACKET_strndup);
ADD_TEST(test_PACKET_contains_zero_byte);
ADD_TEST(test_PACKET_forward);
ADD_TEST(test_PACKET_get_length_prefixed_1);
ADD_TEST(test_PACKET_get_length_prefixed_2);
ADD_TEST(test_PACKET_get_length_prefixed_3);
ADD_TEST(test_PACKET_as_length_prefixed_1);
ADD_TEST(test_PACKET_as_length_prefixed_2);
}

32
test/testutil.c
View file

@ -363,6 +363,38 @@ int test_str_ne(const char *file, int line, const char *st1, const char *st2,
return 1;
}
int test_strn_eq(const char *file, int line, const char *st1, const char *st2,
const char *s1, const char *s2, size_t len)
{
int prec = (int)len;
if (s1 == NULL && s2 == NULL)
return 1;
if (s1 == NULL || s2 == NULL || strncmp(s1, s2, len) != 0) {
test_fail_message(NULL, file, line, "string", "%.s [%.*s] == %s [%.*s]",
st1, prec, print_string_maybe_null(s1),
st2, prec, print_string_maybe_null(s2));
return 0;
}
return 1;
}
int test_strn_ne(const char *file, int line, const char *st1, const char *st2,
const char *s1, const char *s2, size_t len)
{
int prec = (int)len;
if ((s1 == NULL) ^ (s2 == NULL))
return 1;
if (s1 == NULL || strncmp(s1, s2, len) == 0) {
test_fail_message(NULL, file, line, "string", "%s [%.*s] != %s [%.*s]",
st1, prec, print_string_maybe_null(s1),
st2, prec, print_string_maybe_null(s2));
return 0;
}
return 1;
}
/*
* We could use OPENSSL_buf2hexstr() to do this but trying to allocate memory
* in a failure state isn't generally a great idea.

10
test/testutil.h
View file

@ -189,6 +189,14 @@ int test_ptr_null(const char *file, int line, const char *s, const void *p);
DECLARE_COMPARISON(char *, str, eq)
DECLARE_COMPARISON(char *, str, ne)
/*
* Same as above, but for strncmp.
*/
int test_strn_eq(const char *file, int line, const char *, const char *,
const char *a, const char *b, size_t s);
int test_strn_ne(const char *file, int line, const char *, const char *,
const char *a, const char *b, size_t s);
/*
* Equality test for memory blocks where NULL is a legitimate value.
* These calls return 1 if the two memory blocks compare true.
@ -293,6 +301,8 @@ void test_info_c90(const char *desc, ...) PRINTF_FORMAT(1, 2);
# define TEST_str_eq(a, b) test_str_eq(__FILE__, __LINE__, #a, #b, a, b)
# define TEST_str_ne(a, b) test_str_ne(__FILE__, __LINE__, #a, #b, a, b)
# define TEST_strn_eq(a, b, n) test_strn_eq(__FILE__, __LINE__, #a, #b, a, b, n)
# define TEST_strn_ne(a, b, n) test_strn_ne(__FILE__, __LINE__, #a, #b, a, b, n)
# define TEST_mem_eq(a, m, b, n) test_mem_eq(__FILE__, __LINE__, #a, #b, a, m, b, n)
# define TEST_mem_ne(a, m, b, n) test_mem_ne(__FILE__, __LINE__, #a, #b, a, m, b, n)

479
test/wpackettest.c
View file

@ -13,22 +13,22 @@
#include "testutil.h"
#include "test_main_custom.h"
const static unsigned char simple1 = 0xff;
const static unsigned char simple1[] = { 0xff };
const static unsigned char simple2[] = { 0x01, 0xff };
const static unsigned char simple3[] = { 0x00, 0x00, 0x00, 0x01, 0xff };
const static unsigned char nestedsub[] = { 0x03, 0xff, 0x01, 0xff };
const static unsigned char seqsub[] = { 0x01, 0xff, 0x01, 0xff };
const static unsigned char empty = 0x00;
const static unsigned char empty[] = { 0x00 };
const static unsigned char alloc[] = { 0x02, 0xfe, 0xff };
const static unsigned char submem[] = { 0x03, 0x02, 0xfe, 0xff };
const static unsigned char fixed[] = { 0xff, 0xff, 0xff };
static BUF_MEM *buf;
static void testfail(const char *msg, WPACKET *pkt)
static int cleanup(WPACKET *pkt)
{
fprintf(stderr, "%s", msg);
WPACKET_cleanup(pkt);
return 0;
}
static int test_WPACKET_init(void)
@ -38,90 +38,71 @@ static int test_WPACKET_init(void)
size_t written;
unsigned char sbuf[3];
if (!WPACKET_init(&pkt, buf)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
if (!TEST_true(WPACKET_init(&pkt, buf))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
/* Closing a top level WPACKET should fail */
|| WPACKET_close(&pkt)
|| !TEST_false(WPACKET_close(&pkt))
/* Finishing a top level WPACKET should succeed */
|| !WPACKET_finish(&pkt)
|| !TEST_true(WPACKET_finish(&pkt))
/*
* Can't call close or finish on a WPACKET that's already
* finished.
*/
|| WPACKET_close(&pkt)
|| WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(simple1)
|| memcmp(buf->data, &simple1, written) != 0) {
testfail("test_WPACKET_init():1 failed\n", &pkt);
return 0;
}
|| !TEST_false(WPACKET_close(&pkt))
|| !TEST_false(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
return cleanup(&pkt);
/* Now try with a one byte length prefix */
if (!WPACKET_init_len(&pkt, buf, 1)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(simple2)
|| memcmp(buf->data, &simple2, written) != 0) {
testfail("test_WPACKET_init():2 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
return cleanup(&pkt);
/* And a longer length prefix */
if (!WPACKET_init_len(&pkt, buf, 4)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(simple3)
|| memcmp(buf->data, &simple3, written) != 0) {
testfail("test_WPACKET_init():3 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init_len(&pkt, buf, 4))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, simple3, sizeof(simple3)))
return cleanup(&pkt);
if (!WPACKET_init_len(&pkt, buf, 1)) {
testfail("test_WPACKET_init():4 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init_len(&pkt, buf, 1)))
return cleanup(&pkt);
for (i = 1; i < 257; i++) {
/*
* Putting more bytes in than fit for the size of the length prefix
* should fail
*/
if ((!WPACKET_put_bytes_u8(&pkt, 0xff)) == (i != 256)) {
testfail("test_WPACKET_init():4 failed\n", &pkt);
return 0;
}
}
if (!WPACKET_finish(&pkt)) {
testfail("test_WPACKET_init():4 failed\n", &pkt);
return 0;
if (!TEST_int_eq(WPACKET_put_bytes_u8(&pkt, 0xff), i < 256))
return cleanup(&pkt);
}
if (!TEST_true(WPACKET_finish(&pkt)))
return cleanup(&pkt);
/* Test initialising from a fixed size buffer */
if (!WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 0)
if (!TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 0))
/* Adding 3 bytes should succeed */
|| !WPACKET_put_bytes_u24(&pkt, 0xffffff)
|| !TEST_true(WPACKET_put_bytes_u24(&pkt, 0xffffff))
/* Adding 1 more byte should fail */
|| WPACKET_put_bytes_u8(&pkt, 0xff)
|| !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
/* Finishing the top level WPACKET should succeed */
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(fixed)
|| memcmp(sbuf, fixed, sizeof(sbuf)) != 0
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(sbuf, written, fixed, sizeof(sbuf))
/* Initialise with 1 len byte */
|| !WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 1)
|| !TEST_true(WPACKET_init_static_len(&pkt, sbuf, sizeof(sbuf), 1))
/* Adding 2 bytes should succeed */
|| !WPACKET_put_bytes_u16(&pkt, 0xfeff)
|| !TEST_true(WPACKET_put_bytes_u16(&pkt, 0xfeff))
/* Adding 1 more byte should fail */
|| WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(alloc)
|| memcmp(sbuf, alloc, written) != 0) {
testfail("test_WPACKET_init():5 failed\n", &pkt);
return 0;
}
|| !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(sbuf, written, alloc, sizeof(alloc)))
return cleanup(&pkt);
return 1;
}
@ -131,53 +112,44 @@ static int test_WPACKET_set_max_size(void)
WPACKET pkt;
size_t written;
if (!WPACKET_init(&pkt, buf)
if (!TEST_true(WPACKET_init(&pkt, buf))
/*
* No previous lenbytes set so we should be ok to set the max
* possible max size
*/
|| !WPACKET_set_max_size(&pkt, SIZE_MAX)
|| !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX))
/* We should be able to set it smaller too */
|| !WPACKET_set_max_size(&pkt, SIZE_MAX -1)
|| !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX -1))
/* And setting it bigger again should be ok */
|| !WPACKET_set_max_size(&pkt, SIZE_MAX)
|| !WPACKET_finish(&pkt)) {
testfail("test_WPACKET_set_max_size():1 failed\n", &pkt);
return 0;
}
|| !TEST_true(WPACKET_set_max_size(&pkt, SIZE_MAX))
|| !TEST_true(WPACKET_finish(&pkt)))
return cleanup(&pkt);
if (!WPACKET_init_len(&pkt, buf, 1)
if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
/*
* Should fail because we already consumed 1 byte with the
* length
*/
|| WPACKET_set_max_size(&pkt, 0)
|| !TEST_false(WPACKET_set_max_size(&pkt, 0))
/*
* Max size can't be bigger than biggest that will fit in
* lenbytes
*/
|| WPACKET_set_max_size(&pkt, 0x0101)
|| !TEST_false(WPACKET_set_max_size(&pkt, 0x0101))
/* It can be the same as the maximum possible size */
|| !WPACKET_set_max_size(&pkt, 0x0100)
|| !TEST_true(WPACKET_set_max_size(&pkt, 0x0100))
/* Or it can be less */
|| !WPACKET_set_max_size(&pkt, 0x01)
/*
* Should fail because packet is already filled
*/
|| WPACKET_put_bytes_u8(&pkt, 0xff)
/*
* You can't put in more bytes than max size
*/
|| !WPACKET_set_max_size(&pkt, 0x02)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(simple2)
|| memcmp(buf->data, &simple2, written) != 0) {
testfail("test_WPACKET_set_max_size():2 failed\n", &pkt);
return 0;
}
|| !TEST_true(WPACKET_set_max_size(&pkt, 0x01))
/* Should fail because packet is already filled */
|| !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
/* You can't put in more bytes than max size */
|| !TEST_true(WPACKET_set_max_size(&pkt, 0x02))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_false(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
return cleanup(&pkt);
return 1;
}
@ -188,92 +160,77 @@ static int test_WPACKET_start_sub_packet(void)
size_t written;
size_t len;
if (!WPACKET_init(&pkt, buf)
|| !WPACKET_start_sub_packet(&pkt)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
if (!TEST_true(WPACKET_init(&pkt, buf))
|| !TEST_true(WPACKET_start_sub_packet(&pkt))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
/* Can't finish because we have a sub packet */
|| WPACKET_finish(&pkt)
|| !WPACKET_close(&pkt)
|| !TEST_false(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_close(&pkt))
/* Sub packet is closed so can't close again */
|| WPACKET_close(&pkt)
|| !TEST_false(WPACKET_close(&pkt))
/* Now a top level so finish should succeed */
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(simple1)
|| memcmp(buf->data, &simple1, written) != 0) {
testfail("test_WPACKET_start_sub_packet():1 failed\n", &pkt);
return 0;
}
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
return cleanup(&pkt);
/* Single sub-packet with length prefix */
if (!WPACKET_init(&pkt, buf)
|| !WPACKET_start_sub_packet_u8(&pkt)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_close(&pkt)
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(simple2)
|| memcmp(buf->data, &simple2, written) != 0) {
testfail("test_WPACKET_start_sub_packet():2 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init(&pkt, buf))
|| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_close(&pkt))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
return cleanup(&pkt);
/* Nested sub-packets with length prefixes */
if (!WPACKET_init(&pkt, buf)
|| !WPACKET_start_sub_packet_u8(&pkt)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_start_sub_packet_u8(&pkt)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_get_length(&pkt, &len)
|| len != 1
|| !WPACKET_close(&pkt)
|| !WPACKET_get_length(&pkt, &len)
|| len != 3
|| !WPACKET_close(&pkt)
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(nestedsub)
|| memcmp(buf->data, &nestedsub, written) != 0) {
testfail("test_WPACKET_start_sub_packet():3 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init(&pkt, buf))
|| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_get_length(&pkt, &len))
|| !TEST_size_t_eq(len, 1)
|| !TEST_true(WPACKET_close(&pkt))
|| !TEST_true(WPACKET_get_length(&pkt, &len))
|| !TEST_size_t_eq(len, 3)
|| !TEST_true(WPACKET_close(&pkt))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, nestedsub, sizeof(nestedsub)))
return cleanup(&pkt);
/* Sequential sub-packets with length prefixes */
if (!WPACKET_init(&pkt, buf)
|| !WPACKET_start_sub_packet_u8(&pkt)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_close(&pkt)
|| !WPACKET_start_sub_packet_u8(&pkt)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_close(&pkt)
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(seqsub)
|| memcmp(buf->data, &seqsub, written) != 0) {
testfail("test_WPACKET_start_sub_packet():4 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init(&pkt, buf))
|| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_close(&pkt))
|| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_close(&pkt))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, seqsub, sizeof(seqsub)))
return cleanup(&pkt);
/* Nested sub-packets with lengths filled before finish */
if (!WPACKET_init(&pkt, buf)
|| !WPACKET_start_sub_packet_u8(&pkt)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_start_sub_packet_u8(&pkt)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_get_length(&pkt, &len)
|| len != 1
|| !WPACKET_close(&pkt)
|| !WPACKET_get_length(&pkt, &len)
|| len != 3
|| !WPACKET_close(&pkt)
|| !WPACKET_fill_lengths(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(nestedsub)
|| memcmp(buf->data, &nestedsub, written) != 0
|| !WPACKET_finish(&pkt)) {
testfail("test_WPACKET_start_sub_packet():5 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init(&pkt, buf))
|| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_get_length(&pkt, &len))
|| !TEST_size_t_eq(len, 1)
|| !TEST_true(WPACKET_close(&pkt))
|| !TEST_true(WPACKET_get_length(&pkt, &len))
|| !TEST_size_t_eq(len, 3)
|| !TEST_true(WPACKET_close(&pkt))
|| !TEST_true(WPACKET_fill_lengths(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, nestedsub, sizeof(nestedsub))
|| !TEST_true(WPACKET_finish(&pkt)))
return cleanup(&pkt);
return 1;
}
@ -285,71 +242,57 @@ static int test_WPACKET_set_flags(void)
size_t written;
/* Set packet to be non-zero length */
if (!WPACKET_init(&pkt, buf)
|| !WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
if (!TEST_true(WPACKET_init(&pkt, buf))
|| !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH))
/* Should fail because of zero length */
|| WPACKET_finish(&pkt)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(simple1)
|| memcmp(buf->data, &simple1, written) != 0) {
testfail("test_WPACKET_set_flags():1 failed\n", &pkt);
return 0;
}
|| !TEST_false(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
return cleanup(&pkt);
/* Repeat above test in a sub-packet */
if (!WPACKET_init(&pkt, buf)
|| !WPACKET_start_sub_packet(&pkt)
|| !WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
if (!TEST_true(WPACKET_init(&pkt, buf))
|| !TEST_true(WPACKET_start_sub_packet(&pkt))
|| !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_NON_ZERO_LENGTH))
/* Should fail because of zero length */
|| WPACKET_close(&pkt)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_close(&pkt)
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(simple1)
|| memcmp(buf->data, &simple1, written) != 0) {
testfail("test_WPACKET_set_flags():2 failed\n", &pkt);
return 0;
}
|| !TEST_false(WPACKET_close(&pkt))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_close(&pkt))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, simple1, sizeof(simple1)))
return cleanup(&pkt);
/* Set packet to abandon non-zero length */
if (!WPACKET_init_len(&pkt, buf, 1)
|| !WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != 0) {
testfail("test_WPACKET_set_flags():3 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
|| !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_size_t_eq(written, 0))
return cleanup(&pkt);
/* Repeat above test but only abandon a sub-packet */
if (!WPACKET_init_len(&pkt, buf, 1)
|| !WPACKET_start_sub_packet_u8(&pkt)
|| !WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
|| !WPACKET_close(&pkt)
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(empty)
|| memcmp(buf->data, &empty, written) != 0) {
testfail("test_WPACKET_set_flags():4 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
|| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
|| !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
|| !TEST_true(WPACKET_close(&pkt))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, empty, sizeof(empty)))
return cleanup(&pkt);
/* And repeat with a non empty sub-packet */
if (!WPACKET_init(&pkt, buf)
|| !WPACKET_start_sub_packet_u8(&pkt)
|| !WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
|| !WPACKET_put_bytes_u8(&pkt, 0xff)
|| !WPACKET_close(&pkt)
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(simple2)
|| memcmp(buf->data, &simple2, written) != 0) {
testfail("test_WPACKET_set_flags():5 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init(&pkt, buf))
|| !TEST_true(WPACKET_start_sub_packet_u8(&pkt))
|| !TEST_true(WPACKET_set_flags(&pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))
|| !TEST_true(WPACKET_put_bytes_u8(&pkt, 0xff))
|| !TEST_true(WPACKET_close(&pkt))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, simple2, sizeof(simple2)))
return cleanup(&pkt);
return 1;
}
@ -359,36 +302,26 @@ static int test_WPACKET_allocate_bytes(void)
size_t written;
unsigned char *bytes;
if (!WPACKET_init_len(&pkt, buf, 1)
|| !WPACKET_allocate_bytes(&pkt, 2, &bytes)) {
testfail("test_WPACKET_allocate_bytes():1 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
|| !TEST_true(WPACKET_allocate_bytes(&pkt, 2, &bytes)))
return cleanup(&pkt);
bytes[0] = 0xfe;
bytes[1] = 0xff;
if (!WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(alloc)
|| memcmp(buf->data, &alloc, written) != 0) {
testfail("test_WPACKET_allocate_bytes():2 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, alloc, sizeof(alloc)))
return cleanup(&pkt);
/* Repeat with WPACKET_sub_allocate_bytes */
if (!WPACKET_init_len(&pkt, buf, 1)
|| !WPACKET_sub_allocate_bytes_u8(&pkt, 2, &bytes)) {
testfail("test_WPACKET_allocate_bytes():3 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
|| !TEST_true(WPACKET_sub_allocate_bytes_u8(&pkt, 2, &bytes)))
return cleanup(&pkt);
bytes[0] = 0xfe;
bytes[1] = 0xff;
if (!WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(submem)
|| memcmp(buf->data, &submem, written) != 0) {
testfail("test_WPACKET_allocate_bytes():4 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, submem, sizeof(submem)))
return cleanup(&pkt);
return 1;
}
@ -399,26 +332,20 @@ static int test_WPACKET_memcpy(void)
size_t written;
const unsigned char bytes[] = { 0xfe, 0xff };
if (!WPACKET_init_len(&pkt, buf, 1)
|| !WPACKET_memcpy(&pkt, bytes, sizeof(bytes))
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(alloc)
|| memcmp(buf->data, &alloc, written) != 0) {
testfail("test_WPACKET_memcpy():1 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
|| !TEST_true(WPACKET_memcpy(&pkt, bytes, sizeof(bytes)))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, alloc, sizeof(alloc)))
return cleanup(&pkt);
/* Repeat with WPACKET_sub_memcpy() */
if (!WPACKET_init_len(&pkt, buf, 1)
|| !WPACKET_sub_memcpy_u8(&pkt, bytes, sizeof(bytes))
|| !WPACKET_finish(&pkt)
|| !WPACKET_get_total_written(&pkt, &written)
|| written != sizeof(submem)
|| memcmp(buf->data, &submem, written) != 0) {
testfail("test_WPACKET_memcpy():2 failed\n", &pkt);
return 0;
}
if (!TEST_true(WPACKET_init_len(&pkt, buf, 1))
|| !TEST_true(WPACKET_sub_memcpy_u8(&pkt, bytes, sizeof(bytes)))
|| !TEST_true(WPACKET_finish(&pkt))
|| !TEST_true(WPACKET_get_total_written(&pkt, &written))
|| !TEST_mem_eq(buf->data, written, submem, sizeof(submem)))
return cleanup(&pkt);
return 1;
}
@ -427,19 +354,17 @@ int test_main(int argc, char *argv[])
{
int testresult = 0;
buf = BUF_MEM_new();
if (buf != NULL) {
ADD_TEST(test_WPACKET_init);
ADD_TEST(test_WPACKET_set_max_size);
ADD_TEST(test_WPACKET_start_sub_packet);
ADD_TEST(test_WPACKET_set_flags);
ADD_TEST(test_WPACKET_allocate_bytes);
ADD_TEST(test_WPACKET_memcpy);
if (!TEST_ptr(buf = BUF_MEM_new()))
return 0;
testresult = run_tests(argv[0]);
BUF_MEM_free(buf);
}
ADD_TEST(test_WPACKET_init);
ADD_TEST(test_WPACKET_set_max_size);
ADD_TEST(test_WPACKET_start_sub_packet);
ADD_TEST(test_WPACKET_set_flags);
ADD_TEST(test_WPACKET_allocate_bytes);
ADD_TEST(test_WPACKET_memcpy);
testresult = run_tests(argv[0]);
BUF_MEM_free(buf);
return testresult;
}