../libnvme/src/nvme/crypto.c

Bug Summary

File:	.build-ci/../libnvme/src/nvme/crypto.c
Warning:	line 1160, column 11 Potential leak of memory pointed to by 'identity'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-redhat-linux-gnu -O3 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name crypto.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/__w/nvme-cli/nvme-cli/.build-ci -fcoverage-compilation-dir=/__w/nvme-cli/nvme-cli/.build-ci -resource-dir /usr/bin/../lib/clang/22 -include /__w/nvme-cli/nvme-cli/.build-ci/nvme-config.h -I libnvme/src/libnvme3.so.1.0.0.p -I libnvme/src -I ../libnvme/src -I ccan -I ../ccan -I . -I .. -D _FILE_OFFSET_BITS=64 -D _GNU_SOURCE -U NDEBUG -internal-isystem /usr/bin/../lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/16/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -std=gnu11 -ferror-limit 19 -fvisibility=hidden -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-opt-analyze-headers -analyzer-output=html -faddrsig -fdwarf2-cfi-asm -o /__w/nvme-cli/nvme-cli/.build-ci/scan-results/2026-09-23-073103-589-1 -x c ../libnvme/src/nvme/crypto.c
1// SPDX-License-Identifier: LGPL-2.1-or-later
2/*
* This file is part of libnvme.
* Copyright (c) 2020 Western Digital Corporation or its affiliates.
*
* Authors: Keith Busch <keith.busch@wdc.com>
* 	    Chaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
*/

10#include <arpa/inet.h>
11#include <errno(*__errno_location ()).h>
12#include <fcntl.h>
13#include <stdio.h>
14#include <stdlib.h>
15#include <string.h>
16#include <unistd.h>

18#if NVME_HAVE_SYS_RANDOM1
19#include <sys/random.h>
20#endif
21#include <sys/param.h>
22#include <sys/stat.h>

24#ifdef CONFIG_OPENSSL
25#include <openssl/evp.h>
26#include <openssl/hmac.h>
27#include <openssl/kdf.h>
28#include <openssl/core_names.h>
29#include <openssl/params.h>
30#endif

32#ifdef CONFIG_KEYUTILS
33#include <keyutils.h>

35#define NVME_TLS_DEFAULT_KEYRING".nvme" ".nvme"
36#endif

38#include <ccan/endian/endian.h>

40#include <shared/base64-util.h>
41#include <shared/crc32-util.h>
42#include <shared/hex-util.h>
43#include <shared/compiler-attributes-util.h>

45#include <libnvme.h>

47#include "cleanup.h"
48#include "cleanup-linux.h"
49#include "private.h"


52#ifndef CONFIG_OPENSSL
53static unsigned char default_hmac(size_t key_len)
54{
return LIBNVMF_HMAC_ALG_NONE;
56}

58__shr_public__attribute__((visibility("default"))) int libnvmf_gen_kxchap_key(struct libnvme_global_ctx *ctx,
char *hostnqn, enum libnvmf_hmac_alg hmac,
unsigned int key_len, unsigned char *secret,
unsigned char *key)
62{
if (hmac != LIBNVMF_HMAC_ALG_NONE) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "HMAC transformation not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "HMAC transformation not supported; "
 "recompile with OpenSSL support.\n")
	"recompile with OpenSSL support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "HMAC transformation not supported; "
 "recompile with OpenSSL support.\n");
return -EINVAL22;
}

memcpy(key, secret, key_len);
return 0;
71}

73__shr_public__attribute__((visibility("default"))) int libnvmf_create_raw_secret(struct libnvme_global_ctx *ctx,
const char *secret, size_t key_len, unsigned char **raw_secret)
75{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "NVMe TLS is not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "NVMe TLS is not supported; "
 "recompile with OpenSSL support.\n")
 "recompile with OpenSSL support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "NVMe TLS is not supported; "
 "recompile with OpenSSL support.\n");
return -ENOTSUP95;
79}

81static int derive_retained_key(struct libnvme_global_ctx *ctx,
int hmac, const char *hostnqn, unsigned char *generated,
unsigned char *retained, size_t key_len)
84{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "NVMe TLS is not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "NVMe TLS is not supported; "
 "recompile with OpenSSL support.\n")
 "recompile with OpenSSL support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "NVMe TLS is not supported; "
 "recompile with OpenSSL support.\n");
return -ENOTSUP95;
88}

90static int derive_retained_key_compat(struct libnvme_global_ctx *ctx,
int hmac, const char *hostnqn, unsigned char *generated,
unsigned char *retained, size_t key_len)
93{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "NVMe TLS is not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "NVMe TLS is not supported; "
 "recompile with OpenSSL support.\n")
 "recompile with OpenSSL support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "NVMe TLS is not supported; "
 "recompile with OpenSSL support.\n");
return -ENOTSUP95;
97}

99static int derive_psk_digest(struct libnvme_global_ctx *ctx,
const char *hostnqn, const char *subsysnqn,
int version, int cipher,
unsigned char *retained, size_t key_len,
char *digest, size_t digest_len)
104{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "TLS PSK identity version 1 is not "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "TLS PSK identity version 1 is not "
 "supported; recompile with OpenSSL support.\n")
 "supported; recompile with OpenSSL support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "TLS PSK identity version 1 is not "
 "supported; recompile with OpenSSL support.\n");
return -ENOTSUP95;
108}

110static int derive_tls_key(struct libnvme_global_ctx *ctx,
int version, unsigned char cipher, const char *context,
unsigned char *retained, unsigned char *psk, size_t key_len)
113{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "NVMe TLS is not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "NVMe TLS is not supported; "
 "recompile with OpenSSL support.\n")
 "recompile with OpenSSL support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "NVMe TLS is not supported; "
 "recompile with OpenSSL support.\n");
return -ENOTSUP95;
117}

119static int derive_tls_key_compat(struct libnvme_global_ctx *ctx,
int version, unsigned char cipher, const char *context,
unsigned char *retained, unsigned char *psk, size_t key_len)
122{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "NVMe TLS is not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "NVMe TLS is not supported; "
 "recompile with OpenSSL support.\n")
 "recompile with OpenSSL support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "NVMe TLS is not supported; "
 "recompile with OpenSSL support.\n");
return -ENOTSUP95;
126}
127#else /* CONFIG_OPENSSL */
128static unsigned char default_hmac(size_t key_len)
129{
unsigned char hmac = LIBNVMF_HMAC_ALG_NONE;

switch (key_len) {
case 32:
hmac = LIBNVMF_HMAC_ALG_SHA2_256;
break;
case 48:
hmac = LIBNVMF_HMAC_ALG_SHA2_384;
break;
case 64:
hmac = LIBNVMF_HMAC_ALG_SHA2_512;
break;
default:
break;
}
return hmac;
146}

148static const EVP_MD *select_hmac(int hmac, size_t *hmac_len)
149{
const EVP_MD *md = NULL((void*)0);

switch (hmac) {
case LIBNVMF_HMAC_ALG_SHA2_256:
md = EVP_sha256();
*hmac_len = 32;
break;
case LIBNVMF_HMAC_ALG_SHA2_384:
md = EVP_sha384();
*hmac_len = 48;
break;
default:
*hmac_len = 0;
break;
}
return md;
166}

168static DEFINE_CLEANUP_FUNC(void cleanup_evp_pkey_ctx(EVP_PKEY_CTX * *__p) { if (*__p) EVP_PKEY_CTX_free
(*__p); }
cleanup_evp_pkey_ctx, EVP_PKEY_CTX *, EVP_PKEY_CTX_free)void cleanup_evp_pkey_ctx(EVP_PKEY_CTX * *__p) { if (*__p) EVP_PKEY_CTX_free
(*__p); }
170#define __cleanup_evp_pkey_ctx__attribute__((cleanup(cleanup_evp_pkey_ctx))) __cleanup(cleanup_evp_pkey_ctx)__attribute__((cleanup(cleanup_evp_pkey_ctx)))

