From 488976e782a7307cc2df4e1a8aaea1f6dfa757dd Mon Sep 17 00:00:00 2001

From: Peter Jones <pjones@redhat.com>

Date: Mon, 17 Jun 2019 15:04:11 -0400

Subject: [PATCH 37/63] Implement 'efivar --export=foo.var'

Signed-off-by: Peter Jones <pjones@redhat.com>

---

 .gitignore                  |  17 +-

 src/Makefile                |   2 +-

 src/crc32.h                 |  19 ++

 src/efivar.c                | 362 ++++++++++++++++++++------

 src/export.c                | 502 +++++++++++++++++++++++++++++++++---

 src/gpt.c                   |  18 --

 src/include/efivar/efivar.h |   3 +

 7 files changed, 783 insertions(+), 140 deletions(-)

diff --git a/.gitignore b/.gitignore

index 5c3fd0e3f52..947d88eec42 100644

--- a/.gitignore

+++ b/.gitignore

@@ -1,23 +1,26 @@

+.*.c.P

+.*.h.P

+.*.d

 .*.sw?

 *~

 *.a

+*.env

 *.E

 *.o

+*.map

 *.pc

 *.S

 !src/guids.S

 *.so

 *.so.*

+*.spec

 *.tar.*

-.*.c.P

-.*.h.P

-.*.d

+*.var

 core.*

-*.spec

+cov-int

+vgcore.*

+scan-results/

 src/efivar

 src/efivar-static

 src/makeguids

 src/guid-symbols.c

-*.map

-cov-int

-scan-results/

diff --git a/src/Makefile b/src/Makefile

index ecbbc02e1f7..addfaa03c85 100644

--- a/src/Makefile

+++ b/src/Makefile

@@ -17,7 +17,7 @@ STATICTARGETS=$(STATICLIBTARGETS) $(STATICBINTARGETS)

 LIBEFIBOOT_SOURCES = crc32.c creator.c disk.c gpt.c loadopt.c path-helpers.c \

 		     linux.c $(wildcard linux-*.c)

 LIBEFIBOOT_OBJECTS = $(patsubst %.c,%.o,$(LIBEFIBOOT_SOURCES))

-LIBEFIVAR_SOURCES = dp.c dp-acpi.c dp-hw.c dp-media.c dp-message.c \

+LIBEFIVAR_SOURCES = crc32.c dp.c dp-acpi.c dp-hw.c dp-media.c dp-message.c \

 	efivarfs.c error.c export.c guid.c guids.S guid-symbols.c \

 	lib.c vars.c

 LIBEFIVAR_OBJECTS = $(patsubst %.S,%.o,$(patsubst %.c,%.o,$(LIBEFIVAR_SOURCES)))

diff --git a/src/crc32.h b/src/crc32.h

index b5b975a5768..4e833aafac0 100644

--- a/src/crc32.h

+++ b/src/crc32.h

@@ -29,6 +29,25 @@

 extern uint32_t crc32 (const void *buf, unsigned long len, uint32_t seed);

+/**

+ * efi_crc32() - EFI version of crc32 function

+ * @buf: buffer to calculate crc32 of

+ * @len - length of buf

+ *

+ * Description: Returns EFI-style CRC32 value for @buf

+ *

+ * This function uses the little endian Ethernet polynomial

+ * but seeds the function with ~0, and xor's with ~0 at the end.

+ * Note, the EFI Specification, v1.02, has a reference to

+ * Dr. Dobbs Journal, May 1994 (actually it's in May 1992).

+ */

+static inline uint32_t

+efi_crc32(const void *buf, unsigned long len)

+{

+	return (crc32(buf, len, ~0L) ^ ~0L);

+}

+

+

 #endif /* _CRC32_H */

 // vim:fenc=utf-8:tw=75:noet

diff --git a/src/efivar.c b/src/efivar.c

index 7f16ab15bab..885a9af864b 100644

--- a/src/efivar.c

+++ b/src/efivar.c

@@ -46,6 +46,8 @@ extern int optind, opterr, optopt;

 #define ACTION_LIST_GUIDS	0x08

 #define ACTION_WRITE		0x10

 #define ACTION_PRINT_DEC	0x20

+#define ACTION_IMPORT		0x40

