Commit db1312dd authored by Hannes Reinecke's avatar Hannes Reinecke Committed by Jens Axboe
Browse files

nvmet: implement basic In-Band Authentication 



Implement NVMe-oF In-Band authentication according to NVMe TPAR 8006.
This patch adds three additional configfs entries 'dhchap_key',
'dhchap_ctrl_key', and 'dhchap_hash' to the 'host' configfs directory.
The 'dhchap_key' and 'dhchap_ctrl_key' entries need to be in the ASCII
format as specified in NVMe Base Specification v2.0 section 8.13.5.8
'Secret representation'.
'dhchap_hash' defaults to 'hmac(sha256)', and can be written to to
switch to a different HMAC algorithm.

Signed-off-by: default avatarHannes Reinecke <hare@suse.de>
Reviewed-by: default avatarSagi Grimberg <sagi@grimberg.me>
Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent 6490c9ed

drivers/nvme/target/Kconfig

+13 −0
Original line number Diff line number Diff line
@@ -83,3 +83,16 @@ config NVME_TARGET_TCP 
	  devices over TCP.



	  If unsure, say N.



config NVME_TARGET_AUTH

	bool "NVMe over Fabrics In-band Authentication support"

	depends on NVME_TARGET

	select NVME_COMMON

	select CRYPTO

	select CRYPTO_HMAC

	select CRYPTO_SHA256

	select CRYPTO_SHA512

	help

	  This enables support for NVMe over Fabrics In-band Authentication



	  If unsure, say N.

drivers/nvme/target/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ nvmet-y += core.o configfs.o admin-cmd.o fabrics-cmd.o \ 
			discovery.o io-cmd-file.o io-cmd-bdev.o

nvmet-$(CONFIG_NVME_TARGET_PASSTHRU)	+= passthru.o

nvmet-$(CONFIG_BLK_DEV_ZONED)		+= zns.o

nvmet-$(CONFIG_NVME_TARGET_AUTH)	+= fabrics-cmd-auth.o auth.o

nvme-loop-y	+= loop.o

nvmet-rdma-y	+= rdma.o

nvmet-fc-y	+= fc.o

drivers/nvme/target/admin-cmd.c

+2 −0
Original line number Diff line number Diff line
@@ -1018,6 +1018,8 @@ u16 nvmet_parse_admin_cmd(struct nvmet_req *req) 


	if (nvme_is_fabrics(cmd))

		return nvmet_parse_fabrics_admin_cmd(req);

	if (unlikely(!nvmet_check_auth_status(req)))

		return NVME_SC_AUTH_REQUIRED | NVME_SC_DNR;

	if (nvmet_is_disc_subsys(nvmet_req_subsys(req)))

		return nvmet_parse_discovery_cmd(req);

drivers/nvme/target/auth.c

0 → 100644
+367 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * NVMe over Fabrics DH-HMAC-CHAP authentication.

 * Copyright (c) 2020 Hannes Reinecke, SUSE Software Solutions.

 * All rights reserved.

 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/module.h>

#include <linux/init.h>

#include <linux/slab.h>

#include <linux/err.h>

#include <crypto/hash.h>

#include <linux/crc32.h>

#include <linux/base64.h>

#include <linux/ctype.h>

#include <linux/random.h>

#include <linux/nvme-auth.h>

#include <asm/unaligned.h>



#include "nvmet.h"



int nvmet_auth_set_key(struct nvmet_host *host, const char *secret,

		       bool set_ctrl)

{

	unsigned char key_hash;

	char *dhchap_secret;



	if (sscanf(secret, "DHHC-1:%hhd:%*s", &key_hash) != 1)

		return -EINVAL;

	if (key_hash > 3) {

		pr_warn("Invalid DH-HMAC-CHAP hash id %d\n",

			 key_hash);

		return -EINVAL;

	}

	if (key_hash > 0) {

		/* Validate selected hash algorithm */

		const char *hmac = nvme_auth_hmac_name(key_hash);



		if (!crypto_has_shash(hmac, 0, 0)) {

			pr_err("DH-HMAC-CHAP hash %s unsupported\n", hmac);

			return -ENOTSUPP;

		}

	}

	dhchap_secret = kstrdup(secret, GFP_KERNEL);

	if (!dhchap_secret)

		return -ENOMEM;

	if (set_ctrl) {

		host->dhchap_ctrl_secret = strim(dhchap_secret);

		host->dhchap_ctrl_key_hash = key_hash;

	} else {

		host->dhchap_secret = strim(dhchap_secret);

		host->dhchap_key_hash = key_hash;

	}

	return 0;

}