172/* NVMe is using the TLS 1.3 HkdfLabel structure */
173#define HKDF_INFO_MAX_LEN514 514
174#define HKDF_INFO_LABEL_MAX256 256
175#define HKDF_INFO_CONTEXT_MAX256 256

177/*
* derive_retained_key()
*
* Derive a retained PSK according to the NVMe TCP Transport
* Specification 1.3, section 3.6.1.3:
*
* The retained PSK is derived from the configured PSK. The configured PSK
* shall be destroyed as soon as the retained PSK is generated and stored.
* Each NVMe/TCP entity shall support:
* 1) transforming the configured PSK into a retained PSK before it is stored
*    by the NVMe/TCP entity for repeated use with another NVMe/TCP entity; and
* 2) using the configured PSK as a retained PSK.
*
* The method to derive a retained PSK from a configured PSK shall be using
* the HKDF-Extract and HKDF-Expand-Label operations (refer to RFC 5869 and
* RFC 8446):
* 1. PRK = HKDF-Extract(0, Configured PSK); and
* 2. Retained PSK = HKDF-Expand-Label(PRK, “HostNQN”, NQNh,
*                                     Length(Configured PSK)),
* where NQNh is the NQN of the host.
*
* 'hmac' indicates the hash function to be used to transform the configured
* PSK in a retained PSK, encoded as follows:
*
* - 0 indicates no transform (i.e., the configured PSK is used as a
*   retained PSK)
* - 1 indicates SHA-256
* - 2 indicates SHA-384
*/
206static int derive_retained_key(struct libnvme_global_ctx *ctx,
int hmac, const char *hostnqn,
unsigned char *configured, unsigned char *retained,
size_t key_len)
210{
__cleanup_evp_pkey_ctx__attribute__((cleanup(cleanup_evp_pkey_ctx))) EVP_PKEY_CTX *ectx = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) uint8_t *hkdf_info = NULL((void*)0);
char *hkdf_label;
const EVP_MD *md;
size_t hmac_len;
char *pos;
int ret;

/* +1 byte so that the snprintf terminating null can not overflow */
hkdf_info = malloc(HKDF_INFO_MAX_LEN514 + 1);
if (!hkdf_info)
return -ENOMEM12;

if (hmac == LIBNVMF_HMAC_ALG_NONE) {
memcpy(retained, configured, key_len);
return key_len;
}

md = select_hmac(hmac, &hmac_len);
if (!md || !hmac_len)
return -EINVAL22;

ectx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF1036, NULL((void*)0));
if (!ectx)
return -ENOMEM12;

if (EVP_PKEY_derive_init(ectx) <= 0)
return -ENOMEM12;

if (EVP_PKEY_CTX_set_hkdf_md(ectx, md) <= 0)
return -ENOKEY126;

if (EVP_PKEY_CTX_set1_hkdf_key(ectx, configured, key_len) <= 0)
return -ENOKEY126;

if (key_len > USHRT_MAX(32767 * 2 + 1))
return -EINVAL22;

pos = (char *)hkdf_info;
*(uint16_t *)pos = htons(key_len & 0xFFFF)__bswap_16 (key_len & 0xFFFF);
pos += sizeof(uint16_t);

hkdf_label = "tls13 HostNQN";
ret = snprintf(pos, HKDF_INFO_LABEL_MAX256 + 1, "%c%s",
       (int)strlen(hkdf_label), hkdf_label);
if (ret <= 0 || ret > HKDF_INFO_LABEL_MAX256)
return -ENOKEY126;
pos += ret;

ret = snprintf(pos, HKDF_INFO_CONTEXT_MAX256 + 1, "%c%s",
       (int)strlen(hostnqn), hostnqn);
if (ret <= 0 || ret > HKDF_INFO_CONTEXT_MAX256)
return -ENOKEY126;
pos += ret;

if (EVP_PKEY_CTX_add1_hkdf_info(ectx, hkdf_info,
			(pos - (char *)hkdf_info)) <= 0)
return -ENOKEY126;

if (EVP_PKEY_derive(ectx, retained, &key_len) <= 0)
return -ENOKEY126;

return key_len;
274}

276static int derive_retained_key_compat(struct libnvme_global_ctx *ctx,
int hmac, const char *hostnqn, unsigned char *configured,
unsigned char *retained, size_t key_len)
279{
__cleanup_evp_pkey_ctx__attribute__((cleanup(cleanup_evp_pkey_ctx))) EVP_PKEY_CTX *ectx = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) uint8_t *hkdf_info = NULL((void*)0);
const EVP_MD *md;
size_t hmac_len;
char *pos;
int ret;

if (hmac == LIBNVMF_HMAC_ALG_NONE) {
memcpy(retained, configured, key_len);
return key_len;
}

md = select_hmac(hmac, &hmac_len);
if (!md || !hmac_len)
return -EINVAL22;

ectx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF1036, NULL((void*)0));
if (!ectx)
return -ENOMEM12;

if (EVP_PKEY_derive_init(ectx) <= 0)
return -ENOMEM12;

if (EVP_PKEY_CTX_set_hkdf_md(ectx, md) <= 0)
return -ENOKEY126;

if (EVP_PKEY_CTX_set1_hkdf_key(ectx, configured, key_len) <= 0)
return -ENOKEY126;

/* +1 byte so that the snprintf terminating null can not overflow */
hkdf_info = malloc(HKDF_INFO_MAX_LEN514 + 1);
if (!hkdf_info)
return -ENOMEM12;

pos = (char *)hkdf_info;
*(uint16_t *)pos = cpu_to_le16(key_len);
pos += sizeof(uint16_t);

ret = snprintf(pos, HKDF_INFO_LABEL_MAX256 + 1,
       "tls13 HostNQN%s", hostnqn);
if (ret <= 0 || ret > HKDF_INFO_LABEL_MAX256)
return -ENOKEY126;
pos += ret;

if (EVP_PKEY_CTX_add1_hkdf_info(ectx, hkdf_info,
			(pos - (char *)hkdf_info)) <= 0)
return -ENOKEY126;

if (EVP_PKEY_derive(ectx, retained, &key_len) <= 0)
return -ENOKEY126;

return key_len;
332}

334/*
* derive_tls_key()
*
* Derive a TLS PSK from a retained PSK.
*
* The TLS PSK shall be derived as follows from an input PSK (i.e., either
* a retained PSK or a generated PSK) and a PSK identity using the HKDF-Extract
* and HKDF-Expand-Label operations (refer to RFC 5869 and RFC 8446) where the
* hash function is the one specified by the hash specifier of the PSK identity:
* 1. PRK = HKDF-Extract(0, Input PSK); and
* 2. TLS PSK = HKDF-Expand-Label(PRK, “nvme-tls-psk”, PskIdentity, L),
* where PskIdentity is the PSK identity and L is the output size in bytes of
* the hash function (i.e., 32 for SHA-256 and 48 for SHA-384).
*
* Note that this is _not_ the hash value as specified by the configured PSK,
* but rather the hash function of the cipher suite associated with the
* PSK:
* - 1 indicates SHA-256 (for the TLS_AES_128_GCM_SHA256 cipher suite)
* - 2 indicates SHA-384 (for the TLS_AES_256_GCM_SHA384 cipher suite)
*
* and the value '0' is invalid here.
*/

