// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2021 Microsoft Corporation
 *
 * Author: Tushar Sugandhi <tusharsu@linux.microsoft.com>
 *
 * Enables IMA measurements for DM targets
 */

#include "dm-core.h"
#include "dm-ima.h"

#include <linux/ima.h>
#include <linux/sched/mm.h>
#include <crypto/sha2.h>

#define DM_MSG_PREFIX "ima"

/*
 * Internal function to prefix separator characters in input buffer with escape
 * character, so that they don't interfere with the construction of key-value pairs,
 * and clients can split the key1=val1,key2=val2,key3=val3; pairs properly.
 */
static void fix_separator_chars(char *buf)
{
	int l = strlen(buf);
	int i, j, sp = 0;

	for (i = 0; i < l; i++)
		if (buf[i] == '\\' || buf[i] == ';' || buf[i] == '=' || buf[i] == ',')
			sp++;

	if (!sp)
		return;

	buf[l + sp] = '\0';
	for (i = l-1, j = i+sp; i >= 0; i--) {
		buf[j--] = buf[i];
		if (buf[i] == '\\' || buf[i] == ';' || buf[i] == '=' || buf[i] == ',')
			buf[j--] = '\\';
	}
}

static void fix_context_strings(struct dm_ima_context *context)
{
	fix_separator_chars(context->dev_name);
	fix_separator_chars(context->dev_uuid);
}

/*
 * Internal function to allocate memory for IMA measurements.
 */
static void *dm_ima_alloc(size_t len, bool noio)
{
	unsigned int noio_flag;
	void *ptr;

	if (noio)
		noio_flag = memalloc_noio_save();

	ptr = kzalloc(len, GFP_KERNEL);

	if (noio)
		memalloc_noio_restore(noio_flag);

	return ptr;
}

void dm_ima_init(struct mapped_device *md)
{
	md->ima.update_idx = 0;
	md->ima.measure_idx = 0;
	init_waitqueue_head(&md->ima.ima_wq);
	spin_lock_init(&md->ima.ima_lock);
}

void dm_ima_alloc_context(struct dm_ima_context **context, bool noio)
{
	*context = dm_ima_alloc(sizeof(struct dm_ima_context), noio);
}

void dm_ima_free_context(struct dm_ima_context *context)
{
	if (likely(context)) {
		kfree(context->table.device_metadata);
		kfree(context->table.hash);
		kfree(context);
	}
}

static void wait_to_measure(struct dm_ima_measurements *ima,
			    unsigned int update_idx)
{
	spin_lock_irq(&ima->ima_lock);
	wait_event_lock_irq(ima->ima_wq,
			    ima->measure_idx == update_idx,
			    ima->ima_lock);
	spin_unlock_irq(&ima->ima_lock);
}

static void wake_next_measure(struct dm_ima_measurements *ima)
{
	spin_lock_irq(&ima->ima_lock);
	ima->measure_idx++;
	spin_unlock_irq(&ima->ima_lock);
	wake_up_all(&ima->ima_wq);
}

/*
 * Helper function for swapping the table, to make sure that the
 * correct table metadata is saved and restored.
 */
void dm_ima_context_table_op(struct mapped_device *md,
			     struct dm_ima_context *context,
			     enum dm_ima_table_op op)
{
	struct dm_ima_measurements *ima = &md->ima;

	if (unlikely(!context))
		return;

	wait_to_measure(ima, context->update_idx);

	if (op == DM_IMA_TABLE_SAVE) {
		context->table = ima->inactive_table;
		memset(&ima->inactive_table, 0, sizeof(ima->inactive_table));
	} else {
		ima->inactive_table = context->table;
		memset(&context->table, 0, sizeof(context->table));
	}

	wake_next_measure(ima);
}

/*
 * Internal function to copy device data for IMA measurements.
 */
static void dm_ima_copy_device_data(struct mapped_device *md, char *device_data,
				    struct dm_ima_context *context,
				    unsigned int num_targets)
{
	memset(device_data, 0, DM_IMA_DEVICE_BUF_LEN);
	scnprintf(device_data, DM_IMA_DEVICE_BUF_LEN,
		  "name=%s,uuid=%s,major=%d,minor=%d,minor_count=%d,num_targets=%u;",
		  context->dev_name, context->dev_uuid, md->disk->major,
		  md->disk->first_minor, md->disk->minors, num_targets);

}