int nvmet_setup_auth(struct nvmet_ctrl *ctrl)

{

	int ret = 0;

	struct nvmet_host_link *p;

	struct nvmet_host *host = NULL;

	const char *hash_name;



	down_read(&nvmet_config_sem);

	if (nvmet_is_disc_subsys(ctrl->subsys))

		goto out_unlock;



	if (ctrl->subsys->allow_any_host)

		goto out_unlock;



	list_for_each_entry(p, &ctrl->subsys->hosts, entry) {

		pr_debug("check %s\n", nvmet_host_name(p->host));

		if (strcmp(nvmet_host_name(p->host), ctrl->hostnqn))

			continue;

		host = p->host;

		break;

	}

	if (!host) {

		pr_debug("host %s not found\n", ctrl->hostnqn);

		ret = -EPERM;

		goto out_unlock;

	}



	if (!host->dhchap_secret) {

		pr_debug("No authentication provided\n");

		goto out_unlock;

	}



	if (host->dhchap_hash_id == ctrl->shash_id) {

		pr_debug("Re-use existing hash ID %d\n",

			 ctrl->shash_id);

	} else {

		hash_name = nvme_auth_hmac_name(host->dhchap_hash_id);

		if (!hash_name) {

			pr_warn("Hash ID %d invalid\n", host->dhchap_hash_id);

			ret = -EINVAL;

			goto out_unlock;

		}

		ctrl->shash_id = host->dhchap_hash_id;

	}



	/* Skip the 'DHHC-1:XX:' prefix */

	nvme_auth_free_key(ctrl->host_key);

	ctrl->host_key = nvme_auth_extract_key(host->dhchap_secret + 10,

					       host->dhchap_key_hash);

	if (IS_ERR(ctrl->host_key)) {

		ret = PTR_ERR(ctrl->host_key);

		ctrl->host_key = NULL;

		goto out_free_hash;

	}

	pr_debug("%s: using hash %s key %*ph\n", __func__,

		 ctrl->host_key->hash > 0 ?

		 nvme_auth_hmac_name(ctrl->host_key->hash) : "none",

		 (int)ctrl->host_key->len, ctrl->host_key->key);



	nvme_auth_free_key(ctrl->ctrl_key);

	if (!host->dhchap_ctrl_secret) {

		ctrl->ctrl_key = NULL;

		goto out_unlock;

	}



	ctrl->ctrl_key = nvme_auth_extract_key(host->dhchap_ctrl_secret + 10,

					       host->dhchap_ctrl_key_hash);

	if (IS_ERR(ctrl->ctrl_key)) {

		ret = PTR_ERR(ctrl->ctrl_key);

		ctrl->ctrl_key = NULL;

	}

	pr_debug("%s: using ctrl hash %s key %*ph\n", __func__,

		 ctrl->ctrl_key->hash > 0 ?

		 nvme_auth_hmac_name(ctrl->ctrl_key->hash) : "none",

		 (int)ctrl->ctrl_key->len, ctrl->ctrl_key->key);



out_free_hash:

	if (ret) {

		if (ctrl->host_key) {

			nvme_auth_free_key(ctrl->host_key);

			ctrl->host_key = NULL;

		}

		ctrl->shash_id = 0;

	}

out_unlock:

	up_read(&nvmet_config_sem);



	return ret;

}



void nvmet_auth_sq_free(struct nvmet_sq *sq)

{

	kfree(sq->dhchap_c1);

	sq->dhchap_c1 = NULL;

	kfree(sq->dhchap_c2);

	sq->dhchap_c2 = NULL;

	kfree(sq->dhchap_skey);

	sq->dhchap_skey = NULL;

}