357static int derive_tls_key(struct libnvme_global_ctx *ctx,
int version, unsigned char cipher, const char *context,
unsigned char *retained, unsigned char *psk, size_t key_len)
360{
__cleanup_evp_pkey_ctx__attribute__((cleanup(cleanup_evp_pkey_ctx))) EVP_PKEY_CTX *ectx = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) uint8_t *hkdf_info = NULL((void*)0);
char *hkdf_label;
const EVP_MD *md;
size_t hmac_len;
char *pos;
int ret;

/* +1 byte so that the snprintf terminating null can not overflow */
hkdf_info = malloc(HKDF_INFO_MAX_LEN514 + 1);
if (!hkdf_info)
return -ENOMEM12;

md = select_hmac(cipher, &hmac_len);
if (!md || !hmac_len)
return -EINVAL22;

ectx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF1036, NULL((void*)0));
if (!ectx)
return -ENOMEM12;

if (EVP_PKEY_derive_init(ectx) <= 0)
return -ENOMEM12;

if (EVP_PKEY_CTX_set_hkdf_md(ectx, md) <= 0)
return -ENOKEY126;

if (EVP_PKEY_CTX_set1_hkdf_key(ectx, retained, key_len) <= 0)
return -ENOKEY126;

if (key_len > USHRT_MAX(32767 * 2 + 1))
return -EINVAL22;

pos = (char *)hkdf_info;
*(uint16_t *)pos = htons(key_len & 0xFFFF)__bswap_16 (key_len & 0xFFFF);
pos += sizeof(uint16_t);

hkdf_label = "tls13 nvme-tls-psk";
ret = snprintf(pos, HKDF_INFO_LABEL_MAX256 + 1, "%c%s",
       (int)strlen(hkdf_label), hkdf_label);
if (ret <= 0 || ret > HKDF_INFO_LABEL_MAX256)
return -ENOKEY126;
pos += ret;

switch (version) {
case 0:
ret = snprintf(pos, HKDF_INFO_CONTEXT_MAX256 + 1, "%c%s",
	       (int)strlen(context), context);
if (ret <= 0 || ret > HKDF_INFO_CONTEXT_MAX256)
	return -ENOKEY126;
pos += ret;
break;
case 1:
ret = snprintf(pos, HKDF_INFO_CONTEXT_MAX256 + 1, "%c%02d %s",
	       (int)strlen(context) + 3, cipher, context);
if (ret <= 0 || ret > HKDF_INFO_CONTEXT_MAX256)
	return -ENOKEY126;
pos += ret;
break;
default:
return -ENOKEY126;
}

if (EVP_PKEY_CTX_add1_hkdf_info(ectx, hkdf_info,
			(pos - (char *)hkdf_info)) <= 0)
return -ENOKEY126;

if (EVP_PKEY_derive(ectx, psk, &key_len) <= 0)
return -ENOKEY126;

return key_len;
432}

434static int derive_tls_key_compat(struct libnvme_global_ctx *ctx,
int version, unsigned char cipher, const char *context,
unsigned char *retained, unsigned char *psk, size_t key_len)
437{
__cleanup_evp_pkey_ctx__attribute__((cleanup(cleanup_evp_pkey_ctx))) EVP_PKEY_CTX *ectx = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) uint8_t *hkdf_info = NULL((void*)0);
const EVP_MD *md;
size_t hmac_len;
char *pos;
int ret;

md = select_hmac(cipher, &hmac_len);
if (!md || !hmac_len)
return -EINVAL22;

ectx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF1036, NULL((void*)0));
if (!ectx)
return -ENOMEM12;

if (EVP_PKEY_derive_init(ectx) <= 0)
return -ENOMEM12;

if (EVP_PKEY_CTX_set_hkdf_md(ectx, md) <= 0)
return -ENOKEY126;

if (EVP_PKEY_CTX_set1_hkdf_key(ectx, retained, key_len) <= 0)
return -ENOKEY126;

/* +1 byte so that the snprintf terminating null can not overflow */
hkdf_info = malloc(HKDF_INFO_MAX_LEN514 + 1);
if (!hkdf_info)
return -ENOMEM12;

pos = (char *)hkdf_info;
*(uint16_t *)pos = cpu_to_le16(key_len);
pos += sizeof(uint16_t);

ret = snprintf(pos, HKDF_INFO_LABEL_MAX256 + 1, "tls13 nvme-tls-psk");
if (ret <= 0 || ret > HKDF_INFO_LABEL_MAX256)
return -ENOKEY126;
pos += ret;

switch (version) {
case 0:
ret = snprintf(pos, HKDF_INFO_CONTEXT_MAX256 + 1, "%s", context);
if (ret <= 0 || ret > HKDF_INFO_CONTEXT_MAX256)
	return -ENOKEY126;
pos += ret;
break;
case 1:
ret = snprintf(pos, HKDF_INFO_CONTEXT_MAX256 + 1, "%02d %s",
	       cipher, context);
if (ret <= 0 || ret > HKDF_INFO_CONTEXT_MAX256)
	return -ENOKEY126;
pos += ret;
break;
default:
return -ENOKEY126;
}

if (EVP_PKEY_CTX_add1_hkdf_info(ectx, hkdf_info,
			(pos - (char *)hkdf_info)) <= 0)
return -ENOKEY126;

if (EVP_PKEY_derive(ectx, psk, &key_len) <= 0)
return -ENOKEY126;

return key_len;
502}

504static DEFINE_CLEANUP_FUNC(void cleanup_ossl_lib_ctx(OSSL_LIB_CTX * *__p) { if (*__p) OSSL_LIB_CTX_free
(*__p); }
cleanup_ossl_lib_ctx, OSSL_LIB_CTX *, OSSL_LIB_CTX_free)void cleanup_ossl_lib_ctx(OSSL_LIB_CTX * *__p) { if (*__p) OSSL_LIB_CTX_free
(*__p); }
506#define __cleanup_ossl_lib_ctx__attribute__((cleanup(cleanup_ossl_lib_ctx))) __cleanup(cleanup_ossl_lib_ctx)__attribute__((cleanup(cleanup_ossl_lib_ctx)))
507static DEFINE_CLEANUP_FUNC(cleanup_evp_mac_ctx, EVP_MAC_CTX *, EVP_MAC_CTX_free)void cleanup_evp_mac_ctx(EVP_MAC_CTX * *__p) { if (*__p) EVP_MAC_CTX_free
(*__p); }
508#define __cleanup_evp_mac_ctx__attribute__((cleanup(cleanup_evp_mac_ctx))) __cleanup(cleanup_evp_mac_ctx)__attribute__((cleanup(cleanup_evp_mac_ctx)))
509static DEFINE_CLEANUP_FUNC(cleanup_evp_mac, EVP_MAC *, EVP_MAC_free)void cleanup_evp_mac(EVP_MAC * *__p) { if (*__p) EVP_MAC_free
(*__p); }
510#define __cleanup_evp_mac__attribute__((cleanup(cleanup_evp_mac))) __cleanup(cleanup_evp_mac)__attribute__((cleanup(cleanup_evp_mac)))

