common/avb_verify.c

   1 /*
   2  * (C) Copyright 2018, Linaro Limited
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include <avb_verify.h>
   8 #include <blk.h>
   9 #include <fastboot.h>
  10 #include <image.h>
  11 #include <malloc.h>
  12 #include <part.h>
  13 #include <tee.h>
  14 #include <tee/optee_ta_avb.h>
  15
  16 static const unsigned char avb_root_pub[1032] = {
  17         0x0, 0x0, 0x10, 0x0, 0x55, 0xd9, 0x4, 0xad, 0xd8, 0x4,
  18         0xaf, 0xe3, 0xd3, 0x84, 0x6c, 0x7e, 0xd, 0x89, 0x3d, 0xc2,
  19         0x8c, 0xd3, 0x12, 0x55, 0xe9, 0x62, 0xc9, 0xf1, 0xf, 0x5e,
  20         0xcc, 0x16, 0x72, 0xab, 0x44, 0x7c, 0x2c, 0x65, 0x4a, 0x94,
  21         0xb5, 0x16, 0x2b, 0x0, 0xbb, 0x6, 0xef, 0x13, 0x7, 0x53,
  22         0x4c, 0xf9, 0x64, 0xb9, 0x28, 0x7a, 0x1b, 0x84, 0x98, 0x88,
  23         0xd8, 0x67, 0xa4, 0x23, 0xf9, 0xa7, 0x4b, 0xdc, 0x4a, 0xf,
  24         0xf7, 0x3a, 0x18, 0xae, 0x54, 0xa8, 0x15, 0xfe, 0xb0, 0xad,
  25         0xac, 0x35, 0xda, 0x3b, 0xad, 0x27, 0xbc, 0xaf, 0xe8, 0xd3,
  26         0x2f, 0x37, 0x34, 0xd6, 0x51, 0x2b, 0x6c, 0x5a, 0x27, 0xd7,
  27         0x96, 0x6, 0xaf, 0x6b, 0xb8, 0x80, 0xca, 0xfa, 0x30, 0xb4,
  28         0xb1, 0x85, 0xb3, 0x4d, 0xaa, 0xaa, 0xc3, 0x16, 0x34, 0x1a,
  29         0xb8, 0xe7, 0xc7, 0xfa, 0xf9, 0x9, 0x77, 0xab, 0x97, 0x93,
  30         0xeb, 0x44, 0xae, 0xcf, 0x20, 0xbc, 0xf0, 0x80, 0x11, 0xdb,
  31         0x23, 0xc, 0x47, 0x71, 0xb9, 0x6d, 0xd6, 0x7b, 0x60, 0x47,
  32         0x87, 0x16, 0x56, 0x93, 0xb7, 0xc2, 0x2a, 0x9a, 0xb0, 0x4c,
  33         0x1, 0xc, 0x30, 0xd8, 0x93, 0x87, 0xf0, 0xed, 0x6e, 0x8b,
  34         0xbe, 0x30, 0x5b, 0xf6, 0xa6, 0xaf, 0xdd, 0x80, 0x7c, 0x45,
  35         0x5e, 0x8f, 0x91, 0x93, 0x5e, 0x44, 0xfe, 0xb8, 0x82, 0x7,
  36         0xee, 0x79, 0xca, 0xbf, 0x31, 0x73, 0x62, 0x58, 0xe3, 0xcd,
  37         0xc4, 0xbc, 0xc2, 0x11, 0x1d, 0xa1, 0x4a, 0xbf, 0xfe, 0x27,
  38         0x7d, 0xa1, 0xf6, 0x35, 0xa3, 0x5e, 0xca, 0xdc, 0x57, 0x2f,
  39         0x3e, 0xf0, 0xc9, 0x5d, 0x86, 0x6a, 0xf8, 0xaf, 0x66, 0xa7,
  40         0xed, 0xcd, 0xb8, 0xed, 0xa1, 0x5f, 0xba, 0x9b, 0x85, 0x1a,
  41         0xd5, 0x9, 0xae, 0x94, 0x4e, 0x3b, 0xcf, 0xcb, 0x5c, 0xc9,
  42         0x79, 0x80, 0xf7, 0xcc, 0xa6, 0x4a, 0xa8, 0x6a, 0xd8, 0xd3,
  43         0x31, 0x11, 0xf9, 0xf6, 0x2, 0x63, 0x2a, 0x1a, 0x2d, 0xd1,
  44         0x1a, 0x66, 0x1b, 0x16, 0x41, 0xbd, 0xbd, 0xf7, 0x4d, 0xc0,
  45         0x4a, 0xe5, 0x27, 0x49, 0x5f, 0x7f, 0x58, 0xe3, 0x27, 0x2d,
  46         0xe5, 0xc9, 0x66, 0xe, 0x52, 0x38, 0x16, 0x38, 0xfb, 0x16,
  47         0xeb, 0x53, 0x3f, 0xe6, 0xfd, 0xe9, 0xa2, 0x5e, 0x25, 0x59,
  48         0xd8, 0x79, 0x45, 0xff, 0x3, 0x4c, 0x26, 0xa2, 0x0, 0x5a,
  49         0x8e, 0xc2, 0x51, 0xa1, 0x15, 0xf9, 0x7b, 0xf4, 0x5c, 0x81,
  50         0x9b, 0x18, 0x47, 0x35, 0xd8, 0x2d, 0x5, 0xe9, 0xad, 0xf,
  51         0x35, 0x74, 0x15, 0xa3, 0x8e, 0x8b, 0xcc, 0x27, 0xda, 0x7c,
  52         0x5d, 0xe4, 0xfa, 0x4, 0xd3, 0x5, 0xb, 0xba, 0x3a, 0xb2,
  53         0x49, 0x45, 0x2f, 0x47, 0xc7, 0xd, 0x41, 0x3f, 0x97, 0x80,
  54         0x4d, 0x3f, 0xc1, 0xb5, 0xbb, 0x70, 0x5f, 0xa7, 0x37, 0xaf,
  55         0x48, 0x22, 0x12, 0x45, 0x2e, 0xf5, 0xf, 0x87, 0x92, 0xe2,
  56         0x84, 0x1, 0xf9, 0x12, 0xf, 0x14, 0x15, 0x24, 0xce, 0x89,
  57         0x99, 0xee, 0xb9, 0xc4, 0x17, 0x70, 0x70, 0x15, 0xea, 0xbe,
  58         0xc6, 0x6c, 0x1f, 0x62, 0xb3, 0xf4, 0x2d, 0x16, 0x87, 0xfb,
  59         0x56, 0x1e, 0x45, 0xab, 0xae, 0x32, 0xe4, 0x5e, 0x91, 0xed,
  60         0x53, 0x66, 0x5e, 0xbd, 0xed, 0xad, 0xe6, 0x12, 0x39, 0xd,
  61         0x83, 0xc9, 0xe8, 0x6b, 0x6c, 0x2d, 0xa5, 0xee, 0xc4, 0x5a,
  62         0x66, 0xae, 0x8c, 0x97, 0xd7, 0xd, 0x6c, 0x49, 0xc7, 0xf5,
  63         0xc4, 0x92, 0x31, 0x8b, 0x9, 0xee, 0x33, 0xda, 0xa9, 0x37,
  64         0xb6, 0x49, 0x18, 0xf8, 0xe, 0x60, 0x45, 0xc8, 0x33, 0x91,
  65         0xef, 0x20, 0x57, 0x10, 0xbe, 0x78, 0x2d, 0x83, 0x26, 0xd6,
  66         0xca, 0x61, 0xf9, 0x2f, 0xe0, 0xbf, 0x5, 0x30, 0x52, 0x5a,
  67         0x12, 0x1c, 0x0, 0xa7, 0x5d, 0xcc, 0x7c, 0x2e, 0xc5, 0x95,
  68         0x8b, 0xa3, 0x3b, 0xf0, 0x43, 0x2e, 0x5e, 0xdd, 0x0, 0xdb,
  69         0xd, 0xb3, 0x37, 0x99, 0xa9, 0xcd, 0x9c, 0xb7, 0x43, 0xf7,
  70         0x35, 0x44, 0x21, 0xc2, 0x82, 0x71, 0xab, 0x8d, 0xaa, 0xb4,
  71         0x41, 0x11, 0xec, 0x1e, 0x8d, 0xfc, 0x14, 0x82, 0x92, 0x4e,
  72         0x83, 0x6a, 0xa, 0x6b, 0x35, 0x5e, 0x5d, 0xe9, 0x5c, 0xcc,
  73         0x8c, 0xde, 0x39, 0xd1, 0x4a, 0x5b, 0x5f, 0x63, 0xa9, 0x64,
  74         0xe0, 0xa, 0xcb, 0xb, 0xb8, 0x5a, 0x7c, 0xc3, 0xb, 0xe6,
  75         0xbe, 0xfe, 0x8b, 0xf, 0x7d, 0x34, 0x8e, 0x2, 0x66, 0x74,
  76         0x1, 0x6c, 0xca, 0x76, 0xac, 0x7c, 0x67, 0x8, 0x2f, 0x3f,
  77         0x1a, 0xa6, 0x2c, 0x60, 0xb3, 0xff, 0xda, 0x8d, 0xb8, 0x12,
  78         0xc, 0x0, 0x7f, 0xcc, 0x50, 0xa1, 0x5c, 0x64, 0xa1, 0xe2,
  79         0x5f, 0x32, 0x65, 0xc9, 0x9c, 0xbe, 0xd6, 0xa, 0x13, 0x87,
  80         0x3c, 0x2a, 0x45, 0x47, 0xc, 0xca, 0x42, 0x82, 0xfa, 0x89,
  81         0x65, 0xe7, 0x89, 0xb4, 0x8f, 0xf7, 0x1e, 0xe6, 0x23, 0xa5,
  82         0xd0, 0x59, 0x37, 0x79, 0x92, 0xd7, 0xce, 0x3d, 0xfd, 0xe3,
  83         0xa1, 0xb, 0xcf, 0x6c, 0x85, 0xa0, 0x65, 0xf3, 0x5c, 0xc6,
  84         0x4a, 0x63, 0x5f, 0x6e, 0x3a, 0x3a, 0x2a, 0x8b, 0x6a, 0xb6,
  85         0x2f, 0xbb, 0xf8, 0xb2, 0x4b, 0x62, 0xbc, 0x1a, 0x91, 0x25,
  86         0x66, 0xe3, 0x69, 0xca, 0x60, 0x49, 0xb, 0xf6, 0x8a, 0xbe,
  87         0x3e, 0x76, 0x53, 0xc2, 0x7a, 0xa8, 0x4, 0x17, 0x75, 0xf1,
  88         0xf3, 0x3, 0x62, 0x1b, 0x85, 0xb2, 0xb0, 0xef, 0x80, 0x15,
  89         0xb6, 0xd4, 0x4e, 0xdf, 0x71, 0xac, 0xdb, 0x2a, 0x4, 0xd4,
  90         0xb4, 0x21, 0xba, 0x65, 0x56, 0x57, 0xe8, 0xfa, 0x84, 0xa2,
  91         0x7d, 0x13, 0xe, 0xaf, 0xd7, 0x9a, 0x58, 0x2a, 0xa3, 0x81,
  92         0x84, 0x8d, 0x9, 0xa0, 0x6a, 0xc1, 0xbb, 0xd9, 0xf5, 0x86,
  93         0xac, 0xbd, 0x75, 0x61, 0x9, 0xe6, 0x8c, 0x3d, 0x77, 0xb2,
  94         0xed, 0x30, 0x20, 0xe4, 0x0, 0x1d, 0x97, 0xe8, 0xbf, 0xc7,
  95         0x0, 0x1b, 0x21, 0xb1, 0x16, 0xe7, 0x41, 0x67, 0x2e, 0xec,
  96         0x38, 0xbc, 0xe5, 0x1b, 0xb4, 0x6, 0x23, 0x31, 0x71, 0x1c,
  97         0x49, 0xcd, 0x76, 0x4a, 0x76, 0x36, 0x8d, 0xa3, 0x89, 0x8b,
  98         0x4a, 0x7a, 0xf4, 0x87, 0xc8, 0x15, 0xf, 0x37, 0x39, 0xf6,
  99         0x6d, 0x80, 0x19, 0xef, 0x5c, 0xa8, 0x66, 0xce, 0x1b, 0x16,
 100         0x79, 0x21, 0xdf, 0xd7, 0x31, 0x30, 0xc4, 0x21, 0xdd, 0x34,
 101         0x5b, 0xd2, 0x1a, 0x2b, 0x3e, 0x5d, 0xf7, 0xea, 0xca, 0x5,
 102         0x8e, 0xb7, 0xcb, 0x49, 0x2e, 0xa0, 0xe3, 0xf4, 0xa7, 0x48,
 103         0x19, 0x10, 0x9c, 0x4, 0xa7, 0xf4, 0x28, 0x74, 0xc8, 0x6f,
 104         0x63, 0x20, 0x2b, 0x46, 0x24, 0x26, 0x19, 0x1d, 0xd1, 0x2c,
 105         0x31, 0x6d, 0x5a, 0x29, 0xa2, 0x6, 0xa6, 0xb2, 0x41, 0xcc,
 106         0xa, 0x27, 0x96, 0x9, 0x96, 0xac, 0x47, 0x65, 0x78, 0x68,
 107         0x51, 0x98, 0xd6, 0xd8, 0xa6, 0x2d, 0xa0, 0xcf, 0xec, 0xe2,
 108         0x74, 0xf2, 0x82, 0xe3, 0x97, 0xd9, 0x7e, 0xd4, 0xf8, 0xb,
 109         0x70, 0x43, 0x3d, 0xb1, 0x7b, 0x97, 0x80, 0xd6, 0xcb, 0xd7,
 110         0x19, 0xbc, 0x63, 0xb, 0xfd, 0x4d, 0x88, 0xfe, 0x67, 0xac,
 111         0xb8, 0xcc, 0x50, 0xb7, 0x68, 0xb3, 0x5b, 0xd6, 0x1e, 0x25,
 112         0xfc, 0x5f, 0x3c, 0x8d, 0xb1, 0x33, 0x7c, 0xb3, 0x49, 0x1,
 113         0x3f, 0x71, 0x55, 0xe, 0x51, 0xba, 0x61, 0x26, 0xfa, 0xea,
 114         0xe5, 0xb5, 0xe8, 0xaa, 0xcf, 0xcd, 0x96, 0x9f, 0xd6, 0xc1,
 115         0x5f, 0x53, 0x91, 0xad, 0x5, 0xde, 0x20, 0xe7, 0x51, 0xda,
 116         0x5b, 0x95, 0x67, 0xed, 0xf4, 0xee, 0x42, 0x65, 0x70, 0x13,
 117         0xb, 0x70, 0x14, 0x1c, 0xc9, 0xe0, 0x19, 0xca, 0x5f, 0xf5,
 118         0x1d, 0x70, 0x4b, 0x6c, 0x6, 0x74, 0xec, 0xb5, 0x2e, 0x77,
 119         0xe1, 0x74, 0xa1, 0xa3, 0x99, 0xa0, 0x85, 0x9e, 0xf1, 0xac,
 120         0xd8, 0x7e,
 121 };
 122
 123 /**
 124  * ============================================================================
 125  * Boot states support (GREEN, YELLOW, ORANGE, RED) and dm_verity
 126  * ============================================================================
 127  */
 128 char *avb_set_state(AvbOps *ops, enum avb_boot_state boot_state)
 129 {
 130         struct AvbOpsData *data;
 131         char *cmdline = NULL;
 132
 133         if (!ops)
 134                 return NULL;
 135
 136         data = (struct AvbOpsData *)ops->user_data;
 137         if (!data)
 138                 return NULL;
 139
 140         data->boot_state = boot_state;
 141         switch (boot_state) {
 142         case AVB_GREEN:
 143                 cmdline = "androidboot.verifiedbootstate=green";
 144                 break;
 145         case AVB_YELLOW:
 146                 cmdline = "androidboot.verifiedbootstate=yellow";
 147                 break;
 148         case AVB_ORANGE:
 149                 cmdline = "androidboot.verifiedbootstate=orange";
 150         case AVB_RED:
 151                 break;
 152         }
 153
 154         return cmdline;
 155 }
 156
 157 char *append_cmd_line(char *cmdline_orig, char *cmdline_new)
 158 {
 159         char *cmd_line;
 160
 161         if (!cmdline_new)
 162                 return cmdline_orig;
 163
 164         if (cmdline_orig)
 165                 cmd_line = cmdline_orig;
 166         else
 167                 cmd_line = " ";
 168
 169         cmd_line = avb_strdupv(cmd_line, " ", cmdline_new, NULL);
 170
 171         return cmd_line;
 172 }
 173
 174 static int avb_find_dm_args(char **args, char *str)
 175 {
 176         int i;
 177
 178         if (!str)
 179                 return -1;
 180
 181         for (i = 0; i < AVB_MAX_ARGS && args[i]; ++i) {
 182                 if (strstr(args[i], str))
 183                         return i;
 184         }
 185
 186         return -1;
 187 }
 188
 189 static char *avb_set_enforce_option(const char *cmdline, const char *option)
 190 {
 191         char *cmdarg[AVB_MAX_ARGS];
 192         char *newargs = NULL;
 193         int i = 0;
 194         int total_args;
 195
 196         memset(cmdarg, 0, sizeof(cmdarg));
 197         cmdarg[i++] = strtok((char *)cmdline, " ");
 198
 199         do {
 200                 cmdarg[i] = strtok(NULL, " ");
 201                 if (!cmdarg[i])
 202                         break;
 203
 204                 if (++i >= AVB_MAX_ARGS) {
 205                         printf("%s: Can't handle more then %d args\n",
 206                                __func__, i);
 207                         return NULL;
 208                 }
 209         } while (true);
 210
 211         total_args = i;
 212         i = avb_find_dm_args(&cmdarg[0], VERITY_TABLE_OPT_LOGGING);
 213         if (i >= 0) {
 214                 cmdarg[i] = (char *)option;
 215         } else {
 216                 i = avb_find_dm_args(&cmdarg[0], VERITY_TABLE_OPT_RESTART);
 217                 if (i < 0) {
 218                         printf("%s: No verity options found\n", __func__);
 219                         return NULL;
 220                 }
 221
 222                 cmdarg[i] = (char *)option;
 223         }
 224
 225         for (i = 0; i <= total_args; i++)
 226                 newargs = append_cmd_line(newargs, cmdarg[i]);
 227
 228         return newargs;
 229 }
 230
 231 char *avb_set_ignore_corruption(const char *cmdline)
 232 {
 233         char *newargs = NULL;
 234
 235         newargs = avb_set_enforce_option(cmdline, VERITY_TABLE_OPT_LOGGING);
 236         if (newargs)
 237                 newargs = append_cmd_line(newargs,
 238                                           "androidboot.veritymode=eio");
 239
 240         return newargs;
 241 }
 242
 243 char *avb_set_enforce_verity(const char *cmdline)
 244 {
 245         char *newargs;
 246
 247         newargs = avb_set_enforce_option(cmdline, VERITY_TABLE_OPT_RESTART);
 248         if (newargs)
 249                 newargs = append_cmd_line(newargs,
 250                                           "androidboot.veritymode=enforcing");
 251         return newargs;
 252 }
 253
 254 /**
 255  * ============================================================================
 256  * IO(mmc) auxiliary functions
 257  * ============================================================================
 258  */
 259 static unsigned long mmc_read_and_flush(struct mmc_part *part,
 260                                         lbaint_t start,
 261                                         lbaint_t sectors,
 262                                         void *buffer)
 263 {
 264         unsigned long blks;
 265         void *tmp_buf;
 266         size_t buf_size;
 267         bool unaligned = is_buf_unaligned(buffer);
 268
 269         if (start < part->info.start) {
 270                 printf("%s: partition start out of bounds\n", __func__);
 271                 return 0;
 272         }
 273         if ((start + sectors) > (part->info.start + part->info.size)) {
 274                 sectors = part->info.start + part->info.size - start;
 275                 printf("%s: read sector aligned to partition bounds (%ld)\n",
 276                        __func__, sectors);
 277         }
 278
 279         /*
 280          * Reading fails on unaligned buffers, so we have to
 281          * use aligned temporary buffer and then copy to destination
 282          */
 283
 284         if (unaligned) {
 285                 printf("Handling unaligned read buffer..\n");
 286                 tmp_buf = get_sector_buf();
 287                 buf_size = get_sector_buf_size();
 288                 if (sectors > buf_size / part->info.blksz)
 289                         sectors = buf_size / part->info.blksz;
 290         } else {
 291                 tmp_buf = buffer;
 292         }
 293
 294         blks = blk_dread(part->mmc_blk,
 295                          start, sectors, tmp_buf);
 296         /* flush cache after read */
 297         flush_cache((ulong)tmp_buf, sectors * part->info.blksz);
 298
 299         if (unaligned)
 300                 memcpy(buffer, tmp_buf, sectors * part->info.blksz);
 301
 302         return blks;
 303 }
 304
 305 static unsigned long mmc_write(struct mmc_part *part, lbaint_t start,
 306                                lbaint_t sectors, void *buffer)
 307 {
 308         void *tmp_buf;
 309         size_t buf_size;
 310         bool unaligned = is_buf_unaligned(buffer);
 311
 312         if (start < part->info.start) {
 313                 printf("%s: partition start out of bounds\n", __func__);
 314                 return 0;
 315         }
 316         if ((start + sectors) > (part->info.start + part->info.size)) {
 317                 sectors = part->info.start + part->info.size - start;
 318                 printf("%s: sector aligned to partition bounds (%ld)\n",
 319                        __func__, sectors);
 320         }
 321         if (unaligned) {
 322                 tmp_buf = get_sector_buf();
 323                 buf_size = get_sector_buf_size();
 324                 printf("Handling unaligned wrire buffer..\n");
 325                 if (sectors > buf_size / part->info.blksz)
 326                         sectors = buf_size / part->info.blksz;
 327
 328                 memcpy(tmp_buf, buffer, sectors * part->info.blksz);
 329         } else {
 330                 tmp_buf = buffer;
 331         }
 332
 333         return blk_dwrite(part->mmc_blk,
 334                           start, sectors, tmp_buf);
 335 }
 336
 337 static struct mmc_part *get_partition(AvbOps *ops, const char *partition)
 338 {
 339         int ret;
 340         u8 dev_num;
 341         int part_num = 0;
 342         struct mmc_part *part;
 343         struct blk_desc *mmc_blk;
 344
 345         part = malloc(sizeof(struct mmc_part));
 346         if (!part)
 347                 return NULL;
 348
 349         dev_num = get_boot_device(ops);
 350         part->mmc = find_mmc_device(dev_num);
 351         if (!part->mmc) {
 352                 printf("No MMC device at slot %x\n", dev_num);
 353                 goto err;
 354         }
 355
 356         if (mmc_init(part->mmc)) {
 357                 printf("MMC initialization failed\n");
 358                 goto err;
 359         }
 360
 361         ret = mmc_switch_part(part->mmc, part_num);
 362         if (ret)
 363                 goto err;
 364
 365         mmc_blk = mmc_get_blk_desc(part->mmc);
 366         if (!mmc_blk) {
 367                 printf("Error - failed to obtain block descriptor\n");
 368                 goto err;
 369         }
 370
 371         ret = part_get_info_by_name(mmc_blk, partition, &part->info);
 372         if (!ret) {
 373                 printf("Can't find partition '%s'\n", partition);
 374                 goto err;
 375         }
 376
 377         part->dev_num = dev_num;
 378         part->mmc_blk = mmc_blk;
 379
 380         return part;
 381 err:
 382         free(part);
 383         return NULL;
 384 }
 385
 386 static AvbIOResult mmc_byte_io(AvbOps *ops,
 387                                const char *partition,
 388                                s64 offset,
 389                                size_t num_bytes,
 390                                void *buffer,
 391                                size_t *out_num_read,
 392                                enum mmc_io_type io_type)
 393 {
 394         ulong ret;
 395         struct mmc_part *part;
 396         u64 start_offset, start_sector, sectors, residue;
 397         u8 *tmp_buf;
 398         size_t io_cnt = 0;
 399
 400         if (!partition || !buffer || io_type > IO_WRITE)
 401                 return AVB_IO_RESULT_ERROR_IO;
 402
 403         part = get_partition(ops, partition);
 404         if (!part)
 405                 return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
 406
 407         if (!part->info.blksz)
 408                 return AVB_IO_RESULT_ERROR_IO;
 409
 410         start_offset = calc_offset(part, offset);
 411         while (num_bytes) {
 412                 start_sector = start_offset / part->info.blksz;
 413                 sectors = num_bytes / part->info.blksz;
 414                 /* handle non block-aligned reads */
 415                 if (start_offset % part->info.blksz ||
 416                     num_bytes < part->info.blksz) {
 417                         tmp_buf = get_sector_buf();
 418                         if (start_offset % part->info.blksz) {
 419                                 residue = part->info.blksz -
 420                                         (start_offset % part->info.blksz);
 421                                 if (residue > num_bytes)
 422                                         residue = num_bytes;
 423                         } else {
 424                                 residue = num_bytes;
 425                         }
 426
 427                         if (io_type == IO_READ) {
 428                                 ret = mmc_read_and_flush(part,
 429                                                          part->info.start +
 430                                                          start_sector,
 431                                                          1, tmp_buf);
 432
 433                                 if (ret != 1) {
 434                                         printf("%s: read error (%ld, %lld)\n",
 435                                                __func__, ret, start_sector);
 436                                         return AVB_IO_RESULT_ERROR_IO;
 437                                 }
 438                                 /*
 439                                  * if this is not aligned at sector start,
 440                                  * we have to adjust the tmp buffer
 441                                  */
 442                                 tmp_buf += (start_offset % part->info.blksz);
 443                                 memcpy(buffer, (void *)tmp_buf, residue);
 444                         } else {
 445                                 ret = mmc_read_and_flush(part,
 446                                                          part->info.start +
 447                                                          start_sector,
 448                                                          1, tmp_buf);
 449
 450                                 if (ret != 1) {
 451                                         printf("%s: read error (%ld, %lld)\n",
 452                                                __func__, ret, start_sector);
 453                                         return AVB_IO_RESULT_ERROR_IO;
 454                                 }
 455                                 memcpy((void *)tmp_buf +
 456                                         start_offset % part->info.blksz,
 457                                         buffer, residue);
 458
 459                                 ret = mmc_write(part, part->info.start +
 460                                                 start_sector, 1, tmp_buf);
 461                                 if (ret != 1) {
 462                                         printf("%s: write error (%ld, %lld)\n",
 463                                                __func__, ret, start_sector);
 464                                         return AVB_IO_RESULT_ERROR_IO;
 465                                 }
 466                         }
 467
 468                         io_cnt += residue;
 469                         buffer += residue;
 470                         start_offset += residue;
 471                         num_bytes -= residue;
 472                         continue;
 473                 }
 474
 475                 if (sectors) {
 476                         if (io_type == IO_READ) {
 477                                 ret = mmc_read_and_flush(part,
 478                                                          part->info.start +
 479                                                          start_sector,
 480                                                          sectors, buffer);
 481                         } else {
 482                                 ret = mmc_write(part,
 483                                                 part->info.start +
 484                                                 start_sector,
 485                                                 sectors, buffer);
 486                         }
 487
 488                         if (!ret) {
 489                                 printf("%s: sector read error\n", __func__);
 490                                 return AVB_IO_RESULT_ERROR_IO;
 491                         }
 492
 493                         io_cnt += ret * part->info.blksz;
 494                         buffer += ret * part->info.blksz;
 495                         start_offset += ret * part->info.blksz;
 496                         num_bytes -= ret * part->info.blksz;
 497                 }
 498         }
 499
 500         /* Set counter for read operation */
 501         if (io_type == IO_READ && out_num_read)
 502                 *out_num_read = io_cnt;
 503
 504         return AVB_IO_RESULT_OK;
 505 }
 506
 507 /**
 508  * ============================================================================
 509  * AVB 2.0 operations
 510  * ============================================================================
 511  */
 512
 513 /**
 514  * read_from_partition() - reads @num_bytes from  @offset from partition
 515  * identified by a string name
 516  *
 517  * @ops: contains AVB ops handlers
 518  * @partition_name: partition name, NUL-terminated UTF-8 string
 519  * @offset: offset from the beginning of partition
 520  * @num_bytes: amount of bytes to read
 521  * @buffer: destination buffer to store data
 522  * @out_num_read:
 523  *
 524  * @return:
 525  *      AVB_IO_RESULT_OK, if partition was found and read operation succeed
 526  *      AVB_IO_RESULT_ERROR_IO, if i/o error occurred from the underlying i/o
 527  *            subsystem
 528  *      AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION, if there is no partition with
 529  *      the given name
 530  */
 531 static AvbIOResult read_from_partition(AvbOps *ops,
 532                                        const char *partition_name,
 533                                        s64 offset_from_partition,
 534                                        size_t num_bytes,
 535                                        void *buffer,
 536                                        size_t *out_num_read)
 537 {
 538         return mmc_byte_io(ops, partition_name, offset_from_partition,
 539                            num_bytes, buffer, out_num_read, IO_READ);
 540 }
 541
 542 /**
 543  * write_to_partition() - writes N bytes to a partition identified by a string
 544  * name
 545  *
 546  * @ops: AvbOps, contains AVB ops handlers
 547  * @partition_name: partition name
 548  * @offset_from_partition: offset from the beginning of partition
 549  * @num_bytes: amount of bytes to write
 550  * @buf: data to write
 551  * @out_num_read:
 552  *
 553  * @return:
 554  *      AVB_IO_RESULT_OK, if partition was found and read operation succeed
 555  *      AVB_IO_RESULT_ERROR_IO, if input/output error occurred
 556  *      AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION, if partition, specified in
 557  *            @partition_name was not found
 558  */
 559 static AvbIOResult write_to_partition(AvbOps *ops,
 560                                       const char *partition_name,
 561                                       s64 offset_from_partition,
 562                                       size_t num_bytes,
 563                                       const void *buffer)
 564 {
 565         return mmc_byte_io(ops, partition_name, offset_from_partition,
 566                            num_bytes, (void *)buffer, NULL, IO_WRITE);
 567 }
 568
 569 /**
 570  * validate_vmbeta_public_key() - checks if the given public key used to sign
 571  * the vbmeta partition is trusted
 572  *
 573  * @ops: AvbOps, contains AVB ops handlers
 574  * @public_key_data: public key for verifying vbmeta partition signature
 575  * @public_key_length: length of public key
 576  * @public_key_metadata:
 577  * @public_key_metadata_length:
 578  * @out_key_is_trusted:
 579  *
 580  * @return:
 581  *      AVB_IO_RESULT_OK, if partition was found and read operation succeed
 582  */
 583 static AvbIOResult validate_vbmeta_public_key(AvbOps *ops,
 584                                               const u8 *public_key_data,
 585                                               size_t public_key_length,
 586                                               const u8
 587                                               *public_key_metadata,
 588                                               size_t
 589                                               public_key_metadata_length,
 590                                               bool *out_key_is_trusted)
 591 {
 592         if (!public_key_length || !public_key_data || !out_key_is_trusted)
 593                 return AVB_IO_RESULT_ERROR_IO;
 594
 595         *out_key_is_trusted = false;
 596         if (public_key_length != sizeof(avb_root_pub))
 597                 return AVB_IO_RESULT_ERROR_IO;
 598
 599         if (memcmp(avb_root_pub, public_key_data, public_key_length) == 0)
 600                 *out_key_is_trusted = true;
 601
 602         return AVB_IO_RESULT_OK;
 603 }
 604
 605 #ifdef CONFIG_OPTEE_TA_AVB
 606 static int get_open_session(struct AvbOpsData *ops_data)
 607 {
 608         struct udevice *tee = NULL;
 609
 610         while (!ops_data->tee) {
 611                 const struct tee_optee_ta_uuid uuid = TA_AVB_UUID;
 612                 struct tee_open_session_arg arg;
 613                 int rc;
 614
 615                 tee = tee_find_device(tee, NULL, NULL, NULL);
 616                 if (!tee)
 617                         return -ENODEV;
 618
 619                 memset(&arg, 0, sizeof(arg));
 620                 tee_optee_ta_uuid_to_octets(arg.uuid, &uuid);
 621                 rc = tee_open_session(tee, &arg, 0, NULL);
 622                 if (!rc) {
 623                         ops_data->tee = tee;
 624                         ops_data->session = arg.session;
 625                 }
 626         }
 627
 628         return 0;
 629 }
 630
 631 static AvbIOResult invoke_func(struct AvbOpsData *ops_data, u32 func,
 632                                ulong num_param, struct tee_param *param)
 633 {
 634         struct tee_invoke_arg arg;
 635
 636         if (get_open_session(ops_data))
 637                 return AVB_IO_RESULT_ERROR_IO;
 638
 639         memset(&arg, 0, sizeof(arg));
 640         arg.func = func;
 641         arg.session = ops_data->session;
 642
 643         if (tee_invoke_func(ops_data->tee, &arg, num_param, param))
 644                 return AVB_IO_RESULT_ERROR_IO;
 645         switch (arg.ret) {
 646         case TEE_SUCCESS:
 647                 return AVB_IO_RESULT_OK;
 648         case TEE_ERROR_OUT_OF_MEMORY:
 649                 return AVB_IO_RESULT_ERROR_OOM;
 650         case TEE_ERROR_STORAGE_NO_SPACE:
 651                 return AVB_IO_RESULT_ERROR_INSUFFICIENT_SPACE;
 652         case TEE_ERROR_ITEM_NOT_FOUND:
 653                 return AVB_IO_RESULT_ERROR_NO_SUCH_VALUE;
 654         case TEE_ERROR_TARGET_DEAD:
 655                 /*
 656                  * The TA has paniced, close the session to reload the TA
 657                  * for the next request.
 658                  */
 659                 tee_close_session(ops_data->tee, ops_data->session);
 660                 ops_data->tee = NULL;
 661                 return AVB_IO_RESULT_ERROR_IO;
 662         default:
 663                 return AVB_IO_RESULT_ERROR_IO;
 664         }
 665 }
 666 #endif
 667
 668 /**
 669  * read_rollback_index() - gets the rollback index corresponding to the
 670  * location of given by @out_rollback_index.
 671  *
 672  * @ops: contains AvbOps handlers
 673  * @rollback_index_slot:
 674  * @out_rollback_index: used to write a retrieved rollback index.
 675  *
 676  * @return
 677  *       AVB_IO_RESULT_OK, if the roolback index was retrieved
 678  */
 679 static AvbIOResult read_rollback_index(AvbOps *ops,
 680                                        size_t rollback_index_slot,
 681                                        u64 *out_rollback_index)
 682 {
 683 #ifndef CONFIG_OPTEE_TA_AVB
 684         /* For now we always return 0 as the stored rollback index. */
 685         printf("%s not supported yet\n", __func__);
 686
 687         if (out_rollback_index)
 688                 *out_rollback_index = 0;
 689
 690         return AVB_IO_RESULT_OK;
 691 #else
 692         AvbIOResult rc;
 693         struct tee_param param[2];
 694
 695         if (rollback_index_slot >= TA_AVB_MAX_ROLLBACK_LOCATIONS)
 696                 return AVB_IO_RESULT_ERROR_NO_SUCH_VALUE;
 697
 698         memset(param, 0, sizeof(param));
 699         param[0].attr = TEE_PARAM_ATTR_TYPE_VALUE_INPUT;
 700         param[0].u.value.a = rollback_index_slot;
 701         param[1].attr = TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT;
 702
 703         rc = invoke_func(ops->user_data, TA_AVB_CMD_READ_ROLLBACK_INDEX,
 704                          ARRAY_SIZE(param), param);
 705         if (rc)
 706                 return rc;
 707
 708         *out_rollback_index = (u64)param[1].u.value.a << 32 |
 709                               (u32)param[1].u.value.b;
 710         return AVB_IO_RESULT_OK;
 711 #endif
 712 }
 713
 714 /**
 715  * write_rollback_index() - sets the rollback index corresponding to the
 716  * location of given by @out_rollback_index.
 717  *
 718  * @ops: contains AvbOps handlers
 719  * @rollback_index_slot:
 720  * @rollback_index: rollback index to write.
 721  *
 722  * @return
 723  *       AVB_IO_RESULT_OK, if the roolback index was retrieved
 724  */
 725 static AvbIOResult write_rollback_index(AvbOps *ops,
 726                                         size_t rollback_index_slot,
 727                                         u64 rollback_index)
 728 {
 729 #ifndef CONFIG_OPTEE_TA_AVB
 730         /* For now this is a no-op. */
 731         printf("%s not supported yet\n", __func__);
 732
 733         return AVB_IO_RESULT_OK;
 734 #else
 735         struct tee_param param[2];
 736
 737         if (rollback_index_slot >= TA_AVB_MAX_ROLLBACK_LOCATIONS)
 738                 return AVB_IO_RESULT_ERROR_NO_SUCH_VALUE;
 739
 740         memset(param, 0, sizeof(param));
 741         param[0].attr = TEE_PARAM_ATTR_TYPE_VALUE_INPUT;
 742         param[0].u.value.a = rollback_index_slot;
 743         param[1].attr = TEE_PARAM_ATTR_TYPE_VALUE_INPUT;
 744         param[1].u.value.a = (u32)(rollback_index >> 32);
 745         param[1].u.value.b = (u32)rollback_index;
 746
 747         return invoke_func(ops->user_data, TA_AVB_CMD_WRITE_ROLLBACK_INDEX,
 748                            ARRAY_SIZE(param), param);
 749 #endif
 750 }
 751
 752 /**
 753  * read_is_device_unlocked() - gets whether the device is unlocked
 754  *
 755  * @ops: contains AVB ops handlers
 756  * @out_is_unlocked: device unlock state is stored here, true if unlocked,
 757  *       false otherwise
 758  *
 759  * @return:
 760  *       AVB_IO_RESULT_OK: state is retrieved successfully
 761  *       AVB_IO_RESULT_ERROR_IO: an error occurred
 762  */
 763 static AvbIOResult read_is_device_unlocked(AvbOps *ops, bool *out_is_unlocked)
 764 {
 765 #ifndef CONFIG_OPTEE_TA_AVB
 766         /* For now we always return that the device is unlocked. */
 767
 768         printf("%s not supported yet\n", __func__);
 769
 770         *out_is_unlocked = true;
 771
 772         return AVB_IO_RESULT_OK;
 773 #else
 774         AvbIOResult rc;
 775         struct tee_param param = { .attr = TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT };
 776
 777         rc = invoke_func(ops->user_data, TA_AVB_CMD_READ_LOCK_STATE, 1, &param);
 778         if (rc)
 779                 return rc;
 780         *out_is_unlocked = !param.u.value.a;
 781         return AVB_IO_RESULT_OK;
 782 #endif
 783 }
 784
 785 /**
 786  * get_unique_guid_for_partition() - gets the GUID for a partition identified
 787  * by a string name
 788  *
 789  * @ops: contains AVB ops handlers
 790  * @partition: partition name (NUL-terminated UTF-8 string)
 791  * @guid_buf: buf, used to copy in GUID string. Example of value:
 792  *      527c1c6d-6361-4593-8842-3c78fcd39219
 793  * @guid_buf_size: @guid_buf buffer size
 794  *
 795  * @return:
 796  *      AVB_IO_RESULT_OK, on success (GUID found)
 797  *      AVB_IO_RESULT_ERROR_IO, if incorrect buffer size (@guid_buf_size) was
 798  *             provided
 799  *      AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION, if partition was not found
 800  */
 801 static AvbIOResult get_unique_guid_for_partition(AvbOps *ops,
 802                                                  const char *partition,
 803                                                  char *guid_buf,
 804                                                  size_t guid_buf_size)
 805 {
 806         struct mmc_part *part;
 807         size_t uuid_size;
 808
 809         part = get_partition(ops, partition);
 810         if (!part)
 811                 return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
 812
 813         uuid_size = sizeof(part->info.uuid);
 814         if (uuid_size > guid_buf_size)
 815                 return AVB_IO_RESULT_ERROR_IO;
 816
 817         memcpy(guid_buf, part->info.uuid, uuid_size);
 818         guid_buf[uuid_size - 1] = 0;
 819
 820         return AVB_IO_RESULT_OK;
 821 }
 822
 823 /**
 824  * get_size_of_partition() - gets the size of a partition identified
 825  * by a string name
 826  *
 827  * @ops: contains AVB ops handlers
 828  * @partition: partition name (NUL-terminated UTF-8 string)
 829  * @out_size_num_bytes: returns the value of a partition size
 830  *
 831  * @return:
 832  *      AVB_IO_RESULT_OK, on success (GUID found)
 833  *      AVB_IO_RESULT_ERROR_INSUFFICIENT_SPACE, out_size_num_bytes is NULL
 834  *      AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION, if partition was not found
 835  */
 836 static AvbIOResult get_size_of_partition(AvbOps *ops,
 837                                          const char *partition,
 838                                          u64 *out_size_num_bytes)
 839 {
 840         struct mmc_part *part;
 841
 842         if (!out_size_num_bytes)
 843                 return AVB_IO_RESULT_ERROR_INSUFFICIENT_SPACE;
 844
 845         part = get_partition(ops, partition);
 846         if (!part)
 847                 return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
 848
 849         *out_size_num_bytes = part->info.blksz * part->info.size;
 850
 851         return AVB_IO_RESULT_OK;
 852 }
 853
 854 static AvbIOResult read_persistent_value(AvbOps *ops,
 855                                          const char *name,
 856                                          size_t buffer_size,
 857                                          u8 *out_buffer,
 858                                          size_t *out_num_bytes_read)
 859 {
 860         AvbIOResult rc;
 861         struct tee_shm *shm_name;
 862         struct tee_shm *shm_buf;
 863         struct tee_param param[2];
 864         struct udevice *tee;
 865         size_t name_size = strlen(name) + 1;
 866
 867         if (get_open_session(ops->user_data))
 868                 return AVB_IO_RESULT_ERROR_IO;
 869
 870         tee = ((struct AvbOpsData *)ops->user_data)->tee;
 871
 872         rc = tee_shm_alloc(tee, name_size,
 873                            TEE_SHM_ALLOC, &shm_name);
 874         if (rc)
 875                 return AVB_IO_RESULT_ERROR_OOM;
 876
 877         rc = tee_shm_alloc(tee, buffer_size,
 878                            TEE_SHM_ALLOC, &shm_buf);
 879         if (rc) {
 880                 rc = AVB_IO_RESULT_ERROR_OOM;
 881                 goto free_name;
 882         }
 883
 884         memcpy(shm_name->addr, name, name_size);
 885
 886         memset(param, 0, sizeof(param));
 887         param[0].attr = TEE_PARAM_ATTR_TYPE_MEMREF_INPUT;
 888         param[0].u.memref.shm = shm_name;
 889         param[0].u.memref.size = name_size;
 890         param[1].attr = TEE_PARAM_ATTR_TYPE_MEMREF_INOUT;
 891         param[1].u.memref.shm = shm_buf;
 892         param[1].u.memref.size = buffer_size;
 893
 894         rc = invoke_func(ops->user_data, TA_AVB_CMD_READ_PERSIST_VALUE,
 895                          2, param);
 896         if (rc)
 897                 goto out;
 898
 899         if (param[1].u.memref.size > buffer_size) {
 900                 rc = AVB_IO_RESULT_ERROR_NO_SUCH_VALUE;
 901                 goto out;
 902         }
 903
 904         *out_num_bytes_read = param[1].u.memref.size;
 905
 906         memcpy(out_buffer, shm_buf->addr, *out_num_bytes_read);
 907
 908 out:
 909         tee_shm_free(shm_buf);
 910 free_name:
 911         tee_shm_free(shm_name);
 912
 913         return rc;
 914 }
 915
 916 static AvbIOResult write_persistent_value(AvbOps *ops,
 917                                           const char *name,
 918                                           size_t value_size,
 919                                           const u8 *value)
 920 {
 921         AvbIOResult rc;
 922         struct tee_shm *shm_name;
 923         struct tee_shm *shm_buf;
 924         struct tee_param param[2];
 925         struct udevice *tee;
 926         size_t name_size = strlen(name) + 1;
 927
 928         if (get_open_session(ops->user_data))
 929                 return AVB_IO_RESULT_ERROR_IO;
 930
 931         tee = ((struct AvbOpsData *)ops->user_data)->tee;
 932
 933         if (!value_size)
 934                 return AVB_IO_RESULT_ERROR_NO_SUCH_VALUE;
 935
 936         rc = tee_shm_alloc(tee, name_size,
 937                            TEE_SHM_ALLOC, &shm_name);
 938         if (rc)
 939                 return AVB_IO_RESULT_ERROR_OOM;
 940
 941         rc = tee_shm_alloc(tee, value_size,
 942                            TEE_SHM_ALLOC, &shm_buf);
 943         if (rc) {
 944                 rc = AVB_IO_RESULT_ERROR_OOM;
 945                 goto free_name;
 946         }
 947
 948         memcpy(shm_name->addr, name, name_size);
 949         memcpy(shm_buf->addr, value, value_size);
 950
 951         memset(param, 0, sizeof(param));
 952         param[0].attr = TEE_PARAM_ATTR_TYPE_MEMREF_INPUT;
 953         param[0].u.memref.shm = shm_name;
 954         param[0].u.memref.size = name_size;
 955         param[1].attr = TEE_PARAM_ATTR_TYPE_MEMREF_INPUT;
 956         param[1].u.memref.shm = shm_buf;
 957         param[1].u.memref.size = value_size;
 958
 959         rc = invoke_func(ops->user_data, TA_AVB_CMD_WRITE_PERSIST_VALUE,
 960                          2, param);
 961         if (rc)
 962                 goto out;
 963
 964 out:
 965         tee_shm_free(shm_buf);
 966 free_name:
 967         tee_shm_free(shm_name);
 968
 969         return rc;
 970 }
 971 /**
 972  * ============================================================================
 973  * AVB2.0 AvbOps alloc/initialisation/free
 974  * ============================================================================
 975  */
 976 AvbOps *avb_ops_alloc(int boot_device)
 977 {
 978         struct AvbOpsData *ops_data;
 979
 980         ops_data = avb_calloc(sizeof(struct AvbOpsData));
 981         if (!ops_data)
 982                 return NULL;
 983
 984         ops_data->ops.user_data = ops_data;
 985
 986         ops_data->ops.read_from_partition = read_from_partition;
 987         ops_data->ops.write_to_partition = write_to_partition;
 988         ops_data->ops.validate_vbmeta_public_key = validate_vbmeta_public_key;
 989         ops_data->ops.read_rollback_index = read_rollback_index;
 990         ops_data->ops.write_rollback_index = write_rollback_index;
 991         ops_data->ops.read_is_device_unlocked = read_is_device_unlocked;
 992         ops_data->ops.get_unique_guid_for_partition =
 993                 get_unique_guid_for_partition;
 994 #ifdef CONFIG_OPTEE_TA_AVB
 995         ops_data->ops.write_persistent_value = write_persistent_value;
 996         ops_data->ops.read_persistent_value = read_persistent_value;
 997 #endif
 998         ops_data->ops.get_size_of_partition = get_size_of_partition;
 999         ops_data->mmc_dev = boot_device;
1000
1001         return &ops_data->ops;
1002 }
1003
1004 void avb_ops_free(AvbOps *ops)
1005 {
1006         struct AvbOpsData *ops_data;
1007
1008         if (!ops)
1009                 return;
1010
1011         ops_data = ops->user_data;
1012
1013         if (ops_data) {
1014 #ifdef CONFIG_OPTEE_TA_AVB
1015                 if (ops_data->tee)
1016                         tee_close_session(ops_data->tee, ops_data->session);
1017 #endif
1018                 avb_free(ops_data);
1019         }
1020 }