void nvmet_destroy_auth(struct nvmet_ctrl *ctrl)

{

	ctrl->shash_id = 0;



	if (ctrl->host_key) {

		nvme_auth_free_key(ctrl->host_key);

		ctrl->host_key = NULL;

	}

	if (ctrl->ctrl_key) {

		nvme_auth_free_key(ctrl->ctrl_key);

		ctrl->ctrl_key = NULL;

	}

}



bool nvmet_check_auth_status(struct nvmet_req *req)

{

	if (req->sq->ctrl->host_key &&

	    !req->sq->authenticated)

		return false;

	return true;

}



int nvmet_auth_host_hash(struct nvmet_req *req, u8 *response,

			 unsigned int shash_len)

{

	struct crypto_shash *shash_tfm;

	struct shash_desc *shash;

	struct nvmet_ctrl *ctrl = req->sq->ctrl;

	const char *hash_name;

	u8 *challenge = req->sq->dhchap_c1, *host_response;

	u8 buf[4];

	int ret;



	hash_name = nvme_auth_hmac_name(ctrl->shash_id);

	if (!hash_name) {

		pr_warn("Hash ID %d invalid\n", ctrl->shash_id);

		return -EINVAL;

	}



	shash_tfm = crypto_alloc_shash(hash_name, 0, 0);

	if (IS_ERR(shash_tfm)) {

		pr_err("failed to allocate shash %s\n", hash_name);

		return PTR_ERR(shash_tfm);

	}



	if (shash_len != crypto_shash_digestsize(shash_tfm)) {

		pr_debug("%s: hash len mismatch (len %d digest %d)\n",

			 __func__, shash_len,

			 crypto_shash_digestsize(shash_tfm));

		ret = -EINVAL;

		goto out_free_tfm;

	}



	host_response = nvme_auth_transform_key(ctrl->host_key, ctrl->hostnqn);

	if (IS_ERR(host_response)) {

		ret = PTR_ERR(host_response);

		goto out_free_tfm;

	}



	ret = crypto_shash_setkey(shash_tfm, host_response,

				  ctrl->host_key->len);

	if (ret)

		goto out_free_response;



	pr_debug("ctrl %d qid %d host response seq %u transaction %d\n",

		 ctrl->cntlid, req->sq->qid, req->sq->dhchap_s1,

		 req->sq->dhchap_tid);



	shash = kzalloc(sizeof(*shash) + crypto_shash_descsize(shash_tfm),

			GFP_KERNEL);

	if (!shash) {

		ret = -ENOMEM;

		goto out_free_response;

	}

	shash->tfm = shash_tfm;

	ret = crypto_shash_init(shash);

	if (ret)

		goto out;

	ret = crypto_shash_update(shash, challenge, shash_len);

	if (ret)

		goto out;

	put_unaligned_le32(req->sq->dhchap_s1, buf);

	ret = crypto_shash_update(shash, buf, 4);

	if (ret)

		goto out;

	put_unaligned_le16(req->sq->dhchap_tid, buf);

	ret = crypto_shash_update(shash, buf, 2);

	if (ret)

		goto out;

	memset(buf, 0, 4);

	ret = crypto_shash_update(shash, buf, 1);

	if (ret)

		goto out;

	ret = crypto_shash_update(shash, "HostHost", 8);

	if (ret)

		goto out;

	ret = crypto_shash_update(shash, ctrl->hostnqn, strlen(ctrl->hostnqn));

	if (ret)

		goto out;

	ret = crypto_shash_update(shash, buf, 1);

	if (ret)

		goto out;

	ret = crypto_shash_update(shash, ctrl->subsysnqn,

				  strlen(ctrl->subsysnqn));

	if (ret)

		goto out;

	ret = crypto_shash_final(shash, response);

out:

	if (challenge != req->sq->dhchap_c1)

		kfree(challenge);

	kfree(shash);

out_free_response:

	kfree_sensitive(host_response);

out_free_tfm:

	crypto_free_shash(shash_tfm);

	return 0;

}