512__shr_public__attribute__((visibility("default"))) int libnvmf_gen_kxchap_key(struct libnvme_global_ctx *ctx,
char *hostnqn, enum libnvmf_hmac_alg hmac,
unsigned int key_len, unsigned char *secret,
unsigned char *key)
516{
const char hmac_seed[] = "NVMe-over-Fabrics";
__cleanup_ossl_lib_ctx__attribute__((cleanup(cleanup_ossl_lib_ctx))) OSSL_LIB_CTX *lib_ctx = NULL((void*)0);
__cleanup_evp_mac_ctx__attribute__((cleanup(cleanup_evp_mac_ctx))) EVP_MAC_CTX *mac_ctx = NULL((void*)0);
__cleanup_evp_mac__attribute__((cleanup(cleanup_evp_mac))) EVP_MAC *mac = NULL((void*)0);
OSSL_PARAM params[2], *p = params;
char *progq = NULL((void*)0);
char *digest;
size_t len;

lib_ctx = OSSL_LIB_CTX_new();
if (!lib_ctx)
return -ENOMEM12;

mac = EVP_MAC_fetch(lib_ctx, OSSL_MAC_NAME_HMAC"HMAC", progq);
if (!mac)
return -ENOMEM12;

mac_ctx = EVP_MAC_CTX_new(mac);
if (!mac_ctx)
return -ENOMEM12;

switch (hmac) {
case LIBNVMF_HMAC_ALG_NONE:
memcpy(key, secret, key_len);
return 0;
case LIBNVMF_HMAC_ALG_SHA2_256:
digest = OSSL_DIGEST_NAME_SHA2_256"SHA2-256";
break;
case LIBNVMF_HMAC_ALG_SHA2_384:
digest = OSSL_DIGEST_NAME_SHA2_384"SHA2-384";
break;
case LIBNVMF_HMAC_ALG_SHA2_512:
digest = OSSL_DIGEST_NAME_SHA2_512"SHA2-512";
break;
default:
return -EINVAL22;
}
*p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST"digest",
				digest,
				0);
*p = OSSL_PARAM_construct_end();

if (!EVP_MAC_init(mac_ctx, secret, key_len, params))
return -ENOKEY126;

if (!EVP_MAC_update(mac_ctx, (unsigned char *)hostnqn,
	    strlen(hostnqn)))
return -ENOKEY126;

if (!EVP_MAC_update(mac_ctx, (unsigned char *)hmac_seed,
	    strlen(hmac_seed)))
return -ENOKEY126;

if (!EVP_MAC_final(mac_ctx, key, &len, key_len))
return -ENOKEY126;

if (len != key_len)
return -EMSGSIZE90;

return 0;
577}

579static int derive_psk_digest(struct libnvme_global_ctx *ctx,
const char *hostnqn, const char *subsysnqn,
int version, int cipher,
unsigned char *retained, size_t key_len,
char *digest, size_t digest_len)
584{
static const char hmac_seed[] = "NVMe-over-Fabrics";
__cleanup_ossl_lib_ctx__attribute__((cleanup(cleanup_ossl_lib_ctx))) OSSL_LIB_CTX *lib_ctx = NULL((void*)0);
__cleanup_evp_mac_ctx__attribute__((cleanup(cleanup_evp_mac_ctx))) EVP_MAC_CTX *mac_ctx = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) unsigned char *psk_ctx = NULL((void*)0);
__cleanup_evp_mac__attribute__((cleanup(cleanup_evp_mac))) EVP_MAC *mac = NULL((void*)0);
OSSL_PARAM params[2], *p = params;
size_t hmac_len;
char *progq = NULL((void*)0);
char *dig = NULL((void*)0);
int len;

lib_ctx = OSSL_LIB_CTX_new();
if (!lib_ctx)
return -ENOMEM12;

mac = EVP_MAC_fetch(lib_ctx, OSSL_MAC_NAME_HMAC"HMAC", progq);
if (!mac)
return -ENOMEM12;

mac_ctx = EVP_MAC_CTX_new(mac);
if (!mac_ctx)
return -ENOMEM12;

switch (cipher) {
case LIBNVMF_HMAC_ALG_SHA2_256:
dig = OSSL_DIGEST_NAME_SHA2_256"SHA2-256";
break;
case LIBNVMF_HMAC_ALG_SHA2_384:
dig = OSSL_DIGEST_NAME_SHA2_384"SHA2-384";
break;
default:
return -EINVAL22;
}

*p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST"digest",
				dig, 0);
*p = OSSL_PARAM_construct_end();

psk_ctx = malloc(key_len);
if (!psk_ctx)
return -ENOMEM12;

if (!EVP_MAC_init(mac_ctx, retained, key_len, params))
return -ENOKEY126;

if (!EVP_MAC_update(mac_ctx, (unsigned char *)hostnqn,
	    strlen(hostnqn)))
return -ENOKEY126;

if (!EVP_MAC_update(mac_ctx, (unsigned char *)" ", 1))
return -ENOKEY126;

if (!EVP_MAC_update(mac_ctx, (unsigned char *)subsysnqn,
	    strlen(subsysnqn)))
return -ENOKEY126;

if (!EVP_MAC_update(mac_ctx, (unsigned char *)" ", 1))
return -ENOKEY126;

if (!EVP_MAC_update(mac_ctx, (unsigned char *)hmac_seed,
	    strlen(hmac_seed)))
return -ENOKEY126;

if (!EVP_MAC_final(mac_ctx, psk_ctx, &hmac_len, key_len))
return -ENOKEY126;

if (hmac_len > key_len)
return -EMSGSIZE90;

if (hmac_len * 2 > digest_len)
return -EINVAL22;

memset(digest, 0, digest_len);
len = shr_base64_encode(psk_ctx, hmac_len, digest);
if (len < 0)
return len;

return strlen(digest);
663}

665static ssize_t getrandom_bytes(void *buf, size_t buflen)
666{
ssize_t result;
668#if NVME_HAVE_SYS_RANDOM1
result = getrandom(buf, buflen, GRND_NONBLOCK0x01);
670#else
__cleanup_fd__attribute__((cleanup(shr_cleanup_fd))) int fd = -1;

fd = open("/dev/urandom", O_RDONLY00);
if (fd < 0)
return -errno(*__errno_location ());
result = read(fd, buf, buflen);
677#endif
if (result < 0)
return -errno(*__errno_location ());
return result;
681}

683static ssize_t getswordfish(struct libnvme_global_ctx *ctx,
const char *seed, void *buf, size_t buflen)
685{
unsigned char hash[EVP_MAX_MD_SIZE64];
unsigned int counter = 0;
EVP_MD_CTX *md_ctx;
size_t copied = 0;

md_ctx = EVP_MD_CTX_new();
if (!md_ctx)
return -ENOMEM12;

while (copied < buflen) {
beint32_t be_counter;
unsigned int hash_len;
size_t to_copy;

if (EVP_DigestInit_ex(md_ctx, EVP_sha256(), NULL((void*)0)) != 1)
	goto err;

be_counter = cpu_to_be32(counter);

EVP_DigestUpdate(md_ctx, seed, strlen(seed));
EVP_DigestUpdate(md_ctx, &be_counter, sizeof(be_counter));

if (EVP_DigestFinal_ex(md_ctx, hash, &hash_len) != 1)
	goto err;

to_copy = buflen - copied;
if (to_copy > hash_len)
	to_copy = hash_len;

memcpy((unsigned char *)buf + copied, hash, to_copy);
copied += to_copy;
counter++;
}

EVP_MD_CTX_free(md_ctx);
return buflen;

723err:
EVP_MD_CTX_free(md_ctx);
return -EIO5;
726}

728__shr_public__attribute__((visibility("default"))) int libnvmf_create_raw_secret(struct libnvme_global_ctx *ctx,
const char *secret, size_t key_len, unsigned char **raw_secret)
730{
__cleanup_free__attribute__((cleanup(shr_freep))) unsigned char *buf = NULL((void*)0);
int secret_len = 0, i, err;

if (key_len != 32 && key_len != 48 && key_len != 64) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Invalid key length %zu"
, key_len)
	"Invalid key length %zu", key_len)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Invalid key length %zu"
, key_len);
return -EINVAL22;
}

