lib/efi_loader/efi_variable.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  EFI utils
   4  *
   5  *  Copyright (c) 2017 Rob Clark
   6  */
   7
   8 #include <malloc.h>
   9 #include <charset.h>
  10 #include <efi_loader.h>
  11 #include <hexdump.h>
  12
  13 #define READ_ONLY BIT(31)
  14
  15 /*
  16  * Mapping between EFI variables and u-boot variables:
  17  *
  18  *   efi_$guid_$varname = {attributes}(type)value
  19  *
  20  * For example:
  21  *
  22  *   efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_OsIndicationsSupported=
  23  *      "{ro,boot,run}(blob)0000000000000000"
  24  *   efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_BootOrder=
  25  *      "(blob)00010000"
  26  *
  27  * The attributes are a comma separated list of these possible
  28  * attributes:
  29  *
  30  *   + ro   - read-only
  31  *   + boot - boot-services access
  32  *   + run  - runtime access
  33  *
  34  * NOTE: with current implementation, no variables are available after
  35  * ExitBootServices, and all are persisted (if possible).
  36  *
  37  * If not specified, the attributes default to "{boot}".
  38  *
  39  * The required type is one of:
  40  *
  41  *   + utf8 - raw utf8 string
  42  *   + blob - arbitrary length hex string
  43  *
  44  * Maybe a utf16 type would be useful to for a string value to be auto
  45  * converted to utf16?
  46  */
  47
  48 #define PREFIX_LEN (strlen("efi_xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx_"))
  49
  50 /**
  51  * efi_to_native() - convert the UEFI variable name and vendor GUID to U-Boot
  52  *                   variable name
  53  *
  54  * The U-Boot variable name is a concatenation of prefix 'efi', the hexstring
  55  * encoded vendor GUID, and the UTF-8 encoded UEFI variable name separated by
  56  * underscores, e.g. 'efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_BootOrder'.
  57  *
  58  * @native:             pointer to pointer to U-Boot variable name
  59  * @variable_name:      UEFI variable name
  60  * @vendor:             vendor GUID
  61  * Return:              status code
  62  */
  63 static efi_status_t efi_to_native(char **native, const u16 *variable_name,
  64                                   const efi_guid_t *vendor)
  65 {
  66         size_t len;
  67         char *pos;
  68
  69         len = PREFIX_LEN + utf16_utf8_strlen(variable_name) + 1;
  70         *native = malloc(len);
  71         if (!*native)
  72                 return EFI_OUT_OF_RESOURCES;
  73
  74         pos = *native;
  75         pos += sprintf(pos, "efi_%pUl_", vendor);
  76         utf16_utf8_strcpy(&pos, variable_name);
  77
  78         return EFI_SUCCESS;
  79 }
  80
  81 /**
  82  * prefix() - skip over prefix
  83  *
  84  * Skip over a prefix string.
  85  *
  86  * @str:        string with prefix
  87  * @prefix:     prefix string
  88  * Return:      string without prefix, or NULL if prefix not found
  89  */
  90 static const char *prefix(const char *str, const char *prefix)
  91 {
  92         size_t n = strlen(prefix);
  93         if (!strncmp(prefix, str, n))
  94                 return str + n;
  95         return NULL;
  96 }
  97
  98 /**
  99  * parse_attr() - decode attributes part of variable value
 100  *
 101  * Convert the string encoded attributes of a UEFI variable to a bit mask.
 102  * TODO: Several attributes are not supported.
 103  *
 104  * @str:        value of U-Boot variable
 105  * @attrp:      pointer to UEFI attributes
 106  * Return:      pointer to remainder of U-Boot variable value
 107  */
 108 static const char *parse_attr(const char *str, u32 *attrp)
 109 {
 110         u32 attr = 0;
 111         char sep = '{';
 112
 113         if (*str != '{') {
 114                 *attrp = EFI_VARIABLE_BOOTSERVICE_ACCESS;
 115                 return str;
 116         }
 117
 118         while (*str == sep) {
 119                 const char *s;
 120
 121                 str++;
 122
 123                 if ((s = prefix(str, "ro"))) {
 124                         attr |= READ_ONLY;
 125                 } else if ((s = prefix(str, "boot"))) {
 126                         attr |= EFI_VARIABLE_BOOTSERVICE_ACCESS;
 127                 } else if ((s = prefix(str, "run"))) {
 128                         attr |= EFI_VARIABLE_RUNTIME_ACCESS;
 129                 } else {
 130                         printf("invalid attribute: %s\n", str);
 131                         break;
 132                 }
 133
 134                 str = s;
 135                 sep = ',';
 136         }
 137
 138         str++;
 139
 140         *attrp = attr;
 141
 142         return str;
 143 }
 144
 145 /**
 146  * efi_efi_get_variable() - retrieve value of a UEFI variable
 147  *
 148  * This function implements the GetVariable runtime service.
 149  *
 150  * See the Unified Extensible Firmware Interface (UEFI) specification for
 151  * details.
 152  *
 153  * @variable_name:      name of the variable
 154  * @vendor:             vendor GUID
 155  * @attributes:         attributes of the variable
 156  * @data_size:          size of the buffer to which the variable value is copied
 157  * @data:               buffer to which the variable value is copied
 158  * Return:              status code
 159  */
 160 efi_status_t EFIAPI efi_get_variable(u16 *variable_name,
 161                                      const efi_guid_t *vendor, u32 *attributes,
 162                                      efi_uintn_t *data_size, void *data)
 163 {
 164         char *native_name;
 165         efi_status_t ret;
 166         unsigned long in_size;
 167         const char *val, *s;
 168         u32 attr;
 169
 170         EFI_ENTRY("\"%ls\" %pUl %p %p %p", variable_name, vendor, attributes,
 171                   data_size, data);
 172
 173         if (!variable_name || !vendor || !data_size)
 174                 return EFI_EXIT(EFI_INVALID_PARAMETER);
 175
 176         ret = efi_to_native(&native_name, variable_name, vendor);
 177         if (ret)
 178                 return EFI_EXIT(ret);
 179
 180         debug("%s: get '%s'\n", __func__, native_name);
 181
 182         val = env_get(native_name);
 183         free(native_name);
 184         if (!val)
 185                 return EFI_EXIT(EFI_NOT_FOUND);
 186
 187         val = parse_attr(val, &attr);
 188
 189         in_size = *data_size;
 190
 191         if ((s = prefix(val, "(blob)"))) {
 192                 size_t len = strlen(s);
 193
 194                 /* number of hexadecimal digits must be even */
 195                 if (len & 1)
 196                         return EFI_EXIT(EFI_DEVICE_ERROR);
 197
 198                 /* two characters per byte: */
 199                 len /= 2;
 200                 *data_size = len;
 201
 202                 if (in_size < len)
 203                         return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
 204
 205                 if (!data)
 206                         return EFI_EXIT(EFI_INVALID_PARAMETER);
 207
 208                 if (hex2bin(data, s, len))
 209                         return EFI_EXIT(EFI_DEVICE_ERROR);
 210
 211                 debug("%s: got value: \"%s\"\n", __func__, s);
 212         } else if ((s = prefix(val, "(utf8)"))) {
 213                 unsigned len = strlen(s) + 1;
 214
 215                 *data_size = len;
 216
 217                 if (in_size < len)
 218                         return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
 219
 220                 if (!data)
 221                         return EFI_EXIT(EFI_INVALID_PARAMETER);
 222
 223                 memcpy(data, s, len);
 224                 ((char *)data)[len] = '\0';
 225
 226                 debug("%s: got value: \"%s\"\n", __func__, (char *)data);
 227         } else {
 228                 debug("%s: invalid value: '%s'\n", __func__, val);
 229                 return EFI_EXIT(EFI_DEVICE_ERROR);
 230         }
 231
 232         if (attributes)
 233                 *attributes = attr & EFI_VARIABLE_MASK;
 234
 235         return EFI_EXIT(EFI_SUCCESS);
 236 }
 237
 238 /**
 239  * efi_efi_get_next_variable() - get next UEFI variable
 240  *
 241  * This function implements the GetNextVariable runtime service.
 242  *
 243  * See the Unified Extensible Firmware Interface (UEFI) specification for
 244  * details.
 245  *
 246  * @variable_name_size: on entry size of the buffer for the variable name, on
 247  *                      exit the length of the name of the next variable
 248  * @variable_name:      on entry name of the current variable, on exit the name
 249  *                      of the next variable
 250  * @vendor:             vendor GUID
 251  * Return:              status code
 252  */
 253 efi_status_t EFIAPI efi_get_next_variable_name(efi_uintn_t *variable_name_size,
 254                                                u16 *variable_name,
 255                                                const efi_guid_t *vendor)
 256 {
 257         EFI_ENTRY("%p \"%ls\" %pUl", variable_name_size, variable_name, vendor);
 258
 259         return EFI_EXIT(EFI_DEVICE_ERROR);
 260 }
 261
 262 /**
 263  * efi_efi_set_variable() - set value of a UEFI variable
 264  *
 265  * This function implements the SetVariable runtime service.
 266  *
 267  * See the Unified Extensible Firmware Interface (UEFI) specification for
 268  * details.
 269  *
 270  * @variable_name:      name of the variable
 271  * @vendor:             vendor GUID
 272  * @attributes:         attributes of the variable
 273  * @data_size:          size of the buffer with the variable value
 274  * @data:               buffer with the variable value
 275  * Return:              status code
 276  */
 277 efi_status_t EFIAPI efi_set_variable(u16 *variable_name,
 278                                      const efi_guid_t *vendor, u32 attributes,
 279                                      efi_uintn_t data_size, const void *data)
 280 {
 281         char *native_name = NULL, *val = NULL, *s;
 282         efi_status_t ret = EFI_SUCCESS;
 283         u32 attr;
 284
 285         EFI_ENTRY("\"%ls\" %pUl %x %zu %p", variable_name, vendor, attributes,
 286                   data_size, data);
 287
 288         if (!variable_name || !vendor) {
 289                 ret = EFI_INVALID_PARAMETER;
 290                 goto out;
 291         }
 292
 293         ret = efi_to_native(&native_name, variable_name, vendor);
 294         if (ret)
 295                 goto out;
 296
 297 #define ACCESS_ATTR (EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS)
 298
 299         if ((data_size == 0) || !(attributes & ACCESS_ATTR)) {
 300                 /* delete the variable: */
 301                 env_set(native_name, NULL);
 302                 ret = EFI_SUCCESS;
 303                 goto out;
 304         }
 305
 306         val = env_get(native_name);
 307         if (val) {
 308                 parse_attr(val, &attr);
 309
 310                 if (attr & READ_ONLY) {
 311                         /* We should not free val */
 312                         val = NULL;
 313                         ret = EFI_WRITE_PROTECTED;
 314                         goto out;
 315                 }
 316         }
 317
 318         val = malloc(2 * data_size + strlen("{ro,run,boot}(blob)") + 1);
 319         if (!val) {
 320                 ret = EFI_OUT_OF_RESOURCES;
 321                 goto out;
 322         }
 323
 324         s = val;
 325
 326         /*
 327          * store attributes
 328          * TODO: several attributes are not supported
 329          */
 330         attributes &= (EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS);
 331         s += sprintf(s, "{");
 332         while (attributes) {
 333                 u32 attr = 1 << (ffs(attributes) - 1);
 334
 335                 if (attr == EFI_VARIABLE_BOOTSERVICE_ACCESS)
 336                         s += sprintf(s, "boot");
 337                 else if (attr == EFI_VARIABLE_RUNTIME_ACCESS)
 338                         s += sprintf(s, "run");
 339
 340                 attributes &= ~attr;
 341                 if (attributes)
 342                         s += sprintf(s, ",");
 343         }
 344         s += sprintf(s, "}");
 345
 346         /* store payload: */
 347         s += sprintf(s, "(blob)");
 348         s = bin2hex(s, data, data_size);
 349         *s = '\0';
 350
 351         debug("%s: setting: %s=%s\n", __func__, native_name, val);
 352
 353         if (env_set(native_name, val))
 354                 ret = EFI_DEVICE_ERROR;
 355
 356 out:
 357         free(native_name);
 358         free(val);
 359
 360         return EFI_EXIT(ret);
 361 }