int nvmet_auth_ctrl_hash(struct nvmet_req *req, u8 *response,

			 unsigned int shash_len)

{

	struct crypto_shash *shash_tfm;

	struct shash_desc *shash;

	struct nvmet_ctrl *ctrl = req->sq->ctrl;

	const char *hash_name;

	u8 *challenge = req->sq->dhchap_c2, *ctrl_response;

	u8 buf[4];

	int ret;



	hash_name = nvme_auth_hmac_name(ctrl->shash_id);

	if (!hash_name) {

		pr_warn("Hash ID %d invalid\n", ctrl->shash_id);

		return -EINVAL;

	}



	shash_tfm = crypto_alloc_shash(hash_name, 0, 0);

	if (IS_ERR(shash_tfm)) {

		pr_err("failed to allocate shash %s\n", hash_name);

		return PTR_ERR(shash_tfm);

	}



	if (shash_len != crypto_shash_digestsize(shash_tfm)) {

		pr_debug("%s: hash len mismatch (len %d digest %d)\n",

			 __func__, shash_len,

			 crypto_shash_digestsize(shash_tfm));

		ret = -EINVAL;

		goto out_free_tfm;

	}



	ctrl_response = nvme_auth_transform_key(ctrl->ctrl_key,

						ctrl->subsysnqn);

	if (IS_ERR(ctrl_response)) {

		ret = PTR_ERR(ctrl_response);

		goto out_free_tfm;

	}



	ret = crypto_shash_setkey(shash_tfm, ctrl_response,

				  ctrl->ctrl_key->len);

	if (ret)

		goto out_free_response;



	shash = kzalloc(sizeof(*shash) + crypto_shash_descsize(shash_tfm),

			GFP_KERNEL);

	if (!shash) {

		ret = -ENOMEM;

		goto out_free_response;

	}

	shash->tfm = shash_tfm;



	ret = crypto_shash_init(shash);

	if (ret)

		goto out;

	ret = crypto_shash_update(shash, challenge, shash_len);

	if (ret)

		goto out;

	put_unaligned_le32(req->sq->dhchap_s2, buf);

	ret = crypto_shash_update(shash, buf, 4);

	if (ret)

		goto out;

	put_unaligned_le16(req->sq->dhchap_tid, buf);

	ret = crypto_shash_update(shash, buf, 2);

	if (ret)

		goto out;

	memset(buf, 0, 4);

	ret = crypto_shash_update(shash, buf, 1);

	if (ret)

		goto out;

	ret = crypto_shash_update(shash, "Controller", 10);

	if (ret)

		goto out;

	ret = crypto_shash_update(shash, ctrl->subsysnqn,

			    strlen(ctrl->subsysnqn));

	if (ret)

		goto out;

	ret = crypto_shash_update(shash, buf, 1);

	if (ret)

		goto out;

	ret = crypto_shash_update(shash, ctrl->hostnqn, strlen(ctrl->hostnqn));

	if (ret)

		goto out;

	ret = crypto_shash_final(shash, response);

out:

	if (challenge != req->sq->dhchap_c2)

		kfree(challenge);

	kfree(shash);

out_free_response:

	kfree_sensitive(ctrl_response);

out_free_tfm:

	crypto_free_shash(shash_tfm);

	return 0;

}

drivers/nvme/target/configfs.c

+106 −1
Original line number Diff line number Diff line
@@ -11,6 +11,11 @@ 
#include <linux/ctype.h>

#include <linux/pci.h>

#include <linux/pci-p2pdma.h>

#ifdef CONFIG_NVME_TARGET_AUTH

#include <linux/nvme-auth.h>

#endif

#include <crypto/hash.h>

#include <crypto/kpp.h>