buf = malloc(key_len);
if (!buf)
return -ENOMEM12;

if (!secret) {
err = getrandom_bytes(buf, key_len);
if (err < 0)
	return err;

goto out;
}

if (strlen(secret) < 4) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "Input secret too short\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Input secret too short\n"
);
return -EINVAL22;
}

if (!strncmp(secret, "pin:", 4)) {
err = getswordfish(ctx, &secret[4], buf, key_len);
if (err < 0)
	return err;

goto out;
}

for (i = 0; i < strlen(secret); i += 2) {
int hi = shr_hex_to_int(secret[i]);
int lo = shr_hex_to_int(secret[i + 1]);

if (hi < 0 || lo < 0) {
	libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Invalid secret '%s'"
, secret)
		"Invalid secret '%s'", secret)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Invalid secret '%s'"
, secret);
	return -EINVAL22;
}
if (i >= key_len * 2) {
	libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Skipping excess secret bytes\n"
)
		"Skipping excess secret bytes\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Skipping excess secret bytes\n"
);
	break;
}
buf[secret_len++] = (unsigned char)(hi << 4 | lo);
}
if (secret_len != key_len) {
libnvme_msg(ctx, LIBNVME_LOG_ERR,__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Invalid key length (%d bytes)\n"
, secret_len)
	"Invalid key length (%d bytes)\n", secret_len)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "Invalid key length (%d bytes)\n"
, secret_len);
return -EINVAL22;
}

787out:
*raw_secret = buf;
buf = NULL((void*)0);
return 0;
791}

793#endif /* CONFIG_OPENSSL */

795static int gen_tls_identity(const char *hostnqn, const char *subsysnqn,
	    int version, int cipher, char *digest,
	    char *identity)
798{
if (version == 0) {
sprintf(identity, "NVMe%01dR%02d %s %s",
	version, cipher, hostnqn, subsysnqn);
return strlen(identity);
}
if (version > 1 || !digest)
return -EINVAL22;

sprintf(identity, "NVMe%01dR%02d %s %s %s",
version, cipher, hostnqn, subsysnqn, digest);
return strlen(identity);
810}

812static int derive_nvme_keys(struct libnvme_global_ctx *ctx,
const char *hostnqn, const char *subsysnqn,
char *identity, int version,
int hmac, unsigned char *configured,
unsigned char *psk, int key_len, bool_Bool compat)
817{
__cleanup_free__attribute__((cleanup(shr_freep))) unsigned char *retained = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) char *digest = NULL((void*)0);
char *context = identity;
unsigned char cipher;
int ret = -1;

if (!hostnqn || !subsysnqn || !identity || !psk)
return -EINVAL22;

retained = malloc(key_len);
if (!retained)
return -ENOMEM12;

if (compat)
ret = derive_retained_key_compat(ctx, hmac, hostnqn, configured,
				 retained, key_len);
else
ret = derive_retained_key(ctx, hmac, hostnqn, configured,
			  retained, key_len);
if (ret < 0)
return ret;

if (hmac == LIBNVMF_HMAC_ALG_NONE)
cipher = default_hmac(key_len);
else
cipher = hmac;

if (version == 1) {
size_t digest_len = 2 * key_len;

digest = malloc(digest_len);
if (!digest)
	return -ENOMEM12;

ret = derive_psk_digest(ctx, hostnqn, subsysnqn, version,
			cipher, retained, key_len, digest,
			digest_len);
if (ret < 0)
	return ret;
context = digest;
}
ret = gen_tls_identity(hostnqn, subsysnqn, version, cipher,
	       digest, identity);
if (ret < 0)
return ret;
if (compat)
return derive_tls_key_compat(ctx, version, cipher, context,
	retained, psk, key_len);
return derive_tls_key(ctx, version, cipher, context, retained,
	psk, key_len);
868}

870static ssize_t nvme_identity_len(int hmac, int version, const char *hostnqn,
		 const char *subsysnqn)
872{
ssize_t len;

if (!hostnqn || !subsysnqn)
return -EINVAL22;

len = strlen(hostnqn) + strlen(subsysnqn) + 12;
if (version == 1) {
len += 66;
if (hmac == LIBNVMF_HMAC_ALG_SHA2_384)
	len += 32;
} else if (version > 1) {
return -EINVAL22;
}
return len;
887}

889__shr_public__attribute__((visibility("default"))) int libnvmf_generate_tls_key_identity(
struct libnvme_global_ctx *ctx, const char *hostnqn,
const char *subsysnqn, int version, enum libnvmf_hmac_alg hmac,
unsigned char *configured_key, int key_len, char **ident)
893{
__cleanup_free__attribute__((cleanup(shr_freep))) unsigned char *psk = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) char *identity = NULL((void*)0);
ssize_t identity_len;
int ret;

identity_len = nvme_identity_len(hmac, version, hostnqn, subsysnqn);
if (identity_len < 0)
return -EINVAL22;

identity = malloc(identity_len);
if (!identity)
return -ENOMEM12;

psk = malloc(key_len);
if (!psk)
return -ENOMEM12;

memset(psk, 0, key_len);
ret = derive_nvme_keys(ctx, hostnqn, subsysnqn, identity, version, hmac,
	       configured_key, psk, key_len, false0);
if (ret != key_len) {
if (ret < 0)
	return ret;
return -ENOKEY126;
}

*ident = identity;
identity = NULL((void*)0);

return 0;
924}

926__shr_public__attribute__((visibility("default"))) int libnvmf_generate_tls_key_identity_compat(
struct libnvme_global_ctx *ctx, const char *hostnqn,
const char *subsysnqn, int version, enum libnvmf_hmac_alg hmac,
unsigned char *configured_key, int key_len, char **ident)
930{
__cleanup_free__attribute__((cleanup(shr_freep))) unsigned char *psk = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) char *identity = NULL((void*)0);
ssize_t identity_len;
int ret;

identity_len = nvme_identity_len(hmac, version, hostnqn, subsysnqn);
if (identity_len < 0)
return -EINVAL22;

identity = malloc(identity_len);
if (!identity)
return -ENOMEM12;

psk = malloc(key_len);
if (!psk)
return -ENOMEM12;

memset(psk, 0, key_len);
ret = derive_nvme_keys(ctx, hostnqn, subsysnqn, identity, version, hmac,
	       configured_key, psk, key_len, true1);
if (ret != key_len) {
if (ret < 0)
	return ret;
return -ENOKEY126;
}

*ident = identity;
identity = NULL((void*)0);

return 0;
961}

963#ifdef CONFIG_KEYUTILS
964__shr_public__attribute__((visibility("default"))) int libnvmf_lookup_keyring(
struct libnvme_global_ctx *ctx, const char *keyring, long *key)
966{
key_serial_t keyring_id;

if (!keyring)
keyring = NVME_TLS_DEFAULT_KEYRING".nvme";
keyring_id = find_key_by_type_and_desc("keyring", keyring, 0);
if (keyring_id < 0)
return -errno(*__errno_location ());

*key = keyring_id;
return 0;
977}

979__shr_public__attribute__((visibility("default"))) char *libnvmf_describe_key_serial(
struct libnvme_global_ctx *ctx, long key_id)
981{
__cleanup_free__attribute__((cleanup(shr_freep))) char *str = NULL((void*)0);
char *last;

if (keyctl_describe_alloc(key_id, &str) < 0)
return NULL((void*)0);

last = strrchr(str, ';')_Generic (0 ? (str) : (void *) 1, const void *: (const char *
) (strrchr (str, ';')), default: strrchr (str, ';'));
if (!last)
return NULL((void*)0);

last++;
if (strlen(last) == 0)
return NULL((void*)0);

return strdup(last);
997}

