1 /* 2 * (C) Copyright 2018, Linaro Limited 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <avb_verify.h> 8 #include <fastboot.h> 9 #include <image.h> 10 #include <malloc.h> 11 #include <part.h> 12 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, 117 0xd8, 0x7e, 118 }; 119 120 /** 121 * ============================================================================ 122 * Boot states support (GREEN, YELLOW, ORANGE, RED) and dm_verity 123 * ============================================================================ 124 */ 125 char *avb_set_state(AvbOps *ops, enum avb_boot_state boot_state) 126 { 127 struct AvbOpsData *data; 128 char *cmdline = NULL; 129 130 if (!ops) 131 return NULL; 132 133 data = (struct AvbOpsData *)ops->user_data; 134 if (!data) 135 return NULL; 136 137 data->boot_state = boot_state; 138 switch (boot_state) { 139 case AVB_GREEN: 140 cmdline = "androidboot.verifiedbootstate=green"; 141 break; 142 case AVB_YELLOW: 143 cmdline = "androidboot.verifiedbootstate=yellow"; 144 break; 145 case AVB_ORANGE: 146 cmdline = "androidboot.verifiedbootstate=orange"; 147 case AVB_RED: 148 break; 149 } 150 151 return cmdline; 152 } 153 154 char *append_cmd_line(char *cmdline_orig, char *cmdline_new) 155 { 156 char *cmd_line; 157 158 if (!cmdline_new) 159 return cmdline_orig; 160 161 if (cmdline_orig) 162 cmd_line = cmdline_orig; 163 else 164 cmd_line = " "; 165 166 cmd_line = avb_strdupv(cmd_line, " ", cmdline_new, NULL); 167 168 return cmd_line; 169 } 170 171 static int avb_find_dm_args(char **args, char *str) 172 { 173 int i; 174 175 if (!str) 176 return -1; 177 178 for (i = 0; i < AVB_MAX_ARGS, args[i]; ++i) { 179 if (strstr(args[i], str)) 180 return i; 181 } 182 183 return -1; 184 } 185 186 static char *avb_set_enforce_option(const char *cmdline, const char *option) 187 { 188 char *cmdarg[AVB_MAX_ARGS]; 189 char *newargs = NULL; 190 int i = 0; 191 int total_args; 192 193 memset(cmdarg, 0, sizeof(cmdarg)); 194 cmdarg[i++] = strtok((char *)cmdline, " "); 195 196 do { 197 cmdarg[i] = strtok(NULL, " "); 198 if (!cmdarg[i]) 199 break; 200 201 if (++i >= AVB_MAX_ARGS) { 202 printf("%s: Can't handle more then %d args\n", 203 __func__, i); 204 return NULL; 205 } 206 } while (true); 207 208 total_args = i; 209 i = avb_find_dm_args(&cmdarg[0], VERITY_TABLE_OPT_LOGGING); 210 if (i >= 0) { 211 cmdarg[i] = (char *)option; 212 } else { 213 i = avb_find_dm_args(&cmdarg[0], VERITY_TABLE_OPT_RESTART); 214 if (i < 0) { 215 printf("%s: No verity options found\n", __func__); 216 return NULL; 217 } 218 219 cmdarg[i] = (char *)option; 220 } 221 222 for (i = 0; i <= total_args; i++) 223 newargs = append_cmd_line(newargs, cmdarg[i]); 224 225 return newargs; 226 } 227 228 char *avb_set_ignore_corruption(const char *cmdline) 229 { 230 char *newargs = NULL; 231 232 newargs = avb_set_enforce_option(cmdline, VERITY_TABLE_OPT_LOGGING); 233 if (newargs) 234 newargs = append_cmd_line(newargs, 235 "androidboot.veritymode=eio"); 236 237 return newargs; 238 } 239 240 char *avb_set_enforce_verity(const char *cmdline) 241 { 242 char *newargs; 243 244 newargs = avb_set_enforce_option(cmdline, VERITY_TABLE_OPT_RESTART); 245 if (newargs) 246 newargs = append_cmd_line(newargs, 247 "androidboot.veritymode=enforcing"); 248 return newargs; 249 } 250 251 /** 252 * ============================================================================ 253 * IO(mmc) auxiliary functions 254 * ============================================================================ 255 */ 256 static unsigned long mmc_read_and_flush(struct mmc_part *part, 257 lbaint_t start, 258 lbaint_t sectors, 259 void *buffer) 260 { 261 unsigned long blks; 262 void *tmp_buf; 263 size_t buf_size; 264 bool unaligned = is_buf_unaligned(buffer); 265 266 if (start < part->info.start) { 267 printf("%s: partition start out of bounds\n", __func__); 268 return 0; 269 } 270 if ((start + sectors) > (part->info.start + part->info.size)) { 271 sectors = part->info.start + part->info.size - start; 272 printf("%s: read sector aligned to partition bounds (%ld)\n", 273 __func__, sectors); 274 } 275 276 /* 277 * Reading fails on unaligned buffers, so we have to 278 * use aligned temporary buffer and then copy to destination 279 */ 280 281 if (unaligned) { 282 printf("Handling unaligned read buffer..\n"); 283 tmp_buf = get_sector_buf(); 284 buf_size = get_sector_buf_size(); 285 if (sectors > buf_size / part->info.blksz) 286 sectors = buf_size / part->info.blksz; 287 } else { 288 tmp_buf = buffer; 289 } 290 291 blks = part->mmc->block_dev.block_read(part->mmc_blk, 292 start, sectors, tmp_buf); 293 /* flush cache after read */ 294 flush_cache((ulong)tmp_buf, sectors * part->info.blksz); 295 296 if (unaligned) 297 memcpy(buffer, tmp_buf, sectors * part->info.blksz); 298 299 return blks; 300 } 301 302 static unsigned long mmc_write(struct mmc_part *part, lbaint_t start, 303 lbaint_t sectors, void *buffer) 304 { 305 void *tmp_buf; 306 size_t buf_size; 307 bool unaligned = is_buf_unaligned(buffer); 308 309 if (start < part->info.start) { 310 printf("%s: partition start out of bounds\n", __func__); 311 return 0; 312 } 313 if ((start + sectors) > (part->info.start + part->info.size)) { 314 sectors = part->info.start + part->info.size - start; 315 printf("%s: sector aligned to partition bounds (%ld)\n", 316 __func__, sectors); 317 } 318 if (unaligned) { 319 tmp_buf = get_sector_buf(); 320 buf_size = get_sector_buf_size(); 321 printf("Handling unaligned wrire buffer..\n"); 322 if (sectors > buf_size / part->info.blksz) 323 sectors = buf_size / part->info.blksz; 324 325 memcpy(tmp_buf, buffer, sectors * part->info.blksz); 326 } else { 327 tmp_buf = buffer; 328 } 329 330 return part->mmc->block_dev.block_write(part->mmc_blk, 331 start, sectors, tmp_buf); 332 } 333 334 static struct mmc_part *get_partition(AvbOps *ops, const char *partition) 335 { 336 int ret; 337 u8 dev_num; 338 int part_num = 0; 339 struct mmc_part *part; 340 struct blk_desc *mmc_blk; 341 342 part = malloc(sizeof(struct mmc_part)); 343 if (!part) 344 return NULL; 345 346 dev_num = get_boot_device(ops); 347 part->mmc = find_mmc_device(dev_num); 348 if (!part->mmc) { 349 printf("No MMC device at slot %x\n", dev_num); 350 return NULL; 351 } 352 353 if (mmc_init(part->mmc)) { 354 printf("MMC initialization failed\n"); 355 return NULL; 356 } 357 358 ret = mmc_switch_part(part->mmc, part_num); 359 if (ret) 360 return NULL; 361 362 mmc_blk = mmc_get_blk_desc(part->mmc); 363 if (!mmc_blk) { 364 printf("Error - failed to obtain block descriptor\n"); 365 return NULL; 366 } 367 368 ret = part_get_info_by_name(mmc_blk, partition, &part->info); 369 if (!ret) { 370 printf("Can't find partition '%s'\n", partition); 371 return NULL; 372 } 373 374 part->dev_num = dev_num; 375 part->mmc_blk = mmc_blk; 376 377 return part; 378 } 379 380 static AvbIOResult mmc_byte_io(AvbOps *ops, 381 const char *partition, 382 s64 offset, 383 size_t num_bytes, 384 void *buffer, 385 size_t *out_num_read, 386 enum mmc_io_type io_type) 387 { 388 ulong ret; 389 struct mmc_part *part; 390 u64 start_offset, start_sector, sectors, residue; 391 u8 *tmp_buf; 392 size_t io_cnt = 0; 393 394 if (!partition || !buffer || io_type > IO_WRITE) 395 return AVB_IO_RESULT_ERROR_IO; 396 397 part = get_partition(ops, partition); 398 if (!part) 399 return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION; 400 401 start_offset = calc_offset(part, offset); 402 while (num_bytes) { 403 start_sector = start_offset / part->info.blksz; 404 sectors = num_bytes / part->info.blksz; 405 /* handle non block-aligned reads */ 406 if (start_offset % part->info.blksz || 407 num_bytes < part->info.blksz) { 408 tmp_buf = get_sector_buf(); 409 if (start_offset % part->info.blksz) { 410 residue = part->info.blksz - 411 (start_offset % part->info.blksz); 412 if (residue > num_bytes) 413 residue = num_bytes; 414 } else { 415 residue = num_bytes; 416 } 417 418 if (io_type == IO_READ) { 419 ret = mmc_read_and_flush(part, 420 part->info.start + 421 start_sector, 422 1, tmp_buf); 423 424 if (ret != 1) { 425 printf("%s: read error (%ld, %lld)\n", 426 __func__, ret, start_sector); 427 return AVB_IO_RESULT_ERROR_IO; 428 } 429 /* 430 * if this is not aligned at sector start, 431 * we have to adjust the tmp buffer 432 */ 433 tmp_buf += (start_offset % part->info.blksz); 434 memcpy(buffer, (void *)tmp_buf, residue); 435 } else { 436 ret = mmc_read_and_flush(part, 437 part->info.start + 438 start_sector, 439 1, tmp_buf); 440 441 if (ret != 1) { 442 printf("%s: read error (%ld, %lld)\n", 443 __func__, ret, start_sector); 444 return AVB_IO_RESULT_ERROR_IO; 445 } 446 memcpy((void *)tmp_buf + 447 start_offset % part->info.blksz, 448 buffer, residue); 449 450 ret = mmc_write(part, part->info.start + 451 start_sector, 1, tmp_buf); 452 if (ret != 1) { 453 printf("%s: write error (%ld, %lld)\n", 454 __func__, ret, start_sector); 455 return AVB_IO_RESULT_ERROR_IO; 456 } 457 } 458 459 io_cnt += residue; 460 buffer += residue; 461 start_offset += residue; 462 num_bytes -= residue; 463 continue; 464 } 465 466 if (sectors) { 467 if (io_type == IO_READ) { 468 ret = mmc_read_and_flush(part, 469 part->info.start + 470 start_sector, 471 sectors, buffer); 472 } else { 473 ret = mmc_write(part, 474 part->info.start + 475 start_sector, 476 sectors, buffer); 477 } 478 479 if (!ret) { 480 printf("%s: sector read error\n", __func__); 481 return AVB_IO_RESULT_ERROR_IO; 482 } 483 484 io_cnt += ret * part->info.blksz; 485 buffer += ret * part->info.blksz; 486 start_offset += ret * part->info.blksz; 487 num_bytes -= ret * part->info.blksz; 488 } 489 } 490 491 /* Set counter for read operation */ 492 if (io_type == IO_READ && out_num_read) 493 *out_num_read = io_cnt; 494 495 return AVB_IO_RESULT_OK; 496 } 497 498 /** 499 * ============================================================================ 500 * AVB 2.0 operations 501 * ============================================================================ 502 */ 503 504 /** 505 * read_from_partition() - reads @num_bytes from @offset from partition 506 * identified by a string name 507 * 508 * @ops: contains AVB ops handlers 509 * @partition_name: partition name, NUL-terminated UTF-8 string 510 * @offset: offset from the beginning of partition 511 * @num_bytes: amount of bytes to read 512 * @buffer: destination buffer to store data 513 * @out_num_read: 514 * 515 * @return: 516 * AVB_IO_RESULT_OK, if partition was found and read operation succeed 517 * AVB_IO_RESULT_ERROR_IO, if i/o error occurred from the underlying i/o 518 * subsystem 519 * AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION, if there is no partition with 520 * the given name 521 */ 522 static AvbIOResult read_from_partition(AvbOps *ops, 523 const char *partition_name, 524 s64 offset_from_partition, 525 size_t num_bytes, 526 void *buffer, 527 size_t *out_num_read) 528 { 529 return mmc_byte_io(ops, partition_name, offset_from_partition, 530 num_bytes, buffer, out_num_read, IO_READ); 531 } 532 533 /** 534 * write_to_partition() - writes N bytes to a partition identified by a string 535 * name 536 * 537 * @ops: AvbOps, contains AVB ops handlers 538 * @partition_name: partition name 539 * @offset_from_partition: offset from the beginning of partition 540 * @num_bytes: amount of bytes to write 541 * @buf: data to write 542 * @out_num_read: 543 * 544 * @return: 545 * AVB_IO_RESULT_OK, if partition was found and read operation succeed 546 * AVB_IO_RESULT_ERROR_IO, if input/output error occurred 547 * AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION, if partition, specified in 548 * @partition_name was not found 549 */ 550 static AvbIOResult write_to_partition(AvbOps *ops, 551 const char *partition_name, 552 s64 offset_from_partition, 553 size_t num_bytes, 554 const void *buffer) 555 { 556 return mmc_byte_io(ops, partition_name, offset_from_partition, 557 num_bytes, (void *)buffer, NULL, IO_WRITE); 558 } 559 560 /** 561 * validate_vmbeta_public_key() - checks if the given public key used to sign 562 * the vbmeta partition is trusted 563 * 564 * @ops: AvbOps, contains AVB ops handlers 565 * @public_key_data: public key for verifying vbmeta partition signature 566 * @public_key_length: length of public key 567 * @public_key_metadata: 568 * @public_key_metadata_length: 569 * @out_key_is_trusted: 570 * 571 * @return: 572 * AVB_IO_RESULT_OK, if partition was found and read operation succeed 573 */ 574 static AvbIOResult validate_vbmeta_public_key(AvbOps *ops, 575 const u8 *public_key_data, 576 size_t public_key_length, 577 const u8 578 *public_key_metadata, 579 size_t 580 public_key_metadata_length, 581 bool *out_key_is_trusted) 582 { 583 if (!public_key_length || !public_key_data || !out_key_is_trusted) 584 return AVB_IO_RESULT_ERROR_IO; 585 586 *out_key_is_trusted = false; 587 if (public_key_length != sizeof(avb_root_pub)) 588 return AVB_IO_RESULT_ERROR_IO; 589 590 if (memcmp(avb_root_pub, public_key_data, public_key_length) == 0) 591 *out_key_is_trusted = true; 592 593 return AVB_IO_RESULT_OK; 594 } 595 596 /** 597 * read_rollback_index() - gets the rollback index corresponding to the 598 * location of given by @out_rollback_index. 599 * 600 * @ops: contains AvbOps handlers 601 * @rollback_index_slot: 602 * @out_rollback_index: used to write a retrieved rollback index. 603 * 604 * @return 605 * AVB_IO_RESULT_OK, if the roolback index was retrieved 606 */ 607 static AvbIOResult read_rollback_index(AvbOps *ops, 608 size_t rollback_index_slot, 609 u64 *out_rollback_index) 610 { 611 /* For now we always return 0 as the stored rollback index. */ 612 printf("%s not supported yet\n", __func__); 613 614 if (out_rollback_index) 615 *out_rollback_index = 0; 616 617 return AVB_IO_RESULT_OK; 618 } 619 620 /** 621 * write_rollback_index() - sets the rollback index corresponding to the 622 * location of given by @out_rollback_index. 623 * 624 * @ops: contains AvbOps handlers 625 * @rollback_index_slot: 626 * @rollback_index: rollback index to write. 627 * 628 * @return 629 * AVB_IO_RESULT_OK, if the roolback index was retrieved 630 */ 631 static AvbIOResult write_rollback_index(AvbOps *ops, 632 size_t rollback_index_slot, 633 u64 rollback_index) 634 { 635 /* For now this is a no-op. */ 636 printf("%s not supported yet\n", __func__); 637 638 return AVB_IO_RESULT_OK; 639 } 640 641 /** 642 * read_is_device_unlocked() - gets whether the device is unlocked 643 * 644 * @ops: contains AVB ops handlers 645 * @out_is_unlocked: device unlock state is stored here, true if unlocked, 646 * false otherwise 647 * 648 * @return: 649 * AVB_IO_RESULT_OK: state is retrieved successfully 650 * AVB_IO_RESULT_ERROR_IO: an error occurred 651 */ 652 static AvbIOResult read_is_device_unlocked(AvbOps *ops, bool *out_is_unlocked) 653 { 654 /* For now we always return that the device is unlocked. */ 655 656 printf("%s not supported yet\n", __func__); 657 658 *out_is_unlocked = true; 659 660 return AVB_IO_RESULT_OK; 661 } 662 663 /** 664 * get_unique_guid_for_partition() - gets the GUID for a partition identified 665 * by a string name 666 * 667 * @ops: contains AVB ops handlers 668 * @partition: partition name (NUL-terminated UTF-8 string) 669 * @guid_buf: buf, used to copy in GUID string. Example of value: 670 * 527c1c6d-6361-4593-8842-3c78fcd39219 671 * @guid_buf_size: @guid_buf buffer size 672 * 673 * @return: 674 * AVB_IO_RESULT_OK, on success (GUID found) 675 * AVB_IO_RESULT_ERROR_IO, if incorrect buffer size (@guid_buf_size) was 676 * provided 677 * AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION, if partition was not found 678 */ 679 static AvbIOResult get_unique_guid_for_partition(AvbOps *ops, 680 const char *partition, 681 char *guid_buf, 682 size_t guid_buf_size) 683 { 684 struct mmc_part *part; 685 size_t uuid_size; 686 687 part = get_partition(ops, partition); 688 if (!part) 689 return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION; 690 691 uuid_size = sizeof(part->info.uuid); 692 if (uuid_size > guid_buf_size) 693 return AVB_IO_RESULT_ERROR_IO; 694 695 memcpy(guid_buf, part->info.uuid, uuid_size); 696 guid_buf[uuid_size - 1] = 0; 697 698 return AVB_IO_RESULT_OK; 699 } 700 701 /** 702 * ============================================================================ 703 * AVB2.0 AvbOps alloc/initialisation/free 704 * ============================================================================ 705 */ 706 AvbOps *avb_ops_alloc(int boot_device) 707 { 708 struct AvbOpsData *ops_data; 709 710 ops_data = avb_calloc(sizeof(struct AvbOpsData)); 711 if (!ops_data) 712 return NULL; 713 714 ops_data->ops.user_data = ops_data; 715 716 ops_data->ops.read_from_partition = read_from_partition; 717 ops_data->ops.write_to_partition = write_to_partition; 718 ops_data->ops.validate_vbmeta_public_key = validate_vbmeta_public_key; 719 ops_data->ops.read_rollback_index = read_rollback_index; 720 ops_data->ops.write_rollback_index = write_rollback_index; 721 ops_data->ops.read_is_device_unlocked = read_is_device_unlocked; 722 ops_data->ops.get_unique_guid_for_partition = 723 get_unique_guid_for_partition; 724 725 ops_data->mmc_dev = boot_device; 726 727 return &ops_data->ops; 728 } 729 730 void avb_ops_free(AvbOps *ops) 731 { 732 struct AvbOpsData *ops_data; 733 734 if (ops) 735 return; 736 737 ops_data = ops->user_data; 738 739 if (ops_data) 740 avb_free(ops_data); 741 } 742
