nvme: In-band authentication support
Subsystems (4)
Hannes Reinecke
maintainerv13 cover nvme: In-band authentication support
Hi all,
recent updates to the NVMe spec have added definitions for in-band authentication, and seeing that it provides some real benefit especially for NVMe-TCP here's an attempt to implement it.
Thanks to Nicolai Stange the crypto DH framework has been upgraded to provide us with a FFDHE implementation; I've updated the patchset to use the ephemeral key generation provided there.
Note that this is just for in-band authentication. Secure concatenation (ie starting TLS with the negotiated parameters) requires a TLS handshake, which the in-kernel TLS implementation does not provide. This is being worked on with a different patchset which is still WIP.
The nvme-cli support has already been merged; please use the latest nvme-cli git repository to build the most recent version.
A copy of this patchset can be found atgit://git.kernel.org/pub/scm/linux/kernel/git/hare/scsi-devel
branch auth.v13
The patchset is being cut against v5.18.
As usual, comments and reviews are welcome.
Changes to v12:
- Replaces crypto_has_shash() and crypto_has_kpp() helper with CONFIG_ checks
- Fixed kbuild robot warning in pr_fmt()
Changes to v11:
- Fixup type for FAILURE2 message (Prashant Nayak)
- Do not sent SUCCESS2 if bi-directional authentication is not requested
(Martin George)
Changes to v10:
- Fixup error return value when authentication failed
Changes to v9:
- Include review from Chaitanya
- Use sparse array for dhgroup and hash lookup
- Common function for auth_send and auth_receive
Changes to v8:
- Rebased to Nicolais crypto DH rework
- Fixed oops on non-fabrics devices
Changes to v7:
- Space out hash list and dhgroup list in nvme negotiate data to be conformant with the spec
- Update sequence number handling to start with a random value and ignore '0' as mandated by the spec
- Update nvme_auth_generate_key to return the key as suggested by
Sagi
- Add nvmet_parse_fabrics_io_cmd() as suggested by hch
Changes to v6:
- Use 'u8' for DH group id and hash id
- Use 'struct nvme_dhchap_key'
- Rename variables to drop 'DHCHAP'
- Include reviews from Chaitanya
Changes to v5:
- Unify nvme_auth_generate_key()
- Unify nvme_auth_extract_key()
- Fixed bug where re-authentication with wrong controller key would not fail
- Include reviews from Sagi
Changes to v4:
- Validate against blktest suite
- Fixup base64 decoding
- Transform secret with correct hmac algorithm
Changes to v3:
- Renamed parameter to 'dhchap_ctrl_key'
- Fixed bi-directional authentication
- Included reviews from Sagi
- Fixed base64 algorithm for transport encoding
Changes to v2:
- Dropped non-standard algorithms
- Reworked base64 based on fs/crypto/fname.c
- Fixup crash with no keys
Changes to the original submission:
- Included reviews from Vladislav
- Included reviews from Sagi
- Implemented re-authentication support
- Fixed up key handling
Hannes Reinecke (9):
lib/base64: RFC4648-compliant base64 encoding
nvme: add definitions for NVMe In-Band authentication
nvme-fabrics: decode 'authentication required' connect error
nvme: Implement In-Band authentication
nvme-auth: Diffie-Hellman key exchange support
nvmet: parse fabrics commands on io queues
nvmet: Implement basic In-Band Authentication
nvmet-auth: Diffie-Hellman key exchange support
nvmet-auth: expire authentication sessions
drivers/nvme/host/Kconfig | 12 + drivers/nvme/host/Makefile | 1 + drivers/nvme/host/auth.c | 1470 ++++++++++++++++++++++++ drivers/nvme/host/auth.h | 40 + drivers/nvme/host/core.c | 141 ++- drivers/nvme/host/fabrics.c | 83 +- drivers/nvme/host/fabrics.h | 7 + drivers/nvme/host/nvme.h | 31 + drivers/nvme/host/rdma.c | 1 + drivers/nvme/host/tcp.c | 1 + drivers/nvme/host/trace.c | 32 + drivers/nvme/target/Kconfig | 13 + drivers/nvme/target/Makefile | 1 + drivers/nvme/target/admin-cmd.c | 4 +- drivers/nvme/target/auth.c | 523 +++++++++ drivers/nvme/target/configfs.c | 133 ++- drivers/nvme/target/core.c | 15 + drivers/nvme/target/fabrics-cmd-auth.c | 533 +++++++++ drivers/nvme/target/fabrics-cmd.c | 55 +- drivers/nvme/target/nvmet.h | 75 +- include/linux/base64.h | 16 + include/linux/nvme.h | 204 +++- lib/Makefile | 2 +- lib/base64.c | 103 ++ 24 files changed, 3481 insertions(+), 15 deletions(-) create mode 100644 drivers/nvme/host/auth.c create mode 100644 drivers/nvme/host/auth.h create mode 100644 drivers/nvme/target/auth.c create mode 100644 drivers/nvme/target/fabrics-cmd-auth.c create mode 100644 include/linux/base64.h create mode 100644 lib/base64.c
Signature · 1 line
2.29.2
Hannes Reinecke
maintainerPATCH v13 1/9 lib/base64: RFC4648-compliant base64 encoding
Add RFC4648-compliant base64 encoding and decoding routines, based on the base64url encoding in fs/crypto/fname.c.
--- include/linux/base64.h | 16 +++++++ lib/Makefile | 2 +- lib/base64.c | 103 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 120 insertions(+), 1 deletion(-) create mode 100644 include/linux/base64.h create mode 100644 lib/base64.c
include/linux/base64.h new file +16 -0
@@ -0,0 +1,16 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* base64 encoding, lifted from fs/crypto/fname.c. +*/ + +#ifndef _LINUX_BASE64_H +#define _LINUX_BASE64_H + +#include <linux/types.h> + +#define BASE64_CHARS (nbytes) DIV_ROUND_UP((nbytes) * 4, 3) + +int base64_encode (const u8 *src,int len,char *dst); +int base64_decode (const char *src,int len,u8 *dst); + +#endif /* _LINUX_BASE64_H */
lib/Makefile +1 -1
@@ -46,7 +46,7 @@ obj-y += bcd.o sort.o parser.o debug_locks.o random32.o \ bust_spinlocks.o kasprintf.o bitmap.o scatterlist.o \ list_sort.o uuid.o iov_iter.o clz_ctz.o \ bsearch.o find_bit.o llist.o memweight.o kfifo.o \ - percpu-refcount.o rhashtable.o \ + percpu-refcount.o rhashtable.o base64.o \ once.o refcount.o usercopy.o errseq.o bucket_locks.o \ generic-radix-tree.o obj-$(CONFIG_STRING_SELFTEST) += test_string.o
lib/base64.c new file +103 -0
103 lines not on this page · raw message
Signature · 1 line
2.29.2
Hannes Reinecke
maintainerPATCH v13 2/9 nvme: add definitions for NVMe In-Band authentication
In reply to Hannes ReineckeAdd new definitions for NVMe In-band authentication as defined in the NVMe Base Specification v2.0.
--- include/linux/nvme.h | 204 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 203 insertions(+), 1 deletion(-)
include/linux/nvme.h +203 -1
@@ -19,6 +19,7 @@#define NVMF_TRSVCID_SIZE 32#define NVMF_TRADDR_SIZE 256#define NVMF_TSAS_SIZE 256 +#define NVMF_AUTH_HASH_LEN 64#define NVME_DISC_SUBSYS_NAME "nqn.2014-08.org.nvmexpress.discovery"
@@ -1328,6 +1329,8 @@ enum nvmf_capsule_command { nvme_fabrics_type_property_set =0x00 , nvme_fabrics_type_connect =0x01 , nvme_fabrics_type_property_get =0x04 , + nvme_fabrics_type_auth_send =0x05 , + nvme_fabrics_type_auth_receive = 0x06, };#define nvme_fabrics_type_name (type) { type, #type }
@@ -1335,7 +1338,9 @@ enum nvmf_capsule_command {__print_symbolic (type, \nvme_fabrics_type_name (nvme_fabrics_type_property_set), \nvme_fabrics_type_name (nvme_fabrics_type_connect), \ -nvme_fabrics_type_name (nvme_fabrics_type_property_get)) +nvme_fabrics_type_name (nvme_fabrics_type_property_get), \ +nvme_fabrics_type_name (nvme_fabrics_type_auth_send), \ +nvme_fabrics_type_name (nvme_fabrics_type_auth_receive))/* * If not fabrics command, fctype will be ignored.
@@ -1465,6 +1470,200 @@ struct nvmf_property_get_command {__u8 resv4[16 ]; }; +struct nvmf_auth_common_command { +__u8 opcode; +__u8 resv1; +__u16 command_id; +__u8 fctype; +__u8 resv2[19 ]; +union nvme_data_ptr dptr; +__u8 resv3; +__u8 spsp0; +__u8 spsp1; +__u8 secp; +__le32 al_tl; +__u8 resv4[16 ]; +}; + +struct nvmf_auth_send_command { +__u8 opcode; +__u8 resv1; +__u16 command_id; +__u8 fctype; +__u8 resv2[19 ]; +union nvme_data_ptr dptr; +__u8 resv3; +__u8 spsp0; +__u8 spsp1; +__u8 secp; +__le32 tl; +__u8 resv4[16 ]; +}; + +struct nvmf_auth_receive_command { +__u8 opcode; +__u8 resv1; +__u16 command_id; +__u8 fctype; +__u8 resv2[19 ]; +union nvme_data_ptr dptr; +__u8 resv3; +__u8 spsp0; +__u8 spsp1; +__u8 secp; +__le32 al; +__u8 resv4[16 ]; +}; + +/* Value for secp */ +enum { +NVME_AUTH_DHCHAP_PROTOCOL_IDENTIFIER =0xe9 , +}; + +/* Defined value for auth_type */ +enum { +NVME_AUTH_COMMON_MESSAGES =0x00 , +NVME_AUTH_DHCHAP_MESSAGES =0x01 , +}; + +/* Defined messages for auth_id */ +enum { +NVME_AUTH_DHCHAP_MESSAGE_NEGOTIATE =0x00 , +NVME_AUTH_DHCHAP_MESSAGE_CHALLENGE =0x01 , +NVME_AUTH_DHCHAP_MESSAGE_REPLY =0x02 , +NVME_AUTH_DHCHAP_MESSAGE_SUCCESS1 =0x03 , +NVME_AUTH_DHCHAP_MESSAGE_SUCCESS2 =0x04 , +NVME_AUTH_DHCHAP_MESSAGE_FAILURE2 =0xf0 , +NVME_AUTH_DHCHAP_MESSAGE_FAILURE1 =0xf1 , +}; + +struct nvmf_auth_dhchap_protocol_descriptor { +__u8 authid; +__u8 rsvd; +__u8 halen; +__u8 dhlen; +__u8 idlist[60 ]; +}; + +enum { +NVME_AUTH_DHCHAP_AUTH_ID =0x01 , +}; + +/* Defined hash functions for DH-HMAC-CHAP authentication */ +enum { +NVME_AUTH_HASH_SHA256 =0x01 , +NVME_AUTH_HASH_SHA384 =0x02 , +NVME_AUTH_HASH_SHA512 =0x03 , +NVME_AUTH_HASH_INVALID =0xff , +}; + +/* Defined Diffie-Hellman group identifiers for DH-HMAC-CHAP authentication */ +enum { +NVME_AUTH_DHGROUP_NULL =0x00 , +NVME_AUTH_DHGROUP_2048 =0x01 , +NVME_AUTH_DHGROUP_3072 =0x02 , +NVME_AUTH_DHGROUP_4096 =0x03 , +NVME_AUTH_DHGROUP_6144 =0x04 , +NVME_AUTH_DHGROUP_8192 =0x05 , +NVME_AUTH_DHGROUP_INVALID =0xff , +}; + +union nvmf_auth_protocol { +struct nvmf_auth_dhchap_protocol_descriptor dhchap; +}; + +struct nvmf_auth_dhchap_negotiate_data { +__u8 auth_type; +__u8 auth_id; +__le16 rsvd; +__le16 t_id; +__u8 sc_c; +__u8 napd; +union nvmf_auth_protocol auth_protocol[]; +}; + +struct nvmf_auth_dhchap_challenge_data { +__u8 auth_type; +__u8 auth_id; +__u16 rsvd1; +__le16 t_id; +__u8 hl; +__u8 rsvd2; +__u8 hashid; +__u8 dhgid; +__le16 dhvlen; +__le32 seqnum; +/* 'hl' bytes of challenge value */ +__u8 cval[]; +/* followed by 'dhvlen' bytes of DH value */ +}; + +struct nvmf_auth_dhchap_reply_data { +__u8 auth_type; +__u8 auth_id; +__le16 rsvd1; +__le16 t_id; +__u8 hl; +__u8 rsvd2; +__u8 cvalid; +__u8 rsvd3; +__le16 dhvlen; +__le32 seqnum; +/* 'hl' bytes of response data */ +__u8 rval[]; +/* followed by 'hl' bytes of Challenge value */ +/* followed by 'dhvlen' bytes of DH value */ +}; + +enum { +NVME_AUTH_DHCHAP_RESPONSE_VALID = (1 <<0 ), +}; + +struct nvmf_auth_dhchap_success1_data { +__u8 auth_type; +__u8 auth_id; +__le16 rsvd1; +__le16 t_id; +__u8 hl; +__u8 rsvd2; +__u8 rvalid; +__u8 rsvd3[7 ]; +/* 'hl' bytes of response value if 'rvalid' is set */ +__u8 rval[]; +}; + +struct nvmf_auth_dhchap_success2_data { +__u8 auth_type; +__u8 auth_id; +__le16 rsvd1; +__le16 t_id; +__u8 rsvd2[10 ]; +}; + +struct nvmf_auth_dhchap_failure_data { +__u8 auth_type; +__u8 auth_id; +__le16 rsvd1; +__le16 t_id; +__u8 rescode; +__u8 rescode_exp; +}; + +enum { +NVME_AUTH_DHCHAP_FAILURE_REASON_FAILED =0x01 , +}; + +enum { +NVME_AUTH_DHCHAP_FAILURE_FAILED =0x01 , +NVME_AUTH_DHCHAP_FAILURE_NOT_USABLE =0x02 , +NVME_AUTH_DHCHAP_FAILURE_CONCAT_MISMATCH =0x03 , +NVME_AUTH_DHCHAP_FAILURE_HASH_UNUSABLE =0x04 , +NVME_AUTH_DHCHAP_FAILURE_DHGROUP_UNUSABLE =0x05 , +NVME_AUTH_DHCHAP_FAILURE_INCORRECT_PAYLOAD =0x06 , +NVME_AUTH_DHCHAP_FAILURE_INCORRECT_MESSAGE =0x07 , +}; + +struct nvme_dbbuf {__u8 opcode;__u8 flags;
@@ -1508,6 +1707,9 @@ struct nvme_command {struct nvmf_connect_command connect;struct nvmf_property_set_command prop_set;struct nvmf_property_get_command prop_get; +struct nvmf_auth_common_command auth_common; +struct nvmf_auth_send_command auth_send; +struct nvmf_auth_receive_command auth_receive;struct nvme_dbbuf dbbuf;struct nvme_directive_cmd directive; };
Signature · 1 line
2.29.2
Hannes Reinecke
maintainerPATCH v13 3/9 nvme-fabrics: decode 'authentication required' connect error
In reply to Hannes ReineckeThe 'connect' command might fail with NVME_SC_AUTH_REQUIRED, so we should be decoding this error, too.
--- drivers/nvme/host/fabrics.c | 4 ++++ 1 file changed, 4 insertions(+)
drivers/nvme/host/fabrics.c +4 -0
@@ -331,6 +331,10 @@ static void nvmf_log_connect_error(struct nvme_ctrl *ctrl,dev_err (ctrl->device,"Connect command failed: host path error\n" );break ; +case NVME_SC_AUTH_REQUIRED : +dev_err (ctrl->device, +"Connect command failed: authentication required\n" ); +break ;default : dev_err(ctrl->device, "Connect command failed, error wo/DNR bit: %d\n",
Signature · 1 line
2.29.2
Hannes Reinecke
maintainerPATCH v13 4/9 nvme: Implement In-Band authentication
In reply to Hannes ReineckeImplement NVMe-oF In-Band authentication according to NVMe TPAR 8006. This patch adds two new fabric options 'dhchap_secret' to specify the pre-shared key (in ASCII respresentation according to NVMe 2.0 section 8.13.5.8 'Secret representation') and 'dhchap_ctrl_secret' to specify the pre-shared controller key for bi-directional authentication of both the host and the controller.
Re-authentication can be triggered by writing the PSK into the new controller sysfs attribute 'dhchap_secret' or 'dhchap_ctrl_secret'.
--- drivers/nvme/host/Kconfig | 11 + drivers/nvme/host/Makefile | 1 + drivers/nvme/host/auth.c | 1118 +++++++++++++++++++++++++++++++++++ drivers/nvme/host/auth.h | 32 + drivers/nvme/host/core.c | 141 ++++- drivers/nvme/host/fabrics.c | 79 ++- drivers/nvme/host/fabrics.h | 7 + drivers/nvme/host/nvme.h | 31 + drivers/nvme/host/rdma.c | 1 + drivers/nvme/host/tcp.c | 1 + drivers/nvme/host/trace.c | 32 + 11 files changed, 1447 insertions(+), 7 deletions(-) create mode 100644 drivers/nvme/host/auth.c create mode 100644 drivers/nvme/host/auth.h
drivers/nvme/host/Kconfig +11 -0
@@ -91,3 +91,14 @@ config NVME_TCP from https://github.com/linux-nvme/nvme-cli. If unsure, say N. + +config NVME_AUTH + bool "NVM Express over Fabrics In-Band Authentication" + depends on NVME_CORE + select CRYPTO_HMAC + select CRYPTO_SHA256 + select CRYPTO_SHA512 + help + This provides support for NVMe over Fabrics In-Band Authentication. + + If unsure, say N.
drivers/nvme/host/Makefile +1 -0
@@ -15,6 +15,7 @@ nvme-core-$(CONFIG_NVME_MULTIPATH) += multipath.o nvme-core-$(CONFIG_BLK_DEV_ZONED) += zns.o nvme-core-$(CONFIG_FAULT_INJECTION_DEBUG_FS) += fault_inject.o nvme-core-$(CONFIG_NVME_HWMON) += hwmon.o +nvme-core-$(CONFIG_NVME_AUTH) += auth.o nvme-y += pci.o
drivers/nvme/host/auth.c new file +1118 -0
1,118 lines not on this page · raw message
drivers/nvme/host/auth.h new file +32 -0
@@ -0,0 +1,32 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (c) 2021 Hannes Reinecke, SUSE Software Solutions +*/ + +#ifndef _NVME_AUTH_H +#define _NVME_AUTH_H + +#include <crypto/kpp.h> + +struct nvme_dhchap_key { +u8 *key; +size_t len; +u8 hash; +}; + +u32 nvme_auth_get_seqnum (void ); +const char *nvme_auth_dhgroup_name (u8 dhgroup_id); +const char *nvme_auth_dhgroup_kpp (u8 dhgroup_id); +u8 nvme_auth_dhgroup_id (const char *dhgroup_name); + +const char *nvme_auth_hmac_name (u8 hmac_id); +const char *nvme_auth_digest_name (u8 hmac_id); +size_t nvme_auth_hmac_hash_len (u8 hmac_id); +u8 nvme_auth_hmac_id (const char *hmac_name); + +struct nvme_dhchap_key *nvme_auth_extract_key (unsigned char *secret, +u8 key_hash); +void nvme_auth_free_key (struct nvme_dhchap_key *key); +u8 *nvme_auth_transform_key (struct nvme_dhchap_key *key,char *nqn); + +#endif /* _NVME_AUTH_H */
drivers/nvme/host/core.c +137 -4
223 lines not on this page · raw message
drivers/nvme/host/fabrics.c +76 -3
134 lines not on this page · raw message
drivers/nvme/host/fabrics.h +7 -0
@@ -68,6 +68,8 @@ enum {NVMF_OPT_FAIL_FAST_TMO =1 <<20 ,NVMF_OPT_HOST_IFACE =1 <<21 ,NVMF_OPT_DISCOVERY =1 <<22 , +NVMF_OPT_DHCHAP_SECRET =1 <<23 , + NVMF_OPT_DHCHAP_CTRL_SECRET = 1 << 24, };/**
@@ -97,6 +99,9 @@ enum {* @max_reconnects: maximum number of allowed reconnect attempts before removing * the controller, (-1) means reconnect forever, zero means remove * immediately; +* @dhchap_secret: DH-HMAC-CHAP secret +* @dhchap_ctrl_secret: DH-HMAC-CHAP controller secret for bi-directional +* authentication * @disable_sqflow: disable controller sq flow control * @hdr_digest: generate/verify header digest (TCP) * @data_digest: generate/verify data digest (TCP)
@@ -121,6 +126,8 @@ struct nvmf_ctrl_options {unsigned int kato;struct nvmf_host *host;int max_reconnects; +char *dhchap_secret; +char *dhchap_ctrl_secret;bool disable_sqflow;bool hdr_digest;bool data_digest;
drivers/nvme/host/nvme.h +31 -0
@@ -327,6 +327,15 @@ struct nvme_ctrl {struct work_struct ana_work;#endif +#ifdef CONFIG_NVME_AUTH +struct work_struct dhchap_auth_work; +struct list_head dhchap_auth_list; +struct mutex dhchap_auth_mutex; +struct nvme_dhchap_key *host_key; +struct nvme_dhchap_key *ctrl_key; +u16 transaction; +#endif +/* Power saving configuration */ u64 ps_max_latency_us;bool apst_enabled;
@@ -957,6 +966,28 @@ static inline bool nvme_ctrl_sgl_supported(struct nvme_ctrl *ctrl)return ctrl->sgls & ((1 <<0 ) | (1 <<1 )); } +#ifdef CONFIG_NVME_AUTH +void nvme_auth_init_ctrl (struct nvme_ctrl *ctrl); +void nvme_auth_stop (struct nvme_ctrl *ctrl); +int nvme_auth_negotiate (struct nvme_ctrl *ctrl,int qid); +int nvme_auth_wait (struct nvme_ctrl *ctrl,int qid); +void nvme_auth_reset (struct nvme_ctrl *ctrl); +void nvme_auth_free (struct nvme_ctrl *ctrl); +int nvme_auth_generate_key (u8 *secret,struct nvme_dhchap_key **ret_key); +#else +static inline void nvme_auth_init_ctrl (struct nvme_ctrl *ctrl) {}; +static inline void nvme_auth_stop (struct nvme_ctrl *ctrl) {}; +static inline int nvme_auth_negotiate (struct nvme_ctrl *ctrl,int qid) +{ +return -EPROTONOSUPPORT ; +} +static inline int nvme_auth_wait (struct nvme_ctrl *ctrl,int qid) +{ +return NVME_SC_AUTH_REQUIRED ; +} +static inline void nvme_auth_free (struct nvme_ctrl *ctrl) {}; +#endif +u32 nvme_command_effects (struct nvme_ctrl *ctrl,struct nvme_ns *ns,u8 opcode);int nvme_execute_passthru_rq (struct request *rq);
drivers/nvme/host/rdma.c +1 -0
@@ -1197,6 +1197,7 @@ static void nvme_rdma_error_recovery_work(struct work_struct *work)struct nvme_rdma_ctrl *ctrl =container_of (work, struct nvme_rdma_ctrl, err_work); +nvme_auth_stop (&ctrl->ctrl);nvme_stop_keep_alive (&ctrl->ctrl);flush_work (&ctrl->ctrl.async_event_work);nvme_rdma_teardown_io_queues (ctrl, false);
drivers/nvme/host/tcp.c +1 -0
@@ -2174,6 +2174,7 @@ static void nvme_tcp_error_recovery_work(struct work_struct *work) struct nvme_tcp_ctrl, err_work);struct nvme_ctrl *ctrl = &tcp_ctrl->ctrl; +nvme_auth_stop (ctrl);nvme_stop_keep_alive (ctrl);flush_work (&ctrl->async_event_work);nvme_tcp_teardown_io_queues (ctrl, false);
drivers/nvme/host/trace.c +32 -0
@@ -287,6 +287,34 @@ static const char *nvme_trace_fabrics_property_get(struct trace_seq *p, u8 *spc)return ret; } +static const char *nvme_trace_fabrics_auth_send (struct trace_seq *p,u8 *spc) +{ +const char *ret =trace_seq_buffer_ptr (p); +u8 spsp0 = spc[1 ]; +u8 spsp1 = spc[2 ]; +u8 secp = spc[3 ]; +u32 tl =get_unaligned_le32 (spc +4 ); + +trace_seq_printf (p,"spsp0=%02x, spsp1=%02x, secp=%02x, tl=%u" , + spsp0, spsp1, secp, tl); +trace_seq_putc (p,0 ); +return ret; +} + +static const char *nvme_trace_fabrics_auth_receive (struct trace_seq *p,u8 *spc) +{ +const char *ret =trace_seq_buffer_ptr (p); +u8 spsp0 = spc[1 ]; +u8 spsp1 = spc[2 ]; +u8 secp = spc[3 ]; +u32 al =get_unaligned_le32 (spc +4 ); + +trace_seq_printf (p,"spsp0=%02x, spsp1=%02x, secp=%02x, al=%u" , + spsp0, spsp1, secp, al); +trace_seq_putc (p,0 ); +return ret; +} +static const char *nvme_trace_fabrics_common (struct trace_seq *p,u8 *spc) {const char *ret =trace_seq_buffer_ptr (p);
@@ -306,6 +334,10 @@ const char *nvme_trace_parse_fabrics_cmd(struct trace_seq *p,return nvme_trace_fabrics_connect (p, spc);case nvme_fabrics_type_property_get:return nvme_trace_fabrics_property_get (p, spc); +case nvme_fabrics_type_auth_send: +return nvme_trace_fabrics_auth_send (p, spc); +case nvme_fabrics_type_auth_receive: +return nvme_trace_fabrics_auth_receive (p, spc);default :return nvme_trace_fabrics_common (p, spc); }
Signature · 1 line
2.29.2
Christoph Hellwig
maintainerRe: [PATCH 4/9] nvme: Implement In-Band authentication
drivers/nvme/host/Kconfig config NVME_TCP · line 97
Quoted 3 lines · Hannes Reinecke
drivers/nvme/host/Kconfig +3
-0+config NVME_AUTH + bool "NVM Express over Fabrics In-Band Authentication" + depends on NVME_CORE
Does this actually depend on NVME_CORE? As that would suck when pulling this code into the target driver as well. Also in addition to the header location already mentioned by Max, this should probably go into drivers/nvme/common/ if used by the host and target code.
drivers/nvme/host/Kconfig config NVME_TCP · line 102
Quoted 1 line
drivers/nvme/host/Kconfig +1
-0+ This provides support for NVMe over Fabrics In-Band Authentication.
This should probably mention that the support can be used both by the host and target code.
Hannes Reinecke
maintainerRe: [PATCH 4/9] nvme: Implement In-Band authentication
Quoted 10 lines · Christoph Hellwig
drivers/nvme/host/Kconfig config NVME_TCP · line 97
Quoted 3 lines · Hannes Reinecke
drivers/nvme/host/Kconfig +3
-0+config NVME_AUTH + bool "NVM Express over Fabrics In-Band Authentication" + depends on NVME_COREDoes this actually depend on
NVME_CORE? As that would suck when pulling this code into the target driver as well. Also in addition to the header location already mentioned by Max, this should probably go intodrivers/nvme/common/if used by the host and target code.
That would mean to create another nvme module (nvme-common.o?), which would need to be pulled in by both, host and target code. And really it's just the one file in drivers/nvme/host/auth.c.
Sure I can do that if you think that's better ...
Quoted 4 lines
drivers/nvme/host/Kconfig config NVME_TCP · line 102
Quoted 1 line
drivers/nvme/host/Kconfig +1
-0+ This provides support for NVMe over Fabrics In-Band Authentication.This should probably mention that the support can be used both by the host and target code.
Right. Will be doing it.
Cheers,
Hannes
Signature · 5 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), Geschäftsführer: Ivo Totev, Andrew Myers, Andrew McDonald, Martje Boudien Moerman
Christoph Hellwig
maintainerRe: [PATCH 4/9] nvme: Implement In-Band authentication
Quoted 1 line · Hannes Reinecke
That would mean to create another nvme module (nvme-common.o?), which would
Yes, same as we do fork SCSI with scsi_common.ko
Quoted 3 lines
need to be pulled in by both, host and target code. And really it's just the one file in
drivers/nvme/host/auth.c. Sure I can do that if you think that's better ...
Yes, we need to keep our architecture reasonably clean.
Hannes Reinecke
maintainerPATCH v13 5/9 nvme-auth: Diffie-Hellman key exchange support
In reply to Hannes ReineckeImplement Diffie-Hellman key exchange using FFDHE groups for NVMe In-Band Authentication.
--- drivers/nvme/host/Kconfig | 1 + drivers/nvme/host/auth.c | 364 +++++++++++++++++++++++++++++++++++++- drivers/nvme/host/auth.h | 8 + 3 files changed, 367 insertions(+), 6 deletions(-)
drivers/nvme/host/Kconfig +1 -0
@@ -98,6 +98,7 @@ config NVME_AUTH select CRYPTO_HMAC select CRYPTO_SHA256 select CRYPTO_SHA512 + select CRYPTO_DH_RFC7919_GROUPS help This provides support for NVMe over Fabrics In-Band Authentication.
drivers/nvme/host/auth.c +358 -6
462 lines not on this page · raw message
drivers/nvme/host/auth.h +8 -0
@@ -28,5 +28,13 @@ struct nvme_dhchap_key *nvme_auth_extract_key(unsigned char *secret, u8 key_hash);void nvme_auth_free_key (struct nvme_dhchap_key *key);u8 *nvme_auth_transform_key (struct nvme_dhchap_key *key,char *nqn); +int nvme_auth_augmented_challenge (u8 hmac_id,u8 *skey,size_t skey_len, +u8 *challenge,u8 *aug,size_t hlen); +int nvme_auth_gen_privkey (struct crypto_kpp *dh_tfm,u8 dh_gid); +int nvme_auth_gen_pubkey (struct crypto_kpp *dh_tfm, +u8 *host_key,size_t host_key_len); +int nvme_auth_gen_shared_secret (struct crypto_kpp *dh_tfm, +u8 *ctrl_key,size_t ctrl_key_len, +u8 *sess_key,size_t sess_key_len);#endif /* _NVME_AUTH_H */
Signature · 1 line
2.29.2
Hannes Reinecke
maintainerPATCH v13 6/9 nvmet: parse fabrics commands on io queues
In reply to Hannes ReineckeSome fabrics commands can be sent via io queues, so add a new function nvmet_parse_fabrics_io_cmd() and rename the existing nvmet_parse_fabrics_cmd() to nvmet_parse_fabrics_admin_cmd().
--- drivers/nvme/target/admin-cmd.c | 2 +- drivers/nvme/target/core.c | 4 ++++ drivers/nvme/target/fabrics-cmd.c | 17 ++++++++++++++++- drivers/nvme/target/nvmet.h | 3 ++- 4 files changed, 23 insertions(+), 3 deletions(-)
drivers/nvme/target/admin-cmd.c +1 -1
@@ -1017,7 +1017,7 @@ u16 nvmet_parse_admin_cmd(struct nvmet_req *req)u16 ret;if (nvme_is_fabrics (cmd)) -return nvmet_parse_fabrics_cmd (req); +return nvmet_parse_fabrics_admin_cmd (req);if (nvmet_is_disc_subsys (nvmet_req_subsys (req)))return nvmet_parse_discovery_cmd (req);
drivers/nvme/target/core.c +4 -0
@@ -865,8 +865,12 @@ static inline u16 nvmet_io_cmd_check_access(struct nvmet_req *req)static u16 nvmet_parse_io_cmd (struct nvmet_req *req) { +struct nvme_command *cmd = req->cmd;u16 ret; +if (nvme_is_fabrics (cmd)) +return nvmet_parse_fabrics_io_cmd (req); + ret =nvmet_check_ctrl_status (req);if (unlikely (ret))return ret;
drivers/nvme/target/fabrics-cmd.c +16 -1
@@ -82,7 +82,7 @@ static void nvmet_execute_prop_get(struct nvmet_req *req)nvmet_req_complete (req, status); } -u16 nvmet_parse_fabrics_cmd (struct nvmet_req *req) +u16 nvmet_parse_fabrics_admin_cmd (struct nvmet_req *req) {struct nvme_command *cmd = req->cmd;
@@ -103,6 +103,21 @@ u16 nvmet_parse_fabrics_cmd(struct nvmet_req *req)return 0 ; } +u16 nvmet_parse_fabrics_io_cmd (struct nvmet_req *req) +{ +struct nvme_command *cmd = req->cmd; + +switch (cmd->fabrics.fctype) { +default : +pr_debug ("received unknown capsule type 0x%x\n" , + cmd->fabrics.fctype); + req->error_loc = offsetof(struct nvmf_common_command , fctype); +return NVME_SC_INVALID_OPCODE |NVME_SC_DNR ; + } + +return 0 ; +} +static u16 nvmet_install_queue (struct nvmet_ctrl *ctrl,struct nvmet_req *req) {struct nvmf_connect_command *c = &req->cmd->connect;
drivers/nvme/target/nvmet.h +2 -1
@@ -419,7 +419,8 @@ u16 nvmet_file_parse_io_cmd(struct nvmet_req *req);u16 nvmet_bdev_zns_parse_io_cmd (struct nvmet_req *req);u16 nvmet_parse_admin_cmd (struct nvmet_req *req);u16 nvmet_parse_discovery_cmd (struct nvmet_req *req); -u16 nvmet_parse_fabrics_cmd (struct nvmet_req *req); +u16 nvmet_parse_fabrics_admin_cmd (struct nvmet_req *req); +u16 nvmet_parse_fabrics_io_cmd (struct nvmet_req *req);bool nvmet_req_init (struct nvmet_req *req,struct nvmet_cq *cq,struct nvmet_sq *sq,const struct nvmet_fabrics_ops *ops);
Signature · 1 line
2.29.2
Hannes Reinecke
maintainerPATCH v13 7/9 nvmet: Implement basic In-Band Authentication
In reply to Hannes ReineckeImplement 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.
--- drivers/nvme/target/Kconfig | 12 + drivers/nvme/target/Makefile | 1 + drivers/nvme/target/admin-cmd.c | 2 + drivers/nvme/target/auth.c | 365 ++++++++++++++++++ drivers/nvme/target/configfs.c | 105 +++++- drivers/nvme/target/core.c | 11 + drivers/nvme/target/fabrics-cmd-auth.c | 491 +++++++++++++++++++++++++ drivers/nvme/target/fabrics-cmd.c | 38 +- drivers/nvme/target/nvmet.h | 62 ++++ 9 files changed, 1084 insertions(+), 3 deletions(-) create mode 100644 drivers/nvme/target/auth.c create mode 100644 drivers/nvme/target/fabrics-cmd-auth.c
drivers/nvme/target/Kconfig +12 -0
@@ -83,3 +83,15 @@ 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 + depends on NVME_AUTH + 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
@@ -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
@@ -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 new file +365 -0
365 lines not on this page · raw message
drivers/nvme/target/configfs.c +104 -1
134 lines not on this page · raw message
drivers/nvme/target/core.c +11 -0
@@ -795,6 +795,7 @@ void nvmet_sq_destroy(struct nvmet_sq *sq)wait_for_completion (&sq->confirm_done);wait_for_completion (&sq->free_done);percpu_ref_exit (&sq->ref); +nvmet_auth_sq_free (sq);if (ctrl) {/*
@@ -871,6 +872,9 @@ static u16 nvmet_parse_io_cmd(struct nvmet_req *req)if (nvme_is_fabrics (cmd))return nvmet_parse_fabrics_io_cmd (req); +if (unlikely (!nvmet_check_auth_status (req))) +return NVME_SC_AUTH_REQUIRED |NVME_SC_DNR ; + ret =nvmet_check_ctrl_status (req);if (unlikely (ret))return ret;
@@ -1275,6 +1279,11 @@ u16 nvmet_check_ctrl_status(struct nvmet_req *req) req->cmd->common.opcode, req->sq->qid);return NVME_SC_CMD_SEQ_ERROR |NVME_SC_DNR ; } + +if (unlikely (!nvmet_check_auth_status (req))) { +pr_warn ("qid %d not authenticated\n" , req->sq->qid); +return NVME_SC_AUTH_REQUIRED |NVME_SC_DNR ; + }return 0 ; }
@@ -1465,6 +1474,8 @@ static void nvmet_ctrl_free(struct kref *ref)flush_work (&ctrl->async_event_work);cancel_work_sync (&ctrl->fatal_err_work); +nvmet_destroy_auth (ctrl); +ida_free (&cntlid_ida, ctrl->cntlid);nvmet_async_events_free (ctrl);
drivers/nvme/target/fabrics-cmd-auth.c new file +491 -0
491 lines not on this page · raw message
drivers/nvme/target/fabrics-cmd.c +36 -2
@@ -93,6 +93,14 @@ u16 nvmet_parse_fabrics_admin_cmd(struct nvmet_req *req)case nvme_fabrics_type_property_get: req->execute = nvmet_execute_prop_get;break ; +#ifdef CONFIG_NVME_TARGET_AUTH +case nvme_fabrics_type_auth_send: + req->execute = nvmet_execute_auth_send; +break ; +case nvme_fabrics_type_auth_receive: + req->execute = nvmet_execute_auth_receive; +break ; +#endif default :pr_debug ("received unknown capsule type 0x%x\n" , cmd->fabrics.fctype);
@@ -108,6 +116,14 @@ u16 nvmet_parse_fabrics_io_cmd(struct nvmet_req *req)struct nvme_command *cmd = req->cmd;switch (cmd->fabrics.fctype) { +#ifdef CONFIG_NVME_TARGET_AUTH +case nvme_fabrics_type_auth_send: + req->execute = nvmet_execute_auth_send; +break ; +case nvme_fabrics_type_auth_receive: + req->execute = nvmet_execute_auth_receive; +break ; +#endif default :pr_debug ("received unknown capsule type 0x%x\n" , cmd->fabrics.fctype);
@@ -188,6 +204,7 @@ static void nvmet_execute_admin_connect(struct nvmet_req *req)struct nvmf_connect_data *d;struct nvmet_ctrl *ctrl =NULL ;u16 status =0 ; +int ret;if (!nvmet_check_transfer_len (req,sizeof (struct nvmf_connect_data )))return ;
@@ -230,18 +247,32 @@ static void nvmet_execute_admin_connect(struct nvmet_req *req)uuid_copy (&ctrl->hostid, &d->hostid); + ret =nvmet_setup_auth (ctrl); +if (ret <0 ) { +pr_err ("Failed to setup authentication, error %d\n" , ret); +nvmet_ctrl_put (ctrl); +if (ret == -EPERM ) + status = (NVME_SC_CONNECT_INVALID_HOST |NVME_SC_DNR ); +else + status =NVME_SC_INTERNAL ; + goto out; + } + status =nvmet_install_queue (ctrl, req);if (status) {nvmet_ctrl_put (ctrl); goto out; } -pr_info ("creating %s controller %d for subsystem %s for NQN %s%s.\n" , +pr_info ("creating %s controller %d for subsystem %s for NQN %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" :"" ); + ctrl->pi_support ?" T10-PI is enabled" :"" , +nvmet_has_auth (ctrl) ?" with DH-HMAC-CHAP" :"" ); req->cqe->result.u16 =cpu_to_le16 (ctrl->cntlid); +if (nvmet_has_auth (ctrl)) +nvmet_init_auth (ctrl, req); out:kfree (d); complete:
@@ -301,6 +332,9 @@ static void nvmet_execute_io_connect(struct nvmet_req *req) req->cqe->result.u16 =cpu_to_le16 (ctrl->cntlid);pr_debug ("adding queue %d to ctrl %d.\n" , qid, ctrl->cntlid); + req->cqe->result.u16 =cpu_to_le16 (ctrl->cntlid); +if (nvmet_has_auth (ctrl)) +nvmet_init_auth (ctrl, req); out:kfree (d);
drivers/nvme/target/nvmet.h +62 -0
84 lines not on this page · raw message
Signature · 1 line
2.29.2
Hannes Reinecke
maintainerPATCH v13 8/9 nvmet-auth: Diffie-Hellman key exchange support
In reply to Hannes ReineckeImplement Diffie-Hellman key exchange using FFDHE groups for NVMe In-Band Authentication.
This patch adds a new host configfs attribute 'dhchap_dhgroup' to select the FFDHE group to use.
--- drivers/nvme/target/Kconfig | 1 + drivers/nvme/target/auth.c | 157 +++++++++++++++++++++++++ drivers/nvme/target/configfs.c | 28 +++++ drivers/nvme/target/fabrics-cmd-auth.c | 40 +++++-- drivers/nvme/target/nvmet.h | 9 ++ 5 files changed, 227 insertions(+), 8 deletions(-)
drivers/nvme/target/Kconfig +1 -0
@@ -91,6 +91,7 @@ config NVME_TARGET_AUTH select CRYPTO_HMAC select CRYPTO_SHA256 select CRYPTO_SHA512 + select CRYPTO_DH_GROUPS_RFC7919 help This enables support for NVMe over Fabrics In-band Authentication
drivers/nvme/target/auth.c +157 -0
190 lines not on this page · raw message
drivers/nvme/target/configfs.c +28 -0
@@ -1744,10 +1744,38 @@ static ssize_t nvmet_host_dhchap_hash_store(struct config_item *item,CONFIGFS_ATTR (nvmet_host_, dhchap_hash); +static ssize_t nvmet_host_dhchap_dhgroup_show (struct config_item *item, +char *page) +{ +struct nvmet_host *host =to_host (item); +const char *dhgroup =nvme_auth_dhgroup_name (host->dhchap_dhgroup_id); + +return sprintf (page,"%s\n" , dhgroup ? dhgroup :"none" ); +} + +static ssize_t nvmet_host_dhchap_dhgroup_store (struct config_item *item, +const char *page,size_t count) +{ +struct nvmet_host *host =to_host (item); +int dhgroup_id; + + dhgroup_id =nvme_auth_dhgroup_id (page); +if (dhgroup_id ==NVME_AUTH_DHGROUP_INVALID ) +return -EINVAL ; +if (dhgroup_id !=NVME_AUTH_DHGROUP_NULL && + !nvme_auth_dhgroup_kpp (dhgroup_id)) +return -EINVAL ; + host->dhchap_dhgroup_id = dhgroup_id; +return count; +} + +CONFIGFS_ATTR (nvmet_host_, dhchap_dhgroup); +static struct configfs_attribute *nvmet_host_attrs[] = { &nvmet_host_attr_dhchap_key, &nvmet_host_attr_dhchap_ctrl_key, &nvmet_host_attr_dhchap_hash, + &nvmet_host_attr_dhchap_dhgroup,NULL , };#endif /* CONFIG_NVME_TARGET_AUTH */
drivers/nvme/target/fabrics-cmd-auth.c +32 -8
@@ -24,7 +24,7 @@ static u16 nvmet_auth_negotiate(struct nvmet_req *req, void *d) {struct nvmet_ctrl *ctrl = req->sq->ctrl;struct nvmf_auth_dhchap_negotiate_data *data = d; -int i, hash_id =0 , fallback_hash_id =0 , dhgid; +int i, hash_id =0 , fallback_hash_id =0 , dhgid, fallback_dhgid; pr_debug("%s: ctrl %d qid %d: data sc_d %d napd %d authid %d halen %d dhlen %d\n", __func__, ctrl->cntlid, req->sq->qid,
@@ -66,22 +66,32 @@ static u16 nvmet_auth_negotiate(struct nvmet_req *req, void *d) } dhgid =-1 ; + fallback_dhgid =-1 ;for (i =0 ; i < data->auth_protocol[0 ].dhchap.dhlen; i++) {int tmp_dhgid = data->auth_protocol[0 ].dhchap.idlist[i +30 ]; -if (tmp_dhgid ==NVME_AUTH_DHGROUP_NULL ) { +if (tmp_dhgid != ctrl->dh_gid) { dhgid = tmp_dhgid;break ; } +if (fallback_dhgid <0 && +nvme_auth_dhgroup_kpp (tmp_dhgid)) + fallback_dhgid = tmp_dhgid; }if (dhgid <0 ) { -pr_debug ("%s: ctrl %d qid %d: no usable DH group found\n" , +if (fallback_dhgid <0 ) { +pr_debug ("%s: ctrl %d qid %d: no usable DH group found\n" , __func__, ctrl->cntlid, req->sq->qid); -return NVME_AUTH_DHCHAP_FAILURE_DHGROUP_UNUSABLE ; +return NVME_AUTH_DHCHAP_FAILURE_DHGROUP_UNUSABLE ; + } +pr_debug ("%s: ctrl %d qid %d: configured DH group %s not found\n" , + __func__, ctrl->cntlid, req->sq->qid, +nvme_auth_dhgroup_name (fallback_dhgid)); + ctrl->dh_gid = fallback_dhgid; }pr_debug ("%s: ctrl %d qid %d: selected DH group %s (%d)\n" , __func__, ctrl->cntlid, req->sq->qid, -nvme_auth_dhgroup_name (dhgid), dhgid); +nvme_auth_dhgroup_name (ctrl->dh_gid), ctrl->dh_gid);return 0 ; }
@@ -97,7 +107,11 @@ static u16 nvmet_auth_reply(struct nvmet_req *req, void *d) data->hl, data->cvalid, dhvlen);if (dhvlen) { -return NVME_AUTH_DHCHAP_FAILURE_INCORRECT_PAYLOAD ; +if (!ctrl->dh_tfm) +return NVME_AUTH_DHCHAP_FAILURE_INCORRECT_PAYLOAD ; +if (nvmet_auth_ctrl_sesskey (req, data->rval +2 * data->hl, + dhvlen) <0 ) +return NVME_AUTH_DHCHAP_FAILURE_DHGROUP_UNUSABLE ; } response =kmalloc (data->hl,GFP_KERNEL );
@@ -325,6 +339,8 @@ static int nvmet_auth_challenge(struct nvmet_req *req, void *d, int al)int hash_len =nvme_auth_hmac_hash_len (ctrl->shash_id);int data_size =sizeof (*d) + hash_len; +if (ctrl->dh_tfm) + data_size += ctrl->dh_keysize;if (al < data_size) {pr_debug ("%s: buffer too small (al %d need %d)\n" , __func__, al, data_size);
@@ -343,9 +359,15 @@ static int nvmet_auth_challenge(struct nvmet_req *req, void *d, int al)return -ENOMEM ;get_random_bytes (req->sq->dhchap_c1, data->hl);memcpy (data->cval, req->sq->dhchap_c1, data->hl); -pr_debug ("%s: ctrl %d qid %d seq %u transaction %d hl %d dhvlen %u\n" , +if (ctrl->dh_tfm) { + data->dhgid = ctrl->dh_gid; + data->dhvlen =cpu_to_le32 (ctrl->dh_keysize); + ret =nvmet_auth_ctrl_exponential (req, data->cval + data->hl, + ctrl->dh_keysize); + } +pr_debug ("%s: ctrl %d qid %d seq %d transaction %d hl %d dhvlen %zu\n" , __func__, ctrl->cntlid, req->sq->qid, req->sq->dhchap_s1, - req->sq->dhchap_tid, data->hl,0 ); + req->sq->dhchap_tid, data->hl, ctrl->dh_keysize);return ret; }
@@ -463,6 +485,8 @@ void nvmet_execute_auth_receive(struct nvmet_req *req)break ; } req->sq->dhchap_step =NVME_AUTH_DHCHAP_MESSAGE_SUCCESS2 ; +if (!ctrl->ctrl_key) + req->sq->authenticated = true;break ;case NVME_AUTH_DHCHAP_MESSAGE_FAILURE1 :nvmet_auth_failure1 (req, d, al);
drivers/nvme/target/nvmet.h +9 -0
@@ -225,6 +225,10 @@ struct nvmet_ctrl {struct nvme_dhchap_key *host_key;struct nvme_dhchap_key *ctrl_key;u8 shash_id; +struct crypto_kpp *dh_tfm; +u8 dh_gid; +u8 *dh_key; +size_t dh_keysize;#endif };
@@ -701,6 +705,7 @@ int nvmet_setup_auth(struct nvmet_ctrl *ctrl);void nvmet_init_auth (struct nvmet_ctrl *ctrl,struct nvmet_req *req);void nvmet_destroy_auth (struct nvmet_ctrl *ctrl);void nvmet_auth_sq_free (struct nvmet_sq *sq); +int nvmet_setup_dhgroup (struct nvmet_ctrl *ctrl,u8 dhgroup_id);bool nvmet_check_auth_status (struct nvmet_req *req);int nvmet_auth_host_hash (struct nvmet_req *req,u8 *response,unsigned int hash_len);
@@ -710,6 +715,10 @@ static inline bool nvmet_has_auth(struct nvmet_ctrl *ctrl) {return ctrl->host_key !=NULL ; } +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);#else static inline int nvmet_setup_auth (struct nvmet_ctrl *ctrl) {
Signature · 1 line
2.29.2
Hannes Reinecke
maintainerPATCH v13 9/9 nvmet-auth: expire authentication sessions
In reply to Hannes ReineckeEach authentication step is required to be completed within the KATO interval (or two minutes if not set). So add a workqueue function to reset the transaction ID and the expected next protocol step; this will automatically the next authentication command referring to the terminated authentication.
--- drivers/nvme/target/auth.c | 1 + drivers/nvme/target/fabrics-cmd-auth.c | 20 +++++++++++++++++++- drivers/nvme/target/nvmet.h | 1 + 3 files changed, 21 insertions(+), 1 deletion(-)
drivers/nvme/target/auth.c +1 -0
@@ -216,6 +216,7 @@ int nvmet_setup_auth(struct nvmet_ctrl *ctrl)void nvmet_auth_sq_free (struct nvmet_sq *sq) { +cancel_delayed_work (&sq->auth_expired_work);kfree (sq->dhchap_c1); sq->dhchap_c1 =NULL ;kfree (sq->dhchap_c2);
drivers/nvme/target/fabrics-cmd-auth.c +19 -1
@@ -12,9 +12,22 @@#include "nvmet.h" #include "../host/auth.h" +static void nvmet_auth_expired_work (struct work_struct *work) +{ +struct nvmet_sq *sq =container_of (to_delayed_work (work), + struct nvmet_sq, auth_expired_work); + +pr_debug ("%s: ctrl %d qid %d transaction %u expired, resetting\n" , + __func__, sq->ctrl->cntlid, sq->qid, sq->dhchap_tid); + sq->dhchap_step =NVME_AUTH_DHCHAP_MESSAGE_NEGOTIATE ; + sq->dhchap_tid =-1 ; +} +void nvmet_init_auth (struct nvmet_ctrl *ctrl,struct nvmet_req *req) {/* Initialize in-band authentication */ +INIT_DELAYED_WORK (&req->sq->auth_expired_work, + nvmet_auth_expired_work); req->sq->authenticated = false; req->sq->dhchap_step =NVME_AUTH_DHCHAP_MESSAGE_NEGOTIATE ; req->cqe->result.u32 |=0x2 <<16 ;
@@ -323,8 +336,13 @@ void nvmet_execute_auth_send(struct nvmet_req *req) req->cqe->result.u64 =0 ;nvmet_req_complete (req, status);if (req->sq->dhchap_step !=NVME_AUTH_DHCHAP_MESSAGE_SUCCESS2 && - req->sq->dhchap_step !=NVME_AUTH_DHCHAP_MESSAGE_FAILURE2 ) + req->sq->dhchap_step !=NVME_AUTH_DHCHAP_MESSAGE_FAILURE2 ) { +unsigned long auth_expire_secs = ctrl->kato ? ctrl->kato :120 ; + +mod_delayed_work (system_wq, &req->sq->auth_expired_work, + auth_expire_secs *HZ );return ; + }/* Final states, clear up variables */ nvmet_auth_sq_free (req->sq);if (req->sq->dhchap_step ==NVME_AUTH_DHCHAP_MESSAGE_FAILURE2 )
drivers/nvme/target/nvmet.h +1 -0
@@ -109,6 +109,7 @@ struct nvmet_sq {u32 sqhd;bool sqhd_disabled;#ifdef CONFIG_NVME_TARGET_AUTH +struct delayed_work auth_expired_work;bool authenticated;u16 dhchap_tid;u16 dhchap_status;
Signature · 1 line
2.29.2
Quoted 16 lines · Hannes Reinecke
Hi all,
recent updates to the NVMe spec have added definitions for in-band authentication, and seeing that it provides some real benefit especially for NVMe-TCP here's an attempt to implement it.
Thanks to Nicolai Stange the crypto DH framework has been upgraded to provide us with a FFDHE implementation; I've updated the patchset to use the ephemeral key generation provided there.
Note that this is just for in-band authentication. Secure concatenation (ie starting TLS with the negotiated parameters) requires a TLS handshake, which the in-kernel TLS implementation does not provide. This is being worked on with a different patchset which is still WIP.
Quoted 9 lines
The nvme-cli support has already been merged; please use the latest nvme-cli git repository to build the most recent version.
A copy of this patchset can be found at
git://git.kernel.org/pub/scm/linux/kernel/git/hare/scsi-devel
branch auth.v13The patchset is being cut against v5.18.
After compiling the code I tried to disconnect the subsystem which doesn't exists "nvme disconnect -n testnqn" :-
# nvme --version nvme version 2.0 (git 2.0-96-g0b286b1) libnvme version 1.0 (git 1.0-62-gaacaeea)
<1>[ 195.267678] BUG: kernel NULL pointer dereference, address: 0000000000000068 <1>[ 195.269867] #PF: supervisor read access in kernel mode <1>[ 195.271369] #PF: error_code(0x0000) - not-present page <6>[ 195.272865] PGD 10387c067 P4D 10387c067 PUD 103a8b067 PMD 0 <4>[ 195.274522] Oops: 0000 [#1] PREEMPT SMP NOPTI <4>[ 195.275795] CPU: 38 PID: 2376 Comm: nvme Not tainted 5.18.0-rc3nvme+ #79 <4>[ 195.278258] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.14.0-0-g155821a1990b-prebuilt.qemu.org 04/01/2014 <4>[ 195.281560] RIP: 0010:nvme_ctrl_dhchap_ctrl_secret_show+0x16/0x40
[nvme_core]
<4>[ 195.289027] RSP: 0018:ffffc900054d7db8 EFLAGS: 00010282 <4>[ 195.290545] RAX: 0000000000000000 RBX: ffffffffc015f1e0 RCX: 0000000000000000 <4>[ 195.293140] RDX: ffff888178d01000 RSI: ffffffffc015f1e0 RDI: ffff888178d01000 <4>[ 195.295208] RBP: ffffffff822f7380 R08: ffff888103d782b8 R09: ffff8881036918b0 <4>[ 195.297272] R10: 0000000000020000 R11: 0000000000000000 R12: ffffc900054d7e80 <4>[ 195.299335] R13: ffffc900054d7e58 R14: ffff888104de1d48 R15: 0000000000000001 <4>[ 195.301401] FS: 00007f8fdba6dbc0(0000) GS:ffff888fffb80000(0000) knlGS:0000000000000000 <4>[ 195.303729] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 <4>[ 195.305396] CR2: 0000000000000068 CR3: 000000010e286000 CR4: 0000000000350ee0 <4>[ 195.307455] Call Trace: <4>[ 195.308693] <TASK> <4>[ 195.309324] dev_attr_show+0x19/0x40 <4>[ 195.310389] sysfs_kf_seq_show+0xa8/0xe0 <4>[ 195.311534] seq_read_iter+0x11c/0x4b0 <4>[ 195.312631] new_sync_read+0x106/0x180 <4>[ 195.313726] vfs_read+0x138/0x190 <4>[ 195.314697] ksys_read+0x5f/0xe0 <4>[ 195.315645] do_syscall_64+0x3b/0x90 <4>[ 195.316694] entry_SYSCALL_64_after_hwframe+0x44/0xae <4>[ 195.318162] RIP: 0033:0x7f8fdbe71702
<4>[ 195.324685] RSP: 002b:00007ffc70f31bd8 EFLAGS: 00000246 ORIG_RAX: 0000000000000000 <4>[ 195.326406] RAX: ffffffffffffffda RBX: 0000000000d10970 RCX: 00007f8fdbe71702 <4>[ 195.327864] RDX: 0000000000000fff RSI: 00007ffc70f31be0 RDI: 0000000000000003 <4>[ 195.329503] RBP: 00007ffc70f31be0 R08: 0000000000d10830 R09: 00007f8fdbf074e0 <4>[ 195.331139] R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000003 <4>[ 195.332770] R13: 00007f8fdba6daf0 R14: 0000000000d185a3 R15: 0000000000d104c0 <4>[ 195.334404] </TASK>
[38]kdb> bt
Stack traceback for pid 23760xffff8881249c0000 2376 2157 1 38 R 0xffff8881249c23c0 *nvme
CPU: 38 PID: 2376 Comm: nvme Not tainted 5.18.0-rc3nvme+ #79 Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS rel-1.14.0-0-g155821a1990b-prebuilt.qemu.org 04/01/2014 Call Trace: <TASK> dump_stack_lvl+0x45/0x5a kdb_show_stack+0x75/0x80 kdb_bt1+0xb7/0x130 kdb_bt+0x343/0x3b0 kdb_parse+0x2b7/0x6f0 kdb_main_loop+0x47e/0x8f0 kdb_stub+0x224/0x400 kgdb_cpu_enter+0x32d/0x5c0 kgdb_handle_exception+0xb6/0x100 __kgdb_notify+0x30/0x80 kgdb_notify+0x1d/0x30 notify_die+0x6f/0xb0 __die_body+0x7d/0x90 page_fault_oops+0xae/0x270 ? kernfs_fop_open+0x2a9/0x3c0 ? do_user_addr_fault+0x65/0x690 exc_page_fault+0x71/0x170 asm_exc_page_fault+0x1e/0x30 RIP: 0010:nvme_ctrl_dhchap_ctrl_secret_show+0x16/0x40 [nvme_core] Code: c6 78 61 15 c0 e8 5a ed 2e c1 48 98 c3 0f 1f 80 00 00 00 00 0f 1f
44 00 00 49 89 f8 48 89 d7 49 8b 40 78 48 8b 80 98 0b 00 00 <48> 8b 50 68 48 85 d2 74 0f 48 c7 c6 46 60 15 c0 e8 25 ed 2e c1 48
RSP: 0018:ffffc900054d7db8 EFLAGS: 00010282
RAX: 0000000000000000 RBX: ffffffffc015f1e0 RCX: 0000000000000000
RDX: ffff888178d01000 RSI: ffffffffc015f1e0 RDI: ffff888178d01000
RBP: ffffffff822f7380 R08: ffff888103d782b8 R09: ffff8881036918b0
R10: 0000000000020000 R11: 0000000000000000 R12: ffffc900054d7e80
R13: ffffc900054d7e58 R14: ffff888104de1d48 R15: 0000000000000001
? nvme_subsys_show_type+0x50/0x50 [nvme_core] dev_attr_show+0x19/0x40 sysfs_kf_seq_show+0xa8/0xe0 seq_read_iter+0x11c/0x4b0 new_sync_read+0x106/0x180 vfs_read+0x138/0x190 ksys_read+0x5f/0xe0 do_syscall_64+0x3b/0x90 entry_SYSCALL_64_after_hwframe+0x44/0xae RIP: 0033:0x7f8fdbe71702 Code: c0 e9 b2 fe ff ff 50 48 8d 3d ca 2a 0a 00 e8 b5 e8 01 00 0f 1f 44
00 00 f3 0f 1e fa 64 8b 04 25 18 00 00 00 85 c0 75 10 0f 05 <48> 3d 00 f0 ff ff 77 56 c3 0f 1f 44 00 00 48 83 ec 28 48 89 54 24
RSP: 002b:00007ffc70f31bd8 EFLAGS: 00000246 ORIG_RAX: 0000000000000000
RAX: ffffffffffffffda RBX: 0000000000d10970 RCX: 00007f8fdbe71702
RDX: 0000000000000fff RSI: 00007ffc70f31be0 RDI: 0000000000000003
RBP: 00007ffc70f31be0 R08: 0000000000d10830 R09: 00007f8fdbf074e0
R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000003
R13: 00007f8fdba6daf0 R14: 0000000000d185a3 R15: 0000000000d104c0
</TASK>
Quoted 30 lines
RIP: 0010:nvme_ctrl_dhchap_ctrl_secret_show+0x16/0x40 [nvme_core] Code: c6 78 61 15 c0 e8 5a ed 2e c1 48 98 c3 0f 1f 80 00 00 00 00 0f 1f44 00 00 49 89 f8 48 89 d7 49 8b 40 78 48 8b 80 98 0b 00 00 <48> 8b 50 68 48 85 d2 74 0f 48 c7 c6 46 60 15 c0 e8 25 ed 2e c1 48
RSP: 0018:ffffc900054d7db8 EFLAGS: 00010282
RAX: 0000000000000000 RBX:ffffffffc015f1e0RCX: 0000000000000000
RDX:ffff888178d01000RSI:ffffffffc015f1e0RDI:ffff888178d01000
RBP:ffffffff822f7380R08:ffff888103d782b8R09:ffff8881036918b0
R10: 0000000000020000 R11: 0000000000000000 R12:ffffc900054d7e80
R13:ffffc900054d7e58R14:ffff888104de1d48R15: 0000000000000001? nvme_subsys_show_type+0x50/0x50 [nvme_core] dev_attr_show+0x19/0x40 sysfs_kf_seq_show+0xa8/0xe0 seq_read_iter+0x11c/0x4b0 new_sync_read+0x106/0x180 vfs_read+0x138/0x190 ksys_read+0x5f/0xe0 do_syscall_64+0x3b/0x90 entry_SYSCALL_64_after_hwframe+0x44/0xae RIP: 0033:0x7f8fdbe71702 Code: c0 e9 b2 fe ff ff 50 48 8d 3d ca 2a 0a 00 e8 b5 e8 01 00 0f 1f 4400 00 f3 0f 1e fa 64 8b 04 25 18 00 00 00 85 c0 75 10 0f 05 <48> 3d 00 f0 ff ff 77 56 c3 0f 1f 44 00 00 48 83 ec 28 48 89 54 24
RSP: 002b:00007ffc70f31bd8 EFLAGS: 00000246ORIG_RAX: 0000000000000000
RAX: ffffffffffffffda RBX:0000000000d10970RCX:00007f8fdbe71702
RDX:0000000000000fffRSI:00007ffc70f31be0RDI: 0000000000000003
RBP:00007ffc70f31be0R08:0000000000d10830R09:00007f8fdbf074e0
R10: 0000000000000000 R11: 0000000000000246 R12: 0000000000000003
R13:00007f8fdba6daf0R14:0000000000d185a3R15:0000000000d104c0
Quoted 2 lines
</TASK>
Sent out a patch that fixes it, please have a look.