1  /* SPDX-License-Identifier: GPL-2.0-or-later */
  2  
  3  #include "vs.h"
  4  
  5  #include <limits.h>
  6  #include <stdio.h>
  7  #include <stdlib.h>
  8  #include <string.h>
  9  
 10  #include "udk2017.h"
 11  #include "utils.h"
 12  
 13  static size_t get_var_hdr_size(bool auth_vars)
 14  {
 15  	if (auth_vars)
 16  		return sizeof(AUTHENTICATED_VARIABLE_HEADER);
 17  	return sizeof(VARIABLE_HEADER);
 18  }
 19  
 20  struct var_store_t vs_load(struct mem_range_t vs_data, bool auth_vars)
 21  {
 22  	uint8_t *var_hdr = vs_data.start;
 23  
 24  	struct var_store_t vs = {
 25  		.auth_vars = auth_vars,
 26  		.vars = NULL,
 27  	};
 28  
 29  	struct var_t *last_var = NULL;
 30  
 31  	const size_t var_hdr_size = get_var_hdr_size(auth_vars);
 32  	while (var_hdr + var_hdr_size < vs_data.start + vs_data.length) {
 33  		uint16_t start_id;
 34  		uint8_t state;
 35  		struct var_t var = {0};
 36  		uint8_t *var_data = var_hdr;
 37  
 38  		if (auth_vars) {
 39  			const AUTHENTICATED_VARIABLE_HEADER *auth_hdr =
 40  				(void *)var_data;
 41  
 42  			start_id = auth_hdr->StartId;
 43  			state = auth_hdr->State;
 44  
 45  			var.reserved = auth_hdr->Reserved;
 46  			var.attrs = auth_hdr->Attributes;
 47  			var.name_size = auth_hdr->NameSize;
 48  			var.data_size = auth_hdr->DataSize;
 49  			var.guid = auth_hdr->VendorGuid;
 50  		} else {
 51  			const VARIABLE_HEADER *no_auth_hdr = (void *)var_data;
 52  
 53  			start_id = no_auth_hdr->StartId;
 54  			state = no_auth_hdr->State;
 55  
 56  			var.reserved = no_auth_hdr->Reserved;
 57  			var.attrs = no_auth_hdr->Attributes;
 58  			var.name_size = no_auth_hdr->NameSize;
 59  			var.data_size = no_auth_hdr->DataSize;
 60  			var.guid = no_auth_hdr->VendorGuid;
 61  		}
 62  
 63  		var_hdr += HEADER_ALIGN(var_hdr_size +
 64  					var.name_size +
 65  					var.data_size);
 66  
 67  		if (start_id != VARIABLE_DATA)
 68  			break;
 69  
 70  		if (state != VAR_ADDED)
 71  			continue;
 72  
 73  		if (var.data_size == UINT32_MAX ||
 74  		    var.name_size == UINT32_MAX ||
 75  		    var.attrs == UINT32_MAX)
 76  			continue;
 77  
 78  		CHAR16 *name = (void *)(var_data + var_hdr_size);
 79  		var.name = xmalloc(var.name_size);
 80  		memcpy(var.name, name, var.name_size);
 81  
 82  		uint8_t *data =
 83  			(void *)(var_data + var_hdr_size + var.name_size);
 84  		var.data = xmalloc(var.data_size);
 85  		memcpy(var.data, data, var.data_size);
 86  
 87  		struct var_t *var_node = xmalloc(sizeof(*var_node));
 88  		*var_node = var;
 89  		if (last_var != NULL)
 90  			last_var->next = var_node;
 91  		else if (vs.vars == NULL)
 92  			vs.vars = var_node;
 93  		last_var = var_node;
 94  	}
 95  
 96  	return vs;
 97  }
 98  
 99  static void store_var(const struct var_t *var, bool auth_vars, uint8_t *data)