+#define ACTION_EXPORT		0x80

 #define EDIT_APPEND	0

 #define EDIT_WRITE	1

@@ -173,31 +175,10 @@ bad_name:

 }

 static void

-show_variable(char *guid_name, int display_type)

+show_variable_data(efi_guid_t guid, const char *name, uint32_t attributes,

+		   uint8_t *data, size_t data_size,

+		   int display_type)

 {

-	efi_guid_t guid = efi_guid_empty;

-	char *name = NULL;

-	int rc;

-

-	uint8_t *data = NULL;

-	size_t data_size = 0;

-	uint32_t attributes;

-

-	parse_name(guid_name, &name, &guid);

-	if (!name || efi_guid_is_empty(&guid)) {

-		fprintf(stderr, "efivar: could not parse variable name.\n");

-		show_errors();

-		exit(1);

-	}

-

-	errno = 0;

-	rc = efi_get_variable(guid, name, &data, &data_size, &attributes);

-	if (rc < 0) {

-		fprintf(stderr, "efivar: show variable: %m\n");

-		show_errors();

-		exit(1);

-	}

-

 	if (display_type == SHOW_VERBOSE) {

 		printf("GUID: "GUID_FORMAT "\n",

 		       guid.a, guid.b, guid.c, bswap_16(guid.d),

@@ -257,6 +238,117 @@ show_variable(char *guid_name, int display_type)

 		}

 		printf("\n");

 	}

+}

+

+static void

+show_variable(char *guid_name, int display_type)

+{

+	efi_guid_t guid = efi_guid_empty;

+	char *name = NULL;

+	int rc;

+

+	uint8_t *data = NULL;

+	size_t data_size = 0;

+	uint32_t attributes;

+

+	parse_name(guid_name, &name, &guid);

+	if (!name || efi_guid_is_empty(&guid)) {

+		fprintf(stderr, "efivar: could not parse variable name.\n");

+		show_errors();

+		exit(1);

+	}

+

+	errno = 0;

+	rc = efi_get_variable(guid, name, &data, &data_size, &attributes);

+	if (rc < 0) {

+		fprintf(stderr, "efivar: show variable: %m\n");

+		show_errors();

+		exit(1);

+	}

+

+	show_variable_data(guid, name, attributes,

+			   data, data_size, display_type);

+

+	free(name);

+	if (data)

+		free(data);

+}

+

+static void

+save_variable_data(efi_variable_t *var, char *outfile, bool dmpstore)

+{

+	FILE *out = NULL;

+	ssize_t sz;

+	uint8_t *data = NULL;

+	size_t datasz = 0;

+	ssize_t (*export)(efi_variable_t *var, uint8_t *data, size_t size) =

+		dmpstore ? efi_variable_export_dmpstore : efi_variable_export;

+

+	out = fopen(outfile, "w");

+	if (!out)

+		err(1, "Could not open \"%s\" for writing", outfile);

+

+	sz = export(var, data, datasz);

+	data = calloc(sz, 1);

+	if (!data)

+		err(1, "Could not allocate memory");

+	datasz = sz;

+

+	sz = export(var, data, datasz);

+	if (sz < 0)

+		err(1, "Could not format data");

+	datasz = sz;

+

+	sz = fwrite(data, 1, datasz, out);

+	if (sz < (ssize_t)datasz)

+		err(1, "Could not write to \"%s\"", outfile);

+

+	fflush(out);

+	fclose(out);

+}

+

+static void

+save_variable(char *guid_name, char *outfile, bool dmpstore)