999__shr_public__attribute__((visibility("default"))) int libnvmf_lookup_key(
struct libnvme_global_ctx *ctx, const char *type,
const char *identity, long *keyp)
1002{
key_serial_t key;

key = keyctl_search(KEY_SPEC_SESSION_KEYRING-3, type, identity, 0);
if (key < 0)
return -errno(*__errno_location ());

*keyp = key;
return 0;
1011}

1013__shr_public__attribute__((visibility("default"))) int libnvmf_set_keyring(
struct libnvme_global_ctx *ctx, long key_id)
1015{
long err;

if (key_id == 0) {
if (libnvmf_lookup_keyring(ctx, NULL((void*)0), &key_id))
	return -ENOKEY126;
}

err = keyctl_link(key_id, KEY_SPEC_SESSION_KEYRING-3);
if (err < 0)
return -errno(*__errno_location ());
return 0;
1027}

1029__shr_public__attribute__((visibility("default"))) int libnvmf_read_key(
struct libnvme_global_ctx *ctx, long keyring_id, long key_id,
int *len, unsigned char **key)
1032{
void *buffer;
int ret;

ret = libnvmf_set_keyring(ctx, keyring_id);
if (ret < 0)
return ret;

ret = keyctl_read_alloc(key_id, &buffer);
if (ret < 0)
return ret;

*len = ret;
*key = buffer;
return 0;
1047}

1049__shr_public__attribute__((visibility("default"))) int libnvmf_update_key(
struct libnvme_global_ctx *ctx, long keyring_id,
const char *key_type, const char *identity,
unsigned char *key_data, int key_len, long *keyp)
1053{
long key;

key = keyctl_search(keyring_id, key_type, identity, 0);
if (key > 0) {
if (keyctl_revoke(key) < 0)
	return -errno(*__errno_location ());
}
key = add_key(key_type, identity,
      key_data, key_len, keyring_id);
if (key < 0)
return -errno(*__errno_location ());

*keyp = key;
return 0;
1068}

1070struct __scan_keys_data {
struct libnvme_global_ctx *ctx;
libnvmf_scan_tls_keys_cb_t cb;
key_serial_t keyring;
void *data;
1075};

1077int __scan_keys_cb(key_serial_t parent, key_serial_t key, char *desc,
int desc_len, void *data)
1079{
struct __scan_keys_data *d = data;
int ver, hmac, uid, gid, perm;
char type, *ptr;

if (desc_len < 6)
return 0;
if (sscanf(desc, "psk;%d;%d;%08x;NVMe%01d%c%02d %*s",
   &uid, &gid, &perm, &ver, &type, &hmac) != 6)
return 0;
/* skip key type */
ptr = strchr(desc, ';')_Generic (0 ? (desc) : (void *) 1, const void *: (const char *
) (strchr (desc, ';')), default: strchr (desc, ';'));
if (!ptr)
return 0;
/* skip key uid */
ptr = strchr(ptr + 1, ';')_Generic (0 ? (ptr + 1) : (void *) 1, const void *: (const char
 *) (strchr (ptr + 1, ';')), default: strchr (ptr + 1, ';'));
if (!ptr)
return 0;
/* skip key gid */
ptr = strchr(ptr + 1, ';')_Generic (0 ? (ptr + 1) : (void *) 1, const void *: (const char
 *) (strchr (ptr + 1, ';')), default: strchr (ptr + 1, ';'));
if (!ptr)
return 0;
/* skip key permissions */
ptr = strchr(ptr + 1, ';')_Generic (0 ? (ptr + 1) : (void *) 1, const void *: (const char
 *) (strchr (ptr + 1, ';')), default: strchr (ptr + 1, ';'));
if (!ptr)
return 0;
/* Only use the key description for the callback */
(d->cb)(d->ctx, d->keyring, key, ptr + 1, strlen(ptr) - 1, d->data);
return 1;
1108}

1110__shr_public__attribute__((visibility("default"))) int libnvmf_scan_tls_keys(
struct libnvme_global_ctx *ctx, const char *keyring,
libnvmf_scan_tls_keys_cb_t cb, void *data)
1113{
struct __scan_keys_data d;
long keyring_id = 0;
int ret;

ret = libnvmf_lookup_keyring(ctx, keyring, &keyring_id);
if (ret)
return ret;

if (!keyring_id)
return -EINVAL22;

ret = libnvmf_set_keyring(ctx, keyring_id);
if (ret < 0)
return ret;

d.ctx = ctx;
d.keyring = keyring_id;
d.cb = cb;
d.data = data;
ret = recursive_key_scan(keyring_id, __scan_keys_cb, &d);
return ret;
1135}

1137static int __nvme_insert_tls_key(struct libnvme_global_ctx *ctx,
key_serial_t keyring_id, const char *key_type,
const char *hostnqn, const char *subsysnqn,
int version, int hmac, unsigned char *configured_key,
int key_len, bool_Bool compat, long *keyp)
1142{
__cleanup_free__attribute__((cleanup(shr_freep))) unsigned char *psk = NULL((void*)0);
__cleanup_free__attribute__((cleanup(shr_freep))) char *identity = NULL((void*)0);
ssize_t identity_len;
long key = 0;
int ret;

identity_len = nvme_identity_len(hmac, version, hostnqn, subsysnqn);
if (identity_len < 0)
5
←
Assuming 'identity_len' is >= 0→
6
←
Taking false branch→
return identity_len;

identity = malloc(identity_len);
7
←
Memory is allocated→
if (!identity)
8
←
Assuming 'identity' is non-null→
9
←
Taking false branch→
return -ENOMEM12;
memset(identity, 0, identity_len);

psk = malloc(key_len);
if (!psk)
10
←
Assuming 'psk' is null→
11
←
Taking true branch→
return -ENOMEM12;
12
←
Potential leak of memory pointed to by 'identity'
memset(psk, 0, key_len);
ret = derive_nvme_keys(ctx, hostnqn, subsysnqn, identity, version, hmac,
	       configured_key, psk, key_len, compat);
if (ret != key_len) {
if (ret < 0)
	return ret;
return -ENOKEY126;
}

ret = libnvmf_update_key(ctx, keyring_id, key_type, identity,
	      psk, key_len, &key);
if (ret)
return ret;

*keyp = key;
return 0;
1177}

1179__shr_public__attribute__((visibility("default"))) int libnvmf_insert_tls_key_versioned(
struct libnvme_global_ctx *ctx,
const char *keyring, const char *key_type,
const char *hostnqn, const char *subsysnqn,
int version, enum libnvmf_hmac_alg hmac,
unsigned char *configured_key, int key_len,
long *key)
1186{
long keyring_id = 0;
int ret;

ret = libnvmf_lookup_keyring(ctx, keyring, &keyring_id);
if (ret1.1
'ret' is 0
)
2
←
Taking false branch→
return ret;

ret = libnvmf_set_keyring(ctx, keyring_id);
if (ret2.1
'ret' is >= 0
 < 0)
3
←
Taking false branch→
return ret;

return __nvme_insert_tls_key(ctx, keyring_id, key_type,
4
←
Calling '__nvme_insert_tls_key'→
hostnqn, subsysnqn, version, hmac,
configured_key, key_len, false0, key);
1201}

1203__shr_public__attribute__((visibility("default"))) int libnvmf_insert_tls_key_compat(
struct libnvme_global_ctx *ctx,
const char *keyring, const char *key_type,
const char *hostnqn, const char *subsysnqn,
int version, enum libnvmf_hmac_alg hmac,
unsigned char *configured_key, int key_len,
long *key)
1210{
long keyring_id = 0;
int ret;

ret = libnvmf_lookup_keyring(ctx, keyring, &keyring_id);
if (ret)
return ret;

ret = libnvmf_set_keyring(ctx, keyring_id);
if (ret < 0)
return ret;

return __nvme_insert_tls_key(ctx, keyring_id, key_type,
hostnqn, subsysnqn, version, hmac,
configured_key, key_len, true1, key);
1225}