/*
 * Internal wrapper function to call IMA to measure DM data.
 */
static void dm_ima_measure_data(const char *event_name, const void *buf, size_t buf_len,
				bool noio)
{
	unsigned int noio_flag;

	if (noio)
		noio_flag = memalloc_noio_save();

	ima_measure_critical_data(DM_NAME, event_name, buf, buf_len,
				  false, NULL, 0);

	if (noio)
		memalloc_noio_restore(noio_flag);
}

static sector_t dm_ima_capacity(struct mapped_device *md)
{
	return (md->ima.active_table.device_metadata) ?
		md->ima.active_table.capacity : get_capacity(md->disk);
}

/*
 * Build up the IMA data for each target, and finally measure.
 */
void dm_ima_measure_on_table_load(struct dm_table *table,
				  struct dm_ima_context *context)
{
	size_t device_data_buf_len, target_metadata_buf_len, target_data_buf_len, l = 0;
	char *target_metadata_buf = NULL, *target_data_buf = NULL, *digest_buf = NULL;
	char *ima_buf = NULL, *device_data_buf = NULL;
	status_type_t type = STATUSTYPE_IMA;
	size_t cur_total_buf_len = 0;
	unsigned int num_targets, i;
	struct sha256_ctx hash_ctx;
	u8 digest[SHA256_DIGEST_SIZE];
	bool noio = false;
	char table_load_event_name[] = "dm_table_load";

	if (unlikely(!context))
		return;

	wait_to_measure(&table->md->ima, context->update_idx);

	ima_buf = dm_ima_alloc(DM_IMA_MEASUREMENT_BUF_LEN, noio);
	if (!ima_buf)
		goto error;

	target_metadata_buf = dm_ima_alloc(DM_IMA_TARGET_METADATA_BUF_LEN, noio);
	if (!target_metadata_buf)
		goto error;

	target_data_buf = dm_ima_alloc(DM_IMA_TARGET_DATA_BUF_LEN, noio);
	if (!target_data_buf)
		goto error;

	num_targets = table->num_targets;

	device_data_buf = dm_ima_alloc(DM_IMA_DEVICE_BUF_LEN, noio);
	if (!device_data_buf)
		goto error;

	fix_context_strings(context);
	dm_ima_copy_device_data(table->md, device_data_buf, context,
				num_targets);

	sha256_init(&hash_ctx);

	memcpy(ima_buf + l, DM_IMA_VERSION_STR, strlen(DM_IMA_VERSION_STR));
	l += strlen(DM_IMA_VERSION_STR);

	device_data_buf_len = strlen(device_data_buf);
	memcpy(ima_buf + l, device_data_buf, device_data_buf_len);
	l += device_data_buf_len;

	for (i = 0; i < num_targets; i++) {
		struct dm_target *ti = dm_table_get_target(table, i);

		/*
		 * First retrieve the target metadata.
		 */
		target_metadata_buf_len =
			scnprintf(target_metadata_buf,
				  DM_IMA_TARGET_METADATA_BUF_LEN,
				  "target_index=%d,target_begin=%llu,target_len=%llu,",
				  i, ti->begin, ti->len);

		/*
		 * Then retrieve the actual target data.
		 */
		if (ti->type->status)
			ti->type->status(ti, type, 0, target_data_buf,
					 DM_IMA_TARGET_DATA_BUF_LEN);
		else
			target_data_buf[0] = '\0';

		target_data_buf_len = strlen(target_data_buf);

		/*
		 * Check if the total data can fit into the IMA buffer.
		 */
		cur_total_buf_len = l + target_metadata_buf_len + target_data_buf_len;

		/*
		 * IMA measurements for DM targets are best-effort.
		 * If the total data buffered so far, including the current target,
		 * is too large to fit into DM_IMA_MEASUREMENT_BUF_LEN, measure what
		 * we have in the current buffer, and continue measuring the remaining
		 * targets by prefixing the device metadata again.
		 */
		if (unlikely(cur_total_buf_len >= DM_IMA_MEASUREMENT_BUF_LEN)) {
			dm_ima_measure_data(table_load_event_name, ima_buf, l, noio);
			sha256_update(&hash_ctx, (const u8 *)ima_buf, l);

			memset(ima_buf, 0, DM_IMA_MEASUREMENT_BUF_LEN);
			l = 0;

			/*
			 * Each new "dm_table_load" entry in IMA log should have device data
			 * prefix, so that multiple records from the same "dm_table_load" for
			 * a given device can be linked together.
			 */
			memcpy(ima_buf + l, DM_IMA_VERSION_STR, strlen(DM_IMA_VERSION_STR));
			l += strlen(DM_IMA_VERSION_STR);

			memcpy(ima_buf + l, device_data_buf, device_data_buf_len);
			l += device_data_buf_len;
		}

		/*
		 * Fill-in all the target metadata, so that multiple targets for the same
		 * device can be linked together.
		 */
		memcpy(ima_buf + l, target_metadata_buf, target_metadata_buf_len);
		l += target_metadata_buf_len;

		memcpy(ima_buf + l, target_data_buf, target_data_buf_len);
		l += target_data_buf_len;
	}

