Commit fa2e0f8b authored by Hannes Reinecke's avatar Hannes Reinecke Committed by Keith Busch
Browse files

nvmet-tcp: support secure channel concatenation 



Evaluate the SC_C flag during DH-CHAP-HMAC negotiation to check if secure
concatenation as specified in the NVMe Base Specification v2.1, section
8.3.4.3: "Secure Channel Concatenationand" is requested. If requested the
generated PSK is inserted into the keyring once negotiation has finished
allowing for an encrypted connection once the admin queue is restarted.

Signed-off-by: default avatarHannes Reinecke <hare@kernel.org>
Reviewed-by: default avatarSagi Grimberg <sagi@grimberg.me>
Signed-off-by: default avatarKeith Busch <kbusch@kernel.org>
parent 50321672

drivers/nvme/target/auth.c

+70 −0
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 
#include <linux/ctype.h>

#include <linux/random.h>

#include <linux/nvme-auth.h>

#include <linux/nvme-keyring.h>

#include <linux/unaligned.h>



#include "nvmet.h"
@@ -165,6 +166,11 @@ u8 nvmet_setup_auth(struct nvmet_ctrl *ctrl, struct nvmet_sq *sq) 
		goto out_unlock;

	}



	if (nvmet_queue_tls_keyid(sq)) {

		pr_debug("host %s tls enabled\n", ctrl->hostnqn);

		goto out_unlock;

	}



	ret = nvmet_setup_dhgroup(ctrl, host->dhchap_dhgroup_id);

	if (ret < 0) {

		pr_warn("Failed to setup DH group");
@@ -233,6 +239,9 @@ u8 nvmet_setup_auth(struct nvmet_ctrl *ctrl, struct nvmet_sq *sq) 
void nvmet_auth_sq_free(struct nvmet_sq *sq)

{

	cancel_delayed_work(&sq->auth_expired_work);

#ifdef CONFIG_NVME_TARGET_TCP_TLS

	sq->tls_key = 0;

#endif

	kfree(sq->dhchap_c1);

	sq->dhchap_c1 = NULL;

	kfree(sq->dhchap_c2);
@@ -261,6 +270,12 @@ void nvmet_destroy_auth(struct nvmet_ctrl *ctrl) 
		nvme_auth_free_key(ctrl->ctrl_key);

		ctrl->ctrl_key = NULL;

	}

#ifdef CONFIG_NVME_TARGET_TCP_TLS

	if (ctrl->tls_key) {

		key_put(ctrl->tls_key);

		ctrl->tls_key = NULL;

	}

#endif

}



bool nvmet_check_auth_status(struct nvmet_req *req)
@@ -542,3 +557,58 @@ int nvmet_auth_ctrl_sesskey(struct nvmet_req *req, 


	return ret;

}



void nvmet_auth_insert_psk(struct nvmet_sq *sq)

{

	int hash_len = nvme_auth_hmac_hash_len(sq->ctrl->shash_id);

	u8 *psk, *digest, *tls_psk;

	size_t psk_len;

	int ret;

#ifdef CONFIG_NVME_TARGET_TCP_TLS

	struct key *tls_key = NULL;

#endif



	ret = nvme_auth_generate_psk(sq->ctrl->shash_id,

				     sq->dhchap_skey,

				     sq->dhchap_skey_len,

				     sq->dhchap_c1, sq->dhchap_c2,

				     hash_len, &psk, &psk_len);

	if (ret) {

		pr_warn("%s: ctrl %d qid %d failed to generate PSK, error %d\n",

			__func__, sq->ctrl->cntlid, sq->qid, ret);

		return;

	}

	ret = nvme_auth_generate_digest(sq->ctrl->shash_id, psk, psk_len,

					sq->ctrl->subsysnqn,

					sq->ctrl->hostnqn, &digest);

	if (ret) {

		pr_warn("%s: ctrl %d qid %d failed to generate digest, error %d\n",

			__func__, sq->ctrl->cntlid, sq->qid, ret);

		goto out_free_psk;

	}

	ret = nvme_auth_derive_tls_psk(sq->ctrl->shash_id, psk, psk_len,

				       digest, &tls_psk);

	if (ret) {

		pr_warn("%s: ctrl %d qid %d failed to derive TLS PSK, error %d\n",

			__func__, sq->ctrl->cntlid, sq->qid, ret);

		goto out_free_digest;

	}

#ifdef CONFIG_NVME_TARGET_TCP_TLS

	tls_key = nvme_tls_psk_refresh(NULL, sq->ctrl->hostnqn, sq->ctrl->subsysnqn,

				       sq->ctrl->shash_id, tls_psk, psk_len, digest);

	if (IS_ERR(tls_key)) {

		pr_warn("%s: ctrl %d qid %d failed to refresh key, error %ld\n",

			__func__, sq->ctrl->cntlid, sq->qid, PTR_ERR(tls_key));

		tls_key = NULL;

		kfree_sensitive(tls_psk);

	}

	if (sq->ctrl->tls_key)

		key_put(sq->ctrl->tls_key);

	sq->ctrl->tls_key = tls_key;

#endif



out_free_digest:

	kfree_sensitive(digest);

out_free_psk:

	kfree_sensitive(psk);

}

