1
2
3
4
5
6#include "avb_vbmeta_image.h"
7#include "avb_crypto.h"
8#include "avb_rsa.h"
9#include "avb_sha.h"
10#include "avb_util.h"
11#include "avb_version.h"
12
13AvbVBMetaVerifyResult avb_vbmeta_image_verify(
14 const uint8_t* data,
15 size_t length,
16 const uint8_t** out_public_key_data,
17 size_t* out_public_key_length) {
18 AvbVBMetaVerifyResult ret;
19 AvbVBMetaImageHeader h;
20 uint8_t* computed_hash;
21 const AvbAlgorithmData* algorithm;
22 AvbSHA256Ctx sha256_ctx;
23 AvbSHA512Ctx sha512_ctx;
24 const uint8_t* header_block;
25 const uint8_t* authentication_block;
26 const uint8_t* auxiliary_block;
27 int verification_result;
28
29 ret = AVB_VBMETA_VERIFY_RESULT_INVALID_VBMETA_HEADER;
30
31 if (out_public_key_data != NULL) {
32 *out_public_key_data = NULL;
33 }
34 if (out_public_key_length != NULL) {
35 *out_public_key_length = 0;
36 }
37
38
39 if (length < sizeof(AvbVBMetaImageHeader)) {
40 avb_error("Length is smaller than header.\n");
41 goto out;
42 }
43
44
45 if (avb_safe_memcmp(data, AVB_MAGIC, AVB_MAGIC_LEN) != 0) {
46 avb_error("Magic is incorrect.\n");
47 goto out;
48 }
49
50 avb_vbmeta_image_header_to_host_byte_order((const AvbVBMetaImageHeader*)data,
51 &h);
52
53
54
55
56 if ((h.required_libavb_version_major != AVB_VERSION_MAJOR) ||
57 (h.required_libavb_version_minor > AVB_VERSION_MINOR)) {
58 avb_error("Mismatch between image version and libavb version.\n");
59 ret = AVB_VBMETA_VERIFY_RESULT_UNSUPPORTED_VERSION;
60 goto out;
61 }
62
63
64 if (h.release_string[AVB_RELEASE_STRING_SIZE - 1] != '\0') {
65 avb_error("Release string does not end with a NUL byte.\n");
66 goto out;
67 }
68
69
70 if ((h.authentication_data_block_size & 0x3f) != 0 ||
71 (h.auxiliary_data_block_size & 0x3f) != 0) {
72 avb_error("Block size is not a multiple of 64.\n");
73 goto out;
74 }
75
76
77 uint64_t block_total = sizeof(AvbVBMetaImageHeader);
78 if (!avb_safe_add_to(&block_total, h.authentication_data_block_size) ||
79 !avb_safe_add_to(&block_total, h.auxiliary_data_block_size)) {
80 avb_error("Overflow while computing size of boot image.\n");
81 goto out;
82 }
83 if (block_total > length) {
84 avb_error("Block sizes add up to more than given length.\n");
85 goto out;
86 }
87
88 uintptr_t data_ptr = (uintptr_t)data;
89
90 if (!avb_safe_add(NULL, (uint64_t)data_ptr, length)) {
91 avb_error("Boot image location and length mismatch.\n");
92 goto out;
93 }
94
95
96 uint64_t hash_end;
97 if (!avb_safe_add(&hash_end, h.hash_offset, h.hash_size) ||
98 hash_end > h.authentication_data_block_size) {
99 avb_error("Hash is not entirely in its block.\n");
100 goto out;
101 }
102 uint64_t signature_end;
103 if (!avb_safe_add(&signature_end, h.signature_offset, h.signature_size) ||
104 signature_end > h.authentication_data_block_size) {
105 avb_error("Signature is not entirely in its block.\n");
106 goto out;
107 }
108
109
110 uint64_t pubkey_end;
111 if (!avb_safe_add(&pubkey_end, h.public_key_offset, h.public_key_size) ||
112 pubkey_end > h.auxiliary_data_block_size) {
113 avb_error("Public key is not entirely in its block.\n");
114 goto out;
115 }
116
117
118
119 if (h.public_key_metadata_size > 0) {
120 uint64_t pubkey_md_end;
121 if (!avb_safe_add(&pubkey_md_end,
122 h.public_key_metadata_offset,
123 h.public_key_metadata_size) ||
124 pubkey_md_end > h.auxiliary_data_block_size) {
125 avb_error("Public key metadata is not entirely in its block.\n");
126 goto out;
127 }
128 }
129
130
131 if (h.algorithm_type == AVB_ALGORITHM_TYPE_NONE) {
132 ret = AVB_VBMETA_VERIFY_RESULT_OK_NOT_SIGNED;
133 goto out;
134 }
135
136
137 algorithm = avb_get_algorithm_data(h.algorithm_type);
138 if (!algorithm) {
139 avb_error("Invalid or unknown algorithm.\n");
140 goto out;
141 }
142
143
144 if (h.hash_size != algorithm->hash_len) {
145 avb_error("Embedded hash has wrong size.\n");
146 goto out;
147 }
148
149
150
151
152
153 header_block = data;
154 authentication_block = header_block + sizeof(AvbVBMetaImageHeader);
155 auxiliary_block = authentication_block + h.authentication_data_block_size;
156
157 switch (h.algorithm_type) {
158
159 case AVB_ALGORITHM_TYPE_SHA256_RSA2048:
160 case AVB_ALGORITHM_TYPE_SHA256_RSA4096:
161 case AVB_ALGORITHM_TYPE_SHA256_RSA8192:
162 avb_sha256_init(&sha256_ctx);
163 avb_sha256_update(
164 &sha256_ctx, header_block, sizeof(AvbVBMetaImageHeader));
165 avb_sha256_update(
166 &sha256_ctx, auxiliary_block, h.auxiliary_data_block_size);
167 computed_hash = avb_sha256_final(&sha256_ctx);
168 break;
169
170 case AVB_ALGORITHM_TYPE_SHA512_RSA2048:
171 case AVB_ALGORITHM_TYPE_SHA512_RSA4096:
172 case AVB_ALGORITHM_TYPE_SHA512_RSA8192:
173 avb_sha512_init(&sha512_ctx);
174 avb_sha512_update(
175 &sha512_ctx, header_block, sizeof(AvbVBMetaImageHeader));
176 avb_sha512_update(
177 &sha512_ctx, auxiliary_block, h.auxiliary_data_block_size);
178 computed_hash = avb_sha512_final(&sha512_ctx);
179 break;
180 default:
181 avb_error("Unknown algorithm.\n");
182 goto out;
183 }
184
185 if (avb_safe_memcmp(authentication_block + h.hash_offset,
186 computed_hash,
187 h.hash_size) != 0) {
188 avb_error("Hash does not match!\n");
189 ret = AVB_VBMETA_VERIFY_RESULT_HASH_MISMATCH;
190 goto out;
191 }
192
193 verification_result =
194 avb_rsa_verify(auxiliary_block + h.public_key_offset,
195 h.public_key_size,
196 authentication_block + h.signature_offset,
197 h.signature_size,
198 authentication_block + h.hash_offset,
199 h.hash_size,
200 algorithm->padding,
201 algorithm->padding_len);
202
203 if (verification_result == 0) {
204 ret = AVB_VBMETA_VERIFY_RESULT_SIGNATURE_MISMATCH;
205 goto out;
206 }
207
208 if (h.public_key_size > 0) {
209 if (out_public_key_data != NULL) {
210 *out_public_key_data = auxiliary_block + h.public_key_offset;
211 }
212 if (out_public_key_length != NULL) {
213 *out_public_key_length = h.public_key_size;
214 }
215 }
216
217 ret = AVB_VBMETA_VERIFY_RESULT_OK;
218
219out:
220 return ret;
221}
222
223void avb_vbmeta_image_header_to_host_byte_order(const AvbVBMetaImageHeader* src,
224 AvbVBMetaImageHeader* dest) {
225 avb_memcpy(dest, src, sizeof(AvbVBMetaImageHeader));
226
227 dest->required_libavb_version_major =
228 avb_be32toh(dest->required_libavb_version_major);
229 dest->required_libavb_version_minor =
230 avb_be32toh(dest->required_libavb_version_minor);
231
232 dest->authentication_data_block_size =
233 avb_be64toh(dest->authentication_data_block_size);
234 dest->auxiliary_data_block_size =
235 avb_be64toh(dest->auxiliary_data_block_size);
236
237 dest->algorithm_type = avb_be32toh(dest->algorithm_type);
238
239 dest->hash_offset = avb_be64toh(dest->hash_offset);
240 dest->hash_size = avb_be64toh(dest->hash_size);
241
242 dest->signature_offset = avb_be64toh(dest->signature_offset);
243 dest->signature_size = avb_be64toh(dest->signature_size);
244
245 dest->public_key_offset = avb_be64toh(dest->public_key_offset);
246 dest->public_key_size = avb_be64toh(dest->public_key_size);
247
248 dest->public_key_metadata_offset =
249 avb_be64toh(dest->public_key_metadata_offset);
250 dest->public_key_metadata_size = avb_be64toh(dest->public_key_metadata_size);
251
252 dest->descriptors_offset = avb_be64toh(dest->descriptors_offset);
253 dest->descriptors_size = avb_be64toh(dest->descriptors_size);
254
255 dest->rollback_index = avb_be64toh(dest->rollback_index);
256 dest->flags = avb_be32toh(dest->flags);
257}
258
259const char* avb_vbmeta_verify_result_to_string(AvbVBMetaVerifyResult result) {
260 const char* ret = NULL;
261
262 switch (result) {
263 case AVB_VBMETA_VERIFY_RESULT_OK:
264 ret = "OK";
265 break;
266 case AVB_VBMETA_VERIFY_RESULT_OK_NOT_SIGNED:
267 ret = "OK_NOT_SIGNED";
268 break;
269 case AVB_VBMETA_VERIFY_RESULT_INVALID_VBMETA_HEADER:
270 ret = "INVALID_VBMETA_HEADER";
271 break;
272 case AVB_VBMETA_VERIFY_RESULT_UNSUPPORTED_VERSION:
273 ret = "UNSUPPORTED_VERSION";
274 break;
275 case AVB_VBMETA_VERIFY_RESULT_HASH_MISMATCH:
276 ret = "HASH_MISMATCH";
277 break;
278 case AVB_VBMETA_VERIFY_RESULT_SIGNATURE_MISMATCH:
279 ret = "SIGNATURE_MISMATCH";
280 break;
281
282 }
283
284 if (ret == NULL) {
285 avb_error("Unknown AvbVBMetaVerifyResult value.\n");
286 ret = "(unknown)";
287 }
288
289 return ret;
290}
291