	dm_ima_measure_data(table_load_event_name, ima_buf, l, noio);
	sha256_update(&hash_ctx, (const u8 *)ima_buf, l);

	/*
	 * Finalize the table hash, and store it in table->md->ima.inactive_table.hash,
	 * so that the table data can be verified against the future device state change
	 * events, e.g. resume, rename, remove, table-clear etc.
	 */
	sha256_final(&hash_ctx, digest);

	digest_buf = kasprintf(GFP_KERNEL, "sha256:%*phN", SHA256_DIGEST_SIZE,
			       digest);
	if (!digest_buf)
		goto error;

	kfree(table->md->ima.inactive_table.hash);
	table->md->ima.inactive_table.hash = digest_buf;
	table->md->ima.inactive_table.hash_len = strlen(digest_buf);
	table->md->ima.inactive_table.num_targets = num_targets;
	table->md->ima.inactive_table.capacity = dm_table_get_size(table);


	kfree(table->md->ima.inactive_table.device_metadata);
	table->md->ima.inactive_table.device_metadata = device_data_buf;
	table->md->ima.inactive_table.device_metadata_len = device_data_buf_len;

	goto exit;
error:
	kfree(digest_buf);
	kfree(device_data_buf);
exit:
	kfree(ima_buf);
	kfree(target_metadata_buf);
	kfree(target_data_buf);

	wake_next_measure(&table->md->ima);
}

/*
 * Measure IMA data on device resume.
 */
void dm_ima_measure_on_device_resume(struct mapped_device *md, bool swap,
				     struct dm_ima_context *context)
{
	char *device_table_data = NULL;
	char active[] = "active_table_hash=";
	unsigned int active_len = strlen(active);
	unsigned int l = 0;
	bool noio = true;
	bool nodata = true;

	if (unlikely(!context))
		return;

	wait_to_measure(&md->ima, context->update_idx);

	if (swap) {
		kfree(md->ima.active_table.hash);
		kfree(md->ima.active_table.device_metadata);
		md->ima.active_table = context->table;
		memset(&context->table, 0, sizeof(context->table));
		if (md->ima.active_table.device_metadata) {
			/*
			 * A rename could have happened while the swap was
			 * going on. In that case, the saved table info would
			 * still have the old name. Update the metadata to be
			 * sure that it has the current name
			 */
			struct dm_ima_device_table_metadata *table = &md->ima.active_table;
			fix_context_strings(context);
			dm_ima_copy_device_data(md, table->device_metadata,
						context, table->num_targets);
			table->device_metadata_len = strlen(table->device_metadata);
		}
	}

	device_table_data = dm_ima_alloc(DM_IMA_DEVICE_BUF_LEN, noio);
	if (!device_table_data)
		goto error;

	memcpy(device_table_data + l, DM_IMA_VERSION_STR, strlen(DM_IMA_VERSION_STR));
	l += strlen(DM_IMA_VERSION_STR);

	if (md->ima.active_table.device_metadata) {
		memcpy(device_table_data + l, md->ima.active_table.device_metadata,
		       md->ima.active_table.device_metadata_len);
		l += md->ima.active_table.device_metadata_len;

		nodata = false;
	}

	if (md->ima.active_table.hash) {
		memcpy(device_table_data + l, active, active_len);
		l += active_len;

		memcpy(device_table_data + l, md->ima.active_table.hash,
		       md->ima.active_table.hash_len);
		l += md->ima.active_table.hash_len;

		memcpy(device_table_data + l, ";", 1);
		l++;

		nodata = false;
	}

