lib/efi_loader/efi_helper.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2020, Linaro Limited
   4  */
   5
   6 #define LOG_CATEGORY LOGC_EFI
   7 #include <common.h>
   8 #include <env.h>
   9 #include <malloc.h>
  10 #include <dm.h>
  11 #include <fs.h>
  12 #include <efi_load_initrd.h>
  13 #include <efi_loader.h>
  14 #include <efi_variable.h>
  15
  16 #if defined(CONFIG_CMD_EFIDEBUG) || defined(CONFIG_EFI_LOAD_FILE2_INITRD)
  17 /* GUID used by Linux to identify the LoadFile2 protocol with the initrd */
  18 const efi_guid_t efi_lf2_initrd_guid = EFI_INITRD_MEDIA_GUID;
  19 #endif
  20
  21 /**
  22  * efi_create_current_boot_var() - Return Boot#### name were #### is replaced by
  23  *                                 the value of BootCurrent
  24  *
  25  * @var_name:           variable name
  26  * @var_name_size:      size of var_name
  27  *
  28  * Return:      Status code
  29  */
  30 static efi_status_t efi_create_current_boot_var(u16 var_name[],
  31                                                 size_t var_name_size)
  32 {
  33         efi_uintn_t boot_current_size;
  34         efi_status_t ret;
  35         u16 boot_current;
  36         u16 *pos;
  37
  38         boot_current_size = sizeof(boot_current);
  39         ret = efi_get_variable_int(u"BootCurrent",
  40                                    &efi_global_variable_guid, NULL,
  41                                    &boot_current_size, &boot_current, NULL);
  42         if (ret != EFI_SUCCESS)
  43                 goto out;
  44
  45         pos = efi_create_indexed_name(var_name, var_name_size, "Boot",
  46                                       boot_current);
  47         if (!pos) {
  48                 ret = EFI_OUT_OF_RESOURCES;
  49                 goto out;
  50         }
  51
  52 out:
  53         return ret;
  54 }
  55
  56 /**
  57  * efi_get_dp_from_boot() - Retrieve and return a device path from an EFI
  58  *                          Boot### variable.
  59  *                          A boot option may contain an array of device paths.
  60  *                          We use a VenMedia() with a specific GUID to identify
  61  *                          the usage of the array members. This function is
  62  *                          used to extract a specific device path
  63  *
  64  * @guid:       vendor GUID of the VenMedia() device path node identifying the
  65  *              device path
  66  *
  67  * Return:      device path or NULL. Caller must free the returned value
  68  */
  69 struct efi_device_path *efi_get_dp_from_boot(const efi_guid_t guid)
  70 {
  71         struct efi_load_option lo;
  72         void *var_value;
  73         efi_uintn_t size;
  74         efi_status_t ret;
  75         u16 var_name[16];
  76
  77         ret = efi_create_current_boot_var(var_name, sizeof(var_name));
  78         if (ret != EFI_SUCCESS)
  79                 return NULL;
  80
  81         var_value = efi_get_var(var_name, &efi_global_variable_guid, &size);
  82         if (!var_value)
  83                 return NULL;
  84
  85         ret = efi_deserialize_load_option(&lo, var_value, &size);
  86         if (ret != EFI_SUCCESS)
  87                 goto err;
  88
  89         return efi_dp_from_lo(&lo, &guid);
  90
  91 err:
  92         free(var_value);
  93         return NULL;
  94 }
  95
  96 const struct guid_to_hash_map {
  97         efi_guid_t guid;
  98         const char algo[32];
  99         u32 bits;
 100 } guid_to_hash[] = {
 101         {
 102                 EFI_CERT_X509_SHA256_GUID,
 103                 "sha256",
 104                 SHA256_SUM_LEN * 8,
 105         },
 106         {
 107                 EFI_CERT_SHA256_GUID,
 108                 "sha256",
 109                 SHA256_SUM_LEN * 8,
 110         },
 111         {
 112                 EFI_CERT_X509_SHA384_GUID,
 113                 "sha384",
 114                 SHA384_SUM_LEN * 8,
 115         },
 116         {
 117                 EFI_CERT_X509_SHA512_GUID,
 118                 "sha512",
 119                 SHA512_SUM_LEN * 8,
 120         },
 121 };
 122
 123 #define MAX_GUID_TO_HASH_COUNT ARRAY_SIZE(guid_to_hash)
 124
 125 /** guid_to_sha_str - return the sha string e.g "sha256" for a given guid
 126  *                    used on EFI security databases
 127  *
 128  * @guid: guid to check
 129  *
 130  * Return: len or 0 if no match is found
 131  */
 132 const char *guid_to_sha_str(const efi_guid_t *guid)
 133 {
 134         size_t i;
 135
 136         for (i = 0; i < MAX_GUID_TO_HASH_COUNT; i++) {
 137                 if (!guidcmp(guid, &guid_to_hash[i].guid))
 138                         return guid_to_hash[i].algo;
 139         }
 140
 141         return NULL;
 142 }
 143
 144 /** algo_to_len - return the sha size in bytes for a given string
 145  *
 146  * @algo: string indicating hashing algorithm to check
 147  *
 148  * Return: length of hash in bytes or 0 if no match is found
 149  */
 150 int algo_to_len(const char *algo)
 151 {
 152         size_t i;
 153
 154         for (i = 0; i < MAX_GUID_TO_HASH_COUNT; i++) {
 155                 if (!strcmp(algo, guid_to_hash[i].algo))
 156                         return guid_to_hash[i].bits / 8;
 157         }
 158
 159         return 0;
 160 }
 161
 162 /** efi_link_dev - link the efi_handle_t and udevice
 163  *
 164  * @handle:     efi handle to associate with udevice
 165  * @dev:        udevice to associate with efi handle
 166  *
 167  * Return:      0 on success, negative on failure
 168  */
 169 int efi_link_dev(efi_handle_t handle, struct udevice *dev)
 170 {
 171         handle->dev = dev;
 172         return dev_tag_set_ptr(dev, DM_TAG_EFI, handle);
 173 }
 174
 175 /**
 176  * efi_unlink_dev() - unlink udevice and handle
 177  *
 178  * @handle:     EFI handle to unlink
 179  *
 180  * Return:      0 on success, negative on failure
 181  */
 182 int efi_unlink_dev(efi_handle_t handle)
 183 {
 184         int ret;
 185
 186         ret = dev_tag_del(handle->dev, DM_TAG_EFI);
 187         if (ret)
 188                 return ret;
 189         handle->dev = NULL;
 190
 191         return 0;
 192 }
 193
 194 static int u16_tohex(u16 c)
 195 {
 196         if (c >= '0' && c <= '9')
 197                 return c - '0';
 198         if (c >= 'A' && c <= 'F')
 199                 return c - 'A' + 10;
 200
 201         /* not hexadecimal */
 202         return -1;
 203 }
 204
 205 bool efi_varname_is_load_option(u16 *var_name16, int *index)
 206 {
 207         int id, i, digit;
 208
 209         if (memcmp(var_name16, u"Boot", 8))
 210                 return false;
 211
 212         for (id = 0, i = 0; i < 4; i++) {
 213                 digit = u16_tohex(var_name16[4 + i]);
 214                 if (digit < 0)
 215                         break;
 216                 id = (id << 4) + digit;
 217         }
 218         if (i == 4 && !var_name16[8]) {
 219                 if (index)
 220                         *index = id;
 221                 return true;
 222         }
 223
 224         return false;
 225 }
 226
 227 /**
 228  * efi_next_variable_name() - get next variable name
 229  *
 230  * This function is a wrapper of efi_get_next_variable_name_int().
 231  * If efi_get_next_variable_name_int() returns EFI_BUFFER_TOO_SMALL,
 232  * @size and @buf are updated by new buffer size and realloced buffer.
 233  *
 234  * @size:       pointer to the buffer size
 235  * @buf:        pointer to the buffer
 236  * @guid:       pointer to the guid
 237  * Return:      status code
 238  */
 239 efi_status_t efi_next_variable_name(efi_uintn_t *size, u16 **buf, efi_guid_t *guid)
 240 {
 241         u16 *p;
 242         efi_status_t ret;
 243         efi_uintn_t buf_size = *size;
 244
 245         ret = efi_get_next_variable_name_int(&buf_size, *buf, guid);
 246         if (ret == EFI_NOT_FOUND)
 247                 return ret;
 248         if (ret == EFI_BUFFER_TOO_SMALL) {
 249                 p = realloc(*buf, buf_size);
 250                 if (!p)
 251                         return EFI_OUT_OF_RESOURCES;
 252
 253                 *buf = p;
 254                 *size = buf_size;
 255                 ret = efi_get_next_variable_name_int(&buf_size, *buf, guid);
 256         }
 257
 258         return ret;
 259 }