From: sashiko-bot@kernel.org
To: "Hannes Reinecke" <hare@kernel.org>
Cc: linux-nvme@lists.infradead.org
Subject: Re: [PATCH v4 6/9] nvme: allow to pass in key description as dhchap secret
Date: Fri, 20 Nov 2026 11:31:53 +0000 [thread overview]
Message-ID: <sashiko-outbox-225046@kernel.org> (raw)
In-Reply-To: <20261120-dhchap-keyring-v4-v4-6-5f8c7d9926ee@kernel.org>
Thank you for your contribution! Sashiko AI review found 9 potential
issues to consider:
- [High] nvme-fabrics: wrong key revoked in nvmf_free_options() for
dhchap_ctrl_key
- [High] nvme-auth: empty/prefix match and self-revocation in
nvme_auth_extract_key()
- [High] nvme-fabrics: link failure calling nvme_auth_extract_key()
without NVME_AUTH
- [Medium] nvme: unlocked access to dhchap keys and flags in sysfs show
callbacks
- [Medium] nvme: broken sysfs visibility for dhchap_key in
nvme_dev_attrs_are_visible()
- [Medium] nvme-auth: host_key leak and stale flags on
nvme_auth_init_ctrl() error
- [Medium] nvmet: memory leak of keydata buffer in
nvmet_host_dhchap_ctrl_key_store()
- [Low] nvme: unsigned count and missing newline in
dhchap_ctrl_secret_show()
- [Low] nvme-auth: missing keyring param in nvme_auth_extract_key()
kernel-doc
--
commit 2b7a36fa0b1a7939d6a4d7f1cdc10818701d7d40
Author: Hannes Reinecke <hare@kernel.org>
nvme: allow to pass in key description as dhchap secret
This commit updates nvme_auth_extract_key() to look up pre-populated
DH-HMAC-CHAP keys in the keyring before falling back to generating an
ephemeral key from raw secret material, and tracks whether keys were
auto-generated across the host and target drivers so only generated keys
are revoked on release.
> diff --git a/drivers/nvme/common/auth.c b/drivers/nvme/common/auth.c
> index b7092deed9b06..c65bfafe9e3fc 100644
> --- a/drivers/nvme/common/auth.c
> +++ b/drivers/nvme/common/auth.c
> @@ -143,20 +143,32 @@ EXPORT_SYMBOL_GPL(nvme_auth_hmac_hash_len);
> /**
> * nvme_auth_extract_key - extract the DH-HMAC-CHAP key
> *
> - * @secret: key data
> - * @secret_len: length of @secret
> + * @input: key serial or key data
> + * @input_len: length of @input
> + * @generated: indicate whether a key has been generated
> *
> - * Extracts a dhchap key from @secret.
> + * Extracts or generates a key from @input.
> + * @input can either be a key serial or raw key data; in
> + * the latter case a key is generated from @input and
> + * @generated is set to 'true'.
> *
> * Returns the dhchap key or an error pointer on failure.
> */
> -struct key *nvme_auth_extract_key(struct key *keyring, const char *secret,
> - size_t secret_len)
> +struct key *nvme_auth_extract_key(struct key *keyring, const char *input,
> + size_t input_len, bool *generated)
[Severity: Low]
The kernel-doc comment for nvme_auth_extract_key() omits the @keyring
parameter, which triggers a W=1 kernel-doc warning. Also, the comment and
commit message describe @input as a key serial number even though
nvme_dhchap_psk_lookup() searches by key description, and the prototype in
include/linux/nvme-auth.h still names the parameters secret and secret_len.
> {
> struct key *key;
>
> - key = nvme_dhchap_psk_create(keyring, secret, secret_len);
> + /* Check if @input is a key serial number */
> + key = nvme_dhchap_psk_lookup(keyring, input);
> if (!IS_ERR(key)) {
> + *generated = false;
> + return key;
> + }
> + /* Generate a key from @input data */
> + key = nvme_dhchap_psk_create(keyring, input, input_len);
> + if (!IS_ERR(key)) {
> + *generated = true;
> pr_debug("generated dhchap key %s\n",
> key->description);
> }
[Severity: High]
Can calling nvme_dhchap_psk_lookup() here match the wrong key, read out of
bounds, or cause the caller to revoke the key it just looked up?
nvme_dhchap_psk_lookup() searches with nvme_dhchap_psk_match():
drivers/nvme/common/keyring.c:nvme_dhchap_psk_match() {
...
match_id = match_data->raw_data;
match_len = strlen(match_id);
pr_debug("%s: match '%s' '%s' len %zd\n",
__func__, match_id, key->description, match_len);
return !memcmp(key->description, match_id, match_len);
}
Because nvme_dhchap_psk_match() compares match_len bytes with memcmp()
instead of strcmp(), and nvme_auth_extract_key() does not reject
input_len == 0:
1. Writing a single newline to sysfs dhchap_secret_store() or
dhchap_ctrl_secret_store() passes an empty string (match_len == 0), so
!memcmp(key->description, "", 0) matches the first dhchap key in the
keyring with *generated = false.
2. For non-empty inputs, memcmp() prefix-matches any key whose description
starts with input when match_len < strlen(key->description), and reads
past the end of the key->description allocation when match_len >
strlen(key->description) (for example, when passing a raw DHHC-1:...
secret while a key with a shorter description is in the keyring).
3. If nvme_dhchap_psk_lookup() returns the controller's or target host's
currently active auto-generated key (either via an empty write or by
writing the current key's UUID description to dhchap_secret_store(),
dhchap_ctrl_secret_store(), or nvmet_auth_set_key()), the store path
sees that old_key was auto-generated and calls key_revoke(old_key)
without checking key == old_key, revoking the key it then keeps active.
> diff --git a/drivers/nvme/host/auth.c b/drivers/nvme/host/auth.c
> index c189096f825ea..470a6e7e43644 100644
> --- a/drivers/nvme/host/auth.c
> +++ b/drivers/nvme/host/auth.c
[ ... ]
> @@ -1071,6 +1081,7 @@ int nvme_auth_init_ctrl(struct nvme_ctrl *ctrl)
> key_serial(ctrl->opts->dhchap_key));
> return -ENOKEY;
> }
> + ctrl->host_key_generated = ctrl->opts->dhchap_key_generated;
> down_read(&ctrl->host_key->sem);
> ret = key_validate(ctrl->host_key);
> up_read(&ctrl->host_key->sem);
> @@ -1097,6 +1108,8 @@ int nvme_auth_init_ctrl(struct nvme_ctrl *ctrl)
> key_serial(ctrl->opts->dhchap_ctrl_key));
> return -ENOKEY;
> }
> + ctrl->ctrl_key_generated =
> + ctrl->opts->dhchap_ctrl_key_generated;
> down_read(&ctrl->ctrl_key->sem);
> ret = key_validate(ctrl->ctrl_key);
> up_read(&ctrl->ctrl_key->sem);
[Severity: Medium]
If acquiring or validating ctrl->ctrl_key fails in nvme_auth_init_ctrl(),
does this leak ctrl->host_key and leave stale *_key_generated flags set?
On failure of key_get(ctrl->opts->dhchap_ctrl_key) or
key_validate(ctrl->ctrl_key), nvme_auth_init_ctrl() returns -ENOKEY or
-EKEYREVOKED without calling nvme_auth_clear_host_key(ctrl). In
nvme_init_ctrl(), a failure from nvme_auth_init_ctrl() jumps to
out_release_instance before device_initialize(&ctrl->ctrl_device), so
nvme_auth_free() never runs and the ctrl->host_key reference is leaked.
The error paths after setting ctrl->host_key_generated and
ctrl->ctrl_key_generated also clear the key pointer without resetting the
corresponding generated boolean to false.
> diff --git a/drivers/nvme/host/fabrics.c b/drivers/nvme/host/fabrics.c
> index 7ed8618257ca9..cd728768a68fc 100644
> --- a/drivers/nvme/host/fabrics.c
> +++ b/drivers/nvme/host/fabrics.c
[ ... ]
> @@ -1089,7 +1091,8 @@ static int nvmf_parse_options(struct nvmf_ctrl_options *opts,
> if (host_secret) {
> pr_debug("lookup host identity '%s'\n", host_secret);
> key = nvme_auth_extract_key(opts->keyring, host_secret,
> - strlen(host_secret));
> + strlen(host_secret),
> + &opts->dhchap_key_generated);
> if (IS_ERR(key)) {
> ret = PTR_ERR(key);
> goto out;
> @@ -1104,7 +1107,8 @@ static int nvmf_parse_options(struct nvmf_ctrl_options *opts,
> }
> pr_debug("lookup ctrl identity '%s'\n", ctrl_secret);
> key = nvme_auth_extract_key(opts->keyring, ctrl_secret,
> - strlen(ctrl_secret));
> + strlen(ctrl_secret),
> + &opts->dhchap_ctrl_key_generated);
> if (IS_ERR(key)) {
> ret = PTR_ERR(key);
> goto out;
[Severity: High]
Does calling nvme_auth_extract_key() unconditionally in nvmf_parse_options()
break linking when CONFIG_NVME_FABRICS is enabled without CONFIG_NVME_AUTH?
CONFIG_NVME_FABRICS does not select CONFIG_NVME_AUTH, and
include/linux/nvme-auth.h does not provide a !CONFIG_NVME_AUTH stub for
nvme_auth_extract_key(), so builds with CONFIG_NVME_HOST_AUTH disabled (or
CONFIG_NVME_FABRICS=y and CONFIG_NVME_AUTH=m) fail to link.
> @@ -1327,15 +1331,23 @@ void nvmf_free_options(struct nvmf_ctrl_options *opts)
> kfree(opts->host_traddr);
> kfree(opts->host_iface);
> if (opts->dhchap_key) {
> - pr_debug("revoke dhchap host key %08x\n",
> + if (opts->dhchap_key_generated) {
> + pr_debug("revoke dhchap host key %08x\n",
> + key_serial(opts->dhchap_key));
> + key_revoke(opts->dhchap_key);
> + }
> + pr_debug("drop dhchap host key %08x\n",
> key_serial(opts->dhchap_key));
> - key_revoke(opts->dhchap_key);
> key_put(opts->dhchap_key);
> }
> if (opts->dhchap_ctrl_key) {
> - pr_debug("revoke dhchap ctrl key %08x\n",
> + if (opts->dhchap_ctrl_key_generated) {
> + pr_debug("revoke dhchap ctrl key %08x\n",
> + key_serial(opts->dhchap_ctrl_key));
> + key_revoke(opts->dhchap_key);
> + }
> + pr_debug("drop dhchap ctrl key %08x\n",
> key_serial(opts->dhchap_ctrl_key));
> - key_revoke(opts->dhchap_key);
> key_put(opts->dhchap_ctrl_key);
> }
> kfree(opts);
[Severity: High]
In the opts->dhchap_ctrl_key block, should key_revoke(opts->dhchap_key) be
key_revoke(opts->dhchap_ctrl_key)?
Passing opts->dhchap_key here accesses it after key_put(opts->dhchap_key)
has already dropped the reference (risking a use-after-free), revokes a
pre-populated host key when only the controller key was auto-generated, and
leaves the auto-generated opts->dhchap_ctrl_key unrevoked.
> diff --git a/drivers/nvme/host/sysfs.c b/drivers/nvme/host/sysfs.c
> index 1311f5e29b004..47caed2ce3978 100644
> --- a/drivers/nvme/host/sysfs.c
> +++ b/drivers/nvme/host/sysfs.c
> @@ -828,13 +828,14 @@ static ssize_t dhchap_secret_show(struct device *dev,
> down_read(&key->sem);
> if (key_validate(key))
> count = sysfs_emit(buf, "<invalidated>\n");
> - else {
> + else if (ctrl->host_key_generated) {
> count = key->type->read(key, buf, PAGE_SIZE);
> if (count > 0) {
> buf[count] = '\n';
> count++;
> }
> - }
> + } else
> + count = sysfs_emit(buf, "%s\n", key->description);
> up_read(&key->sem);
> return count;
> }
[ ... ]
> @@ -869,19 +872,25 @@ static ssize_t dhchap_secret_store(struct device *dev,
> up_read(&key->sem);
> if (ret) {
> dev_warn(ctrl->dev, "key %08x invalidated\n", key_serial(key));
> - dev_dbg(ctrl->dev, "revoke host key %08x\n", key_serial(key));
> - key_revoke(key);
> + if (generated) {
> + dev_dbg(ctrl->dev, "revoke host key %08x\n", key_serial(key));
> + key_revoke(key);
> + synchronize_rcu();
> + }
> key_put(key);
> kfree_sensitive(dhchap_secret);
> return ret;
> }
> mutex_lock(&ctrl->dhchap_auth_mutex);
> old_key = ctrl->host_key;
> - dev_dbg(ctrl->dev, "revoke host key %08x\n",
> - key_serial(old_key));
> - key_revoke(old_key);
> -
> + if (ctrl->host_key_generated) {
> + dev_dbg(ctrl->dev, "revoke host key %08x\n",
> + key_serial(old_key));
> + key_revoke(old_key);
> + synchronize_rcu();
> + }
> ctrl->host_key = key;
> + ctrl->host_key_generated = generated;
> mutex_unlock(&ctrl->dhchap_auth_mutex);
> key_put(old_key);
> kfree_sensitive(dhchap_secret);
[Severity: Medium]
Can dhchap_secret_show(), dhchap_ctrl_secret_show(), dhchap_key_show(), and
dhchap_ctrl_key_show() race with concurrent stores and trigger a
use-after-free or read a mismatched *_key_generated flag?
Unlike nvmet_host_dhchap_key_show() in drivers/nvme/target/configfs.c, the
host sysfs show callbacks read ctrl->host_key / ctrl->ctrl_key and
ctrl->host_key_generated / ctrl->ctrl_key_generated without holding
ctrl->dhchap_auth_mutex or pinning the key with key_get():
CPU0 CPU1
dhchap_secret_show() dhchap_secret_store()
key = ctrl->host_key;
mutex_lock(&ctrl->dhchap_auth_mutex);
old_key = ctrl->host_key;
ctrl->host_key = new_key;
ctrl->host_key_generated = true;
mutex_unlock(&ctrl->dhchap_auth_mutex);
key_put(old_key);
down_read(&key->sem); <-- use-after-free
Even if old_key still has another reference (such as when old_key was a
pre-populated user key in the keyring), CPU0 can pair old_key with the newly
written ctrl->host_key_generated == true and dump the pre-populated key's
raw secret via key->type->read() instead of its description.
> @@ -906,13 +915,14 @@ static ssize_t dhchap_ctrl_secret_show(struct device *dev,
> down_read(&key->sem);
> if (key_validate(key))
> count = sysfs_emit(buf, "<invalidated>");
> - else {
> + else if (ctrl->ctrl_key_generated) {
> count = key->type->read(key, buf, PAGE_SIZE);
> if (count > 0) {
> buf[count] = '\n';
> count++;
> }
> - }
> + } else
> + count = sysfs_emit(buf, "%s\n", key->description);
> up_read(&key->sem);
> return count;
> }
[Severity: Low]
In dhchap_ctrl_secret_show(), count is declared as unsigned size_t (unlike
ssize_t in dhchap_secret_show()), so a negative error return from
key->type->read() would wrap to a large positive value, pass count > 0, and
write out of bounds at buf[count] = '\n'. Also,
sysfs_emit(buf, "<invalidated>") is missing the trailing '\n' present in the
other show callbacks.
[ ... ]
> @@ -1066,8 +1088,12 @@ static umode_t nvme_dev_attrs_are_visible(struct kobject *kobj,
> #ifdef CONFIG_NVME_HOST_AUTH
> if (a == &dev_attr_dhchap_secret.attr && !ctrl->opts)
> return 0;
> + if (a == &dev_attr_dhchap_key.attr && ctrl->host_key_generated)
> + return 0;
> if (a == &dev_attr_dhchap_ctrl_secret.attr && !ctrl->opts)
> return 0;
> + if (a == &dev_attr_dhchap_ctrl_key.attr && ctrl->ctrl_key_generated)
> + return 0;
> #endif
>
> return a->mode;
[Severity: Medium]
Should the visibility checks for dev_attr_dhchap_key.attr and
dev_attr_dhchap_ctrl_key.attr also check !ctrl->opts, and how is attribute
visibility updated when keys change at runtime?
Without a !ctrl->opts check, dhchap_key and dhchap_ctrl_key are exposed in
sysfs on non-Fabrics controllers (such as PCIe controllers, where
ctrl->opts is NULL and the *_key_generated fields are false) even though
dhchap_secret and dhchap_ctrl_secret are hidden. In addition, because
nvme_dev_attrs_are_visible() is only evaluated when the sysfs group is
created and dhchap_secret_store() / dhchap_ctrl_secret_store() do not call
sysfs_update_group(), switching a controller at runtime between an
auto-generated secret and a pre-populated key description leaves dhchap_key
and dhchap_ctrl_key stuck in their initial visibility state.
> diff --git a/drivers/nvme/target/configfs.c b/drivers/nvme/target/configfs.c
> index 880cf5151588a..319947aa0a40f 100644
> --- a/drivers/nvme/target/configfs.c
> +++ b/drivers/nvme/target/configfs.c
[ ... ]
> @@ -2305,13 +2306,14 @@ static ssize_t nvmet_host_dhchap_ctrl_key_show(struct config_item *item,
> down_read(&key->sem);
> if (key_validate(key))
> ret = sprintf(page, "<invalidated>\n");
> - else {
> + else if (host->dhchap_ctrl_key_generated) {
> ret = key->type->read(key, page, PAGE_SIZE);
> if (ret > 0) {
> page[ret] = '\n';
> ret++;
> }
> - }
> + } else
> + ret = sprintf(page, "%s\n", key->description);
> up_read(&key->sem);
> key_put(key);
> }
[Severity: Medium]
Does nvmet_host_dhchap_ctrl_key_store() just below this function leak
keydata on every write?
drivers/nvme/target/configfs.c:nvmet_host_dhchap_ctrl_key_store() {
...
keydata = kstrndup(page, len, GFP_KERNEL);
if (!keydata)
return -ENOMEM;
ret = nvmet_auth_set_key(host, keydata, true);
...
return ret < 0 ? ret : count;
}
Unlike nvmet_host_dhchap_key_store(), which calls kfree_sensitive(keydata)
after nvmet_auth_set_key(), nvmet_host_dhchap_ctrl_key_store() returns
without freeing keydata, leaking the buffer and leaving key material in slab
memory.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261120-dhchap-keyring-v4-v4-0-5f8c7d9926ee@kernel.org?part=6
next prev parent reply other threads:[~2026-11-20 11:31 UTC|newest]
Thread overview: 30+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-20 11:13 [PATCH v4 0/9] nvme-auth: switch to use the kernel keyring Hannes Reinecke
2026-11-20 11:14 ` [PATCH v4 1/9] nvme-auth: modify nvme_auth_transform_key() to return status Hannes Reinecke
2026-11-20 11:19 ` sashiko-bot
2026-11-20 11:42 ` Hannes Reinecke
2026-11-20 11:14 ` [PATCH v4 2/9] nvme-keyring: add 'dhchap' key type Hannes Reinecke
2026-11-20 11:28 ` sashiko-bot
2026-11-20 12:28 ` Hannes Reinecke
2026-11-20 11:14 ` [PATCH v4 3/9] nvme-auth: switch to use 'struct key' Hannes Reinecke
2026-11-20 11:31 ` sashiko-bot
2026-11-20 13:08 ` Hannes Reinecke
2026-11-20 19:24 ` kernel test robot
2026-11-20 19:37 ` kernel test robot
2026-11-20 11:14 ` [PATCH v4 4/9] nvme: parse dhchap keys during option parsing Hannes Reinecke
2026-11-20 11:32 ` sashiko-bot
2026-11-20 13:55 ` Hannes Reinecke
2026-11-20 11:14 ` [PATCH v4 5/9] nvmet-auth: parse dhchap key from configfs attribute Hannes Reinecke
2026-11-20 11:28 ` sashiko-bot
2026-11-20 14:15 ` Hannes Reinecke
2026-11-20 11:14 ` [PATCH v4 6/9] nvme: allow to pass in key description as dhchap secret Hannes Reinecke
2026-11-20 11:31 ` sashiko-bot [this message]
2026-11-20 14:48 ` Hannes Reinecke
2026-11-20 11:14 ` [PATCH v4 7/9] nvme-auth: wait for authentication to finish when changing keys Hannes Reinecke
2026-11-20 11:26 ` sashiko-bot
2026-11-20 14:52 ` Hannes Reinecke
2026-11-20 11:14 ` [PATCH v4 8/9] nvme-fabrics: allow to pass in keyring by name Hannes Reinecke
2026-11-20 11:37 ` sashiko-bot
2026-11-20 15:02 ` Hannes Reinecke
2026-11-20 11:14 ` [PATCH v4 9/9] nvmet: add configfs attribute 'dhchap_keyring' Hannes Reinecke
2026-11-20 11:39 ` sashiko-bot
2026-11-20 15:27 ` Hannes Reinecke
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=sashiko-outbox-225046@kernel.org \
--to=sashiko-bot@kernel.org \
--cc=hare@kernel.org \
--cc=linux-nvme@lists.infradead.org \
--cc=sashiko-reviews@lists.linux.dev \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.