drivers/nvme/target/core.c

+3 −2
Original line number Diff line number Diff line
@@ -1664,11 +1664,12 @@ struct nvmet_ctrl *nvmet_alloc_ctrl(struct nvmet_alloc_ctrl_args *args) 


	args->status = NVME_SC_SUCCESS;



	pr_info("Created %s controller %d for subsystem %s for NQN %s%s%s.\n",

	pr_info("Created %s controller %d for subsystem %s for NQN %s%s%s%s.\n",

		nvmet_is_disc_subsys(ctrl->subsys) ? "discovery" : "nvm",

		ctrl->cntlid, ctrl->subsys->subsysnqn, ctrl->hostnqn,

		ctrl->pi_support ? " T10-PI is enabled" : "",

		nvmet_has_auth(ctrl) ? " with DH-HMAC-CHAP" : "");

		nvmet_has_auth(ctrl, args->sq) ? " with DH-HMAC-CHAP" : "",

		nvmet_queue_tls_keyid(args->sq) ? ", TLS" : "");



	return ctrl;

drivers/nvme/target/fabrics-cmd-auth.c

+53 −5
Original line number Diff line number Diff line
@@ -43,8 +43,26 @@ static u8 nvmet_auth_negotiate(struct nvmet_req *req, void *d) 
		 data->auth_protocol[0].dhchap.halen,

		 data->auth_protocol[0].dhchap.dhlen);

	req->sq->dhchap_tid = le16_to_cpu(data->t_id);

	if (data->sc_c)

	if (data->sc_c != NVME_AUTH_SECP_NOSC) {

		if (!IS_ENABLED(CONFIG_NVME_TARGET_TCP_TLS))

			return NVME_AUTH_DHCHAP_FAILURE_CONCAT_MISMATCH;

		/* Secure concatenation can only be enabled on the admin queue */

		if (req->sq->qid)

			return NVME_AUTH_DHCHAP_FAILURE_CONCAT_MISMATCH;

		switch (data->sc_c) {

		case NVME_AUTH_SECP_NEWTLSPSK:

			if (nvmet_queue_tls_keyid(req->sq))

				return NVME_AUTH_DHCHAP_FAILURE_CONCAT_MISMATCH;

			break;

		case NVME_AUTH_SECP_REPLACETLSPSK:

			if (!nvmet_queue_tls_keyid(req->sq))

				return NVME_AUTH_DHCHAP_FAILURE_CONCAT_MISMATCH;

			break;

		default:

			return NVME_AUTH_DHCHAP_FAILURE_CONCAT_MISMATCH;

		}

		ctrl->concat = true;

	}



	if (data->napd != 1)

		return NVME_AUTH_DHCHAP_FAILURE_HASH_UNUSABLE;
@@ -103,6 +121,12 @@ static u8 nvmet_auth_negotiate(struct nvmet_req *req, void *d) 
			 nvme_auth_dhgroup_name(fallback_dhgid));

		ctrl->dh_gid = fallback_dhgid;

	}

	if (ctrl->dh_gid == NVME_AUTH_DHGROUP_NULL && ctrl->concat) {

		pr_debug("%s: ctrl %d qid %d: NULL DH group invalid "

			 "for secure channel concatenation\n", __func__,

			 ctrl->cntlid, req->sq->qid);

		return NVME_AUTH_DHCHAP_FAILURE_CONCAT_MISMATCH;

	}

	pr_debug("%s: ctrl %d qid %d: selected DH group %s (%d)\n",

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

		 nvme_auth_dhgroup_name(ctrl->dh_gid), ctrl->dh_gid);