1227__shr_public__attribute__((visibility("default"))) int libnvmf_revoke_tls_key(struct libnvme_global_ctx *ctx,
const char *keyring, const char *key_type,
const char *identity)
1230{
long keyring_id = 0, key;
int ret;

ret = libnvmf_lookup_keyring(ctx, keyring, &keyring_id);
if (ret)
return ret;

key = keyctl_search(keyring_id, key_type, identity, 0);
if (key < 0)
return -errno(*__errno_location ());

key = keyctl_revoke(key);
if (key < 0)
return -errno(*__errno_location ());

return 0;
1247}

1249static int __nvme_import_tls_key(struct libnvme_global_ctx *ctx, long keyring_id,
const char *hostnqn, const char *subsysnqn,
const char *identity, const char *key,
long *keyp)
1253{
__cleanup_free__attribute__((cleanup(shr_freep))) unsigned char *key_data = NULL((void*)0);
unsigned char version;
enum libnvmf_hmac_alg hmac;
size_t key_len;
int ret;

ret = libnvmf_import_tls_key_versioned(ctx, key, &version,
			    &hmac, &key_len, &key_data);
if (ret)
return ret;

if (hmac == LIBNVMF_HMAC_ALG_NONE || !identity) {
/*
 * This is a configured PSK (hmac 0) or we don't know the
 * identity and so the assumption is it is also a
 * configured PSK. Derive a TLS PSK from it and load the
 * newly created key into the keystore.
 */
return __nvme_insert_tls_key(ctx, keyring_id, "psk",
	hostnqn, subsysnqn, version, hmac,
	key_data, key_len, false0, keyp);
}

return libnvmf_update_key(ctx, keyring_id, "psk", identity,
	      key_data, key_len, keyp);
1279}

1281int __libnvmf_import_keys_from_config(struct libnvme_host *h, struct libnvme_ctrl *c,
long *keyring_id, long *key_id)
1283{
const char *hostnqn = libnvme_host_get_hostnqn(h);
const char *subsysnqn = libnvme_ctrl_get_subsysnqn(c);
const char *keyring, *key, *identity;
long kr_id = 0, id = 0;
int ret;

if (!hostnqn || !subsysnqn) {
libnvme_msg(h->ctx, LIBNVME_LOG_ERR, "Invalid NQNs (%s, %s)\n",__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "Invalid NQNs (%s, %s)\n"
, hostnqn, subsysnqn)
	 hostnqn, subsysnqn)__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "Invalid NQNs (%s, %s)\n"
, hostnqn, subsysnqn);
return -EINVAL22;
}

/* If we don't have a key avoid all keyring operations */
key = libnvme_ctrl_get_tls_key(c);
if (!key)
goto out;

if (libnvme_ctrl_get_keyring(c, &keyring, NULL((void*)0)) == 0) {
ret = libnvmf_lookup_keyring(h->ctx, keyring, &kr_id);
if (ret)
	return ret;
} else
kr_id = c->cfg.keyring_id;

/*
* Fallback to the default keyring. This makes the keyring
* explicit on the ctrl rather than left unset, which matters
* to anything downstream that inspects this connection's
* parameters.
*/
if (!kr_id) {
ret = libnvmf_lookup_keyring(h->ctx, ".nvme", &kr_id);
if (ret)
	return ret;
}

if (libnvmf_set_keyring(h->ctx, kr_id) < 0) {
libnvme_msg(h->ctx, LIBNVME_LOG_ERR, "Failed to set keyring\n")__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to set keyring\n"
);
return -errno(*__errno_location ());
}

identity = libnvme_ctrl_get_tls_key_identity(c);
if (identity) {
ret = libnvmf_lookup_key(h->ctx, "psk", identity, &id);
if (ret && !(ret == -ENOKEY126 || ret == -EKEYREVOKED128)) {
	libnvme_msg(h->ctx, LIBNVME_LOG_ERR,__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to lookup key for identity %s, error %d\n"
, identity, ret)
		 "Failed to lookup key for identity %s, error %d\n",__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to lookup key for identity %s, error %d\n"
, identity, ret)
		  identity, ret)__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to lookup key for identity %s, error %d\n"
, identity, ret);
	return ret;
}
}

if (!id) {
ret = __nvme_import_tls_key(h->ctx, kr_id, hostnqn,
			    subsysnqn, identity, key, &id);
if (ret) {
	libnvme_msg(h->ctx, LIBNVME_LOG_ERR,__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to insert TLS PSK, error %d\n"
, ret)
		 "Failed to insert TLS PSK, error %d\n", ret)__libnvme_msg(h->ctx, LIBNVME_LOG_ERR, ((void*)0), "Failed to insert TLS PSK, error %d\n"
, ret);
	return ret;
}
}

1346out:
*keyring_id = kr_id;
*key_id = id;

return 0;
1351}
1352#else
1353__shr_public__attribute__((visibility("default"))) int libnvmf_lookup_keyring(
struct libnvme_global_ctx *ctx, const char *keyring, long *key)
1355{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "key operations not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n")
 "recompile with keyutils support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n");
return -ENOTSUP95;
1359}

1361__shr_public__attribute__((visibility("default"))) char *libnvmf_describe_key_serial(
struct libnvme_global_ctx *ctx, long key_id)
1363{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "key operations not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n")
 "recompile with keyutils support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n");
return NULL((void*)0);
1367}

1369__shr_public__attribute__((visibility("default"))) int libnvmf_lookup_key(
struct libnvme_global_ctx *ctx, const char *type,
const char *identity, long *key)
1372{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "key operations not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n")
 "recompile with keyutils support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n");
return -ENOTSUP95;
1376}

1378__shr_public__attribute__((visibility("default"))) int libnvmf_set_keyring(
struct libnvme_global_ctx *ctx, long key_id)
1380{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "key operations not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n")
 "recompile with keyutils support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n");
return -ENOTSUP95;
1384}

1386__shr_public__attribute__((visibility("default"))) int libnvmf_read_key(
struct libnvme_global_ctx *ctx, long keyring_id, long key_id,
int *len, unsigned char **key)
1389{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "key operations not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n")
 "recompile with keyutils support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n");
return -ENOTSUP95;
1393}

1395__shr_public__attribute__((visibility("default"))) int libnvmf_update_key(
struct libnvme_global_ctx *ctx, long keyring_id,
const char *key_type, const char *identity,
unsigned char *key_data, int key_len, long *key)
1399{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "key operations not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n")
 "recompile with keyutils support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n");
return -ENOTSUP95;
1403}

1405__shr_public__attribute__((visibility("default"))) int libnvmf_scan_tls_keys(
struct libnvme_global_ctx *ctx, const char *keyring,
libnvmf_scan_tls_keys_cb_t cb, void *data)
1408{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "key operations not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n")
 "recompile with keyutils support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n");
return -ENOTSUP95;
1412}

1414__shr_public__attribute__((visibility("default"))) int libnvmf_insert_tls_key_versioned(
struct libnvme_global_ctx *ctx,
const char *keyring, const char *key_type,
const char *hostnqn, const char *subsysnqn,
int version, enum libnvmf_hmac_alg hmac,
unsigned char *configured_key, int key_len,
long *keyp)
1421{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "key operations not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n")
 "recompile with keyutils support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n");
