passwdobj-attributes.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Functions corresponding to password object type attributes under
  4 * BIOS PASSWORD for use with hp-bioscfg driver.
  5 *
  6 * Copyright (c) 2022 HP Development Company, L.P.
  7 */
  8
  9#include "bioscfg.h"
 10
 11GET_INSTANCE_ID(password);
 12/*
 13 * Clear all passwords copied to memory for a particular
 14 * authentication instance
 15 */
 16static int clear_passwords(const int instance)
 17{
 18	struct password_data *password_data = &bioscfg_drv.password_data[instance];
 19
 20	if (!password_data->is_enabled)
 21		return 0;
 22
 23	memset(password_data->current_password,
 24	       0, sizeof(password_data->current_password));
 25	memset(password_data->new_password,
 26	       0, sizeof(password_data->new_password));
 27
 28	return 0;
 29}
 30
 31/*
 32 * Clear all credentials copied to memory for both Power-ON and Setup
 33 * BIOS instances
 34 */
 35int hp_clear_all_credentials(void)
 36{
 37	int count = bioscfg_drv.password_instances_count;
 38	int instance;
 39
 40	/* clear all passwords */
 41	for (instance = 0; instance < count; instance++)
 42		clear_passwords(instance);
 43
 44	/* clear auth_token */
 45	kfree(bioscfg_drv.spm_data.auth_token);
 46	bioscfg_drv.spm_data.auth_token = NULL;
 47
 48	return 0;
 49}
 50
 51int hp_get_password_instance_for_type(const char *name)
 52{
 53	int count = bioscfg_drv.password_instances_count;
 54	int instance;
 55
 56	for (instance = 0; instance < count; instance++)
 57		if (!strcmp(bioscfg_drv.password_data[instance].common.display_name, name))
 58			return instance;
 59
 60	return -EINVAL;
 61}
 62
 63static int validate_password_input(int instance_id, const char *buf)
 64{
 65	int length;
 66	struct password_data *password_data = &bioscfg_drv.password_data[instance_id];
 67
 68	length = strlen(buf);
 69	if (buf[length - 1] == '\n')
 70		length--;
 71
 72	if (length > MAX_PASSWD_SIZE)
 73		return INVALID_BIOS_AUTH;
 74
 75	if (password_data->min_password_length > length ||
 76	    password_data->max_password_length < length)
 77		return INVALID_BIOS_AUTH;
 78	return SUCCESS;
 79}
 80
 81ATTRIBUTE_N_PROPERTY_SHOW(is_enabled, password);
 82static struct kobj_attribute password_is_password_set = __ATTR_RO(is_enabled);
 83
 84static int store_password_instance(struct kobject *kobj, const char *buf,
 85				   size_t count, bool is_current)
 86{
 87	char *buf_cp;
 88	int id, ret = 0;
 89
 90	buf_cp = kstrdup(buf, GFP_KERNEL);
 91	if (!buf_cp)
 92		return -ENOMEM;
 93
 94	ret = hp_enforce_single_line_input(buf_cp, count);
 95	if (!ret) {
 96		id = get_password_instance_id(kobj);
 97
 98		if (id >= 0)
 99			ret = validate_password_input(id, buf_cp);
100	}
101
102	if (!ret) {
103		if (is_current)
104			strscpy(bioscfg_drv.password_data[id].current_password, buf_cp);
105		else
106			strscpy(bioscfg_drv.password_data[id].new_password, buf_cp);
107	}
108
109	kfree(buf_cp);
110	return ret < 0 ? ret : count;
111}
112
113static ssize_t current_password_store(struct kobject *kobj,
114				      struct kobj_attribute *attr,
115				      const char *buf, size_t count)
116{
117	return store_password_instance(kobj, buf, count, true);
118}
119
120static struct kobj_attribute password_current_password = __ATTR_WO(current_password);
121
122static ssize_t new_password_store(struct kobject *kobj,
123				  struct kobj_attribute *attr,
124				  const char *buf, size_t count)
125{
126	return store_password_instance(kobj, buf, count, true);
127}
128
129static struct kobj_attribute password_new_password = __ATTR_WO(new_password);
130
131ATTRIBUTE_N_PROPERTY_SHOW(min_password_length, password);
132static struct kobj_attribute password_min_password_length = __ATTR_RO(min_password_length);
133
134ATTRIBUTE_N_PROPERTY_SHOW(max_password_length, password);
135static struct kobj_attribute password_max_password_length = __ATTR_RO(max_password_length);
136
137static ssize_t role_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
138{
139	if (!strcmp(kobj->name, SETUP_PASSWD))
140		return sysfs_emit(buf, "%s\n", BIOS_ADMIN);
141
142	if (!strcmp(kobj->name, POWER_ON_PASSWD))
143		return sysfs_emit(buf, "%s\n", POWER_ON);
144
145	return -EIO;
146}
147
148static struct kobj_attribute password_role = __ATTR_RO(role);
149
150static ssize_t mechanism_show(struct kobject *kobj, struct kobj_attribute *attr,
151			      char *buf)
152{
153	int i = get_password_instance_id(kobj);
154
155	if (i < 0)
156		return i;
157
158	if (bioscfg_drv.password_data[i].mechanism != PASSWORD)
159		return -EINVAL;
160
161	return sysfs_emit(buf, "%s\n", PASSWD_MECHANISM_TYPES);
162}
163
164static struct kobj_attribute password_mechanism = __ATTR_RO(mechanism);
165
166ATTRIBUTE_VALUES_PROPERTY_SHOW(encodings, password, SEMICOLON_SEP);
167static struct kobj_attribute password_encodings_val = __ATTR_RO(encodings);
168
169static struct attribute *password_attrs[] = {
170	&password_is_password_set.attr,
171	&password_min_password_length.attr,
172	&password_max_password_length.attr,
173	&password_current_password.attr,
174	&password_new_password.attr,
175	&password_role.attr,
176	&password_mechanism.attr,
177	&password_encodings_val.attr,
178	NULL
179};
180
181static const struct attribute_group password_attr_group = {
182	.attrs = password_attrs
183};
184
185int hp_alloc_password_data(void)
186{
187	bioscfg_drv.password_instances_count = hp_get_instance_count(HP_WMI_BIOS_PASSWORD_GUID);
188	bioscfg_drv.password_data = kcalloc(bioscfg_drv.password_instances_count,
189					    sizeof(*bioscfg_drv.password_data), GFP_KERNEL);
190	if (!bioscfg_drv.password_data) {
191		bioscfg_drv.password_instances_count = 0;
192		return -ENOMEM;
193	}
194
195	return 0;
196}
197
198/* Expected Values types associated with each element */
199static const acpi_object_type expected_password_types[] = {
200	[NAME] = ACPI_TYPE_STRING,
201	[VALUE] = ACPI_TYPE_STRING,
202	[PATH] = ACPI_TYPE_STRING,
203	[IS_READONLY] = ACPI_TYPE_INTEGER,
204	[DISPLAY_IN_UI] = ACPI_TYPE_INTEGER,
205	[REQUIRES_PHYSICAL_PRESENCE] = ACPI_TYPE_INTEGER,
206	[SEQUENCE] = ACPI_TYPE_INTEGER,
207	[PREREQUISITES_SIZE] = ACPI_TYPE_INTEGER,
208	[PREREQUISITES] = ACPI_TYPE_STRING,
209	[SECURITY_LEVEL] = ACPI_TYPE_INTEGER,
210	[PSWD_MIN_LENGTH] = ACPI_TYPE_INTEGER,
211	[PSWD_MAX_LENGTH] = ACPI_TYPE_INTEGER,
212	[PSWD_SIZE] = ACPI_TYPE_INTEGER,
213	[PSWD_ENCODINGS] = ACPI_TYPE_STRING,
214	[PSWD_IS_SET] = ACPI_TYPE_INTEGER,
215};
216
217static int hp_populate_password_elements_from_package(union acpi_object *password_obj,
218						      int password_obj_count,
219						      int instance_id)
220{
221	char *str_value = NULL;
222	int value_len;
223	int ret;
224	u32 size;
225	u32 int_value = 0;
226	int elem;
227	int reqs;
228	int eloc;
229	int pos_values;
230	struct password_data *password_data = &bioscfg_drv.password_data[instance_id];
231
232	if (!password_obj)
233		return -EINVAL;
234
235	for (elem = 1, eloc = 1; elem < password_obj_count; elem++, eloc++) {
236		/* ONLY look at the first PASSWORD_ELEM_CNT elements */
237		if (eloc == PSWD_ELEM_CNT)
238			goto exit_package;
239
240		switch (password_obj[elem].type) {
241		case ACPI_TYPE_STRING:
242			if (PREREQUISITES != elem && PSWD_ENCODINGS != elem) {
243				ret = hp_convert_hexstr_to_str(password_obj[elem].string.pointer,
244							       password_obj[elem].string.length,
245							       &str_value, &value_len);
246				if (ret)
247					continue;
248			}
249			break;
250		case ACPI_TYPE_INTEGER:
251			int_value = (u32)password_obj[elem].integer.value;
252			break;
253		default:
254			pr_warn("Unsupported object type [%d]\n", password_obj[elem].type);
255			continue;
256		}
257
258		/* Check that both expected and read object type match */
259		if (expected_password_types[eloc] != password_obj[elem].type) {
260			pr_err("Error expected type %d for elem %d, but got type %d instead\n",
261			       expected_password_types[eloc], elem, password_obj[elem].type);
262			kfree(str_value);
263			return -EIO;
264		}
265
266		/* Assign appropriate element value to corresponding field*/
267		switch (eloc) {
268		case VALUE:
269			break;
270		case PATH:
271			strscpy(password_data->common.path, str_value);
272			break;
273		case IS_READONLY:
274			password_data->common.is_readonly = int_value;
275			break;
276		case DISPLAY_IN_UI:
277			password_data->common.display_in_ui = int_value;
278			break;
279		case REQUIRES_PHYSICAL_PRESENCE:
280			password_data->common.requires_physical_presence = int_value;
281			break;
282		case SEQUENCE:
283			password_data->common.sequence = int_value;
284			break;
285		case PREREQUISITES_SIZE:
286			if (int_value > MAX_PREREQUISITES_SIZE) {
287				pr_warn("Prerequisites size value exceeded the maximum number of elements supported or data may be malformed\n");
288				int_value = MAX_PREREQUISITES_SIZE;
289			}
290			password_data->common.prerequisites_size = int_value;
291
292			/* This step is needed to keep the expected
293			 * element list pointing to the right obj[elem].type
294			 * when the size is zero. PREREQUISITES
295			 * object is omitted by BIOS when the size is
296			 * zero.
297			 */
298			if (int_value == 0)
299				eloc++;
300			break;
301		case PREREQUISITES:
302			size = min_t(u32, password_data->common.prerequisites_size,
303				     MAX_PREREQUISITES_SIZE);
304
305			for (reqs = 0; reqs < size; reqs++) {
306				if (elem + reqs >= password_obj_count) {
307					pr_err("Error elem-objects package is too small\n");
308					return -EINVAL;
309				}
310
311				ret = hp_convert_hexstr_to_str(password_obj[elem + reqs].string.pointer,
312							       password_obj[elem + reqs].string.length,
313							       &str_value, &value_len);
314
315				if (ret)
316					break;
317
318				strscpy(password_data->common.prerequisites[reqs], str_value);
319
320				kfree(str_value);
321				str_value = NULL;
322
323			}
324			break;
325		case SECURITY_LEVEL:
326			password_data->common.security_level = int_value;
327			break;
328		case PSWD_MIN_LENGTH:
329			password_data->min_password_length = int_value;
330			break;
331		case PSWD_MAX_LENGTH:
332			password_data->max_password_length = int_value;
333			break;
334		case PSWD_SIZE:
335
336			if (int_value > MAX_ENCODINGS_SIZE) {
337				pr_warn("Password Encoding size value exceeded the maximum number of elements supported or data may be malformed\n");
338				int_value = MAX_ENCODINGS_SIZE;
339			}
340			password_data->encodings_size = int_value;
341
342			/* This step is needed to keep the expected
343			 * element list pointing to the right obj[elem].type
344			 * when the size is zero. PSWD_ENCODINGS
345			 * object is omitted by BIOS when the size is
346			 * zero.
347			 */
348			if (int_value == 0)
349				eloc++;
350			break;
351		case PSWD_ENCODINGS:
352			size = min_t(u32, password_data->encodings_size, MAX_ENCODINGS_SIZE);
353			for (pos_values = 0; pos_values < size; pos_values++) {
354				ret = hp_convert_hexstr_to_str(password_obj[elem + pos_values].string.pointer,
355							       password_obj[elem + pos_values].string.length,
356							       &str_value, &value_len);
357				if (ret)
358					break;
359
360				strscpy(password_data->encodings[pos_values], str_value);
361				kfree(str_value);
362				str_value = NULL;
363
364			}
365			break;
366		case PSWD_IS_SET:
367			password_data->is_enabled = int_value;
368			break;
369		default:
370			pr_warn("Invalid element: %d found in Password attribute or data may be malformed\n", elem);
371			break;
372		}
373
374		kfree(str_value);
375		str_value = NULL;
376	}
377
378exit_package:
379	kfree(str_value);
380	return 0;
381}
382
383/**
384 * hp_populate_password_package_data()
385 *	Populate all properties for an instance under password attribute
386 *
387 * @password_obj: ACPI object with password data
388 * @instance_id: The instance to enumerate
389 * @attr_name_kobj: The parent kernel object
390 */
391int hp_populate_password_package_data(union acpi_object *password_obj, int instance_id,
392				      struct kobject *attr_name_kobj)
393{
394	struct password_data *password_data = &bioscfg_drv.password_data[instance_id];
395
396	password_data->attr_name_kobj = attr_name_kobj;
397
398	hp_populate_password_elements_from_package(password_obj,
399						   password_obj->package.count,
400						   instance_id);
401
402	hp_friendly_user_name_update(password_data->common.path,
403				     attr_name_kobj->name,
404				     password_data->common.display_name,
405				     sizeof(password_data->common.display_name));
406
407	if (!strcmp(attr_name_kobj->name, SETUP_PASSWD))
408		return sysfs_create_group(attr_name_kobj, &password_attr_group);
409
410	return sysfs_create_group(attr_name_kobj, &password_attr_group);
411}
412
413static int hp_populate_password_elements_from_buffer(u8 *buffer_ptr, u32 *buffer_size,
414						     int instance_id)
415{
416	int values;
417	int isreadonly;
418	struct password_data *password_data = &bioscfg_drv.password_data[instance_id];
419	int ret = 0;
420
421	/*
422	 * Only data relevant to this driver and its functionality is
423	 * read. BIOS defines the order in which each * element is
424	 * read. Element 0 data is not relevant to this
425	 * driver hence it is ignored. For clarity, all element names
426	 * (DISPLAY_IN_UI) which defines the order in which is read
427	 * and the name matches the variable where the data is stored.
428	 *
429	 * In earlier implementation, reported errors were ignored
430	 * causing the data to remain uninitialized. It is not
431	 * possible to determine if data read from BIOS is valid or
432	 * not. It is for this reason functions may return a error
433	 * without validating the data itself.
434	 */
435
436	// VALUE:
437	ret = hp_get_string_from_buffer(&buffer_ptr, buffer_size, password_data->current_password,
438					sizeof(password_data->current_password));
439	if (ret < 0)
440		goto buffer_exit;
441
442	// COMMON:
443	ret = hp_get_common_data_from_buffer(&buffer_ptr, buffer_size,
444					     &password_data->common);
445	if (ret < 0)
446		goto buffer_exit;
447
448	// PSWD_MIN_LENGTH:
449	ret = hp_get_integer_from_buffer(&buffer_ptr, buffer_size,
450					 &password_data->min_password_length);
451	if (ret < 0)
452		goto buffer_exit;
453
454	// PSWD_MAX_LENGTH:
455	ret = hp_get_integer_from_buffer(&buffer_ptr, buffer_size,
456					 &password_data->max_password_length);
457	if (ret < 0)
458		goto buffer_exit;
459
460	// PSWD_SIZE:
461	ret = hp_get_integer_from_buffer(&buffer_ptr, buffer_size,
462					 &password_data->encodings_size);
463	if (ret < 0)
464		goto buffer_exit;
465
466	if (password_data->encodings_size > MAX_ENCODINGS_SIZE) {
467		/* Report a message and limit possible values size to maximum value */
468		pr_warn("Password Encoding size value exceeded the maximum number of elements supported or data may be malformed\n");
469		password_data->encodings_size = MAX_ENCODINGS_SIZE;
470	}
471
472	// PSWD_ENCODINGS:
473	for (values = 0; values < password_data->encodings_size; values++) {
474		ret = hp_get_string_from_buffer(&buffer_ptr, buffer_size,
475						password_data->encodings[values],
476						sizeof(password_data->encodings[values]));
477		if (ret < 0)
478			break;
479	}
480
481	// PSWD_IS_SET:
482	ret = hp_get_integer_from_buffer(&buffer_ptr, buffer_size, &isreadonly);
483	if (ret < 0)
484		goto buffer_exit;
485
486	password_data->is_enabled = isreadonly ? true : false;
487
488buffer_exit:
489	return ret;
490}
491
492/**
493 * hp_populate_password_buffer_data()
494 * Populate all properties for an instance under password object attribute
495 *
496 * @buffer_ptr: Buffer pointer
497 * @buffer_size: Buffer size
498 * @instance_id: The instance to enumerate
499 * @attr_name_kobj: The parent kernel object
500 */
501int hp_populate_password_buffer_data(u8 *buffer_ptr, u32 *buffer_size, int instance_id,
502				     struct kobject *attr_name_kobj)
503{
504	struct password_data *password_data = &bioscfg_drv.password_data[instance_id];
505	int ret = 0;
506
507	password_data->attr_name_kobj = attr_name_kobj;
508
509	/* Populate Password attributes */
510	ret = hp_populate_password_elements_from_buffer(buffer_ptr, buffer_size,
511							instance_id);
512	if (ret < 0)
513		return ret;
514
515	hp_friendly_user_name_update(password_data->common.path,
516				     attr_name_kobj->name,
517				     password_data->common.display_name,
518				     sizeof(password_data->common.display_name));
519	if (!strcmp(attr_name_kobj->name, SETUP_PASSWD))
520		return sysfs_create_group(attr_name_kobj, &password_attr_group);
521
522	return sysfs_create_group(attr_name_kobj, &password_attr_group);
523}
524
525/**
526 * hp_exit_password_attributes() - Clear all attribute data
527 *
528 * Clears all data allocated for this group of attributes
529 */
530void hp_exit_password_attributes(void)
531{
532	int instance_id;
533
534	for (instance_id = 0; instance_id < bioscfg_drv.password_instances_count;
535	     instance_id++) {
536		struct kobject *attr_name_kobj =
537			bioscfg_drv.password_data[instance_id].attr_name_kobj;
538
539		if (attr_name_kobj)
540			sysfs_remove_group(attr_name_kobj,
541					   &password_attr_group);
542	}
543	bioscfg_drv.password_instances_count = 0;
544	kfree(bioscfg_drv.password_data);
545	bioscfg_drv.password_data = NULL;
546}