Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [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 "2sysincludes.h" |
| 13 | #include "2common.h" |
| 14 | #include "2rsa.h" |
| 15 | #include "vb2_common.h" |
| 16 | #include "host_common.h" |
| 17 | #include "host_key2.h" |
| 18 | #include "host_signature2.h" |
| 19 | #include "test_common.h" |
| 20 | |
| 21 | |
| 22 | static const uint8_t test_data[] = "This is some test data to sign."; |
| 23 | static const uint32_t test_size = sizeof(test_data); |
| 24 | |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 25 | static void test_unpack_key(const struct vb2_packed_key *key) |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 26 | { |
| 27 | struct vb2_public_key pubk; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 28 | struct vb2_packed_key *key2; |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 29 | uint32_t size = key->c.total_size; |
| 30 | |
| 31 | /* Make a copy of the key for testing */ |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 32 | key2 = (struct vb2_packed_key *)malloc(size); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 33 | |
| 34 | memcpy(key2, key, size); |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 35 | TEST_SUCC(vb2_unpack_key(&pubk, (uint8_t *)key2, size), |
| 36 | "vb2_unpack_key() ok"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 37 | |
| 38 | memcpy(key2, key, size); |
| 39 | key2->key_offset += 4; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 40 | TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 41 | VB2_ERROR_COMMON_MEMBER_SIZE, |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 42 | "vb2_unpack_key() buffer too small"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 43 | |
| 44 | memcpy(key2, key, size); |
| 45 | key2->c.fixed_size += size; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 46 | TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 47 | VB2_ERROR_COMMON_FIXED_SIZE, |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 48 | "vb2_unpack_key() buffer too small for desc"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 49 | |
| 50 | memcpy(key2, key, size); |
| 51 | key2->c.desc_size = 0; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 52 | TEST_SUCC(vb2_unpack_key(&pubk, (uint8_t *)key2, size), |
| 53 | "vb2_unpack_key() no desc"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 54 | TEST_EQ(strcmp(pubk.desc, ""), 0, " empty desc string"); |
| 55 | |
| 56 | memcpy(key2, key, size); |
| 57 | key2->c.magic++; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 58 | TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 59 | VB2_ERROR_UNPACK_KEY_MAGIC, |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 60 | "vb2_unpack_key() bad magic"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 61 | |
| 62 | memcpy(key2, key, size); |
| 63 | key2->c.struct_version_major++; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 64 | TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 65 | VB2_ERROR_UNPACK_KEY_STRUCT_VERSION, |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 66 | "vb2_unpack_key() bad major version"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 67 | |
| 68 | /* |
| 69 | * Minor version changes are ok. Note that this test assumes that the |
| 70 | * source key struct version is the highest actually known to the |
| 71 | * reader. If the reader does know about minor version + 1 and that |
| 72 | * adds fields, this test will likely fail. But at that point, we |
| 73 | * should have already added a test for minor version compatibility to |
| 74 | * handle both old and new struct versions, so someone will have |
| 75 | * noticed this comment. |
| 76 | */ |
| 77 | memcpy(key2, key, size); |
| 78 | key2->c.struct_version_minor++; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 79 | TEST_SUCC(vb2_unpack_key(&pubk, (uint8_t *)key2, size), |
| 80 | "vb2_unpack_key() minor version change ok"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 81 | |
| 82 | memcpy(key2, key, size); |
| 83 | key2->sig_alg = VB2_SIG_INVALID; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 84 | TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 85 | VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM, |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 86 | "vb2_unpack_key() bad sig algorithm"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 87 | |
| 88 | memcpy(key2, key, size); |
| 89 | key2->hash_alg = VB2_HASH_INVALID; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 90 | TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 91 | VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM, |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 92 | "vb2_unpack_key() bad hash algorithm"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 93 | |
| 94 | memcpy(key2, key, size); |
| 95 | key2->key_size -= 4; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 96 | TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 97 | VB2_ERROR_UNPACK_KEY_SIZE, |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 98 | "vb2_unpack_key() invalid size"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 99 | |
| 100 | memcpy(key2, key, size); |
| 101 | key2->key_offset--; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 102 | TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 103 | VB2_ERROR_COMMON_MEMBER_UNALIGNED, |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 104 | "vb2_unpack_key() unaligned data"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 105 | |
| 106 | memcpy(key2, key, size); |
| 107 | *(uint32_t *)((uint8_t *)key2 + key2->key_offset) /= 2; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 108 | TEST_EQ(vb2_unpack_key(&pubk, (uint8_t *)key2, size), |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 109 | VB2_ERROR_UNPACK_KEY_ARRAY_SIZE, |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 110 | "vb2_unpack_key() invalid key array size"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 111 | |
| 112 | free(key2); |
| 113 | } |
| 114 | |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 115 | static void test_verify_signature(const struct vb2_signature *sig) |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 116 | { |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 117 | struct vb2_signature *sig2; |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 118 | uint8_t *buf2; |
| 119 | uint32_t size; |
| 120 | |
| 121 | /* Make a copy of the signature */ |
| 122 | size = sig->c.total_size; |
| 123 | buf2 = malloc(size); |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 124 | sig2 = (struct vb2_signature *)buf2; |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 125 | |
| 126 | memcpy(buf2, sig, size); |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 127 | TEST_SUCC(vb2_verify_signature(sig2, size), "verify_sig ok"); |
| 128 | sig2->c.magic = VB2_MAGIC_PACKED_KEY; |
| 129 | TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_MAGIC, |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 130 | "verify_sig magic"); |
| 131 | |
| 132 | memcpy(buf2, sig, size); |
| 133 | sig2->c.total_size += 4; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 134 | TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_COMMON_TOTAL_SIZE, |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 135 | "verify_sig common header"); |
| 136 | |
| 137 | memcpy(buf2, sig, size); |
| 138 | sig2->c.struct_version_minor++; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 139 | TEST_SUCC(vb2_verify_signature(sig2, size), "verify_sig minor ver"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 140 | sig2->c.struct_version_major++; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 141 | TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_VERSION, |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 142 | "verify_sig major ver"); |
| 143 | |
| 144 | memcpy(buf2, sig, size); |
| 145 | sig2->c.fixed_size -= 4; |
| 146 | sig2->c.desc_size += 4; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 147 | TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_HEADER_SIZE, |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 148 | "verify_sig header size"); |
| 149 | |
| 150 | memcpy(buf2, sig, size); |
| 151 | sig2->sig_size += 4; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 152 | TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_COMMON_MEMBER_SIZE, |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 153 | "verify_sig sig size"); |
| 154 | |
| 155 | memcpy(buf2, sig, size); |
| 156 | sig2->sig_alg = VB2_SIG_INVALID; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 157 | TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_ALGORITHM, |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 158 | "verify_sig sig alg"); |
| 159 | |
| 160 | memcpy(buf2, sig, size); |
| 161 | sig2->sig_alg = (sig2->sig_alg == VB2_SIG_NONE ? |
| 162 | VB2_SIG_RSA1024 : VB2_SIG_NONE); |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 163 | TEST_EQ(vb2_verify_signature(sig2, size), VB2_ERROR_SIG_SIZE, |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 164 | "verify_sig sig size"); |
| 165 | |
| 166 | free(buf2); |
| 167 | } |
| 168 | |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 169 | static void test_verify_data(const struct vb2_public_key *pubk_orig, |
| 170 | const struct vb2_signature *sig) |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 171 | { |
Bill Richardson | 73e5eb3 | 2015-01-26 12:18:25 -0800 | [diff] [blame] | 172 | uint8_t workbuf[VB2_VERIFY_DATA_WORKBUF_BYTES] |
| 173 | __attribute__ ((aligned (VB2_WORKBUF_ALIGN))); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 174 | struct vb2_workbuf wb; |
| 175 | |
| 176 | struct vb2_public_key pubk; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 177 | struct vb2_signature *sig2; |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 178 | uint8_t *buf2; |
| 179 | uint32_t size; |
| 180 | |
| 181 | vb2_workbuf_init(&wb, workbuf, sizeof(workbuf)); |
| 182 | |
| 183 | pubk = *pubk_orig; |
| 184 | |
| 185 | /* Allocate signature copy for tests */ |
| 186 | size = sig->c.total_size; |
| 187 | buf2 = malloc(size); |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 188 | sig2 = (struct vb2_signature *)buf2; |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 189 | |
| 190 | memcpy(buf2, sig, size); |
| 191 | pubk.sig_alg = VB2_SIG_INVALID; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 192 | TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
| 193 | VB2_ERROR_VDATA_ALGORITHM, "vb2_verify_data() bad sig alg"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 194 | pubk = *pubk_orig; |
| 195 | |
| 196 | memcpy(buf2, sig, size); |
| 197 | pubk.hash_alg = VB2_HASH_INVALID; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 198 | TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 199 | VB2_ERROR_VDATA_DIGEST_SIZE, |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 200 | "vb2_verify_data() bad hash alg"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 201 | pubk = *pubk_orig; |
| 202 | |
| 203 | vb2_workbuf_init(&wb, workbuf, 4); |
| 204 | memcpy(buf2, sig, size); |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 205 | TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 206 | VB2_ERROR_VDATA_WORKBUF_DIGEST, |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 207 | "vb2_verify_data() workbuf too small"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 208 | vb2_workbuf_init(&wb, workbuf, sizeof(workbuf)); |
| 209 | |
| 210 | memcpy(buf2, sig, size); |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 211 | TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
| 212 | 0, "vb2_verify_data() ok"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 213 | |
| 214 | memcpy(buf2, sig, size); |
| 215 | sig2->sig_size -= 16; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 216 | TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
| 217 | VB2_ERROR_VDATA_SIG_SIZE, "vb2_verify_data() wrong sig size"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 218 | |
| 219 | memcpy(buf2, sig, size); |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 220 | TEST_EQ(vb2_verify_data(test_data, test_size - 1, sig2, &pubk, &wb), |
| 221 | VB2_ERROR_VDATA_SIZE, "vb2_verify_data() wrong data size"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 222 | |
| 223 | memcpy(buf2, sig, size); |
| 224 | sig2->hash_alg = (sig2->hash_alg == VB2_HASH_SHA1 ? |
| 225 | VB2_HASH_SHA256 : VB2_HASH_SHA1); |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 226 | TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 227 | VB2_ERROR_VDATA_ALGORITHM_MISMATCH, |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 228 | "vb2_verify_data() alg mismatch"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 229 | |
| 230 | |
| 231 | memcpy(buf2, sig, size); |
| 232 | buf2[sig2->sig_offset] ^= 0x5A; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 233 | TEST_EQ(vb2_verify_data(test_data, test_size, sig2, &pubk, &wb), |
| 234 | VB2_ERROR_RSA_PADDING, "vb2_verify_data() wrong sig"); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 235 | |
| 236 | free(buf2); |
| 237 | } |
| 238 | |
| 239 | int test_algorithm(int key_algorithm, const char *keys_dir) |
| 240 | { |
| 241 | char filename[1024]; |
| 242 | int rsa_len = siglen_map[key_algorithm] * 8; |
| 243 | |
| 244 | enum vb2_signature_algorithm sig_alg = |
| 245 | vb2_crypto_to_signature(key_algorithm); |
| 246 | enum vb2_hash_algorithm hash_alg = vb2_crypto_to_hash(key_algorithm); |
| 247 | |
| 248 | struct vb2_private_key *prik = NULL; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 249 | struct vb2_signature *sig2 = NULL; |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 250 | struct vb2_public_key *pubk = NULL; |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 251 | struct vb2_packed_key *key2 = NULL; |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 252 | |
| 253 | printf("***Testing algorithm: %s\n", algo_strings[key_algorithm]); |
| 254 | |
| 255 | sprintf(filename, "%s/key_rsa%d.pem", keys_dir, rsa_len); |
| 256 | TEST_SUCC(vb2_private_key_read_pem(&prik, filename), |
| 257 | "Read private key"); |
| 258 | prik->hash_alg = hash_alg; |
| 259 | prik->sig_alg = sig_alg; |
| 260 | vb2_private_key_set_desc(prik, "private key"); |
| 261 | |
| 262 | sprintf(filename, "%s/key_rsa%d.keyb", keys_dir, rsa_len); |
| 263 | TEST_SUCC(vb2_public_key_read_keyb(&pubk, filename), |
| 264 | "Read public key"); |
| 265 | pubk->hash_alg = hash_alg; |
| 266 | vb2_public_key_set_desc(pubk, "public key"); |
| 267 | TEST_SUCC(vb2_public_key_pack(&key2, pubk), "Pack public key"); |
| 268 | |
| 269 | /* Calculate good signatures */ |
| 270 | TEST_SUCC(vb2_sign_data(&sig2, test_data, test_size, prik, ""), |
| 271 | "Make test signature"); |
| 272 | |
Randall Spangler | 308d254 | 2014-12-04 09:54:37 -0800 | [diff] [blame] | 273 | test_unpack_key(key2); |
| 274 | test_verify_data(pubk, sig2); |
| 275 | test_verify_signature(sig2); |
Randall Spangler | 108d991 | 2014-12-02 15:55:56 -0800 | [diff] [blame] | 276 | |
| 277 | free(key2); |
| 278 | free(sig2); |
| 279 | vb2_private_key_free(prik); |
| 280 | vb2_public_key_free(pubk); |
| 281 | |
| 282 | return 0; |
| 283 | } |
| 284 | |
| 285 | /* Test only the algorithms we use */ |
| 286 | const int key_algs[] = { |
| 287 | VB2_ALG_RSA2048_SHA256, |
| 288 | VB2_ALG_RSA4096_SHA256, |
| 289 | VB2_ALG_RSA8192_SHA512, |
| 290 | }; |
| 291 | |
| 292 | int main(int argc, char *argv[]) { |
| 293 | |
| 294 | if (argc == 2) { |
| 295 | int i; |
| 296 | |
| 297 | for (i = 0; i < ARRAY_SIZE(key_algs); i++) { |
| 298 | if (test_algorithm(key_algs[i], argv[1])) |
| 299 | return 1; |
| 300 | } |
| 301 | |
| 302 | } else if (argc == 3 && !strcasecmp(argv[2], "--all")) { |
| 303 | /* Test all the algorithms */ |
| 304 | int alg; |
| 305 | |
| 306 | for (alg = 0; alg < kNumAlgorithms; alg++) { |
| 307 | if (test_algorithm(alg, argv[1])) |
| 308 | return 1; |
| 309 | } |
| 310 | |
| 311 | } else { |
| 312 | fprintf(stderr, "Usage: %s <keys_dir> [--all]", argv[0]); |
| 313 | return -1; |
| 314 | } |
| 315 | |
| 316 | return gTestSuccess ? 0 : 255; |
| 317 | } |