@@ -148,12 +172,22 @@ static u8 nvmet_auth_reply(struct nvmet_req *req, void *d) 
	if (memcmp(data->rval, response, data->hl)) {

		pr_info("ctrl %d qid %d host response mismatch\n",

			ctrl->cntlid, req->sq->qid);

		pr_debug("ctrl %d qid %d rval %*ph\n",

			 ctrl->cntlid, req->sq->qid, data->hl, data->rval);

		pr_debug("ctrl %d qid %d response %*ph\n",

			 ctrl->cntlid, req->sq->qid, data->hl, response);

		kfree(response);

		return NVME_AUTH_DHCHAP_FAILURE_FAILED;

	}

	kfree(response);

	pr_debug("%s: ctrl %d qid %d host authenticated\n",

		 __func__, ctrl->cntlid, req->sq->qid);

	if (!data->cvalid && ctrl->concat) {

		pr_debug("%s: ctrl %d qid %d invalid challenge\n",

			 __func__, ctrl->cntlid, req->sq->qid);

		return NVME_AUTH_DHCHAP_FAILURE_FAILED;

	}

	req->sq->dhchap_s2 = le32_to_cpu(data->seqnum);

	if (data->cvalid) {

		req->sq->dhchap_c2 = kmemdup(data->rval + data->hl, data->hl,

					     GFP_KERNEL);
@@ -163,11 +197,23 @@ static u8 nvmet_auth_reply(struct nvmet_req *req, void *d) 
		pr_debug("%s: ctrl %d qid %d challenge %*ph\n",

			 __func__, ctrl->cntlid, req->sq->qid, data->hl,

			 req->sq->dhchap_c2);

	} else {

	}

	/*

	 * NVMe Base Spec 2.2 section 8.3.4.5.4: DH-HMAC-CHAP_Reply message

	 * Sequence Number (SEQNUM): [ .. ]

	 * The value 0h is used to indicate that bidirectional authentication

	 * is not performed, but a challenge value C2 is carried in order to

	 * generate a pre-shared key (PSK) for subsequent establishment of a

	 * secure channel.

	 */

	if (req->sq->dhchap_s2 == 0) {

		if (ctrl->concat)

			nvmet_auth_insert_psk(req->sq);

		req->sq->authenticated = true;

		kfree(req->sq->dhchap_c2);

		req->sq->dhchap_c2 = NULL;

	}

	req->sq->dhchap_s2 = le32_to_cpu(data->seqnum);

	} else if (!data->cvalid)

		req->sq->authenticated = true;



	return 0;

}
@@ -303,6 +349,8 @@ void nvmet_execute_auth_send(struct nvmet_req *req) 
		}

		goto done_kfree;

	case NVME_AUTH_DHCHAP_MESSAGE_SUCCESS2:

		if (ctrl->concat)

			nvmet_auth_insert_psk(req->sq);

		req->sq->authenticated = true;

		pr_debug("%s: ctrl %d qid %d ctrl authenticated\n",

			 __func__, ctrl->cntlid, req->sq->qid);

drivers/nvme/target/fabrics-cmd.c

+15 −1
Original line number Diff line number Diff line
@@ -236,8 +236,22 @@ static u16 nvmet_install_queue(struct nvmet_ctrl *ctrl, struct nvmet_req *req) 


static u32 nvmet_connect_result(struct nvmet_ctrl *ctrl, struct nvmet_sq *sq)

{

	bool needs_auth = nvmet_has_auth(ctrl);

	bool needs_auth = nvmet_has_auth(ctrl, sq);

	key_serial_t keyid = nvmet_queue_tls_keyid(sq);



	/* Do not authenticate I/O queues for secure concatenation */

	if (ctrl->concat && sq->qid)

		needs_auth = false;



	if (keyid)

		pr_debug("%s: ctrl %d qid %d should %sauthenticate, tls psk %08x\n",

			 __func__, ctrl->cntlid, sq->qid,

			 needs_auth ? "" : "not ", keyid);

	else

		pr_debug("%s: ctrl %d qid %d should %sauthenticate%s\n",

			 __func__, ctrl->cntlid, sq->qid,

			 needs_auth ? "" : "not ",

			 ctrl->concat ? ", secure concatenation" : "");

	return (u32)ctrl->cntlid |

		(needs_auth ? NVME_CONNECT_AUTHREQ_ATR : 0);

}