+{

+	efi_guid_t guid = efi_guid_empty;

+	char *name = NULL;

+	int rc;

+

+	uint8_t *data = NULL;

+	size_t data_size = 0;

+	uint32_t attributes = 7;

+	efi_variable_t *var;

+

+	parse_name(guid_name, &name, &guid);

+	if (!name || efi_guid_is_empty(&guid)) {

+		fprintf(stderr, "efivar: could not parse variable name.\n");

+		show_errors();

+		exit(1);

+	}

+

+	errno = 0;

+	rc = efi_get_variable(guid, name, &data, &data_size, &attributes);

+	if (rc < 0) {

+		fprintf(stderr, "efivar: show variable: %m\n");

+		show_errors();

+		exit(1);

+	}

+

+	var = efi_variable_alloc();

+	if (!var) {

+		fprintf(stderr, "efivar: could not allocate variable storage.\n");

+		show_errors();

+		exit(1);

+	}

+

+	efi_variable_set_name(var, (unsigned char *)name);

+	efi_variable_set_guid(var, &guid);

+	efi_variable_set_attributes(var, attributes);

+	efi_variable_set_data(var, data, data_size);

+

+	save_variable_data(var, outfile, dmpstore);

+

+	efi_variable_free(var, false);

 	free(name);

 	if (data)

@@ -372,16 +464,18 @@ usage(int ret)

 	FILE *out = ret == 0 ? stdout : stderr;

 	fprintf(out,

 		"Usage: %s [OPTION...]\n"

+		"  -t, --attributes=<attributes>     attributes to use on append\n"

 		"  -l, --list                        list current variables\n"

 		"  -p, --print                       print variable specified by --name\n"

+		"  -D, --dmpstore                    use DMPSTORE format when exporting\n"

 		"  -d, --print-decimal               print variable in decimal values specified\n"

 		"                                    by --name\n"

 		"  -n, --name=<guid-name>            variable to manipulate, in the form\n"

 		"                                    8be4df61-93ca-11d2-aa0d-00e098032b8c-Boot0000\n"

 		"  -a, --append                      append to variable specified by --name\n"

+		"  -f, --datafile=<file>             load or save variable contents from <file>\n"

 		"  -e, --export=<file>               export variable to <file>\n"

-		"  -f, --fromfile=<file>             use data from <file>\n"

-		"  -t, --attributes=<attributes>     attributes to use on append\n"

+		"  -i, --import=<file>               import variable from 

 		"  -L, --list-guids                  show internal guid list\n"

 		"  -w, --write                       write to variable specified by --name\n\n"

 		"Help options:\n"

@@ -398,55 +492,79 @@ int main(int argc, char *argv[])

 	int action = 0;

 	uint8_t *data = NULL;

 	size_t data_size = 0;

-	char *name = NULL;

-	char *file = NULL;

-	uint32_t attributes = 0;

-	char *sopts = "lpdn:af:t:Lw?";

-	struct option lopts[] =

-		{ {"list", no_argument, 0, 'l'},

-		  {"print", no_argument, 0, 'p'},

-		  {"print-decimal", no_argument, 0, 'd'},

-		  {"name", required_argument, 0, 'n'},

-		  {"append", no_argument, 0, 'a'},

-		  {"fromfile", required_argument, 0, 'f'},

-		  {"attributes", required_argument, 0, 't'},

-		  {"list-guids", no_argument, 0, 'L'},

-		  {"write", no_argument, 0, 'w'},

-		  {"help", no_argument, 0, '?'},

-		  {"usage", no_argument, 0, 0},

-		  {0, 0, 0, 0}

-		};

+	char *guid_name = NULL;

+	char *infile = NULL;

+	char *outfile = NULL;

+	char *datafile = NULL;

+	bool dmpstore = false;

+	int verbose = 0;

+	uint32_t attributes = EFI_VARIABLE_NON_VOLATILE

+			      | EFI_VARIABLE_BOOTSERVICE_ACCESS

+			      | EFI_VARIABLE_RUNTIME_ACCESS;

+	char *sopts = "aA:Dde:f:i:Llpn:vw?";

+	struct option lopts[] = {

+		{"append", no_argument, 0, 'a'},

+		{"attributes", required_argument, 0, 'A'},

+		{"datafile", required_argument, 0, 'f'},

+		{"dmpstore", no_argument, 0, 'D'},

+		{"export", required_argument, 0, 'e'},

+		{"help", no_argument, 0, '?'},

+		{"import", required_argument, 0, 'i'},

+		{"list", no_argument, 0, 'l'},

+		{"list-guids", no_argument, 0, 'L'},

+		{"name", required_argument, 0, 'n'},

+		{"print", no_argument, 0, 'p'},

+		{"print-decimal", no_argument, 0, 'd'},

+		{"usage", no_argument, 0, 0},

+		{"verbose", no_argument, 0, 'v'},

+		{"write", no_argument, 0, 'w'},

+		{0, 0, 0, 0}

+	};

 	while ((c = getopt_long(argc, argv, sopts, lopts, &i)) != -1) {

 		switch (c) {

-			case 'l':

-				action |= ACTION_LIST;

+			case 'A':

+				attributes = strtoul(optarg, NULL, 10);

+				if (errno == ERANGE || errno == EINVAL)

+					err(1,

+					    "invalid argument for -t: %s: %m\n",

+					    optarg);

 				break;

-			case 'p':

-				action |= ACTION_PRINT;

+			case 'a':

+				action |= ACTION_APPEND;

+				break;

+			case 'D':

+				dmpstore = true;

 				break;

 			case 'd':

 				action |= ACTION_PRINT_DEC;

 				break;

-			case 'n':

-				name = optarg;

-				break;

-			case 'a':

-				action |= ACTION_APPEND;

+			case 'e':

+				action |= ACTION_EXPORT;

+				outfile = optarg;

 				break;

 			case 'f':

-				file = optarg;

+				datafile = optarg;

 				break;

-			case 't':

-				attributes = strtoul(optarg, NULL, 10);

-				if (errno == ERANGE || errno == EINVAL)

-					err(1,

-					    "invalid argument for -t: %s: %m\n",

-					    optarg);

+			case 'i':

+				action |= ACTION_IMPORT;

+				infile = optarg;

 				break;

 			case 'L':

 				action |= ACTION_LIST_GUIDS;

 				break;

+			case 'l':

+				action |= ACTION_LIST;

+				break;

+			case 'n':

+				guid_name = optarg;

+				break;

+			case 'p':

+				action |= ACTION_PRINT;

+				break;

+			case 'v':

+				verbose += 1;

+				break;

 			case 'w':

 				action |= ACTION_WRITE;

 				break;

@@ -460,7 +578,9 @@ int main(int argc, char *argv[])

 		}

 	}

-	if (name)

+	efi_set_verbose(verbose, stderr);

+

+	if (guid_name && !outfile)

 		action |= ACTION_PRINT;

 	switch (action) {

@@ -468,23 +588,23 @@ int main(int argc, char *argv[])

 			list_all_variables();

 			break;

 		case ACTION_PRINT:

-			validate_name(name);

-			show_variable(name, SHOW_VERBOSE);

+			validate_name(guid_name);

+			show_variable(guid_name, SHOW_VERBOSE);

 			break;

 		case ACTION_PRINT_DEC | ACTION_PRINT:

-			validate_name(name);

-			show_variable(name, SHOW_DECIMAL);

+			validate_name(guid_name);

+			show_variable(guid_name, SHOW_DECIMAL);

 			break;

 		case ACTION_APPEND | ACTION_PRINT:

-			validate_name(name);

-			prepare_data(file, &data, &data_size);

-			edit_variable(name, data, data_size, attributes,

+			validate_name(guid_name);

+			prepare_data(infile, &data, &data_size);

+			edit_variable(guid_name, data, data_size, attributes,

 				      EDIT_APPEND);

 			break;

 		case ACTION_WRITE | ACTION_PRINT:

-			validate_name(name);

-			prepare_data(file, &data, &data_size);

-			edit_variable(name, data, data_size, attributes,

+			validate_name(guid_name);

+			prepare_data(infile, &data, &data_size);

+			edit_variable(guid_name, data, data_size, attributes,

 				      EDIT_WRITE);

 			break;

 		case ACTION_LIST_GUIDS: {

@@ -509,10 +629,108 @@ int main(int argc, char *argv[])

 					guid[i].symbol + strlen("efi_guid_"),

 					guid[i].symbol, guid[i].name);

 			}

+			break;

+					}

+		case ACTION_EXPORT:

+			if (datafile) {

+				char *name = NULL;

+				efi_guid_t guid = efi_guid_zero;

+				efi_variable_t *var;

+

+				parse_name(guid_name, &name, &guid);

+				prepare_data(datafile, &data, &data_size);

+

+				var = efi_variable_alloc();

+				if (!var)

+					err(1, "Could not allocate memory");

+

+				efi_variable_set_name(var, (unsigned char *)name);

+				efi_variable_set_guid(var, &guid);

+				efi_variable_set_attributes(var, attributes);

+				efi_variable_set_data(var, data, data_size);

+

+				save_variable_data(var, outfile, dmpstore);

+

+				efi_variable_free(var, false);

+			} else {

+				validate_name(guid_name);

+				save_variable(guid_name, outfile, dmpstore);

+			}

+			break;

+		case ACTION_IMPORT:

+		case ACTION_IMPORT | ACTION_PRINT:

+		case ACTION_IMPORT | ACTION_PRINT | ACTION_PRINT_DEC:

+			{

+				ssize_t sz;

+				efi_variable_t *var = NULL;

+				char *name;

+				efi_guid_t *guid;

+				uint64_t attributes;

+				int display_type = (action & ACTION_PRINT_DEC)

+					? SHOW_VERBOSE|SHOW_DECIMAL

+					: SHOW_VERBOSE;

+

+

+				prepare_data(infile, &data, &data_size);

+				sz = efi_variable_import(data, data_size, &var);

+				if (sz < 0)

+					err(1, "Could not import data from \"%s\"", infile);

+

+				free(data);

+				data = NULL;

+				data_size = 0;

+

+				name = (char *)efi_variable_get_name(var);

+				efi_variable_get_guid(var, &guid);

+				efi_variable_get_attributes(var, &attributes);

+				efi_variable_get_data(var, &data, &data_size);

+

+				if (datafile) {

+					FILE *out;

+					int rc;

+

+					out = fopen(datafile, "w");

+					if (!out)

+						err(1, "Could not open \"%s\" for writing",

+						    datafile);

+

+					rc = fwrite(data, data_size, 1, out);

+					if (rc < (long)data_size)

+						err(1, "Could not write to \"%s\"",

+						    datafile);

+

+					fclose(out);

+					free(guid_name);

+				}

+				if (action & ACTION_PRINT)

+					show_variable_data(*guid, name,

+						((uint32_t)(attributes & 0xffffffff)),

+						 data, data_size, display_type);

+

+				efi_variable_free(var, false);

+				break;

+			}

+		case ACTION_IMPORT | ACTION_EXPORT:

+			{

+				efi_variable_t *var = NULL;

+				ssize_t sz;

+

+				if (datafile)

+					errx(1, "--datafile cannot be used with --import and --export");

+

+				prepare_data(infile, &data, &data_size);

+				sz = efi_variable_import(data, data_size, &var);

+				if (sz < 0)

+					err(1, "Could not import data from \"%s\"", infile);

+

+				save_variable_data(var, outfile, dmpstore);

+

+				efi_variable_free(var, false);

+				break;

+			}

 		case ACTION_USAGE:

 		default:

 			usage(EXIT_FAILURE);

-		}

 	};

 	return 0;

diff --git a/src/export.c b/src/export.c

index 6b78412cce1..cfb021525ff 100644

--- a/src/export.c

+++ b/src/export.c

@@ -27,7 +27,7 @@

 #include "efivar.h"

-#define EFIVAR_MAGIC 0xf3df1597

+#define EFIVAR_MAGIC 0xf3df1597u

 #define ATTRS_UNSET 0xa5a5a5a5a5a5a5a5

 #define ATTRS_MASK 0xffffffff

@@ -50,12 +50,166 @@ struct efi_variable {

  *	uint32_t data_len;

  *	char16_t name[];

  *	uint8_t data[];

- *	uint32_t magic;

+ *	uint32_t crc32;

+ * }

+ *

+ * Unfortunately the exported structure from dmpstore is:

+ * struct {

+ *	uint32_t name_size; // in bytes

+ *	uint32_t data_size; // in bytes

+ *	char16_t name[];

+ *	efi_guid_t guid;

+ *	uint32_t attr;

+ *	unit8_t data[];

+ *	uint32_t crc32;

  * }

  */

-ssize_t NONNULL(1, 3) PUBLIC

-efi_variable_import(uint8_t *data, size_t size, efi_variable_t **var_out)

+#ifdef EFIVAR_BUILD_ENVIRONMENT

+#error wtf

+#endif

+

+ssize_t NONNULL(1, 3)

+efi_variable_import_dmpstore(uint8_t *data, size_t size,

+			     efi_variable_t **var_out)

+{

+	efi_variable_t var;

+	uint32_t namesz;

+	uint32_t datasz;

+	size_t min = sizeof (uint32_t)		/* name size */

+		   + sizeof (uint32_t)		/* data size */

+		   + sizeof (char16_t)		/* two bytes of name */

+		   + sizeof (efi_guid_t)	/* guid */

+		   + sizeof (uint32_t)		/* attr */

+		   + 1				/* one byte of data */

+		   + sizeof (uint32_t);		/* crc32 */

+	size_t sz = sizeof (uint32_t)		/* name size */

+		  + sizeof (uint32_t)		/* data size */

+		  + sizeof (efi_guid_t)		/* guid */

+		  + sizeof (uint32_t)		/* attr */

+		  + sizeof (uint32_t);		/* crc32 */

+	uint8_t *ptr = data;

+	uint32_t crc;

+	int saved_errno;

+

+	if (size <= min) {

+etoosmall:

+		errno = EINVAL;

+		efi_error("data size is too small for dmpstore variable (%zu < %zu)",

+			  size, min);

+		return -1;

+	}

+

+	memset(&var, 0, sizeof(var));

+

+	namesz = *(uint32_t *)ptr;

+	debug("namesz:%"PRIu32, namesz);

+	ptr += sizeof(uint32_t);

+

+	if (namesz <= 2) {

+		errno = EINVAL;

+		debug("name size (%"PRIu32") must be greater than 2", namesz);

+		return -1;

+	}

+

+	if (namesz % 2 != 0) {

+		errno = EINVAL;

+		efi_error("name size (%"PRIu32") cannot be odd", namesz);

+		return -1;

+	}

+

+	datasz = *(uint32_t *)ptr;

+	ptr += sizeof(uint32_t);

+	debug("datasz:%"PRIu32, datasz);

+

+	if (datasz == 0) {

+		errno = EINVAL;

+		efi_error("data size (%"PRIu32") must be nonzero", datasz);

+		return -1;

+	}

+

+	if (add(sz, namesz, &sz)) {

+overflow:

+		errno = EOVERFLOW;

+		efi_error("arithmetic overflow computing allocation size");

+		return -1;

+	}

+

+	if (add(sz, datasz, &min))

+		goto overflow;

+

+	if (size < min)

+		goto etoosmall;

+	size = min;

+

+	if (!(ptr[namesz - 1] == 0 && ptr[namesz -2] == 0)) {

+		errno = EINVAL;

+		efi_error("variable name is not properly terminated.");

+		return -1;

+	}

+

+	crc = efi_crc32(data, size - sizeof(uint32_t));

+	debug("efi_crc32(%p, %lu) -> 0x%"PRIx32", expected 0x%"PRIx32,

+	      data, size - sizeof(uint32_t), crc,

+	      *(uint32_t*)(data + size - sizeof(uint32_t)));

+

+	if (memcmp(data + size - sizeof(uint32_t),

+		    &crc, sizeof(uint32_t))) {

+		errno = EINVAL;

+		efi_error("crc32 did not match");

+		return -1;

+	}

+

+	var.name = ucs2_to_utf8(ptr, -1);

+	if (!var.name)

+		goto oom;

+	ptr += namesz;

+

+	var.guid = malloc(sizeof (efi_guid_t));

+	if (!var.guid)

+		goto oom;

+	memcpy(var.guid, ptr, sizeof (efi_guid_t));

+	ptr += sizeof (efi_guid_t);

+

+	var.attrs = *(uint32_t *)ptr;

+	ptr += sizeof(uint32_t);

+

+	var.data_size = datasz;

+	var.data = malloc(datasz);

+	if (!var.data) {

+		efi_error("Could not allocate %"PRIu32" bytes", datasz);

+		goto oom;

+	}

+	memcpy(var.data, ptr, datasz);

+

+	if (!*var_out) {

+		*var_out =malloc(sizeof (var));

+		if (!*var_out)

+			goto oom;

+		memcpy(*var_out, &var, sizeof (var));

+	} else {

+		return -1;

+	}

+	return size;

+oom:

+	saved_errno = errno;

+

+	if (var.guid)

+		free(var.guid);