diff options
Diffstat (limited to 'tests/vb21_common2_tests.c')
| -rw-r--r-- | tests/vb21_common2_tests.c | 128 |
1 files changed, 64 insertions, 64 deletions
diff --git a/tests/vb21_common2_tests.c b/tests/vb21_common2_tests.c index a88e126b..e4e1e2fc 100644 --- a/tests/vb21_common2_tests.c +++ b/tests/vb21_common2_tests.c @@ -12,7 +12,7 @@ #include "2sysincludes.h" #include "2common.h" #include "2rsa.h" -#include "vb2_common.h" +#include "vb21_common.h" #include "host_common.h" #include "host_key2.h" #include "host_signature2.h" @@ -22,48 +22,48 @@ static const uint8_t test_data[] = "This is some test data to sign."; static const uint32_t test_size = sizeof(test_data); -static void test_unpack_key(const struct vb2_packed_key *key) +static void test_unpack_key(const struct vb21_packed_key *key) { struct vb2_public_key pubk; - struct vb2_packed_key *key2; + struct vb21_packed_key *key2; uint32_t size = key->c.total_size; /* Make a copy of the key for testing */ - key2 = (struct vb2_packed_key *)malloc(size); + key2 = (struct vb21_packed_key *)malloc(size); memcpy(key2, key, size); - TEST_SUCC(vb2_unpack_key(&pubk, (uint8_t *)key2, size), - "vb2_unpack_key() ok"); + TEST_SUCC(vb21_unpack_key(&pubk, (uint8_t *)key2, size), + "vb21_unpack_key() ok"); memcpy(key2, key, size); key2->key_offset += 4; - TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), + TEST_EQ(vb21_unpack_key(&pubk, (uint8_t *)key2, size), VB2_ERROR_COMMON_MEMBER_SIZE, - "vb2_unpack_key() buffer too small"); + "vb21_unpack_key() buffer too small"); memcpy(key2, key, size); key2->c.fixed_size += size; - TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), + TEST_EQ(vb21_unpack_key(&pubk, (uint8_t *)key2, size), VB2_ERROR_COMMON_FIXED_SIZE, - "vb2_unpack_key() buffer too small for desc"); + "vb21_unpack_key() buffer too small for desc"); memcpy(key2, key, size); key2->c.desc_size = 0; - TEST_SUCC(vb2_unpack_key(&pubk, (uint8_t *)key2, size), - "vb2_unpack_key() no desc"); + TEST_SUCC(vb21_unpack_key(&pubk, (uint8_t *)key2, size), + "vb21_unpack_key() no desc"); TEST_EQ(strcmp(pubk.desc, ""), 0, " empty desc string"); memcpy(key2, key, size); key2->c.magic++; - TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), + TEST_EQ(vb21_unpack_key(&pubk, (uint8_t *)key2, size), VB2_ERROR_UNPACK_KEY_MAGIC, - "vb2_unpack_key() bad magic"); + "vb21_unpack_key() bad magic"); memcpy(key2, key, size); key2->c.struct_version_major++; - TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), + TEST_EQ(vb21_unpack_key(&pubk, (uint8_t *)key2, size), VB2_ERROR_UNPACK_KEY_STRUCT_VERSION, - "vb2_unpack_key() bad major version"); + "vb21_unpack_key() bad major version"); /* * Minor version changes are ok. Note that this test assumes that the @@ -76,105 +76,105 @@ static void test_unpack_key(const struct vb2_packed_key *key) */ memcpy(key2, key, size); key2->c.struct_version_minor++; - TEST_SUCC(vb2_unpack_key(&pubk, (uint8_t *)key2, size), - "vb2_unpack_key() minor version change ok"); + TEST_SUCC(vb21_unpack_key(&pubk, (uint8_t *)key2, size), + "vb21_unpack_key() minor version change ok"); memcpy(key2, key, size); key2->sig_alg = VB2_SIG_INVALID; - TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), + TEST_EQ(vb21_unpack_key(&pubk, (uint8_t *)key2, size), VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM, - "vb2_unpack_key() bad sig algorithm"); + "vb21_unpack_key() bad sig algorithm"); memcpy(key2, key, size); key2->hash_alg = VB2_HASH_INVALID; - TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), + TEST_EQ(vb21_unpack_key(&pubk, (uint8_t *)key2, size), VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM, - "vb2_unpack_key() bad hash algorithm"); + "vb21_unpack_key() bad hash algorithm"); memcpy(key2, key, size); key2->key_size -= 4; - TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), + TEST_EQ(vb21_unpack_key(&pubk, (uint8_t *)key2, size), VB2_ERROR_UNPACK_KEY_SIZE, - "vb2_unpack_key() invalid size"); + "vb21_unpack_key() invalid size"); memcpy(key2, key, size); key2->key_offset--; - TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), + TEST_EQ(vb21_unpack_key(&pubk, (uint8_t *)key2, size), VB2_ERROR_COMMON_MEMBER_UNALIGNED, - "vb2_unpack_key() unaligned data"); + "vb21_unpack_key() unaligned data"); memcpy(key2, key, size); *(uint32_t *)((uint8_t *)key2 + key2->key_offset) /= 2; - TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), + TEST_EQ(vb21_unpack_key(&pubk, (uint8_t *)key2, size), VB2_ERROR_UNPACK_KEY_ARRAY_SIZE, - "vb2_unpack_key() invalid key array size"); + "vb21_unpack_key() invalid key array size"); free(key2); } -static void test_verify_signature(const struct vb2_signature *sig) +static void test_verify_signature(const struct vb21_signature *sig) { - struct vb2_signature *sig2; + struct vb21_signature *sig2; uint8_t *buf2; uint32_t size; /* Make a copy of the signature */ size = sig->c.total_size; buf2 = malloc(size); - sig2 = (struct vb2_signature *)buf2; + sig2 = (struct vb21_signature *)buf2; memcpy(buf2, sig, size); - TEST_SUCC(vb2_verify_signature(sig2, size), "verify_sig ok"); - sig2->c.magic = VB2_MAGIC_PACKED_KEY; - TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_MAGIC, + TEST_SUCC(vb21_verify_signature(sig2, size), "verify_sig ok"); + sig2->c.magic = VB21_MAGIC_PACKED_KEY; + TEST_EQ(vb21_verify_signature(sig2, size), VB2_ERROR_SIG_MAGIC, "verify_sig magic"); memcpy(buf2, sig, size); sig2->c.total_size += 4; - TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_COMMON_TOTAL_SIZE, + TEST_EQ(vb21_verify_signature(sig2, size), VB2_ERROR_COMMON_TOTAL_SIZE, "verify_sig common header"); memcpy(buf2, sig, size); sig2->c.struct_version_minor++; - TEST_SUCC(vb2_verify_signature(sig2, size), "verify_sig minor ver"); + TEST_SUCC(vb21_verify_signature(sig2, size), "verify_sig minor ver"); sig2->c.struct_version_major++; - TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_VERSION, + TEST_EQ(vb21_verify_signature(sig2, size), VB2_ERROR_SIG_VERSION, "verify_sig major ver"); memcpy(buf2, sig, size); sig2->c.fixed_size -= 4; sig2->c.desc_size += 4; - TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_HEADER_SIZE, + TEST_EQ(vb21_verify_signature(sig2, size), VB2_ERROR_SIG_HEADER_SIZE, "verify_sig header size"); memcpy(buf2, sig, size); sig2->sig_size += 4; - TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_COMMON_MEMBER_SIZE, + TEST_EQ(vb21_verify_signature(sig2, size), VB2_ERROR_COMMON_MEMBER_SIZE, "verify_sig sig size"); memcpy(buf2, sig, size); sig2->sig_alg = VB2_SIG_INVALID; - TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_ALGORITHM, + TEST_EQ(vb21_verify_signature(sig2, size), VB2_ERROR_SIG_ALGORITHM, "verify_sig sig alg"); memcpy(buf2, sig, size); sig2->sig_alg = (sig2->sig_alg == VB2_SIG_NONE ? VB2_SIG_RSA1024 : VB2_SIG_NONE); - TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_SIZE, + TEST_EQ(vb21_verify_signature(sig2, size), VB2_ERROR_SIG_SIZE, "verify_sig sig size"); free(buf2); } static void test_verify_data(const struct vb2_public_key *pubk_orig, - const struct vb2_signature *sig) + const struct vb21_signature *sig) { uint8_t workbuf[VB2_VERIFY_DATA_WORKBUF_BYTES] __attribute__ ((aligned (VB2_WORKBUF_ALIGN))); struct vb2_workbuf wb; struct vb2_public_key pubk; - struct vb2_signature *sig2; + struct vb21_signature *sig2; uint8_t *buf2; uint32_t size; @@ -185,53 +185,53 @@ static void test_verify_data(const struct vb2_public_key *pubk_orig, /* Allocate signature copy for tests */ size = sig->c.total_size; buf2 = malloc(size); - sig2 = (struct vb2_signature *)buf2; + sig2 = (struct vb21_signature *)buf2; memcpy(buf2, sig, size); pubk.sig_alg = VB2_SIG_INVALID; - TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), - VB2_ERROR_VDATA_ALGORITHM, "vb2_verify_data() bad sig alg"); + TEST_EQ(vb21_verify_data(test_data, test_size, sig2, &pubk, &wb), + VB2_ERROR_VDATA_ALGORITHM, "vb21_verify_data() bad sig alg"); pubk = *pubk_orig; memcpy(buf2, sig, size); pubk.hash_alg = VB2_HASH_INVALID; - TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), + TEST_EQ(vb21_verify_data(test_data, test_size, sig2, &pubk, &wb), VB2_ERROR_VDATA_DIGEST_SIZE, - "vb2_verify_data() bad hash alg"); + "vb21_verify_data() bad hash alg"); pubk = *pubk_orig; vb2_workbuf_init(&wb, workbuf, 4); memcpy(buf2, sig, size); - TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), + TEST_EQ(vb21_verify_data(test_data, test_size, sig2, &pubk, &wb), VB2_ERROR_VDATA_WORKBUF_DIGEST, - "vb2_verify_data() workbuf too small"); + "vb21_verify_data() workbuf too small"); vb2_workbuf_init(&wb, workbuf, sizeof(workbuf)); memcpy(buf2, sig, size); - TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), - 0, "vb2_verify_data() ok"); + TEST_EQ(vb21_verify_data(test_data, test_size, sig2, &pubk, &wb), + 0, "vb21_verify_data() ok"); memcpy(buf2, sig, size); sig2->sig_size -= 16; - TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), - VB2_ERROR_VDATA_SIG_SIZE, "vb2_verify_data() wrong sig size"); + TEST_EQ(vb21_verify_data(test_data, test_size, sig2, &pubk, &wb), + VB2_ERROR_VDATA_SIG_SIZE, "vb21_verify_data() wrong sig size"); memcpy(buf2, sig, size); - TEST_EQ(vb2_verify_data(test_data, test_size - 1, sig2, &pubk, &wb), - VB2_ERROR_VDATA_SIZE, "vb2_verify_data() wrong data size"); + TEST_EQ(vb21_verify_data(test_data, test_size - 1, sig2, &pubk, &wb), + VB2_ERROR_VDATA_SIZE, "vb21_verify_data() wrong data size"); memcpy(buf2, sig, size); sig2->hash_alg = (sig2->hash_alg == VB2_HASH_SHA1 ? VB2_HASH_SHA256 : VB2_HASH_SHA1); - TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), + TEST_EQ(vb21_verify_data(test_data, test_size, sig2, &pubk, &wb), VB2_ERROR_VDATA_ALGORITHM_MISMATCH, - "vb2_verify_data() alg mismatch"); + "vb21_verify_data() alg mismatch"); memcpy(buf2, sig, size); buf2[sig2->sig_offset] ^= 0x5A; - TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), - VB2_ERROR_RSA_PADDING, "vb2_verify_data() wrong sig"); + TEST_EQ(vb21_verify_data(test_data, test_size, sig2, &pubk, &wb), + VB2_ERROR_RSA_PADDING, "vb21_verify_data() wrong sig"); free(buf2); } @@ -246,9 +246,9 @@ int test_algorithm(int key_algorithm, const char *keys_dir) enum vb2_hash_algorithm hash_alg = vb2_crypto_to_hash(key_algorithm); struct vb2_private_key *prik = NULL; - struct vb2_signature *sig2 = NULL; + struct vb21_signature *sig2 = NULL; struct vb2_public_key *pubk = NULL; - struct vb2_packed_key *key2 = NULL; + struct vb21_packed_key *key2 = NULL; printf("***Testing algorithm: %s\n", algo_strings[key_algorithm]); @@ -264,10 +264,10 @@ int test_algorithm(int key_algorithm, const char *keys_dir) "Read public key"); pubk->hash_alg = hash_alg; vb2_public_key_set_desc(pubk, "public key"); - TEST_SUCC(vb2_public_key_pack(&key2, pubk), "Pack public key"); + TEST_SUCC(vb21_public_key_pack(&key2, pubk), "Pack public key"); /* Calculate good signatures */ - TEST_SUCC(vb2_sign_data(&sig2, test_data, test_size, prik, ""), + TEST_SUCC(vb21_sign_data(&sig2, test_data, test_size, prik, ""), "Make test signature"); test_unpack_key(key2); |