100  {
101  	if (auth_vars) {
102  		AUTHENTICATED_VARIABLE_HEADER hdr;
103  		memset(&hdr, 0xff, sizeof(hdr));
104  
105  		hdr.StartId = VARIABLE_DATA;
106  		hdr.State = VAR_ADDED;
107  		hdr.Reserved = var->reserved;
108  		hdr.Attributes = var->attrs;
109  		hdr.VendorGuid = var->guid;
110  		hdr.NameSize = var->name_size;
111  		hdr.DataSize = var->data_size;
112  
113  		memcpy(data, &hdr, sizeof(hdr));
114  		data += sizeof(hdr);
115  	} else {
116  		VARIABLE_HEADER hdr;
117  		memset(&hdr, 0xff, sizeof(hdr));
118  
119  		hdr.StartId = VARIABLE_DATA;
120  		hdr.State = VAR_ADDED;
121  		hdr.Reserved = var->reserved;
122  		hdr.Attributes = var->attrs;
123  		hdr.VendorGuid = var->guid;
124  		hdr.NameSize = var->name_size;
125  		hdr.DataSize = var->data_size;
126  
127  		memcpy(data, &hdr, sizeof(hdr));
128  		data += sizeof(hdr);
129  	}
130  
131  	memcpy(data, var->name, var->name_size);
132  	memcpy(data + var->name_size, var->data, var->data_size);
133  }
134  
135  bool vs_store(struct var_store_t *vs, struct mem_range_t vs_data)
136  {
137  	uint8_t *out_data = vs_data.start;
138  
139  	const size_t var_hdr_size = get_var_hdr_size(vs->auth_vars);
140  	for (struct var_t *var = vs->vars; var != NULL; var = var->next) {
141  		const size_t var_size =
142  			var_hdr_size + var->name_size + var->data_size;
143  		if (out_data + var_size > vs_data.start + vs_data.length) {
144  			fprintf(stderr,
145  				"Not enough space to serialize Variable Store.\n");
146  			return false;
147  		}
148  
149  		store_var(var, vs->auth_vars, out_data);
150  		out_data += HEADER_ALIGN(var_size);
151  	}
152  
153  	// The rest is "uninitialized".
154  	memset(out_data, 0xff, vs_data.length - (out_data - vs_data.start));
155  
156  	return true;
157  }
158  
159  struct var_t *vs_new_var(struct var_store_t *vs)
160  {
161  	struct var_t *new_var = xmalloc(sizeof(*new_var));
162  
163  	memset(new_var, 0, sizeof(*new_var));
164  	new_var->attrs = EFI_VARIABLE_NON_VOLATILE
165  				   | EFI_VARIABLE_BOOTSERVICE_ACCESS
166  				   | EFI_VARIABLE_RUNTIME_ACCESS;
167  
168  	struct var_t *var = vs->vars;
169  	if (var == NULL) {
170  		vs->vars = new_var;
171  	} else {
172  		while (var->next != NULL)
173  			var = var->next;
174  		var->next = new_var;
175  	}
176  
177  	return new_var;
178  }
179  
180  struct var_t *vs_find(struct var_store_t *vs,
181  		      const char name[],
182  		      const EFI_GUID *guid)
183  {
184  	size_t name_size;
185  	CHAR16 *uchar_name = to_uchars(name, &name_size);
186  
187  	struct var_t *var;
188  	for (var = vs->vars; var != NULL; var = var->next) {
189  		if (var->name_size != name_size)
190  			continue;
191  		if (memcmp(var->name, uchar_name, name_size) != 0)
192  			continue;
193  		if (memcmp(&var->guid, guid, sizeof(*guid)) != 0)
194  			continue;
195  		break;
196  	}
197  
198  	free(uchar_name);
199  	return var;
200  }
201  
202  static void free_var(struct var_t *var)
203  {
204  	free(var->name);
205  	free(var->data);
206  	free(var);
207  }
208  
209  void vs_delete(struct var_store_t *vs, struct var_t *var)
210  {
211  	if (vs->vars == var) {
212  		vs->vars = var->next;
213  		free_var(var);
214  		return;
215  	}
216  
217  	for (struct var_t *v = vs->vars; v != NULL; v = v->next) {
218  		if (v->next == var) {
219  			v->next = var->next;
220  			free_var(var);
221  			return;
222  		}
223  	}
224  }
225  
226  void vs_free(struct var_store_t *vs)
227  {
228  	for (struct var_t *next, *var = vs->vars; var != NULL; var = next) {
229  		next = var->next;
230  		free_var(var);
231  	}
232  }