return -ENOTSUP95;
1425}

1427__shr_public__attribute__((visibility("default"))) int libnvmf_insert_tls_key_compat(
struct libnvme_global_ctx *ctx,
const char *keyring, const char *key_type,
const char *hostnqn, const char *subsysnqn,
int version, enum libnvmf_hmac_alg hmac,
unsigned char *configured_key, int key_len,
long *keyp)
1434{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "key operations not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n")
 "recompile with keyutils support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n");
return -ENOTSUP95;
1438}

1440__shr_public__attribute__((visibility("default"))) int libnvmf_revoke_tls_key(struct libnvme_global_ctx *ctx,
const char *keyring, const char *key_type,
const char *identity)
1443{
libnvme_msg(ctx, LIBNVME_LOG_ERR, "key operations not supported; "__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n")
 "recompile with keyutils support.\n")__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "key operations not supported; "
 "recompile with keyutils support.\n");
return -ENOTSUP95;
1447}

1449int __libnvmf_import_keys_from_config(struct libnvme_host *h, struct libnvme_ctrl *c,
		   long *keyring_id, long *key_id)
1451{
*keyring_id = 0;
*key_id = 0;

return 0;
1456}
1457#endif

1459__shr_public__attribute__((visibility("default"))) int libnvmf_insert_tls_key(struct libnvme_global_ctx *ctx,
const char *keyring, const char *key_type,
const char *hostnqn, const char *subsysnqn,
enum libnvmf_hmac_alg hmac,
unsigned char *configured_key, int key_len, long *key)
1464{
return libnvmf_insert_tls_key_versioned(ctx, keyring, key_type,
1
Calling 'libnvmf_insert_tls_key_versioned'→
			     hostnqn, subsysnqn, 0, hmac,
			     configured_key, key_len, key);
1468}

1470/*
* PSK Interchange Format
* NVMeTLSkey-<v>:<xx>:<s>:
*
* x: version as one ASCII char
* yy: hmac encoded as two ASCII chars
*     00: no transform ('configured PSK')
*     01: SHA-256
*     02: SHA-384
* s:  32 or 48 bytes binary followed by a CRC-32 of the configured PSK
*     (4 bytes) encoded as base64
*/
1482__shr_public__attribute__((visibility("default"))) int libnvmf_export_tls_key_versioned(
struct libnvme_global_ctx *ctx, unsigned char version,
enum libnvmf_hmac_alg hmac, const unsigned char *key_data,
size_t key_len, char **encoded_keyp)
1486{
unsigned int raw_len, encoded_len, len;
unsigned long crc = shr_crc32(0L, NULL((void*)0), 0);
unsigned char raw_secret[52];
char *encoded_key;

switch (hmac) {
case LIBNVMF_HMAC_ALG_NONE:
if (key_len != 32 && key_len != 48)
	return -EINVAL22;
break;
case LIBNVMF_HMAC_ALG_SHA2_256:
if (key_len != 32)
	return -EINVAL22;
break;
case LIBNVMF_HMAC_ALG_SHA2_384:
if (key_len != 48)
	return -EINVAL22;
break;
default:
return -EINVAL22;
}
raw_len = key_len;

memcpy(raw_secret, key_data, raw_len);
crc = shr_crc32(crc, raw_secret, raw_len);
raw_secret[raw_len++] = crc & 0xff;
raw_secret[raw_len++] = (crc >> 8) & 0xff;
raw_secret[raw_len++] = (crc >> 16) & 0xff;
raw_secret[raw_len++] = (crc >> 24) & 0xff;

encoded_len = (raw_len * 2) + 20;
encoded_key = malloc(encoded_len);
if (!encoded_key)
return -ENOMEM12;

memset(encoded_key, 0, encoded_len);
len = sprintf(encoded_key, "NVMeTLSkey-%x:%02x:", version, hmac);
len += shr_base64_encode(raw_secret, raw_len, encoded_key + len);
encoded_key[len++] = ':';
encoded_key[len++] = '\0';

*encoded_keyp = encoded_key;
return 0;
1530}

1532__shr_public__attribute__((visibility("default"))) int libnvmf_export_tls_key(struct libnvme_global_ctx *ctx,
const unsigned char *key_data, int key_len, char **encoded_keyp)
1534{
enum libnvmf_hmac_alg hmac;

if (key_len == 32)
hmac = LIBNVMF_HMAC_ALG_SHA2_256;
else
hmac = LIBNVMF_HMAC_ALG_SHA2_384;

return libnvmf_export_tls_key_versioned(ctx, 1, hmac, key_data,
key_len, encoded_keyp);
1544}

1546__shr_public__attribute__((visibility("default"))) int libnvmf_import_tls_key_versioned(
struct libnvme_global_ctx *ctx, const char *encoded_key,
unsigned char *version, enum libnvmf_hmac_alg *hmac,
size_t *key_len, unsigned char **keyp)
1550{
unsigned char decoded_key[128], *key_data;
unsigned int crc = shr_crc32(0L, NULL((void*)0), 0);
unsigned int key_crc;
int err, _version, _hmac, decoded_len;
size_t len;

if (sscanf(encoded_key, "NVMeTLSkey-%d:%02x:*s",
   &_version, &_hmac) != 2)
return -EINVAL22;

if (_version != 1)
return -EINVAL22;

*version = _version;

len = strlen(encoded_key);
switch (_hmac) {
case LIBNVMF_HMAC_ALG_NONE:
if (len != 65 && len != 89)
	return -EINVAL22;
break;
case LIBNVMF_HMAC_ALG_SHA2_256:
if (len != 65)
	return -EINVAL22;
break;
case LIBNVMF_HMAC_ALG_SHA2_384:
if (len != 89)
	return -EINVAL22;
break;
default:
return -EINVAL22;
}
*hmac = _hmac;

err = shr_base64_decode(encoded_key + 16, len - 17, decoded_key);
if (err < 0)
return -ENOKEY126;

decoded_len = err;
decoded_len -= 4;
if (decoded_len != 32 && decoded_len != 48)
return -ENOKEY126;

crc = shr_crc32(crc, decoded_key, decoded_len);
key_crc = ((uint32_t)decoded_key[decoded_len]) |
((uint32_t)decoded_key[decoded_len + 1] << 8) |
((uint32_t)decoded_key[decoded_len + 2] << 16) |
((uint32_t)decoded_key[decoded_len + 3] << 24);
if (key_crc != crc) {
libnvme_msg(ctx, LIBNVME_LOG_ERR, "CRC mismatch (key %08x, crc %08x)",__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "CRC mismatch (key %08x, crc %08x)"
, key_crc, crc)
	 key_crc, crc)__libnvme_msg(ctx, LIBNVME_LOG_ERR, ((void*)0), "CRC mismatch (key %08x, crc %08x)"
, key_crc, crc);
return -ENOKEY126;
}

key_data = malloc(decoded_len);
if (!key_data)
return -ENOMEM12;
memcpy(key_data, decoded_key, decoded_len);

*key_len = decoded_len;
*keyp = key_data;
return 0;
1613}

1615__shr_public__attribute__((visibility("default"))) int libnvmf_import_tls_key(
struct libnvme_global_ctx *ctx, const char *encoded_key,
int *key_len, enum libnvmf_hmac_alg *hmac, unsigned char **keyp)
1618{
unsigned char version;
enum libnvmf_hmac_alg _hmac;
unsigned char *psk;
size_t len;
int ret;

ret = libnvmf_import_tls_key_versioned(ctx, encoded_key, &version,
			    &_hmac, &len, &psk);
if (ret)
return ret;

*hmac = _hmac;
*key_len = len;
*keyp = psk;
return 0;
1634}
