Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 1 | /* Copyright (c) 2014 The Chromium OS Authors. All rights reserved. |
| 2 | * Use of this source code is governed by a BSD-style license that can be |
| 3 | * found in the LICENSE file. |
| 4 | * |
| 5 | * Tests for firmware image library. |
| 6 | */ |
| 7 | |
| 8 | #include <stdint.h> |
| 9 | #include <stdio.h> |
| 10 | #include <string.h> |
| 11 | |
| 12 | #include "file_keys.h" |
| 13 | #include "host_common.h" |
Randall Spangler | d274a2e | 2014-10-23 17:38:18 -0700 | [diff] [blame] | 14 | #include "vb2_convert_structs.h" |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 15 | #include "vboot_common.h" |
| 16 | #include "test_common.h" |
| 17 | |
| 18 | #include "2common.h" |
| 19 | #include "2rsa.h" |
| 20 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 21 | static const uint8_t test_data[] = "This is some test data to sign."; |
| 22 | static const uint32_t test_size = sizeof(test_data); |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 23 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 24 | static void test_unpack_key(const struct vb2_packed_key *key1) |
| 25 | { |
| 26 | struct vb2_public_key pubk; |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 27 | |
| 28 | /* |
| 29 | * Key data follows the header for a newly allocated key, so we can |
| 30 | * calculate the buffer size by looking at how far the key data goes. |
| 31 | */ |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 32 | uint32_t size = key1->key_offset + key1->key_size; |
| 33 | uint8_t *buf = malloc(size); |
| 34 | struct vb2_packed_key *key = (struct vb2_packed_key *)buf; |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 35 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 36 | memcpy(key, key1, size); |
| 37 | TEST_SUCC(vb2_unpack_key(&pubk, buf, size), "vb2_unpack_key() ok"); |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 38 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 39 | TEST_EQ(pubk.sig_alg, vb2_crypto_to_signature(key->algorithm), |
Randall Spangler | c8c2f02 | 2014-10-23 09:48:20 -0700 | [diff] [blame] | 40 | "vb2_unpack_key() sig_alg"); |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 41 | TEST_EQ(pubk.hash_alg, vb2_crypto_to_hash(key->algorithm), |
Randall Spangler | 4eef812 | 2014-10-23 10:07:54 -0700 | [diff] [blame] | 42 | "vb2_unpack_key() hash_alg"); |
| 43 | |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 44 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 45 | memcpy(key, key1, size); |
| 46 | key->algorithm = VB2_ALG_COUNT; |
| 47 | TEST_EQ(vb2_unpack_key(&pubk, buf, size), |
Randall Spangler | c8c2f02 | 2014-10-23 09:48:20 -0700 | [diff] [blame] | 48 | VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM, |
Randall Spangler | 224f5ac | 2014-06-06 09:42:30 -0700 | [diff] [blame] | 49 | "vb2_unpack_key() invalid algorithm"); |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 50 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 51 | memcpy(key, key1, size); |
| 52 | key->key_size--; |
| 53 | TEST_EQ(vb2_unpack_key(&pubk, buf, size), |
Randall Spangler | 224f5ac | 2014-06-06 09:42:30 -0700 | [diff] [blame] | 54 | VB2_ERROR_UNPACK_KEY_SIZE, |
| 55 | "vb2_unpack_key() invalid size"); |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 56 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 57 | memcpy(key, key1, size); |
| 58 | key->key_offset++; |
| 59 | TEST_EQ(vb2_unpack_key(&pubk, buf, size + 1), |
Randall Spangler | 224f5ac | 2014-06-06 09:42:30 -0700 | [diff] [blame] | 60 | VB2_ERROR_UNPACK_KEY_ALIGN, |
| 61 | "vb2_unpack_key() unaligned data"); |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 62 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 63 | memcpy(key, key1, size); |
| 64 | *(uint32_t *)(buf + key->key_offset) /= 2; |
| 65 | TEST_EQ(vb2_unpack_key(&pubk, buf, size), |
Randall Spangler | 224f5ac | 2014-06-06 09:42:30 -0700 | [diff] [blame] | 66 | VB2_ERROR_UNPACK_KEY_ARRAY_SIZE, |
| 67 | "vb2_unpack_key() invalid key array size"); |
| 68 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 69 | memcpy(key, key1, size); |
| 70 | TEST_EQ(vb2_unpack_key(&pubk, buf, size - 1), |
Randall Spangler | 224f5ac | 2014-06-06 09:42:30 -0700 | [diff] [blame] | 71 | VB2_ERROR_INSIDE_DATA_OUTSIDE, |
| 72 | "vb2_unpack_key() buffer too small"); |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 73 | |
| 74 | free(key); |
| 75 | } |
| 76 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 77 | static void test_unpack_key2(const struct vb2_packed_key *key1) |
Randall Spangler | d274a2e | 2014-10-23 17:38:18 -0700 | [diff] [blame] | 78 | { |
Randall Spangler | d274a2e | 2014-10-23 17:38:18 -0700 | [diff] [blame] | 79 | struct vb2_public_key pubk; |
| 80 | struct vb2_packed_key2 *key2; |
| 81 | uint32_t size; |
| 82 | |
| 83 | /* Should be able to handle a vboot1-style key binary as well */ |
| 84 | TEST_SUCC(vb2_unpack_key2(&pubk, (uint8_t *)key1, |
| 85 | key1->key_offset + key1->key_size), |
| 86 | "vb2_unpack_key2() passthru"); |
| 87 | |
| 88 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
| 89 | TEST_SUCC(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
| 90 | "vb2_unpack_key2() ok"); |
| 91 | free(key2); |
| 92 | |
| 93 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
| 94 | key2->key_offset += 4; |
| 95 | TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
Randall Spangler | 6b5b8f6 | 2014-10-31 15:18:48 -0700 | [diff] [blame] | 96 | VB2_ERROR_COMMON_MEMBER_SIZE, |
Randall Spangler | d274a2e | 2014-10-23 17:38:18 -0700 | [diff] [blame] | 97 | "vb2_unpack_key2() buffer too small"); |
| 98 | free(key2); |
| 99 | |
| 100 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
Randall Spangler | 6f7f5df | 2014-10-31 11:47:52 -0700 | [diff] [blame] | 101 | key2->c.fixed_size += size; |
Randall Spangler | d274a2e | 2014-10-23 17:38:18 -0700 | [diff] [blame] | 102 | TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
Randall Spangler | 6b5b8f6 | 2014-10-31 15:18:48 -0700 | [diff] [blame] | 103 | VB2_ERROR_COMMON_FIXED_SIZE, |
Randall Spangler | d274a2e | 2014-10-23 17:38:18 -0700 | [diff] [blame] | 104 | "vb2_unpack_key2() buffer too small for desc"); |
| 105 | free(key2); |
| 106 | |
| 107 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
| 108 | key2->c.desc_size = 0; |
Randall Spangler | d274a2e | 2014-10-23 17:38:18 -0700 | [diff] [blame] | 109 | TEST_SUCC(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
| 110 | "vb2_unpack_key2() no desc"); |
| 111 | TEST_EQ(strcmp(pubk.desc, ""), 0, " empty desc string"); |
| 112 | free(key2); |
| 113 | |
| 114 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
| 115 | key2->c.magic++; |
| 116 | TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
| 117 | VB2_ERROR_INSIDE_DATA_OUTSIDE, |
| 118 | "vb2_unpack_key2() bad magic"); |
| 119 | free(key2); |
| 120 | |
| 121 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
| 122 | key2->c.struct_version_major++; |
| 123 | TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
| 124 | VB2_ERROR_UNPACK_KEY_STRUCT_VERSION, |
| 125 | "vb2_unpack_key2() bad major version"); |
| 126 | free(key2); |
| 127 | |
| 128 | /* |
| 129 | * Minor version changes are ok. Note that this test assumes that the |
| 130 | * source key struct version is the highest actually known to the |
| 131 | * reader. If the reader does know about minor version + 1 and that |
| 132 | * adds fields, this test will likely fail. But at that point, we |
| 133 | * should have already added a test for minor version compatibility to |
| 134 | * handle both old and new struct versions, so someone will have |
| 135 | * noticed this comment. |
| 136 | */ |
| 137 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
| 138 | key2->c.struct_version_minor++; |
| 139 | TEST_SUCC(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
| 140 | "vb2_unpack_key2() minor version change ok"); |
| 141 | free(key2); |
| 142 | |
| 143 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
Randall Spangler | 6300a64 | 2014-11-01 15:55:26 -0700 | [diff] [blame] | 144 | key2->sig_alg = VB2_SIG_INVALID; |
Randall Spangler | d274a2e | 2014-10-23 17:38:18 -0700 | [diff] [blame] | 145 | TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
| 146 | VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM, |
| 147 | "vb2_unpack_key2() bad sig algorithm"); |
| 148 | free(key2); |
| 149 | |
| 150 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
Randall Spangler | 6300a64 | 2014-11-01 15:55:26 -0700 | [diff] [blame] | 151 | key2->hash_alg = VB2_HASH_INVALID; |
Randall Spangler | d274a2e | 2014-10-23 17:38:18 -0700 | [diff] [blame] | 152 | TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
| 153 | VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM, |
| 154 | "vb2_unpack_key2() bad hash algorithm"); |
| 155 | free(key2); |
| 156 | |
| 157 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
Randall Spangler | 6b5b8f6 | 2014-10-31 15:18:48 -0700 | [diff] [blame] | 158 | key2->key_size -= 4; |
Randall Spangler | d274a2e | 2014-10-23 17:38:18 -0700 | [diff] [blame] | 159 | TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
| 160 | VB2_ERROR_UNPACK_KEY_SIZE, |
| 161 | "vb2_unpack_key2() invalid size"); |
| 162 | free(key2); |
| 163 | |
| 164 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
| 165 | key2->key_offset--; |
| 166 | TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
Randall Spangler | 6b5b8f6 | 2014-10-31 15:18:48 -0700 | [diff] [blame] | 167 | VB2_ERROR_COMMON_MEMBER_UNALIGNED, |
Randall Spangler | d274a2e | 2014-10-23 17:38:18 -0700 | [diff] [blame] | 168 | "vb2_unpack_key2() unaligned data"); |
| 169 | free(key2); |
| 170 | |
| 171 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
| 172 | *(uint32_t *)((uint8_t *)key2 + key2->key_offset) /= 2; |
| 173 | TEST_EQ(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
| 174 | VB2_ERROR_UNPACK_KEY_ARRAY_SIZE, |
| 175 | "vb2_unpack_key2() invalid key array size"); |
| 176 | free(key2); |
| 177 | } |
| 178 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 179 | static void test_verify_data(struct vb2_packed_key *key1, |
| 180 | const struct vb2_signature *sig) |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 181 | { |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 182 | uint8_t workbuf[VB2_VERIFY_DATA_WORKBUF_BYTES]; |
| 183 | struct vb2_workbuf wb; |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 184 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 185 | uint32_t pubkey_size = key1->key_offset + key1->key_size; |
| 186 | struct vb2_public_key pubk, pubk_orig; |
| 187 | uint32_t sig_total_size = sig->sig_offset + sig->sig_size; |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 188 | struct vb2_signature *sig2; |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 189 | |
| 190 | vb2_workbuf_init(&wb, workbuf, sizeof(workbuf)); |
| 191 | |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 192 | /* Allocate signature copy for tests */ |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 193 | sig2 = (struct vb2_signature *)malloc(sig_total_size); |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 194 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 195 | TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key1, pubkey_size), |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 196 | 0, "vb2_verify_data() unpack key"); |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 197 | pubk_orig = pubk; |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 198 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 199 | memcpy(sig2, sig, sig_total_size); |
| 200 | pubk.sig_alg = VB2_SIG_INVALID; |
| 201 | TEST_NEQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
Randall Spangler | c8c2f02 | 2014-10-23 09:48:20 -0700 | [diff] [blame] | 202 | 0, "vb2_verify_data() bad sig alg"); |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 203 | pubk.sig_alg = pubk_orig.sig_alg; |
Randall Spangler | c8c2f02 | 2014-10-23 09:48:20 -0700 | [diff] [blame] | 204 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 205 | memcpy(sig2, sig, sig_total_size); |
| 206 | pubk.hash_alg = VB2_HASH_INVALID; |
| 207 | TEST_NEQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
Randall Spangler | c8c2f02 | 2014-10-23 09:48:20 -0700 | [diff] [blame] | 208 | 0, "vb2_verify_data() bad hash alg"); |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 209 | pubk.hash_alg = pubk_orig.hash_alg; |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 210 | |
| 211 | vb2_workbuf_init(&wb, workbuf, 4); |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 212 | memcpy(sig2, sig, sig_total_size); |
| 213 | TEST_NEQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 214 | 0, "vb2_verify_data() workbuf too small"); |
| 215 | vb2_workbuf_init(&wb, workbuf, sizeof(workbuf)); |
| 216 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 217 | memcpy(sig2, sig, sig_total_size); |
| 218 | TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 219 | 0, "vb2_verify_data() ok"); |
| 220 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 221 | memcpy(sig2, sig, sig_total_size); |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 222 | sig2->sig_size -= 16; |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 223 | TEST_NEQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 224 | 0, "vb2_verify_data() wrong sig size"); |
| 225 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 226 | memcpy(sig2, sig, sig_total_size); |
| 227 | TEST_NEQ(vb2_verify_data(test_data, test_size - 1, sig2, &pubk, &wb), |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 228 | 0, "vb2_verify_data() input buffer too small"); |
| 229 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 230 | memcpy(sig2, sig, sig_total_size); |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 231 | vb2_signature_data(sig2)[0] ^= 0x5A; |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 232 | TEST_NEQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 233 | 0, "vb2_verify_data() wrong sig"); |
| 234 | |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 235 | free(sig2); |
| 236 | } |
| 237 | |
Randall Spangler | c0ce70b | 2014-10-31 11:19:14 -0700 | [diff] [blame] | 238 | static void test_verify_signature(const struct vb2_packed_key *key1, |
| 239 | const struct vb2_signature *sig1) |
| 240 | { |
| 241 | struct vb2_public_key pubk; |
| 242 | struct vb2_packed_key2 *key2; |
| 243 | struct vb2_signature2 *sig2; |
| 244 | uint8_t *buf2good, *buf2; |
| 245 | uint32_t size; |
| 246 | |
| 247 | /* Unpack and convert the public key */ |
| 248 | TEST_SUCC(vb2_unpack_key2(&pubk, (uint8_t *)key1, |
| 249 | key1->key_offset + key1->key_size), |
| 250 | "verify_sig vb2_unpack_key2() passthru"); |
| 251 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
| 252 | TEST_PTR_NEQ(key2, 0, "verify_sig convert pub key"); |
| 253 | |
| 254 | buf2good = (uint8_t *) |
| 255 | vb2_convert_signature2(sig1, "test desc", key2, &size); |
| 256 | buf2 = malloc(size); |
| 257 | sig2 = (struct vb2_signature2 *)buf2; |
| 258 | |
| 259 | memcpy(buf2, buf2good, size); |
| 260 | TEST_PTR_NEQ(sig1, 0, "verify_sig convert signature"); |
| 261 | TEST_SUCC(vb2_verify_signature2(sig2, size), "verify_sig ok"); |
| 262 | sig2->c.magic = VB2_MAGIC_PACKED_KEY2; |
| 263 | TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_MAGIC, |
| 264 | "verify_sig magic"); |
| 265 | |
| 266 | memcpy(buf2, buf2good, size); |
| 267 | sig2->c.total_size += 4; |
| 268 | TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_COMMON_TOTAL_SIZE, |
| 269 | "verify_sig common header"); |
| 270 | |
| 271 | memcpy(buf2, buf2good, size); |
| 272 | sig2->c.struct_version_minor++; |
| 273 | TEST_SUCC(vb2_verify_signature2(sig2, size), "verify_sig minor ver"); |
| 274 | sig2->c.struct_version_major++; |
| 275 | TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_VERSION, |
| 276 | "verify_sig major ver"); |
| 277 | |
| 278 | memcpy(buf2, buf2good, size); |
| 279 | sig2->c.fixed_size -= 4; |
| 280 | sig2->c.desc_size += 4; |
| 281 | TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_HEADER_SIZE, |
| 282 | "verify_sig header size"); |
| 283 | |
| 284 | memcpy(buf2, buf2good, size); |
| 285 | sig2->sig_size += 4; |
| 286 | TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_COMMON_MEMBER_SIZE, |
| 287 | "verify_sig sig size"); |
| 288 | |
| 289 | memcpy(buf2, buf2good, size); |
| 290 | sig2->sig_alg = VB2_SIG_INVALID; |
| 291 | TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_ALGORITHM, |
| 292 | "verify_sig sig alg"); |
| 293 | |
| 294 | memcpy(buf2, buf2good, size); |
| 295 | sig2->sig_alg = (sig2->sig_alg == VB2_SIG_NONE ? |
| 296 | VB2_SIG_RSA1024 : VB2_SIG_NONE); |
| 297 | TEST_EQ(vb2_verify_signature2(sig2, size), VB2_ERROR_SIG_SIZE, |
| 298 | "verify_sig sig size"); |
| 299 | |
| 300 | free(buf2); |
| 301 | free(buf2good); |
| 302 | free(key2); |
| 303 | } |
| 304 | |
Randall Spangler | b885c3b | 2014-11-01 17:56:46 -0700 | [diff] [blame] | 305 | static void test_verify_data2(struct vb2_packed_key *key1, |
| 306 | const struct vb2_signature *sig1) |
| 307 | { |
| 308 | uint8_t workbuf[VB2_VERIFY_DATA_WORKBUF_BYTES]; |
| 309 | struct vb2_workbuf wb; |
| 310 | |
| 311 | struct vb2_public_key pubk, pubk_orig; |
| 312 | struct vb2_packed_key2 *key2; |
| 313 | struct vb2_signature2 *sig2; |
| 314 | uint8_t *buf2good, *buf2; |
| 315 | uint32_t size; |
| 316 | |
| 317 | vb2_workbuf_init(&wb, workbuf, sizeof(workbuf)); |
| 318 | |
| 319 | /* Unpack and convert the public key */ |
| 320 | key2 = vb2_convert_packed_key2(key1, "Test key", &size); |
| 321 | TEST_PTR_NEQ(key2, 0, "verify_data convert pub key"); |
| 322 | TEST_SUCC(vb2_unpack_key2(&pubk, (uint8_t *)key2, size), |
| 323 | "verify_data2 unpack key"); |
| 324 | pubk_orig = pubk; |
| 325 | |
| 326 | /* Convert signature and allocate copy for tests */ |
| 327 | buf2good = (uint8_t *) |
| 328 | vb2_convert_signature2(sig1, "test desc", key2, &size); |
| 329 | buf2 = malloc(size); |
| 330 | sig2 = (struct vb2_signature2 *)buf2; |
| 331 | |
| 332 | memcpy(buf2, buf2good, size); |
| 333 | pubk.sig_alg = VB2_SIG_INVALID; |
| 334 | TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb), |
| 335 | VB2_ERROR_VDATA_ALGORITHM, "vb2_verify_data2() bad sig alg"); |
| 336 | pubk.sig_alg = pubk_orig.sig_alg; |
| 337 | |
| 338 | memcpy(buf2, buf2good, size); |
| 339 | pubk.hash_alg = VB2_HASH_INVALID; |
| 340 | TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb), |
| 341 | VB2_ERROR_VDATA_DIGEST_SIZE, |
| 342 | "vb2_verify_data2() bad hash alg"); |
| 343 | pubk.hash_alg = pubk_orig.hash_alg; |
| 344 | |
| 345 | vb2_workbuf_init(&wb, workbuf, 4); |
| 346 | memcpy(buf2, buf2good, size); |
| 347 | TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb), |
| 348 | VB2_ERROR_VDATA_WORKBUF_DIGEST, |
| 349 | "vb2_verify_data2() workbuf too small"); |
| 350 | vb2_workbuf_init(&wb, workbuf, sizeof(workbuf)); |
| 351 | |
| 352 | memcpy(buf2, buf2good, size); |
| 353 | TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb), |
| 354 | 0, "vb2_verify_data2() ok"); |
| 355 | |
| 356 | memcpy(buf2, buf2good, size); |
| 357 | sig2->sig_size -= 16; |
| 358 | TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb), |
| 359 | VB2_ERROR_VDATA_SIG_SIZE, "vb2_verify_data2() wrong sig size"); |
| 360 | |
| 361 | memcpy(buf2, buf2good, size); |
| 362 | TEST_EQ(vb2_verify_data2(test_data, test_size - 1, sig2, &pubk, &wb), |
| 363 | VB2_ERROR_VDATA_SIZE, "vb2_verify_data2() wrong data size"); |
| 364 | |
| 365 | memcpy(buf2, buf2good, size); |
| 366 | sig2->hash_alg = (sig2->hash_alg == VB2_HASH_SHA1 ? |
| 367 | VB2_HASH_SHA256 : VB2_HASH_SHA1); |
| 368 | TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb), |
| 369 | VB2_ERROR_VDATA_ALGORITHM_MISMATCH, |
| 370 | "vb2_verify_data2() alg mismatch"); |
| 371 | |
| 372 | |
| 373 | memcpy(buf2, buf2good, size); |
| 374 | buf2[sig2->sig_offset] ^= 0x5A; |
| 375 | TEST_EQ(vb2_verify_data2(test_data, test_size, sig2, &pubk, &wb), |
| 376 | VB2_ERROR_RSA_PADDING, "vb2_verify_data2() wrong sig"); |
| 377 | |
| 378 | free(buf2); |
| 379 | free(buf2good); |
| 380 | } |
| 381 | |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 382 | int test_algorithm(int key_algorithm, const char *keys_dir) |
| 383 | { |
| 384 | char filename[1024]; |
| 385 | int rsa_len = siglen_map[key_algorithm] * 8; |
| 386 | |
| 387 | VbPrivateKey *private_key = NULL; |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 388 | |
| 389 | struct vb2_signature *sig = NULL; |
| 390 | struct vb2_packed_key *key1; |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 391 | |
| 392 | printf("***Testing algorithm: %s\n", algo_strings[key_algorithm]); |
| 393 | |
| 394 | sprintf(filename, "%s/key_rsa%d.pem", keys_dir, rsa_len); |
| 395 | private_key = PrivateKeyReadPem(filename, key_algorithm); |
| 396 | if (!private_key) { |
| 397 | fprintf(stderr, "Error reading private_key: %s\n", filename); |
| 398 | return 1; |
| 399 | } |
| 400 | |
| 401 | sprintf(filename, "%s/key_rsa%d.keyb", keys_dir, rsa_len); |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 402 | key1 = (struct vb2_packed_key *) |
| 403 | PublicKeyReadKeyb(filename, key_algorithm, 1); |
| 404 | if (!key1) { |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 405 | fprintf(stderr, "Error reading public_key: %s\n", filename); |
| 406 | return 1; |
| 407 | } |
| 408 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 409 | /* Calculate good signature */ |
| 410 | sig = (struct vb2_signature *) |
| 411 | CalculateSignature(test_data, sizeof(test_data), private_key); |
| 412 | TEST_PTR_NEQ(sig, 0, "Calculate signature"); |
| 413 | if (!sig) |
| 414 | return 1; |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 415 | |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 416 | test_unpack_key(key1); |
| 417 | test_unpack_key2(key1); |
| 418 | test_verify_data(key1, sig); |
Randall Spangler | b885c3b | 2014-11-01 17:56:46 -0700 | [diff] [blame] | 419 | test_verify_data2(key1, sig); |
Randall Spangler | c0ce70b | 2014-10-31 11:19:14 -0700 | [diff] [blame] | 420 | test_verify_signature(key1, sig); |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 421 | |
| 422 | if (key1) |
| 423 | free(key1); |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 424 | if (private_key) |
| 425 | free(private_key); |
Randall Spangler | 3c6ec76 | 2014-11-01 17:49:08 -0700 | [diff] [blame] | 426 | if (sig) |
| 427 | free(sig); |
Randall Spangler | 7141d73 | 2014-05-15 15:34:54 -0700 | [diff] [blame] | 428 | |
| 429 | return 0; |
| 430 | } |
| 431 | |
| 432 | /* Test only the algorithms we use */ |
| 433 | const int key_algs[] = { |
| 434 | VB2_ALG_RSA2048_SHA256, |
| 435 | VB2_ALG_RSA4096_SHA256, |
| 436 | VB2_ALG_RSA8192_SHA512, |
| 437 | }; |
| 438 | |
| 439 | int main(int argc, char *argv[]) { |
| 440 | |
| 441 | if (argc == 2) { |
| 442 | int i; |
| 443 | |
| 444 | for (i = 0; i < ARRAY_SIZE(key_algs); i++) { |
| 445 | if (test_algorithm(key_algs[i], argv[1])) |
| 446 | return 1; |
| 447 | } |
| 448 | |
| 449 | } else if (argc == 3 && !strcasecmp(argv[2], "--all")) { |
| 450 | /* Test all the algorithms */ |
| 451 | int alg; |
| 452 | |
| 453 | for (alg = 0; alg < kNumAlgorithms; alg++) { |
| 454 | if (test_algorithm(alg, argv[1])) |
| 455 | return 1; |
| 456 | } |
| 457 | |
| 458 | } else { |
| 459 | fprintf(stderr, "Usage: %s <keys_dir> [--all]", argv[0]); |
| 460 | return -1; |
| 461 | } |
| 462 | |
| 463 | return gTestSuccess ? 0 : 255; |
| 464 | } |