	if (nodata) {
		fix_context_strings(context);
		l = scnprintf(device_table_data, DM_IMA_DEVICE_BUF_LEN,
			      "%sname=%s,uuid=%s;device_resume=no_data;",
			      DM_IMA_VERSION_STR, context->dev_name,
			      context->dev_uuid);
	}
	l += scnprintf(device_table_data + l, DM_IMA_DEVICE_BUF_LEN - l,
		       "current_device_capacity=%llu;", dm_ima_capacity(md));

	dm_ima_measure_data("dm_device_resume", device_table_data, l, noio);

error:
	kfree(device_table_data);

	wake_next_measure(&md->ima);
}

/*
 * Measure IMA data on remove.
 */
void dm_ima_measure_on_device_remove(struct mapped_device *md, bool remove_all,
				     struct dm_ima_context *context,
				     unsigned int idx)
{
	char *device_table_data;
	char active_table_str[] = "active_table_hash=";
	char inactive_table_str[] = "inactive_table_hash=";
	char device_active_str[] = "device_active_metadata=";
	char device_inactive_str[] = "device_inactive_metadata=";
	unsigned int active_table_len = strlen(active_table_str);
	unsigned int inactive_table_len = strlen(inactive_table_str);
	unsigned int device_active_len = strlen(device_active_str);
	unsigned int device_inactive_len = strlen(device_inactive_str);
	unsigned int l = 0;
	bool noio = true;
	bool nodata = true;

	wait_to_measure(&md->ima, idx);

	if (unlikely(!context))
		goto exit;

	device_table_data = dm_ima_alloc(DM_IMA_DEVICE_BUF_LEN*2, noio);
	if (!device_table_data)
		goto exit;

	memcpy(device_table_data + l, DM_IMA_VERSION_STR, strlen(DM_IMA_VERSION_STR));
	l += strlen(DM_IMA_VERSION_STR);

	if (md->ima.active_table.device_metadata) {
		memcpy(device_table_data + l, device_active_str, device_active_len);
		l += device_active_len;

		memcpy(device_table_data + l, md->ima.active_table.device_metadata,
		       md->ima.active_table.device_metadata_len);
		l += md->ima.active_table.device_metadata_len;

		nodata = false;
	}

	if (md->ima.inactive_table.device_metadata) {
		memcpy(device_table_data + l, device_inactive_str, device_inactive_len);
		l += device_inactive_len;

		memcpy(device_table_data + l, md->ima.inactive_table.device_metadata,
		       md->ima.inactive_table.device_metadata_len);
		l += md->ima.inactive_table.device_metadata_len;

		nodata = false;
	}

	if (md->ima.active_table.hash) {
		memcpy(device_table_data + l, active_table_str, active_table_len);
		l += active_table_len;

		memcpy(device_table_data + l, md->ima.active_table.hash,
			   md->ima.active_table.hash_len);
		l += md->ima.active_table.hash_len;

		memcpy(device_table_data + l, ",", 1);
		l++;

		nodata = false;
	}

	if (md->ima.inactive_table.hash) {
		memcpy(device_table_data + l, inactive_table_str, inactive_table_len);
		l += inactive_table_len;

		memcpy(device_table_data + l, md->ima.inactive_table.hash,
		       md->ima.inactive_table.hash_len);
		l += md->ima.inactive_table.hash_len;

		memcpy(device_table_data + l, ",", 1);
		l++;

		nodata = false;
	}
	/*
	 * In case both active and inactive tables, and corresponding
	 * device metadata is cleared/missing - record the name and uuid
	 * in IMA measurements.
	 */
	if (nodata) {
		fix_context_strings(context);
		l = scnprintf(device_table_data, DM_IMA_DEVICE_BUF_LEN,
			      "%sname=%s,uuid=%s;device_remove=no_data;",
			      DM_IMA_VERSION_STR, context->dev_name,
			      context->dev_uuid);
	}

	l += scnprintf(device_table_data + l, (DM_IMA_DEVICE_BUF_LEN * 2) - l,
		       "remove_all=%c;current_device_capacity=%llu;",
		       remove_all ? 'y' : 'n', dm_ima_capacity(md));

	dm_ima_measure_data("dm_device_remove", device_table_data, l, noio);

	kfree(device_table_data);
exit:
	kfree(md->ima.active_table.device_metadata);
	kfree(md->ima.inactive_table.device_metadata);

	kfree(md->ima.active_table.hash);
	kfree(md->ima.inactive_table.hash);

	memset(&md->ima.active_table, 0, sizeof(md->ima.active_table));
	memset(&md->ima.inactive_table, 0, sizeof(md->ima.inactive_table));

	wake_next_measure(&md->ima);
}