drivers/nvme/target/nvmet.h

+29 −3
Original line number Diff line number Diff line
@@ -164,6 +164,9 @@ struct nvmet_sq { 
	u32			dhchap_s2;

	u8			*dhchap_skey;

	int			dhchap_skey_len;

#endif

#ifdef CONFIG_NVME_TARGET_TCP_TLS

	struct key		*tls_key;

#endif

	struct completion	free_done;

	struct completion	confirm_done;
@@ -289,6 +292,7 @@ struct nvmet_ctrl { 
	u64			err_counter;

	struct nvme_error_slot	slots[NVMET_ERROR_LOG_SLOTS];

	bool			pi_support;

	bool			concat;

#ifdef CONFIG_NVME_TARGET_AUTH

	struct nvme_dhchap_key	*host_key;

	struct nvme_dhchap_key	*ctrl_key;
@@ -297,6 +301,9 @@ struct nvmet_ctrl { 
	u8			dh_gid;

	u8			*dh_key;

	size_t			dh_keysize;

#endif

#ifdef CONFIG_NVME_TARGET_TCP_TLS

	struct key		*tls_key;

#endif

	struct nvmet_pr_log_mgr pr_log_mgr;

};
@@ -853,6 +860,22 @@ static inline void nvmet_req_bio_put(struct nvmet_req *req, struct bio *bio) 
		bio_put(bio);

}



#ifdef CONFIG_NVME_TARGET_TCP_TLS

static inline key_serial_t nvmet_queue_tls_keyid(struct nvmet_sq *sq)

{

	return sq->tls_key ? key_serial(sq->tls_key) : 0;

}

static inline void nvmet_sq_put_tls_key(struct nvmet_sq *sq)

{

	if (sq->tls_key) {

		key_put(sq->tls_key);

		sq->tls_key = NULL;

	}

}

#else

static inline key_serial_t nvmet_queue_tls_keyid(struct nvmet_sq *sq) { return 0; }

static inline void nvmet_sq_put_tls_key(struct nvmet_sq *sq) {}

#endif

#ifdef CONFIG_NVME_TARGET_AUTH

u32 nvmet_auth_send_data_len(struct nvmet_req *req);

void nvmet_execute_auth_send(struct nvmet_req *req);
@@ -871,14 +894,15 @@ int nvmet_auth_host_hash(struct nvmet_req *req, u8 *response, 
			 unsigned int hash_len);

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

			 unsigned int hash_len);

static inline bool nvmet_has_auth(struct nvmet_ctrl *ctrl)

static inline bool nvmet_has_auth(struct nvmet_ctrl *ctrl, struct nvmet_sq *sq)

{

	return ctrl->host_key != NULL;

	return ctrl->host_key != NULL && !nvmet_queue_tls_keyid(sq);

}

int nvmet_auth_ctrl_exponential(struct nvmet_req *req,

				u8 *buf, int buf_size);

int nvmet_auth_ctrl_sesskey(struct nvmet_req *req,

			    u8 *buf, int buf_size);

void nvmet_auth_insert_psk(struct nvmet_sq *sq);

#else

static inline u8 nvmet_setup_auth(struct nvmet_ctrl *ctrl,

				  struct nvmet_sq *sq)
@@ -894,11 +918,13 @@ static inline bool nvmet_check_auth_status(struct nvmet_req *req) 
{

	return true;

}

static inline bool nvmet_has_auth(struct nvmet_ctrl *ctrl)

static inline bool nvmet_has_auth(struct nvmet_ctrl *ctrl,

				  struct nvmet_sq *sq)

{

	return false;

}

static inline const char *nvmet_dhchap_dhgroup_name(u8 dhgid) { return NULL; }

static inline void nvmet_auth_insert_psk(struct nvmet_sq *sq) {};

#endif



int nvmet_pr_init_ns(struct nvmet_ns *ns);