#include "nvmet.h"
@@ -1680,10 +1685,102 @@ static const struct config_item_type nvmet_ports_type = { 
static struct config_group nvmet_subsystems_group;

static struct config_group nvmet_ports_group;



static void nvmet_host_release(struct config_item *item)

#ifdef CONFIG_NVME_TARGET_AUTH

static ssize_t nvmet_host_dhchap_key_show(struct config_item *item,

		char *page)

{

	u8 *dhchap_secret = to_host(item)->dhchap_secret;



	if (!dhchap_secret)

		return sprintf(page, "\n");

	return sprintf(page, "%s\n", dhchap_secret);

}



static ssize_t nvmet_host_dhchap_key_store(struct config_item *item,

		const char *page, size_t count)

{

	struct nvmet_host *host = to_host(item);

	int ret;



	ret = nvmet_auth_set_key(host, page, false);

	/*

	 * Re-authentication is a soft state, so keep the

	 * current authentication valid until the host

	 * requests re-authentication.

	 */

	return ret < 0 ? ret : count;

}



CONFIGFS_ATTR(nvmet_host_, dhchap_key);



static ssize_t nvmet_host_dhchap_ctrl_key_show(struct config_item *item,

		char *page)

{

	u8 *dhchap_secret = to_host(item)->dhchap_ctrl_secret;



	if (!dhchap_secret)

		return sprintf(page, "\n");

	return sprintf(page, "%s\n", dhchap_secret);

}



static ssize_t nvmet_host_dhchap_ctrl_key_store(struct config_item *item,

		const char *page, size_t count)

{

	struct nvmet_host *host = to_host(item);

	int ret;



	ret = nvmet_auth_set_key(host, page, true);

	/*

	 * Re-authentication is a soft state, so keep the

	 * current authentication valid until the host

	 * requests re-authentication.

	 */

	return ret < 0 ? ret : count;

}



CONFIGFS_ATTR(nvmet_host_, dhchap_ctrl_key);



static ssize_t nvmet_host_dhchap_hash_show(struct config_item *item,

		char *page)

{

	struct nvmet_host *host = to_host(item);

	const char *hash_name = nvme_auth_hmac_name(host->dhchap_hash_id);



	return sprintf(page, "%s\n", hash_name ? hash_name : "none");

}



static ssize_t nvmet_host_dhchap_hash_store(struct config_item *item,

		const char *page, size_t count)

{

	struct nvmet_host *host = to_host(item);

	u8 hmac_id;



	hmac_id = nvme_auth_hmac_id(page);

	if (hmac_id == NVME_AUTH_HASH_INVALID)

		return -EINVAL;

	if (!crypto_has_shash(nvme_auth_hmac_name(hmac_id), 0, 0))

		return -ENOTSUPP;

	host->dhchap_hash_id = hmac_id;

	return count;

}



CONFIGFS_ATTR(nvmet_host_, dhchap_hash);



static struct configfs_attribute *nvmet_host_attrs[] = {

	&nvmet_host_attr_dhchap_key,

	&nvmet_host_attr_dhchap_ctrl_key,

	&nvmet_host_attr_dhchap_hash,

	NULL,

};

#endif /* CONFIG_NVME_TARGET_AUTH */



static void nvmet_host_release(struct config_item *item)

{

	struct nvmet_host *host = to_host(item);

#ifdef CONFIG_NVME_TARGET_AUTH

	if (host->dhchap_secret)

		kfree(host->dhchap_secret);

#endif

	kfree(host);

}
@@ -1693,6 +1790,9 @@ static struct configfs_item_operations nvmet_host_item_ops = { 


static const struct config_item_type nvmet_host_type = {

	.ct_item_ops		= &nvmet_host_item_ops,

#ifdef CONFIG_NVME_TARGET_AUTH

	.ct_attrs		= nvmet_host_attrs,

#endif

	.ct_owner		= THIS_MODULE,

};
@@ -1705,6 +1805,11 @@ static struct config_group *nvmet_hosts_make_group(struct config_group *group, 
	if (!host)

		return ERR_PTR(-ENOMEM);



#ifdef CONFIG_NVME_TARGET_AUTH

	/* Default to SHA256 */

	host->dhchap_hash_id = NVME_AUTH_HASH_SHA256;

#endif



	config_group_init_type_name(&host->group, name, &nvmet_host_type);



	return &host->group;