/*
 * Measure ima data on table clear.
 */
void dm_ima_measure_on_table_clear(struct mapped_device *md,
				   struct dm_ima_context *context)
{
	unsigned int l = 0;
	char *device_table_data = NULL;
	char inactive_str[] = "inactive_table_hash=";
	unsigned int inactive_len = strlen(inactive_str);
	bool noio = true;
	bool nodata = true;

	if (unlikely(!context))
		return;

	wait_to_measure(&md->ima, context->update_idx);

	device_table_data = dm_ima_alloc(DM_IMA_DEVICE_BUF_LEN, noio);
	if (!device_table_data)
		goto error;

	memcpy(device_table_data + l, DM_IMA_VERSION_STR, strlen(DM_IMA_VERSION_STR));
	l += strlen(DM_IMA_VERSION_STR);

	if (md->ima.inactive_table.device_metadata_len &&
	    md->ima.inactive_table.hash_len) {
		memcpy(device_table_data + l, md->ima.inactive_table.device_metadata,
		       md->ima.inactive_table.device_metadata_len);
		l += md->ima.inactive_table.device_metadata_len;

		memcpy(device_table_data + l, inactive_str, inactive_len);
		l += inactive_len;

		memcpy(device_table_data + l, md->ima.inactive_table.hash,
			   md->ima.inactive_table.hash_len);

		l += md->ima.inactive_table.hash_len;

		memcpy(device_table_data + l, ";", 1);
		l++;

		nodata = false;
	}

	if (nodata) {
		fix_context_strings(context);
		l = scnprintf(device_table_data, DM_IMA_DEVICE_BUF_LEN,
			      "%sname=%s,uuid=%s;table_clear=no_data;",
			      DM_IMA_VERSION_STR, context->dev_name,
			      context->dev_uuid);
	}

	l += scnprintf(device_table_data + l, DM_IMA_DEVICE_BUF_LEN - l,
		       "current_device_capacity=%llu;", dm_ima_capacity(md));

	dm_ima_measure_data("dm_table_clear", device_table_data, l, noio);

error:
	kfree(md->ima.inactive_table.hash);
	kfree(md->ima.inactive_table.device_metadata);
	memset(&md->ima.inactive_table, 0, sizeof(md->ima.inactive_table));

	kfree(device_table_data);

	wake_next_measure(&md->ima);
}

/*
 * Measure IMA data on device rename.
 */
void dm_ima_measure_on_device_rename(struct mapped_device *md,
				     struct dm_ima_context *context)
{
	char *old_device_data = NULL;
	char *combined_device_data = NULL;
	bool noio = true;
	int len;
	struct dm_ima_device_table_metadata *table;

	if (unlikely(!context))
		return;

	wait_to_measure(&md->ima, context->update_idx);

	fix_context_strings(context);

	combined_device_data = dm_ima_alloc(DM_IMA_DEVICE_BUF_LEN * 2, noio);
	if (!combined_device_data)
		goto exit;

	if (md->ima.active_table.device_metadata)
		old_device_data = md->ima.active_table.device_metadata;
	else if (md->ima.inactive_table.device_metadata)
		old_device_data = md->ima.inactive_table.device_metadata;
	else
		old_device_data = "device_rename=no_data;";
	len = scnprintf(combined_device_data, DM_IMA_DEVICE_BUF_LEN * 2,
			"%s%snew_name=%s,new_uuid=%s;current_device_capacity=%llu;",
			DM_IMA_VERSION_STR, old_device_data, context->dev_name,
			context->dev_uuid, dm_ima_capacity(md));

	dm_ima_measure_data("dm_device_rename", combined_device_data, len, noio);
	kfree(combined_device_data);

exit:
	if (md->ima.active_table.device_metadata) {
		table = &md->ima.active_table;
		dm_ima_copy_device_data(md, table->device_metadata, context,
					table->num_targets);
		table->device_metadata_len = strlen(table->device_metadata);
	}

	if (md->ima.inactive_table.device_metadata) {
		table = &md->ima.inactive_table;
		dm_ima_copy_device_data(md, table->device_metadata, context,
					table->num_targets);
		table->device_metadata_len = strlen(table->device_metadata);
	}

	wake_next_measure(&md->ima);
}