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 INCLUDE[evp_test]=../include
DEPEND[evp_test]=../libcrypto 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 INCLUDE[evp_extra_test]=../include
DEPEND[evp_extra_test]=../libcrypto DEPEND[evp_extra_test]=../libcrypto
@ -191,7 +191,7 @@ IF[{- !$disabled{tests} -}]
INCLUDE[bad_dtls_test]=../include INCLUDE[bad_dtls_test]=../include
DEPEND[bad_dtls_test]=../libcrypto ../libssl DEPEND[bad_dtls_test]=../libcrypto ../libssl
SOURCE[packettest]=packettest.c SOURCE[packettest]=packettest.c testutil.c test_main.c
INCLUDE[packettest]=../include INCLUDE[packettest]=../include
DEPEND[packettest]=../libcrypto 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) static CT_TEST_FIXTURE set_up(const char *const test_case_name)
{ {
CT_TEST_FIXTURE fixture; CT_TEST_FIXTURE fixture;
int setup_ok = 1; int ok = 0;
memset(&fixture, 0, sizeof(fixture)); memset(&fixture, 0, sizeof(fixture));
fixture.test_case_name = test_case_name; fixture.test_case_name = test_case_name;
fixture.epoch_time_in_ms = 1473269626000; /* Sep 7 17:33:46 2016 GMT */ fixture.epoch_time_in_ms = 1473269626000; /* Sep 7 17:33:46 2016 GMT */
fixture.ctlog_store = CTLOG_STORE_new(); if (!TEST_ptr(fixture.ctlog_store = CTLOG_STORE_new())
|| !TEST_int_eq(
if (fixture.ctlog_store == NULL) { CTLOG_STORE_load_default_file(fixture.ctlog_store), 1))
setup_ok = 0;
fprintf(stderr, "Failed to create a new CT log store\n");
goto end; goto end;
} ok = 1;
if (CTLOG_STORE_load_default_file(fixture.ctlog_store) != 1) {
setup_ok = 0;
fprintf(stderr, "Failed to load CT log list\n");
goto end;
}
end: end:
if (!setup_ok) { if (!ok) {
CTLOG_STORE_free(fixture.ctlog_store); CTLOG_STORE_free(fixture.ctlog_store);
TEST_error("Failed to setup");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
return fixture; 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) 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 #ifndef OPENSSL_SYS_VMS
sep = "/"; const char *sep = "/";
#else
const char *sep = "";
#endif #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) { if (full_file != NULL) {
OPENSSL_strlcpy(full_file, dir, full_file_l); OPENSSL_strlcpy(full_file, dir, len);
OPENSSL_strlcat(full_file, sep, full_file_l); OPENSSL_strlcat(full_file, sep, len);
OPENSSL_strlcat(full_file, file, full_file_l); OPENSSL_strlcat(full_file, file, len);
} }
return full_file; return full_file;
@ -121,65 +112,54 @@ static X509 *load_pem_cert(const char *dir, const char *file)
if (file_path != NULL) { if (file_path != NULL) {
BIO *cert_io = BIO_new_file(file_path, "r"); BIO *cert_io = BIO_new_file(file_path, "r");
OPENSSL_free(file_path);
if (cert_io != NULL) if (cert_io != NULL)
cert = PEM_read_bio_X509(cert_io, NULL, NULL, NULL); cert = PEM_read_bio_X509(cert_io, NULL, NULL, NULL);
BIO_free(cert_io); BIO_free(cert_io);
} }
OPENSSL_free(file_path);
return cert; return cert;
} }
static int read_text_file(const char *dir, const char *file, static int read_text_file(const char *dir, const char *file,
char *buffer, int buffer_length) char *buffer, int buffer_length)
{ {
int result = -1; int len = -1;
char *file_path = mk_file_path(dir, file); char *file_path = mk_file_path(dir, file);
if (file_path != NULL) { if (file_path != NULL) {
BIO *file_io = BIO_new_file(file_path, "r"); BIO *file_io = BIO_new_file(file_path, "r");
OPENSSL_free(file_path);
if (file_io != NULL) { if (file_io != NULL)
result = BIO_read(file_io, buffer, buffer_length); len = BIO_read(file_io, buffer, buffer_length);
BIO_free(file_io); BIO_free(file_io);
}
} }
return result; OPENSSL_free(file_path);
return len;
} }
static int compare_sct_list_printout(STACK_OF(SCT) *sct, static int compare_sct_list_printout(STACK_OF(SCT) *sct,
const char *expected_output) const char *expected_output)
{ {
BIO *text_buffer = NULL; BIO *text_buffer = NULL;
char *actual_output = NULL; char *actual_output = NULL;
int result = 1; int result = 0;
text_buffer = BIO_new(BIO_s_mem()); if (!TEST_ptr(text_buffer = BIO_new(BIO_s_mem())))
if (text_buffer == NULL) {
fprintf(stderr, "Unable to allocate buffer\n");
goto end; goto end;
}
SCT_LIST_print(sct, text_buffer, 0, "\n", NULL); SCT_LIST_print(sct, text_buffer, 0, "\n", NULL);
/* Append null terminator because we're about to use the buffer contents /* Append \0 because we're about to use the buffer contents as a string. */
* as a string. */ if (!TEST_true(BIO_write(text_buffer, "\0", 1)))
if (BIO_write(text_buffer, "\0", 1) != 1) {
fprintf(stderr, "Failed to append null terminator to SCT text\n");
goto end; goto end;
}
BIO_get_mem_data(text_buffer, &actual_output); 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) { result = 1;
fprintf(stderr,
"Expected SCT printout:\n%s\nActual SCT printout:\n%s\n",
expected_output, actual_output);
}
end: end:
BIO_free(text_buffer); BIO_free(text_buffer);
@ -191,55 +171,41 @@ static int compare_extension_printout(X509_EXTENSION *extension,
{ {
BIO *text_buffer = NULL; BIO *text_buffer = NULL;
char *actual_output = NULL; char *actual_output = NULL;
int result = 1; int result = 0;
text_buffer = BIO_new(BIO_s_mem()); if (!TEST_ptr(text_buffer = BIO_new(BIO_s_mem()))
if (text_buffer == NULL) { || !TEST_true(X509V3_EXT_print(text_buffer, extension,
fprintf(stderr, "Unable to allocate buffer\n"); X509V3_EXT_DEFAULT, 0)))
goto end; goto end;
}
if (!X509V3_EXT_print(text_buffer, extension, X509V3_EXT_DEFAULT, 0)) { /* Append \0 because we're about to use the buffer contents as a string. */
fprintf(stderr, "Failed to print extension\n"); if (!TEST_true(BIO_write(text_buffer, "\0", 1)))
goto end; 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); 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) { result = 1;
fprintf(stderr,
"Expected SCT printout:\n%s\nActual SCT printout:\n%s\n",
expected_output, actual_output);
}
end: end:
BIO_free(text_buffer); BIO_free(text_buffer);
return result; return result;
} }
static int assert_validity(CT_TEST_FIXTURE fixture, static int assert_validity(CT_TEST_FIXTURE fixture, STACK_OF(SCT) *scts,
STACK_OF(SCT) *scts, CT_POLICY_EVAL_CTX *policy_ctx)
CT_POLICY_EVAL_CTX *policy_ctx) { {
int invalid_sct_count = 0; int invalid_sct_count = 0;
int valid_sct_count = 0; int valid_sct_count = 0;
int i; int i;
if (SCT_LIST_validate(scts, policy_ctx) < 0) { if (!TEST_int_ge(SCT_LIST_validate(scts, policy_ctx), 0))
fprintf(stderr, "Error verifying SCTs\n");
return 0; return 0;
}
for (i = 0; i < sk_SCT_num(scts); ++i) { for (i = 0; i < sk_SCT_num(scts); ++i) {
SCT *sct_i = sk_SCT_value(scts, i); SCT *sct_i = sk_SCT_value(scts, i);
switch (SCT_get_validation_status(sct_i)) { switch (SCT_get_validation_status(sct_i)) {
case SCT_VALIDATION_STATUS_VALID: case SCT_VALIDATION_STATUS_VALID:
++valid_sct_count; ++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) - int unverified_sct_count = sk_SCT_num(scts) -
invalid_sct_count - valid_sct_count; invalid_sct_count - valid_sct_count;
fprintf(stderr, TEST_info("%d SCTs failed, %d SCTs unverified",
"%d SCTs failed verification\n" invalid_sct_count, unverified_sct_count);
"%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);
return 0; return 0;
} }
@ -291,12 +251,8 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
expected_sct_text, expected_sct_text,
CT_TEST_MAX_FILE_SIZE - 1); CT_TEST_MAX_FILE_SIZE - 1);
if (sct_text_len < 0) { if (!TEST_int_ge(sct_text_len, 0))
fprintf(stderr, "Test data file not found: %s\n",
fixture.sct_text_file);
goto end; goto end;
}
expected_sct_text[sct_text_len] = '\0'; 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) { if (fixture.certificate_file != NULL) {
int sct_extension_index; int sct_extension_index;
X509_EXTENSION *sct_extension = NULL; X509_EXTENSION *sct_extension = NULL;
cert = load_pem_cert(fixture.certs_dir, fixture.certificate_file);
if (cert == NULL) { if (!TEST_ptr(cert = load_pem_cert(fixture.certs_dir,
fprintf(stderr, "Unable to load certificate: %s\n", fixture.certificate_file)))
fixture.certificate_file);
goto end; goto end;
}
CT_POLICY_EVAL_CTX_set1_cert(ct_policy_ctx, cert); CT_POLICY_EVAL_CTX_set1_cert(ct_policy_ctx, cert);
if (fixture.issuer_file != NULL) { if (fixture.issuer_file != NULL) {
issuer = load_pem_cert(fixture.certs_dir, fixture.issuer_file); if (!TEST_ptr(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);
goto end; goto end;
}
CT_POLICY_EVAL_CTX_set1_issuer(ct_policy_ctx, issuer); 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); X509_get_ext_by_NID(cert, NID_ct_precert_scts, -1);
sct_extension = X509_get_ext(cert, sct_extension_index); sct_extension = X509_get_ext(cert, sct_extension_index);
if (fixture.expected_sct_count > 0) { if (fixture.expected_sct_count > 0) {
if (sct_extension == NULL) { if (!TEST_ptr(sct_extension))
fprintf(stderr, "SCT extension not found in: %s\n",
fixture.certificate_file);
goto end; goto end;
}
if (fixture.sct_text_file if (fixture.sct_text_file
&& compare_extension_printout(sct_extension, && !compare_extension_printout(sct_extension,
expected_sct_text)) { expected_sct_text))
goto end; goto end;
}
if (fixture.test_validity) { if (fixture.test_validity) {
int i; int i;
@ -353,30 +297,24 @@ static int execute_cert_test(CT_TEST_FIXTURE fixture)
for (i = 0; i < sk_SCT_num(scts); ++i) { for (i = 0; i < sk_SCT_num(scts); ++i) {
SCT *sct_i = sk_SCT_value(scts, i); SCT *sct_i = sk_SCT_value(scts, i);
if (!SCT_set_source(sct_i, SCT_SOURCE_X509V3_EXTENSION)) { if (!TEST_true(SCT_set_source(sct_i,
fprintf(stderr, SCT_SOURCE_X509V3_EXTENSION)))
"Error setting SCT source to X509v3 extension\n");
goto end; goto end;
}
} }
if (!assert_validity(fixture, scts, ct_policy_ctx)) if (!assert_validity(fixture, scts, ct_policy_ctx))
goto end; goto end;
} }
} else if (sct_extension != NULL) { } else if (!TEST_ptr_null(sct_extension)) {
fprintf(stderr,
"Expected no SCTs, but found SCT extension in: %s\n",
fixture.certificate_file);
goto end; goto end;
} }
} }
if (fixture.tls_sct_list != NULL) { if (fixture.tls_sct_list != NULL) {
const unsigned char *p = fixture.tls_sct_list; 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; goto end;
}
if (fixture.test_validity && cert != NULL) { if (fixture.test_validity && cert != NULL) {
if (!assert_validity(fixture, scts, ct_policy_ctx)) 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 if (fixture.sct_text_file
&& compare_sct_list_printout(scts, expected_sct_text)) { && !compare_sct_list_printout(scts, expected_sct_text)) {
goto end; goto end;
} }
tls_sct_list_len = i2o_SCT_LIST(scts, &tls_sct_list); tls_sct_list_len = i2o_SCT_LIST(scts, &tls_sct_list);
if (tls_sct_list_len != fixture.tls_sct_list_len || if (!TEST_mem_eq(fixture.tls_sct_list, fixture.tls_sct_list_len,
memcmp(fixture.tls_sct_list, tls_sct_list, tls_sct_list_len) != 0) { tls_sct_list, tls_sct_list_len))
fprintf(stderr,
"Failed to encode SCTs into TLS format correctly\n");
goto end; goto end;
}
} }
success = 1; success = 1;
@ -520,15 +455,11 @@ static int test_encode_tls_sct()
SETUP_CT_TEST_FIXTURE(); SETUP_CT_TEST_FIXTURE();
fixture.sct_list = sk_SCT_new_null(); fixture.sct_list = sk_SCT_new_null();
sct = SCT_new_from_base64(SCT_VERSION_V1, log_id, if (!TEST_ptr(sct = SCT_new_from_base64(SCT_VERSION_V1, log_id,
CT_LOG_ENTRY_TYPE_X509, timestamp, CT_LOG_ENTRY_TYPE_X509, timestamp,
extensions, signature); extensions, signature)))
if (sct == NULL) {
tear_down(fixture);
fprintf(stderr, "Failed to create SCT from base64-encoded test data\n");
return 0; return 0;
}
sk_SCT_push(fixture.sct_list, sct); sk_SCT_push(fixture.sct_list, sct);
fixture.sct_dir = ct_dir; fixture.sct_dir = ct_dir;
@ -548,11 +479,8 @@ static int test_default_ct_policy_eval_ctx_time_is_now()
1000; 1000;
const time_t time_tolerance = 600; /* 10 minutes */ const time_t time_tolerance = 600; /* 10 minutes */
if (fabs(difftime(time(NULL), default_time)) > time_tolerance) { if (!TEST_uint_le(fabs(difftime(time(NULL), default_time)), time_tolerance))
fprintf(stderr,
"Default CT_POLICY_EVAL_CTX time is not approximately now.\n");
goto end; goto end;
}
success = 1; success = 1;
end: end:
@ -562,13 +490,10 @@ end:
int test_main(int argc, char *argv[]) int test_main(int argc, char *argv[])
{ {
int result = 0; if ((ct_dir = getenv("CT_DIR")) == NULL)
char *tmp_env; ct_dir = "ct";
if ((certs_dir = getenv("CERTS_DIR")) == NULL)
tmp_env = getenv("CT_DIR"); certs_dir = "certs";
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");
ADD_TEST(test_no_scts_in_certificate); ADD_TEST(test_no_scts_in_certificate);
ADD_TEST(test_one_sct_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_encode_tls_sct);
ADD_TEST(test_default_ct_policy_eval_ctx_time_is_now); ADD_TEST(test_default_ct_policy_eval_ctx_time_is_now);
result = run_tests(argv[0]); return run_tests(argv[0]);
OPENSSL_free(ct_dir);
OPENSSL_free(certs_dir);
return result;
} }
#else #else
int test_main(int argc, char *argv[]) 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/evp.h>
#include <openssl/rsa.h> #include <openssl/rsa.h>
#include <openssl/x509.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 * kExampleRSAKeyDER is an RSA private key in ASN.1, DER format. Of course, you
@ -186,6 +188,18 @@ static const unsigned char kExampleBadECKeyDER[] = {
}; };
#endif #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) static EVP_PKEY *load_example_rsa_key(void)
{ {
EVP_PKEY *ret = NULL; EVP_PKEY *ret = NULL;
@ -193,19 +207,17 @@ static EVP_PKEY *load_example_rsa_key(void)
EVP_PKEY *pkey = NULL; EVP_PKEY *pkey = NULL;
RSA *rsa = NULL; RSA *rsa = NULL;
if (!d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))) { if (!TEST_true(d2i_RSAPrivateKey(&rsa, &derp, sizeof(kExampleRSAKeyDER))))
return NULL; return NULL;
}
pkey = EVP_PKEY_new(); if (!TEST_ptr(pkey = EVP_PKEY_new())
if (pkey == NULL || !EVP_PKEY_set1_RSA(pkey, rsa)) { || !TEST_true(EVP_PKEY_set1_RSA(pkey, rsa)))
goto out; goto end;
}
ret = pkey; ret = pkey;
pkey = NULL; pkey = NULL;
out: end:
EVP_PKEY_free(pkey); EVP_PKEY_free(pkey);
RSA_free(rsa); RSA_free(rsa);
@ -218,48 +230,37 @@ static int test_EVP_DigestSignInit(void)
EVP_PKEY *pkey = NULL; EVP_PKEY *pkey = NULL;
unsigned char *sig = NULL; unsigned char *sig = NULL;
size_t sig_len = 0; 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(); if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
md_ctx_verify = EVP_MD_CTX_new(); || !TEST_ptr(md_ctx_verify = EVP_MD_CTX_new())
if (md_ctx == NULL || md_ctx_verify == NULL) || !TEST_ptr(pkey = load_example_rsa_key()))
goto out; goto out;
pkey = load_example_rsa_key(); if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
if (pkey == NULL || || !TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
!EVP_DigestSignInit(md_ctx, NULL, EVP_sha256(), NULL, pkey) ||
!EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))) {
goto out; goto out;
}
/* Determine the size of the signature. */ /* 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; 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 (!TEST_ptr(sig = OPENSSL_malloc(sig_len))
if (sig == NULL || !EVP_DigestSignFinal(md_ctx, sig, &sig_len)) { || !TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
goto out; goto out;
}
/* Ensure that the signature round-trips. */ /* Ensure that the signature round-trips. */
if (!EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sha256(), NULL, pkey) if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sha256(),
|| !EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg)) NULL, pkey))
|| !EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)) { || !TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify,
kMsg, sizeof(kMsg)))
|| !TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
goto out; goto out;
}
ret = 1; ret = 1;
out: out:
if (!ret) {
ERR_print_errors_fp(stderr);
}
EVP_MD_CTX_free(md_ctx); EVP_MD_CTX_free(md_ctx);
EVP_MD_CTX_free(md_ctx_verify); EVP_MD_CTX_free(md_ctx_verify);
EVP_PKEY_free(pkey); EVP_PKEY_free(pkey);
@ -272,56 +273,44 @@ static int test_EVP_DigestVerifyInit(void)
{ {
int ret = 0; int ret = 0;
EVP_PKEY *pkey = NULL; EVP_PKEY *pkey = NULL;
EVP_MD_CTX *md_ctx; EVP_MD_CTX *md_ctx = NULL;
md_ctx = EVP_MD_CTX_new(); if (!TEST_ptr(md_ctx = EVP_MD_CTX_new())
|| !TEST_ptr(pkey = load_example_rsa_key()))
pkey = load_example_rsa_key(); goto out;
if (pkey == NULL ||
!EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey) || if (!TEST_true(EVP_DigestVerifyInit(md_ctx, NULL, EVP_sha256(), NULL, pkey))
!EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)) || || !TEST_true(EVP_DigestVerifyUpdate(md_ctx, kMsg, sizeof(kMsg)))
!EVP_DigestVerifyFinal(md_ctx, kSignature, sizeof(kSignature))) { || !TEST_true(EVP_DigestVerifyFinal(md_ctx, kSignature,
sizeof(kSignature))))
goto out; goto out;
}
ret = 1; ret = 1;
out: out:
if (!ret) {
ERR_print_errors_fp(stderr);
}
EVP_MD_CTX_free(md_ctx); EVP_MD_CTX_free(md_ctx);
EVP_PKEY_free(pkey); EVP_PKEY_free(pkey);
return ret; return ret;
} }
static int test_d2i_AutoPrivateKey(const unsigned char *input, static int test_d2i_AutoPrivateKey(int i)
size_t input_len, int expected_id)
{ {
int ret = 0; int ret = 0;
const unsigned char *p; const unsigned char *p;
EVP_PKEY *pkey = NULL; 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; p = input;
pkey = d2i_AutoPrivateKey(NULL, &p, input_len); if (!TEST_ptr(pkey = d2i_AutoPrivateKey(NULL, &p, input_len))
if (pkey == NULL || p != input + input_len) { || !TEST_ptr_eq(p, input + input_len)
fprintf(stderr, "d2i_AutoPrivateKey failed\n"); || !TEST_int_eq(EVP_PKEY_id(pkey), expected_id))
goto done; goto done;
}
if (EVP_PKEY_id(pkey) != expected_id) {
fprintf(stderr, "Did not decode expected type\n");
goto done;
}
ret = 1; ret = 1;
done: done:
if (!ret) {
ERR_print_errors_fp(stderr);
}
EVP_PKEY_free(pkey); EVP_PKEY_free(pkey);
return ret; return ret;
} }
@ -335,18 +324,16 @@ static int test_EVP_PKCS82PKEY(void)
PKCS8_PRIV_KEY_INFO *p8inf = NULL; PKCS8_PRIV_KEY_INFO *p8inf = NULL;
EVP_PKEY *pkey = NULL; EVP_PKEY *pkey = NULL;
p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp, sizeof(kExampleBadECKeyDER)); if (!TEST_ptr(p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &derp,
sizeof(kExampleBadECKeyDER))))
if (!p8inf || derp != kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)) {
fprintf(stderr, "Failed to parse key\n");
goto done; goto done;
}
pkey = EVP_PKCS82PKEY(p8inf); if (!TEST_ptr_eq(derp,
if (pkey) { kExampleBadECKeyDER + sizeof(kExampleBadECKeyDER)))
fprintf(stderr, "Imported invalid EC key\n"); goto done;
if (!TEST_ptr_null(pkey = EVP_PKCS82PKEY(p8inf)))
goto done; goto done;
}
ret = 1; ret = 1;
@ -358,52 +345,13 @@ static int test_EVP_PKCS82PKEY(void)
} }
#endif #endif
int main(void) void register_tests(void)
{ {
CRYPTO_set_mem_debug(1); ADD_TEST(test_EVP_DigestSignInit);
CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON); ADD_TEST(test_EVP_DigestVerifyInit);
ADD_ALL_TESTS(test_d2i_AutoPrivateKey,
sizeof(keydata) / sizeof(keydata[0]));
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;
}
#ifndef OPENSSL_NO_EC #ifndef OPENSSL_NO_EC
if (!test_d2i_AutoPrivateKey(kExampleECKeyDER, sizeof(kExampleECKeyDER), ADD_TEST(test_EVP_PKCS82PKEY);
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;
}
#endif #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 "../ssl/packet_locl.h"
#include "testutil.h"
#include "test_main.h"
#define BUF_LEN 255 #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; PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
|| PACKET_remaining(&pkt) != BUF_LEN || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
|| !PACKET_forward(&pkt, BUF_LEN - 1) || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
|| PACKET_remaining(&pkt) != 1 || !TEST_size_t_eq(PACKET_remaining(&pkt), 1)
|| !PACKET_forward(&pkt, 1) || !TEST_true(PACKET_forward(&pkt, 1))
|| PACKET_remaining(&pkt) != 0) { || !TEST_size_t_eq(PACKET_remaining(&pkt), 0)))
fprintf(stderr, "test_PACKET_remaining() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_end(unsigned char buf[BUF_LEN]) static int test_PACKET_end()
{ {
PACKET pkt; PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, sizeof(smbuf))
|| PACKET_remaining(&pkt) != BUF_LEN || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
|| PACKET_end(&pkt) != buf + BUF_LEN || !TEST_ptr_ne(PACKET_end(&pkt), smbuf + BUF_LEN)
|| !PACKET_forward(&pkt, BUF_LEN - 1) || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 1))
|| PACKET_end(&pkt) != buf + BUF_LEN || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)
|| !PACKET_forward(&pkt, 1) || !TEST_true(PACKET_forward(&pkt, 1))
|| PACKET_end(&pkt) != buf + BUF_LEN) { || !TEST_ptr_eq(PACKET_end(&pkt), smbuf + BUF_LEN)))
fprintf(stderr, "test_PACKET_end() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_get_1(unsigned char buf[BUF_LEN]) static int test_PACKET_get_1()
{ {
unsigned int i; unsigned int i;
PACKET pkt; PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !PACKET_get_1(&pkt, &i) || !TEST_true(PACKET_get_1(&pkt, &i))
|| i != 0x02 || !TEST_uint_eq(i, 0x02)
|| !PACKET_forward(&pkt, BUF_LEN - 2) || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 2))
|| !PACKET_get_1(&pkt, &i) || !TEST_true(PACKET_get_1(&pkt, &i))
|| i != 0xfe || !TEST_uint_eq(i, 0xfe)
|| PACKET_get_1(&pkt, &i)) { || !TEST_false(PACKET_get_1(&pkt, &i)))
fprintf(stderr, "test_PACKET_get_1() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_get_4(unsigned char buf[BUF_LEN]) static int test_PACKET_get_4()
{ {
unsigned long i; unsigned long i;
PACKET pkt; PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !PACKET_get_4(&pkt, &i) || !TEST_true(PACKET_get_4(&pkt, &i))
|| i != 0x08060402UL || !TEST_ulong_eq(i, 0x08060402UL)
|| !PACKET_forward(&pkt, BUF_LEN - 8) || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
|| !PACKET_get_4(&pkt, &i) || !TEST_true(PACKET_get_4(&pkt, &i))
|| i != 0xfefcfaf8UL || !TEST_ulong_eq(i, 0xfefcfaf8UL)
|| PACKET_get_4(&pkt, &i)) { || !TEST_false(PACKET_get_4(&pkt, &i)))
fprintf(stderr, "test_PACKET_get_4() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_get_net_2(unsigned char buf[BUF_LEN]) static int test_PACKET_get_net_2()
{ {
unsigned int i; unsigned int i;
PACKET pkt; PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !PACKET_get_net_2(&pkt, &i) || !TEST_true(PACKET_get_net_2(&pkt, &i))
|| i != 0x0204 || !TEST_uint_eq(i, 0x0204)
|| !PACKET_forward(&pkt, BUF_LEN - 4) || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 4))
|| !PACKET_get_net_2(&pkt, &i) || !TEST_true(PACKET_get_net_2(&pkt, &i))
|| i != 0xfcfe || !TEST_uint_eq(i, 0xfcfe)
|| PACKET_get_net_2(&pkt, &i)) { || !TEST_false(PACKET_get_net_2(&pkt, &i)))
fprintf(stderr, "test_PACKET_get_net_2() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_get_net_3(unsigned char buf[BUF_LEN]) static int test_PACKET_get_net_3()
{ {
unsigned long i; unsigned long i;
PACKET pkt; PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !PACKET_get_net_3(&pkt, &i) || !TEST_true(PACKET_get_net_3(&pkt, &i))
|| i != 0x020406UL || !TEST_ulong_eq(i, 0x020406UL)
|| !PACKET_forward(&pkt, BUF_LEN - 6) || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 6))
|| !PACKET_get_net_3(&pkt, &i) || !TEST_true(PACKET_get_net_3(&pkt, &i))
|| i != 0xfafcfeUL || !TEST_ulong_eq(i, 0xfafcfeUL)
|| PACKET_get_net_3(&pkt, &i)) { || !TEST_false(PACKET_get_net_3(&pkt, &i)))
fprintf(stderr, "test_PACKET_get_net_3() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_get_net_4(unsigned char buf[BUF_LEN]) static int test_PACKET_get_net_4()
{ {
unsigned long i; unsigned long i;
PACKET pkt; PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !PACKET_get_net_4(&pkt, &i) || !TEST_true(PACKET_get_net_4(&pkt, &i))
|| i != 0x02040608UL || !TEST_ulong_eq(i, 0x02040608UL)
|| !PACKET_forward(&pkt, BUF_LEN - 8) || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
|| !PACKET_get_net_4(&pkt, &i) || !TEST_true(PACKET_get_net_4(&pkt, &i))
|| i != 0xf8fafcfeUL || !TEST_ulong_eq(i, 0xf8fafcfeUL)
|| PACKET_get_net_4(&pkt, &i)) { || !TEST_false(PACKET_get_net_4(&pkt, &i)))
fprintf(stderr, "test_PACKET_get_net_4() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_get_sub_packet(unsigned char buf[BUF_LEN]) static int test_PACKET_get_sub_packet()
{ {
PACKET pkt, subpkt; PACKET pkt, subpkt;
unsigned long i; unsigned long i;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !PACKET_get_sub_packet(&pkt, &subpkt, 4) || !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
|| !PACKET_get_net_4(&subpkt, &i) || !TEST_true(PACKET_get_net_4(&subpkt, &i))
|| i != 0x02040608UL || !TEST_ulong_eq(i, 0x02040608UL)
|| PACKET_remaining(&subpkt) || !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
|| !PACKET_forward(&pkt, BUF_LEN - 8) || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
|| !PACKET_get_sub_packet(&pkt, &subpkt, 4) || !TEST_true(PACKET_get_sub_packet(&pkt, &subpkt, 4))
|| !PACKET_get_net_4(&subpkt, &i) || !TEST_true(PACKET_get_net_4(&subpkt, &i))
|| i != 0xf8fafcfeUL || !TEST_ulong_eq(i, 0xf8fafcfeUL)
|| PACKET_remaining(&subpkt) || !TEST_size_t_eq(PACKET_remaining(&subpkt), 0)
|| PACKET_get_sub_packet(&pkt, &subpkt, 4)) { || !TEST_false(PACKET_get_sub_packet(&pkt, &subpkt, 4)))
fprintf(stderr, "test_PACKET_get_sub_packet() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_get_bytes(unsigned char buf[BUF_LEN]) static int test_PACKET_get_bytes()
{ {
const unsigned char *bytes; const unsigned char *bytes;
PACKET pkt; PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !PACKET_get_bytes(&pkt, &bytes, 4) || !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
|| bytes[0] != 2 || bytes[1] != 4 || !TEST_uchar_eq(bytes[0], 2)
|| bytes[2] != 6 || bytes[3] != 8 || !TEST_uchar_eq(bytes[1], 4)
|| PACKET_remaining(&pkt) != BUF_LEN -4 || !TEST_uchar_eq(bytes[2], 6)
|| !PACKET_forward(&pkt, BUF_LEN - 8) || !TEST_uchar_eq(bytes[3], 8)
|| !PACKET_get_bytes(&pkt, &bytes, 4) || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN -4)
|| bytes[0] != 0xf8 || bytes[1] != 0xfa || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
|| bytes[2] != 0xfc || bytes[3] != 0xfe || !TEST_true(PACKET_get_bytes(&pkt, &bytes, 4))
|| PACKET_remaining(&pkt)) { || !TEST_uchar_eq(bytes[0], 0xf8)
fprintf(stderr, "test_PACKET_get_bytes() failed\n"); || !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 0;
}
return 1; return 1;
} }
static int test_PACKET_copy_bytes(unsigned char buf[BUF_LEN]) static int test_PACKET_copy_bytes()
{ {
unsigned char bytes[4]; unsigned char bytes[4];
PACKET pkt; PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !PACKET_copy_bytes(&pkt, bytes, 4) || !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
|| bytes[0] != 2 || bytes[1] != 4 || !TEST_char_eq(bytes[0], 2)
|| bytes[2] != 6 || bytes[3] != 8 || !TEST_char_eq(bytes[1], 4)
|| PACKET_remaining(&pkt) != BUF_LEN - 4 || !TEST_char_eq(bytes[2], 6)
|| !PACKET_forward(&pkt, BUF_LEN - 8) || !TEST_char_eq(bytes[3], 8)
|| !PACKET_copy_bytes(&pkt, bytes, 4) || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN - 4)
|| bytes[0] != 0xf8 || bytes[1] != 0xfa || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 8))
|| bytes[2] != 0xfc || bytes[3] != 0xfe || !TEST_true(PACKET_copy_bytes(&pkt, bytes, 4))
|| PACKET_remaining(&pkt)) { || !TEST_uchar_eq(bytes[0], 0xf8)
fprintf(stderr, "test_PACKET_copy_bytes() failed\n"); || !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 0;
}
return 1; return 1;
} }
static int test_PACKET_copy_all(unsigned char buf[BUF_LEN]) static int test_PACKET_copy_all()
{ {
unsigned char tmp[BUF_LEN]; unsigned char tmp[BUF_LEN];
PACKET pkt; PACKET pkt;
size_t len; size_t len;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !PACKET_copy_all(&pkt, tmp, BUF_LEN, &len) || !TEST_true(PACKET_copy_all(&pkt, tmp, BUF_LEN, &len))
|| len != BUF_LEN || !TEST_size_t_eq(len, BUF_LEN)
|| memcmp(buf, tmp, BUF_LEN) != 0 || !TEST_mem_eq(smbuf, BUF_LEN, tmp, BUF_LEN)
|| PACKET_remaining(&pkt) != BUF_LEN || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
|| PACKET_copy_all(&pkt, tmp, BUF_LEN - 1, &len)) { || !TEST_false(PACKET_copy_all(&pkt, tmp, BUF_LEN - 1, &len)))
fprintf(stderr, "test_PACKET_copy_bytes() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_memdup(unsigned char buf[BUF_LEN]) static int test_PACKET_memdup()
{ {
unsigned char *data = NULL; unsigned char *data = NULL;
size_t len; size_t len;
PACKET pkt; PACKET pkt;
int result = 0;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !PACKET_memdup(&pkt, &data, &len) || !TEST_true(PACKET_memdup(&pkt, &data, &len))
|| len != BUF_LEN || !TEST_size_t_eq(len, BUF_LEN)
|| memcmp(data, PACKET_data(&pkt), len) || !TEST_mem_eq(data, len, PACKET_data(&pkt), len)
|| !PACKET_forward(&pkt, 10) || !TEST_true(PACKET_forward(&pkt, 10))
|| !PACKET_memdup(&pkt, &data, &len) || !TEST_true(PACKET_memdup(&pkt, &data, &len))
|| len != BUF_LEN - 10 || !TEST_size_t_eq(len, BUF_LEN - 10)
|| memcmp(data, PACKET_data(&pkt), len)) { || !TEST_mem_eq(data, len, PACKET_data(&pkt), len))
fprintf(stderr, "test_PACKET_memdup() failed\n"); goto end;
OPENSSL_free(data); result = 1;
return 0; end:
}
OPENSSL_free(data); OPENSSL_free(data);
return 1; return result;
} }
static int test_PACKET_strndup() static int test_PACKET_strndup()
{ {
char buf[10], buf2[10]; char buf1[10], buf2[10];
char *data = NULL; char *data = NULL;
PACKET pkt; PACKET pkt;
int result = 0;
memset(buf, 'x', 10); memset(buf1, 'x', 10);
memset(buf2, 'y', 10); memset(buf2, 'y', 10);
buf2[5] = '\0'; buf2[5] = '\0';
if ( !PACKET_buf_init(&pkt, (unsigned char*)buf, 10) if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
|| !PACKET_strndup(&pkt, &data) || !TEST_true(PACKET_strndup(&pkt, &data))
|| strlen(data) != 10 || !TEST_size_t_eq(strlen(data), 10)
|| strncmp(data, buf, 10) || !TEST_strn_eq(data, buf1, 10)
|| !PACKET_buf_init(&pkt, (unsigned char*)buf2, 10) || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
|| !PACKET_strndup(&pkt, &data) || !TEST_true(PACKET_strndup(&pkt, &data))
|| strlen(data) != 5 || !TEST_size_t_eq(strlen(data), 5)
|| strcmp(data, buf2)) { || !TEST_str_eq(data, buf2))
fprintf(stderr, "test_PACKET_strndup failed\n"); goto end;
OPENSSL_free(data);
return 0;
}
result = 1;
end:
OPENSSL_free(data); OPENSSL_free(data);
return 1; return result;
} }
static int test_PACKET_contains_zero_byte() static int test_PACKET_contains_zero_byte()
{ {
char buf[10], buf2[10]; char buf1[10], buf2[10];
PACKET pkt; PACKET pkt;
memset(buf, 'x', 10); memset(buf1, 'x', 10);
memset(buf2, 'y', 10); memset(buf2, 'y', 10);
buf2[5] = '\0'; buf2[5] = '\0';
if ( !PACKET_buf_init(&pkt, (unsigned char*)buf, 10) if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10))
|| PACKET_contains_zero_byte(&pkt) || !TEST_false(PACKET_contains_zero_byte(&pkt))
|| !PACKET_buf_init(&pkt, (unsigned char*)buf2, 10) || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10))
|| !PACKET_contains_zero_byte(&pkt)) { || !TEST_true(PACKET_contains_zero_byte(&pkt)))
fprintf(stderr, "test_PACKET_contains_zero_byte failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_forward(unsigned char buf[BUF_LEN]) static int test_PACKET_forward()
{ {
const unsigned char *byte; const unsigned char *byte;
PACKET pkt; PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !PACKET_forward(&pkt, 1) || !TEST_true(PACKET_forward(&pkt, 1))
|| !PACKET_get_bytes(&pkt, &byte, 1) || !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
|| byte[0] != 4 || !TEST_uchar_eq(byte[0], 4)
|| !PACKET_forward(&pkt, BUF_LEN - 3) || !TEST_true(PACKET_forward(&pkt, BUF_LEN - 3))
|| !PACKET_get_bytes(&pkt, &byte, 1) || !TEST_true(PACKET_get_bytes(&pkt, &byte, 1))
|| byte[0] != 0xfe) { || !TEST_uchar_eq(byte[0], 0xfe))
fprintf(stderr, "test_PACKET_forward() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_buf_init() static int test_PACKET_buf_init()
{ {
unsigned char buf[BUF_LEN]; unsigned char buf1[BUF_LEN];
PACKET pkt; PACKET pkt;
/* Also tests PACKET_remaining() */ /* Also tests PACKET_remaining() */
if ( !PACKET_buf_init(&pkt, buf, 4) if (!TEST_true(PACKET_buf_init(&pkt, buf1, 4))
|| PACKET_remaining(&pkt) != 4 || !TEST_size_t_eq(PACKET_remaining(&pkt), 4)
|| !PACKET_buf_init(&pkt, buf, BUF_LEN) || !TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
|| PACKET_remaining(&pkt) != BUF_LEN || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
|| PACKET_buf_init(&pkt, buf, -1)) { || !TEST_false(PACKET_buf_init(&pkt, buf1, -1)))
fprintf(stderr, "test_PACKET_buf_init() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
@ -339,135 +322,119 @@ static int test_PACKET_null_init()
PACKET pkt; PACKET pkt;
PACKET_null_init(&pkt); PACKET_null_init(&pkt);
if ( PACKET_remaining(&pkt) != 0 if (!TEST_size_t_eq(PACKET_remaining(&pkt), 0)
|| PACKET_forward(&pkt, 1)) { || !TEST_false(PACKET_forward(&pkt, 1)))
fprintf(stderr, "test_PACKET_null_init() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_equal(unsigned char buf[BUF_LEN]) static int test_PACKET_equal()
{ {
PACKET pkt; PACKET pkt;
if ( !PACKET_buf_init(&pkt, buf, 4) if (!TEST_true(PACKET_buf_init(&pkt, smbuf, 4))
|| !PACKET_equal(&pkt, buf, 4) || !TEST_true(PACKET_equal(&pkt, smbuf, 4))
|| PACKET_equal(&pkt, buf + 1, 4) || !TEST_false(PACKET_equal(&pkt, smbuf + 1, 4))
|| !PACKET_buf_init(&pkt, buf, BUF_LEN) || !TEST_true(PACKET_buf_init(&pkt, smbuf, BUF_LEN))
|| !PACKET_equal(&pkt, buf, BUF_LEN) || !TEST_true(PACKET_equal(&pkt, smbuf, BUF_LEN))
|| PACKET_equal(&pkt, buf, BUF_LEN - 1) || !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN - 1))
|| PACKET_equal(&pkt, buf, BUF_LEN + 1) || !TEST_false(PACKET_equal(&pkt, smbuf, BUF_LEN + 1))
|| PACKET_equal(&pkt, buf, 0)) { || !TEST_false(PACKET_equal(&pkt, smbuf, 0)))
fprintf(stderr, "test_PACKET_equal() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_get_length_prefixed_1() static int test_PACKET_get_length_prefixed_1()
{ {
unsigned char buf[BUF_LEN]; unsigned char buf1[BUF_LEN];
const size_t len = 16; const size_t len = 16;
unsigned int i; unsigned int i;
PACKET pkt, short_pkt, subpkt; PACKET pkt, short_pkt, subpkt = {0};
buf[0] = len; buf1[0] = len;
for (i = 1; i < BUF_LEN; i++) { for (i = 1; i < BUF_LEN; i++)
buf[i] = (i * 2) & 0xff; buf1[i] = (i * 2) & 0xff;
}
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
|| !PACKET_buf_init(&short_pkt, buf, len) || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
|| !PACKET_get_length_prefixed_1(&pkt, &subpkt) || !TEST_true(PACKET_get_length_prefixed_1(&pkt, &subpkt))
|| PACKET_remaining(&subpkt) != len || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
|| !PACKET_get_net_2(&subpkt, &i) || !TEST_true(PACKET_get_net_2(&subpkt, &i))
|| i != 0x0204 || !TEST_uint_eq(i, 0x0204)
|| PACKET_get_length_prefixed_1(&short_pkt, &subpkt) || !TEST_false(PACKET_get_length_prefixed_1(&short_pkt, &subpkt))
|| PACKET_remaining(&short_pkt) != len) { || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
fprintf(stderr, "test_PACKET_get_length_prefixed_1() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_get_length_prefixed_2() static int test_PACKET_get_length_prefixed_2()
{ {
unsigned char buf[1024]; unsigned char buf1[1024];
const size_t len = 516; /* 0x0204 */ const size_t len = 516; /* 0x0204 */
unsigned int i; unsigned int i;
PACKET pkt, short_pkt, subpkt; PACKET pkt, short_pkt, subpkt = {0};
for (i = 1; i <= 1024; i++) { for (i = 1; i <= 1024; i++)
buf[i-1] = (i * 2) & 0xff; buf1[i - 1] = (i * 2) & 0xff;
}
if ( !PACKET_buf_init(&pkt, buf, 1024) if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
|| !PACKET_buf_init(&short_pkt, buf, len) || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
|| !PACKET_get_length_prefixed_2(&pkt, &subpkt) || !TEST_true(PACKET_get_length_prefixed_2(&pkt, &subpkt))
|| PACKET_remaining(&subpkt) != len || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
|| !PACKET_get_net_2(&subpkt, &i) || !TEST_true(PACKET_get_net_2(&subpkt, &i))
|| i != 0x0608 || !TEST_uint_eq(i, 0x0608)
|| PACKET_get_length_prefixed_2(&short_pkt, &subpkt) || !TEST_false(PACKET_get_length_prefixed_2(&short_pkt, &subpkt))
|| PACKET_remaining(&short_pkt) != len) { || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
fprintf(stderr, "test_PACKET_get_length_prefixed_2() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_get_length_prefixed_3() static int test_PACKET_get_length_prefixed_3()
{ {
unsigned char buf[1024]; unsigned char buf1[1024];
const size_t len = 516; /* 0x000204 */ const size_t len = 516; /* 0x000204 */
unsigned int i; unsigned int i;
PACKET pkt, short_pkt, subpkt; PACKET pkt, short_pkt, subpkt = {0};
for (i = 0; i < 1024; i++) { for (i = 0; i < 1024; i++)
buf[i] = (i * 2) & 0xff; buf1[i] = (i * 2) & 0xff;
}
if ( !PACKET_buf_init(&pkt, buf, 1024) if (!TEST_true(PACKET_buf_init(&pkt, buf1, 1024))
|| !PACKET_buf_init(&short_pkt, buf, len) || !TEST_true(PACKET_buf_init(&short_pkt, buf1, len))
|| !PACKET_get_length_prefixed_3(&pkt, &subpkt) || !TEST_true(PACKET_get_length_prefixed_3(&pkt, &subpkt))
|| PACKET_remaining(&subpkt) != len || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)
|| !PACKET_get_net_2(&subpkt, &i) || !TEST_true(PACKET_get_net_2(&subpkt, &i))
|| i != 0x0608 || !TEST_uint_eq(i, 0x0608)
|| PACKET_get_length_prefixed_3(&short_pkt, &subpkt) || !TEST_false(PACKET_get_length_prefixed_3(&short_pkt, &subpkt))
|| PACKET_remaining(&short_pkt) != len) { || !TEST_size_t_eq(PACKET_remaining(&short_pkt), len))
fprintf(stderr, "test_PACKET_get_length_prefixed_3() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
static int test_PACKET_as_length_prefixed_1() static int test_PACKET_as_length_prefixed_1()
{ {
unsigned char buf[BUF_LEN]; unsigned char buf1[BUF_LEN];
const size_t len = 16; const size_t len = 16;
unsigned int i; unsigned int i;
PACKET pkt, exact_pkt, subpkt; PACKET pkt, exact_pkt, subpkt;
buf[0] = len; buf1[0] = len;
for (i = 1; i < BUF_LEN; i++) { for (i = 1; i < BUF_LEN; i++)
buf[i] = (i * 2) & 0xff; buf1[i] = (i * 2) & 0xff;
}
if ( !PACKET_buf_init(&pkt, buf, BUF_LEN) if (!TEST_true(PACKET_buf_init(&pkt, buf1, BUF_LEN))
|| !PACKET_buf_init(&exact_pkt, buf, len + 1) || !TEST_true(PACKET_buf_init(&exact_pkt, buf1, len + 1))
|| PACKET_as_length_prefixed_1(&pkt, &subpkt) || !TEST_false(PACKET_as_length_prefixed_1(&pkt, &subpkt))
|| PACKET_remaining(&pkt) != BUF_LEN || !TEST_size_t_eq(PACKET_remaining(&pkt), BUF_LEN)
|| !PACKET_as_length_prefixed_1(&exact_pkt, &subpkt) || !TEST_true(PACKET_as_length_prefixed_1(&exact_pkt, &subpkt)
|| PACKET_remaining(&exact_pkt) != 0 || !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
|| PACKET_remaining(&subpkt) != len) { || !TEST_size_t_eq(PACKET_remaining(&subpkt), len)))
fprintf(stderr, "test_PACKET_as_length_prefixed_1() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
@ -479,59 +446,49 @@ static int test_PACKET_as_length_prefixed_2()
unsigned int i; unsigned int i;
PACKET pkt, exact_pkt, subpkt; PACKET pkt, exact_pkt, subpkt;
for (i = 1; i <= 1024; i++) { for (i = 1; i <= 1024; i++)
buf[i-1] = (i * 2) & 0xff; buf[i-1] = (i * 2) & 0xff;
}
if ( !PACKET_buf_init(&pkt, buf, 1024) if (!TEST_true(PACKET_buf_init(&pkt, buf, 1024))
|| !PACKET_buf_init(&exact_pkt, buf, len + 2) || !TEST_true(PACKET_buf_init(&exact_pkt, buf, len + 2))
|| PACKET_as_length_prefixed_2(&pkt, &subpkt) || !TEST_false(PACKET_as_length_prefixed_2(&pkt, &subpkt))
|| PACKET_remaining(&pkt) != 1024 || !TEST_size_t_eq(PACKET_remaining(&pkt), 1024)
|| !PACKET_as_length_prefixed_2(&exact_pkt, &subpkt) || !TEST_true(PACKET_as_length_prefixed_2(&exact_pkt, &subpkt))
|| PACKET_remaining(&exact_pkt) != 0 || !TEST_size_t_eq(PACKET_remaining(&exact_pkt), 0)
|| PACKET_remaining(&subpkt) != len) { || !TEST_size_t_eq(PACKET_remaining(&subpkt), len))
fprintf(stderr, "test_PACKET_as_length_prefixed_2() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
int main(int argc, char **argv) void register_tests(void)
{ {
unsigned char buf[BUF_LEN];
unsigned int i; unsigned int i;
for (i=1; i<=BUF_LEN; i++) { for (i = 1; i <= BUF_LEN; i++)
buf[i-1] = (i * 2) & 0xff; smbuf[i - 1] = (i * 2) & 0xff;
}
i = 0;
if ( !test_PACKET_buf_init() ADD_TEST(test_PACKET_buf_init);
|| !test_PACKET_null_init() ADD_TEST(test_PACKET_null_init);
|| !test_PACKET_remaining(buf) ADD_TEST(test_PACKET_remaining);
|| !test_PACKET_end(buf) ADD_TEST(test_PACKET_end);
|| !test_PACKET_equal(buf) ADD_TEST(test_PACKET_equal);
|| !test_PACKET_get_1(buf) ADD_TEST(test_PACKET_get_1);
|| !test_PACKET_get_4(buf) ADD_TEST(test_PACKET_get_4);
|| !test_PACKET_get_net_2(buf) ADD_TEST(test_PACKET_get_net_2);
|| !test_PACKET_get_net_3(buf) ADD_TEST(test_PACKET_get_net_3);
|| !test_PACKET_get_net_4(buf) ADD_TEST(test_PACKET_get_net_4);
|| !test_PACKET_get_sub_packet(buf) ADD_TEST(test_PACKET_get_sub_packet);
|| !test_PACKET_get_bytes(buf) ADD_TEST(test_PACKET_get_bytes);
|| !test_PACKET_copy_bytes(buf) ADD_TEST(test_PACKET_copy_bytes);
|| !test_PACKET_copy_all(buf) ADD_TEST(test_PACKET_copy_all);
|| !test_PACKET_memdup(buf) ADD_TEST(test_PACKET_memdup);
|| !test_PACKET_strndup() ADD_TEST(test_PACKET_strndup);
|| !test_PACKET_contains_zero_byte() ADD_TEST(test_PACKET_contains_zero_byte);
|| !test_PACKET_forward(buf) ADD_TEST(test_PACKET_forward);
|| !test_PACKET_get_length_prefixed_1() ADD_TEST(test_PACKET_get_length_prefixed_1);
|| !test_PACKET_get_length_prefixed_2() ADD_TEST(test_PACKET_get_length_prefixed_2);
|| !test_PACKET_get_length_prefixed_3() ADD_TEST(test_PACKET_get_length_prefixed_3);
|| !test_PACKET_as_length_prefixed_1() ADD_TEST(test_PACKET_as_length_prefixed_1);
|| !test_PACKET_as_length_prefixed_2()) { ADD_TEST(test_PACKET_as_length_prefixed_2);
return 1;
}
printf("PASS\n");
return 0;
} }

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