2 * (C) Copyright 2018, Linaro Limited
4 * SPDX-License-Identifier: GPL-2.0+
7 #include <avb_verify.h>
13 const unsigned char avb_root_pub[1032] = {
14 0x0, 0x0, 0x10, 0x0, 0x55, 0xd9, 0x4, 0xad, 0xd8, 0x4,
15 0xaf, 0xe3, 0xd3, 0x84, 0x6c, 0x7e, 0xd, 0x89, 0x3d, 0xc2,
16 0x8c, 0xd3, 0x12, 0x55, 0xe9, 0x62, 0xc9, 0xf1, 0xf, 0x5e,
17 0xcc, 0x16, 0x72, 0xab, 0x44, 0x7c, 0x2c, 0x65, 0x4a, 0x94,
18 0xb5, 0x16, 0x2b, 0x0, 0xbb, 0x6, 0xef, 0x13, 0x7, 0x53,
19 0x4c, 0xf9, 0x64, 0xb9, 0x28, 0x7a, 0x1b, 0x84, 0x98, 0x88,
20 0xd8, 0x67, 0xa4, 0x23, 0xf9, 0xa7, 0x4b, 0xdc, 0x4a, 0xf,
21 0xf7, 0x3a, 0x18, 0xae, 0x54, 0xa8, 0x15, 0xfe, 0xb0, 0xad,
22 0xac, 0x35, 0xda, 0x3b, 0xad, 0x27, 0xbc, 0xaf, 0xe8, 0xd3,
23 0x2f, 0x37, 0x34, 0xd6, 0x51, 0x2b, 0x6c, 0x5a, 0x27, 0xd7,
24 0x96, 0x6, 0xaf, 0x6b, 0xb8, 0x80, 0xca, 0xfa, 0x30, 0xb4,
25 0xb1, 0x85, 0xb3, 0x4d, 0xaa, 0xaa, 0xc3, 0x16, 0x34, 0x1a,
26 0xb8, 0xe7, 0xc7, 0xfa, 0xf9, 0x9, 0x77, 0xab, 0x97, 0x93,
27 0xeb, 0x44, 0xae, 0xcf, 0x20, 0xbc, 0xf0, 0x80, 0x11, 0xdb,
28 0x23, 0xc, 0x47, 0x71, 0xb9, 0x6d, 0xd6, 0x7b, 0x60, 0x47,
29 0x87, 0x16, 0x56, 0x93, 0xb7, 0xc2, 0x2a, 0x9a, 0xb0, 0x4c,
30 0x1, 0xc, 0x30, 0xd8, 0x93, 0x87, 0xf0, 0xed, 0x6e, 0x8b,
31 0xbe, 0x30, 0x5b, 0xf6, 0xa6, 0xaf, 0xdd, 0x80, 0x7c, 0x45,
32 0x5e, 0x8f, 0x91, 0x93, 0x5e, 0x44, 0xfe, 0xb8, 0x82, 0x7,
33 0xee, 0x79, 0xca, 0xbf, 0x31, 0x73, 0x62, 0x58, 0xe3, 0xcd,
34 0xc4, 0xbc, 0xc2, 0x11, 0x1d, 0xa1, 0x4a, 0xbf, 0xfe, 0x27,
35 0x7d, 0xa1, 0xf6, 0x35, 0xa3, 0x5e, 0xca, 0xdc, 0x57, 0x2f,
36 0x3e, 0xf0, 0xc9, 0x5d, 0x86, 0x6a, 0xf8, 0xaf, 0x66, 0xa7,
37 0xed, 0xcd, 0xb8, 0xed, 0xa1, 0x5f, 0xba, 0x9b, 0x85, 0x1a,
38 0xd5, 0x9, 0xae, 0x94, 0x4e, 0x3b, 0xcf, 0xcb, 0x5c, 0xc9,
39 0x79, 0x80, 0xf7, 0xcc, 0xa6, 0x4a, 0xa8, 0x6a, 0xd8, 0xd3,
40 0x31, 0x11, 0xf9, 0xf6, 0x2, 0x63, 0x2a, 0x1a, 0x2d, 0xd1,
41 0x1a, 0x66, 0x1b, 0x16, 0x41, 0xbd, 0xbd, 0xf7, 0x4d, 0xc0,
42 0x4a, 0xe5, 0x27, 0x49, 0x5f, 0x7f, 0x58, 0xe3, 0x27, 0x2d,
43 0xe5, 0xc9, 0x66, 0xe, 0x52, 0x38, 0x16, 0x38, 0xfb, 0x16,
44 0xeb, 0x53, 0x3f, 0xe6, 0xfd, 0xe9, 0xa2, 0x5e, 0x25, 0x59,
45 0xd8, 0x79, 0x45, 0xff, 0x3, 0x4c, 0x26, 0xa2, 0x0, 0x5a,
46 0x8e, 0xc2, 0x51, 0xa1, 0x15, 0xf9, 0x7b, 0xf4, 0x5c, 0x81,
47 0x9b, 0x18, 0x47, 0x35, 0xd8, 0x2d, 0x5, 0xe9, 0xad, 0xf,
48 0x35, 0x74, 0x15, 0xa3, 0x8e, 0x8b, 0xcc, 0x27, 0xda, 0x7c,
49 0x5d, 0xe4, 0xfa, 0x4, 0xd3, 0x5, 0xb, 0xba, 0x3a, 0xb2,
50 0x49, 0x45, 0x2f, 0x47, 0xc7, 0xd, 0x41, 0x3f, 0x97, 0x80,
51 0x4d, 0x3f, 0xc1, 0xb5, 0xbb, 0x70, 0x5f, 0xa7, 0x37, 0xaf,
52 0x48, 0x22, 0x12, 0x45, 0x2e, 0xf5, 0xf, 0x87, 0x92, 0xe2,
53 0x84, 0x1, 0xf9, 0x12, 0xf, 0x14, 0x15, 0x24, 0xce, 0x89,
54 0x99, 0xee, 0xb9, 0xc4, 0x17, 0x70, 0x70, 0x15, 0xea, 0xbe,
55 0xc6, 0x6c, 0x1f, 0x62, 0xb3, 0xf4, 0x2d, 0x16, 0x87, 0xfb,
56 0x56, 0x1e, 0x45, 0xab, 0xae, 0x32, 0xe4, 0x5e, 0x91, 0xed,
57 0x53, 0x66, 0x5e, 0xbd, 0xed, 0xad, 0xe6, 0x12, 0x39, 0xd,
58 0x83, 0xc9, 0xe8, 0x6b, 0x6c, 0x2d, 0xa5, 0xee, 0xc4, 0x5a,
59 0x66, 0xae, 0x8c, 0x97, 0xd7, 0xd, 0x6c, 0x49, 0xc7, 0xf5,
60 0xc4, 0x92, 0x31, 0x8b, 0x9, 0xee, 0x33, 0xda, 0xa9, 0x37,
61 0xb6, 0x49, 0x18, 0xf8, 0xe, 0x60, 0x45, 0xc8, 0x33, 0x91,
62 0xef, 0x20, 0x57, 0x10, 0xbe, 0x78, 0x2d, 0x83, 0x26, 0xd6,
63 0xca, 0x61, 0xf9, 0x2f, 0xe0, 0xbf, 0x5, 0x30, 0x52, 0x5a,
64 0x12, 0x1c, 0x0, 0xa7, 0x5d, 0xcc, 0x7c, 0x2e, 0xc5, 0x95,
65 0x8b, 0xa3, 0x3b, 0xf0, 0x43, 0x2e, 0x5e, 0xdd, 0x0, 0xdb,
66 0xd, 0xb3, 0x37, 0x99, 0xa9, 0xcd, 0x9c, 0xb7, 0x43, 0xf7,
67 0x35, 0x44, 0x21, 0xc2, 0x82, 0x71, 0xab, 0x8d, 0xaa, 0xb4,
68 0x41, 0x11, 0xec, 0x1e, 0x8d, 0xfc, 0x14, 0x82, 0x92, 0x4e,
69 0x83, 0x6a, 0xa, 0x6b, 0x35, 0x5e, 0x5d, 0xe9, 0x5c, 0xcc,
70 0x8c, 0xde, 0x39, 0xd1, 0x4a, 0x5b, 0x5f, 0x63, 0xa9, 0x64,
71 0xe0, 0xa, 0xcb, 0xb, 0xb8, 0x5a, 0x7c, 0xc3, 0xb, 0xe6,
72 0xbe, 0xfe, 0x8b, 0xf, 0x7d, 0x34, 0x8e, 0x2, 0x66, 0x74,
73 0x1, 0x6c, 0xca, 0x76, 0xac, 0x7c, 0x67, 0x8, 0x2f, 0x3f,
74 0x1a, 0xa6, 0x2c, 0x60, 0xb3, 0xff, 0xda, 0x8d, 0xb8, 0x12,
75 0xc, 0x0, 0x7f, 0xcc, 0x50, 0xa1, 0x5c, 0x64, 0xa1, 0xe2,
76 0x5f, 0x32, 0x65, 0xc9, 0x9c, 0xbe, 0xd6, 0xa, 0x13, 0x87,
77 0x3c, 0x2a, 0x45, 0x47, 0xc, 0xca, 0x42, 0x82, 0xfa, 0x89,
78 0x65, 0xe7, 0x89, 0xb4, 0x8f, 0xf7, 0x1e, 0xe6, 0x23, 0xa5,
79 0xd0, 0x59, 0x37, 0x79, 0x92, 0xd7, 0xce, 0x3d, 0xfd, 0xe3,
80 0xa1, 0xb, 0xcf, 0x6c, 0x85, 0xa0, 0x65, 0xf3, 0x5c, 0xc6,
81 0x4a, 0x63, 0x5f, 0x6e, 0x3a, 0x3a, 0x2a, 0x8b, 0x6a, 0xb6,
82 0x2f, 0xbb, 0xf8, 0xb2, 0x4b, 0x62, 0xbc, 0x1a, 0x91, 0x25,
83 0x66, 0xe3, 0x69, 0xca, 0x60, 0x49, 0xb, 0xf6, 0x8a, 0xbe,
84 0x3e, 0x76, 0x53, 0xc2, 0x7a, 0xa8, 0x4, 0x17, 0x75, 0xf1,
85 0xf3, 0x3, 0x62, 0x1b, 0x85, 0xb2, 0xb0, 0xef, 0x80, 0x15,
86 0xb6, 0xd4, 0x4e, 0xdf, 0x71, 0xac, 0xdb, 0x2a, 0x4, 0xd4,
87 0xb4, 0x21, 0xba, 0x65, 0x56, 0x57, 0xe8, 0xfa, 0x84, 0xa2,
88 0x7d, 0x13, 0xe, 0xaf, 0xd7, 0x9a, 0x58, 0x2a, 0xa3, 0x81,
89 0x84, 0x8d, 0x9, 0xa0, 0x6a, 0xc1, 0xbb, 0xd9, 0xf5, 0x86,
90 0xac, 0xbd, 0x75, 0x61, 0x9, 0xe6, 0x8c, 0x3d, 0x77, 0xb2,
91 0xed, 0x30, 0x20, 0xe4, 0x0, 0x1d, 0x97, 0xe8, 0xbf, 0xc7,
92 0x0, 0x1b, 0x21, 0xb1, 0x16, 0xe7, 0x41, 0x67, 0x2e, 0xec,
93 0x38, 0xbc, 0xe5, 0x1b, 0xb4, 0x6, 0x23, 0x31, 0x71, 0x1c,
94 0x49, 0xcd, 0x76, 0x4a, 0x76, 0x36, 0x8d, 0xa3, 0x89, 0x8b,
95 0x4a, 0x7a, 0xf4, 0x87, 0xc8, 0x15, 0xf, 0x37, 0x39, 0xf6,
96 0x6d, 0x80, 0x19, 0xef, 0x5c, 0xa8, 0x66, 0xce, 0x1b, 0x16,
97 0x79, 0x21, 0xdf, 0xd7, 0x31, 0x30, 0xc4, 0x21, 0xdd, 0x34,
98 0x5b, 0xd2, 0x1a, 0x2b, 0x3e, 0x5d, 0xf7, 0xea, 0xca, 0x5,
99 0x8e, 0xb7, 0xcb, 0x49, 0x2e, 0xa0, 0xe3, 0xf4, 0xa7, 0x48,
100 0x19, 0x10, 0x9c, 0x4, 0xa7, 0xf4, 0x28, 0x74, 0xc8, 0x6f,
101 0x63, 0x20, 0x2b, 0x46, 0x24, 0x26, 0x19, 0x1d, 0xd1, 0x2c,
102 0x31, 0x6d, 0x5a, 0x29, 0xa2, 0x6, 0xa6, 0xb2, 0x41, 0xcc,
103 0xa, 0x27, 0x96, 0x9, 0x96, 0xac, 0x47, 0x65, 0x78, 0x68,
104 0x51, 0x98, 0xd6, 0xd8, 0xa6, 0x2d, 0xa0, 0xcf, 0xec, 0xe2,
105 0x74, 0xf2, 0x82, 0xe3, 0x97, 0xd9, 0x7e, 0xd4, 0xf8, 0xb,
106 0x70, 0x43, 0x3d, 0xb1, 0x7b, 0x97, 0x80, 0xd6, 0xcb, 0xd7,
107 0x19, 0xbc, 0x63, 0xb, 0xfd, 0x4d, 0x88, 0xfe, 0x67, 0xac,
108 0xb8, 0xcc, 0x50, 0xb7, 0x68, 0xb3, 0x5b, 0xd6, 0x1e, 0x25,
109 0xfc, 0x5f, 0x3c, 0x8d, 0xb1, 0x33, 0x7c, 0xb3, 0x49, 0x1,
110 0x3f, 0x71, 0x55, 0xe, 0x51, 0xba, 0x61, 0x26, 0xfa, 0xea,
111 0xe5, 0xb5, 0xe8, 0xaa, 0xcf, 0xcd, 0x96, 0x9f, 0xd6, 0xc1,
112 0x5f, 0x53, 0x91, 0xad, 0x5, 0xde, 0x20, 0xe7, 0x51, 0xda,
113 0x5b, 0x95, 0x67, 0xed, 0xf4, 0xee, 0x42, 0x65, 0x70, 0x13,
114 0xb, 0x70, 0x14, 0x1c, 0xc9, 0xe0, 0x19, 0xca, 0x5f, 0xf5,
115 0x1d, 0x70, 0x4b, 0x6c, 0x6, 0x74, 0xec, 0xb5, 0x2e, 0x77,
116 0xe1, 0x74, 0xa1, 0xa3, 0x99, 0xa0, 0x85, 0x9e, 0xf1, 0xac,
121 * ============================================================================
122 * IO(mmc) auxiliary functions
123 * ============================================================================
125 static unsigned long mmc_read_and_flush(struct mmc_part *part,
133 bool unaligned = is_buf_unaligned(buffer);
135 if (start < part->info.start) {
136 printf("%s: partition start out of bounds\n", __func__);
139 if ((start + sectors) > (part->info.start + part->info.size)) {
140 sectors = part->info.start + part->info.size - start;
141 printf("%s: read sector aligned to partition bounds (%ld)\n",
146 * Reading fails on unaligned buffers, so we have to
147 * use aligned temporary buffer and then copy to destination
151 printf("Handling unaligned read buffer..\n");
152 tmp_buf = get_sector_buf();
153 buf_size = get_sector_buf_size();
154 if (sectors > buf_size / part->info.blksz)
155 sectors = buf_size / part->info.blksz;
160 blks = part->mmc->block_dev.block_read(part->mmc_blk,
161 start, sectors, tmp_buf);
162 /* flush cache after read */
163 flush_cache((ulong)tmp_buf, sectors * part->info.blksz);
166 memcpy(buffer, tmp_buf, sectors * part->info.blksz);
171 static unsigned long mmc_write(struct mmc_part *part, lbaint_t start,
172 lbaint_t sectors, void *buffer)
176 bool unaligned = is_buf_unaligned(buffer);
178 if (start < part->info.start) {
179 printf("%s: partition start out of bounds\n", __func__);
182 if ((start + sectors) > (part->info.start + part->info.size)) {
183 sectors = part->info.start + part->info.size - start;
184 printf("%s: sector aligned to partition bounds (%ld)\n",
188 tmp_buf = get_sector_buf();
189 buf_size = get_sector_buf_size();
190 printf("Handling unaligned wrire buffer..\n");
191 if (sectors > buf_size / part->info.blksz)
192 sectors = buf_size / part->info.blksz;
194 memcpy(tmp_buf, buffer, sectors * part->info.blksz);
199 return part->mmc->block_dev.block_write(part->mmc_blk,
200 start, sectors, tmp_buf);
203 static struct mmc_part *get_partition(AvbOps *ops, const char *partition)
208 struct mmc_part *part;
209 struct blk_desc *mmc_blk;
211 part = malloc(sizeof(struct mmc_part));
215 dev_num = get_boot_device(ops);
216 part->mmc = find_mmc_device(dev_num);
218 printf("No MMC device at slot %x\n", dev_num);
222 if (mmc_init(part->mmc)) {
223 printf("MMC initialization failed\n");
227 ret = mmc_switch_part(part->mmc, part_num);
231 mmc_blk = mmc_get_blk_desc(part->mmc);
233 printf("Error - failed to obtain block descriptor\n");
237 ret = part_get_info_by_name(mmc_blk, partition, &part->info);
239 printf("Can't find partition '%s'\n", partition);
243 part->dev_num = dev_num;
244 part->mmc_blk = mmc_blk;
249 static AvbIOResult mmc_byte_io(AvbOps *ops,
250 const char *partition,
254 size_t *out_num_read,
255 enum mmc_io_type io_type)
258 struct mmc_part *part;
259 u64 start_offset, start_sector, sectors, residue;
263 if (!partition || !buffer || io_type > IO_WRITE)
264 return AVB_IO_RESULT_ERROR_IO;
266 part = get_partition(ops, partition);
268 return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
270 start_offset = calc_offset(part, offset);
272 start_sector = start_offset / part->info.blksz;
273 sectors = num_bytes / part->info.blksz;
274 /* handle non block-aligned reads */
275 if (start_offset % part->info.blksz ||
276 num_bytes < part->info.blksz) {
277 tmp_buf = get_sector_buf();
278 if (start_offset % part->info.blksz) {
279 residue = part->info.blksz -
280 (start_offset % part->info.blksz);
281 if (residue > num_bytes)
287 if (io_type == IO_READ) {
288 ret = mmc_read_and_flush(part,
294 printf("%s: read error (%ld, %lld)\n",
295 __func__, ret, start_sector);
296 return AVB_IO_RESULT_ERROR_IO;
299 * if this is not aligned at sector start,
300 * we have to adjust the tmp buffer
302 tmp_buf += (start_offset % part->info.blksz);
303 memcpy(buffer, (void *)tmp_buf, residue);
305 ret = mmc_read_and_flush(part,
311 printf("%s: read error (%ld, %lld)\n",
312 __func__, ret, start_sector);
313 return AVB_IO_RESULT_ERROR_IO;
315 memcpy((void *)tmp_buf +
316 start_offset % part->info.blksz,
319 ret = mmc_write(part, part->info.start +
320 start_sector, 1, tmp_buf);
322 printf("%s: write error (%ld, %lld)\n",
323 __func__, ret, start_sector);
324 return AVB_IO_RESULT_ERROR_IO;
330 start_offset += residue;
331 num_bytes -= residue;
336 if (io_type == IO_READ) {
337 ret = mmc_read_and_flush(part,
342 ret = mmc_write(part,
349 printf("%s: sector read error\n", __func__);
350 return AVB_IO_RESULT_ERROR_IO;
353 io_cnt += ret * part->info.blksz;
354 buffer += ret * part->info.blksz;
355 start_offset += ret * part->info.blksz;
356 num_bytes -= ret * part->info.blksz;
360 /* Set counter for read operation */
361 if (io_type == IO_READ && out_num_read)
362 *out_num_read = io_cnt;
364 return AVB_IO_RESULT_OK;
368 * ============================================================================
370 * ============================================================================
374 * read_from_partition() - reads @num_bytes from @offset from partition
375 * identified by a string name
377 * @ops: contains AVB ops handlers
378 * @partition_name: partition name, NUL-terminated UTF-8 string
379 * @offset: offset from the beginning of partition
380 * @num_bytes: amount of bytes to read
381 * @buffer: destination buffer to store data
385 * AVB_IO_RESULT_OK, if partition was found and read operation succeed
386 * AVB_IO_RESULT_ERROR_IO, if i/o error occurred from the underlying i/o
388 * AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION, if there is no partition with
391 static AvbIOResult read_from_partition(AvbOps *ops,
392 const char *partition_name,
393 s64 offset_from_partition,
396 size_t *out_num_read)
398 return mmc_byte_io(ops, partition_name, offset_from_partition,
399 num_bytes, buffer, out_num_read, IO_READ);
403 * write_to_partition() - writes N bytes to a partition identified by a string
406 * @ops: AvbOps, contains AVB ops handlers
407 * @partition_name: partition name
408 * @offset_from_partition: offset from the beginning of partition
409 * @num_bytes: amount of bytes to write
410 * @buf: data to write
414 * AVB_IO_RESULT_OK, if partition was found and read operation succeed
415 * AVB_IO_RESULT_ERROR_IO, if input/output error occurred
416 * AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION, if partition, specified in
417 * @partition_name was not found
419 static AvbIOResult write_to_partition(AvbOps *ops,
420 const char *partition_name,
421 s64 offset_from_partition,
425 return mmc_byte_io(ops, partition_name, offset_from_partition,
426 num_bytes, (void *)buffer, NULL, IO_WRITE);
430 * validate_vmbeta_public_key() - checks if the given public key used to sign
431 * the vbmeta partition is trusted
433 * @ops: AvbOps, contains AVB ops handlers
434 * @public_key_data: public key for verifying vbmeta partition signature
435 * @public_key_length: length of public key
436 * @public_key_metadata:
437 * @public_key_metadata_length:
438 * @out_key_is_trusted:
441 * AVB_IO_RESULT_OK, if partition was found and read operation succeed
443 static AvbIOResult validate_vbmeta_public_key(AvbOps *ops,
444 const u8 *public_key_data,
445 size_t public_key_length,
447 *public_key_metadata,
449 public_key_metadata_length,
450 bool *out_key_is_trusted)
452 if (!public_key_length || !public_key_data || !out_key_is_trusted)
453 return AVB_IO_RESULT_ERROR_IO;
455 *out_key_is_trusted = false;
456 if (public_key_length != sizeof(avb_root_pub))
457 return AVB_IO_RESULT_ERROR_IO;
459 if (memcmp(avb_root_pub, public_key_data, public_key_length) == 0)
460 *out_key_is_trusted = true;
462 return AVB_IO_RESULT_OK;
466 * read_rollback_index() - gets the rollback index corresponding to the
467 * location of given by @out_rollback_index.
469 * @ops: contains AvbOps handlers
470 * @rollback_index_slot:
471 * @out_rollback_index: used to write a retrieved rollback index.
474 * AVB_IO_RESULT_OK, if the roolback index was retrieved
476 static AvbIOResult read_rollback_index(AvbOps *ops,
477 size_t rollback_index_slot,
478 u64 *out_rollback_index)
480 /* For now we always return 0 as the stored rollback index. */
481 printf("TODO: implement %s.\n", __func__);
483 if (out_rollback_index)
484 *out_rollback_index = 0;
486 return AVB_IO_RESULT_OK;
490 * write_rollback_index() - sets the rollback index corresponding to the
491 * location of given by @out_rollback_index.
493 * @ops: contains AvbOps handlers
494 * @rollback_index_slot:
495 * @rollback_index: rollback index to write.
498 * AVB_IO_RESULT_OK, if the roolback index was retrieved
500 static AvbIOResult write_rollback_index(AvbOps *ops,
501 size_t rollback_index_slot,
504 /* For now this is a no-op. */
505 printf("TODO: implement %s.\n", __func__);
507 return AVB_IO_RESULT_OK;
511 * read_is_device_unlocked() - gets whether the device is unlocked
513 * @ops: contains AVB ops handlers
514 * @out_is_unlocked: device unlock state is stored here, true if unlocked,
518 * AVB_IO_RESULT_OK: state is retrieved successfully
519 * AVB_IO_RESULT_ERROR_IO: an error occurred
521 static AvbIOResult read_is_device_unlocked(AvbOps *ops, bool *out_is_unlocked)
523 /* For now we always return that the device is unlocked. */
525 printf("TODO: implement %s.\n", __func__);
527 *out_is_unlocked = true;
529 return AVB_IO_RESULT_OK;
533 * get_unique_guid_for_partition() - gets the GUID for a partition identified
536 * @ops: contains AVB ops handlers
537 * @partition: partition name (NUL-terminated UTF-8 string)
538 * @guid_buf: buf, used to copy in GUID string. Example of value:
539 * 527c1c6d-6361-4593-8842-3c78fcd39219
540 * @guid_buf_size: @guid_buf buffer size
543 * AVB_IO_RESULT_OK, on success (GUID found)
544 * AVB_IO_RESULT_ERROR_IO, if incorrect buffer size (@guid_buf_size) was
546 * AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION, if partition was not found
548 static AvbIOResult get_unique_guid_for_partition(AvbOps *ops,
549 const char *partition,
551 size_t guid_buf_size)
553 struct mmc_part *part;
556 part = get_partition(ops, partition);
558 return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
560 uuid_size = sizeof(part->info.uuid);
561 if (uuid_size > guid_buf_size)
562 return AVB_IO_RESULT_ERROR_IO;
564 memcpy(guid_buf, part->info.uuid, uuid_size);
565 guid_buf[uuid_size - 1] = 0;
567 return AVB_IO_RESULT_OK;
571 * ============================================================================
572 * AVB2.0 AvbOps alloc/initialisation/free
573 * ============================================================================
575 AvbOps *avb_ops_alloc(int boot_device)
577 struct AvbOpsData *ops_data;
579 ops_data = avb_calloc(sizeof(struct AvbOpsData));
583 ops_data->ops.user_data = ops_data;
585 ops_data->ops.read_from_partition = read_from_partition;
586 ops_data->ops.write_to_partition = write_to_partition;
587 ops_data->ops.validate_vbmeta_public_key = validate_vbmeta_public_key;
588 ops_data->ops.read_rollback_index = read_rollback_index;
589 ops_data->ops.write_rollback_index = write_rollback_index;
590 ops_data->ops.read_is_device_unlocked = read_is_device_unlocked;
591 ops_data->ops.get_unique_guid_for_partition =
592 get_unique_guid_for_partition;
594 ops_data->mmc_dev = boot_device;
596 return &ops_data->ops;
599 void avb_ops_free(AvbOps *ops)
601 struct AvbOpsData *ops_data;
606 ops_data = ops->user_data;