drivers/nvme/common/tests/auth_kunit.c

Source file repositories/reference/linux-study-clean/drivers/nvme/common/tests/auth_kunit.c

File Facts

System
Linux kernel
Corpus path
drivers/nvme/common/tests/auth_kunit.c
Extension
.c
Size
5484 bytes
Lines
176
Domain
Representative Device Path
Bucket
PCIe NVMe Storage Path
Inferred role
Representative Device Path: implementation source
Status
source implementation candidate

Why This File Exists

Part of the selected hardware vertical slice: PCI discovery, driver binding, NVMe queues, block requests, DMA, interrupts, and completion.

Dependency Surface

Detected Declarations

Annotated Snippet

struct nvme_auth_test_values {
	u8 hmac_id;
	size_t hash_len;
	u8 expected_psk[NVME_AUTH_MAX_DIGEST_SIZE];
	char *expected_psk_digest;
	u8 expected_tls_psk[NVME_AUTH_MAX_DIGEST_SIZE];
};

static void kfree_action(void *ptr)
{
	kfree(ptr);
}

static void kunit_add_kfree_action(struct kunit *test, void *ptr)
{
	KUNIT_ASSERT_EQ(test, 0,
			kunit_add_action_or_reset(test, kfree_action, ptr));
}

/*
 * Test the derivation of a TLS PSK from the initial skey.  The vals parameter
 * gives the expected value of tls_psk as well as the intermediate values psk
 * and psk_digest.  The inputs are implicitly the fixed values set below.
 */
static void
test_nvme_auth_derive_tls_psk(struct kunit *test,
			      const struct nvme_auth_test_values *vals)
{
	const u8 hmac_id = vals->hmac_id;
	const size_t hash_len = vals->hash_len;
	const size_t skey_len = hash_len;
	u8 skey[NVME_AUTH_MAX_DIGEST_SIZE];
	u8 c1[NVME_AUTH_MAX_DIGEST_SIZE];
	u8 c2[NVME_AUTH_MAX_DIGEST_SIZE];
	const char *subsysnqn = "subsysnqn";
	const char *hostnqn = "hostnqn";
	u8 *psk = NULL, *tls_psk = NULL;
	char *psk_digest = NULL;
	size_t psk_len;
	int ret;

	for (int i = 0; i < NVME_AUTH_MAX_DIGEST_SIZE; i++) {
		skey[i] = 'A' + i;
		c1[i] = i;
		c2[i] = 0xff - i;
	}

	ret = nvme_auth_generate_psk(hmac_id, skey, skey_len, c1, c2, hash_len,
				     &psk, &psk_len);
	kunit_add_kfree_action(test, psk);
	KUNIT_ASSERT_EQ(test, 0, ret);
	KUNIT_ASSERT_EQ(test, hash_len, psk_len);
	KUNIT_ASSERT_MEMEQ(test, vals->expected_psk, psk, psk_len);

	ret = nvme_auth_generate_digest(hmac_id, psk, psk_len, subsysnqn,
					hostnqn, &psk_digest);
	kunit_add_kfree_action(test, psk_digest);
	if (vals->expected_psk_digest == NULL) {
		/*
		 * Algorithm has an ID assigned but is not supported by
		 * nvme_auth_generate_digest().
		 */
		KUNIT_ASSERT_EQ(test, -EINVAL, ret);
		return;
	}
	KUNIT_ASSERT_EQ(test, 0, ret);
	KUNIT_ASSERT_STREQ(test, vals->expected_psk_digest, psk_digest);

	ret = nvme_auth_derive_tls_psk(hmac_id, psk, psk_len, psk_digest,
				       &tls_psk);
	kunit_add_kfree_action(test, tls_psk);
	KUNIT_ASSERT_EQ(test, 0, ret);
	KUNIT_ASSERT_MEMEQ(test, vals->expected_tls_psk, tls_psk, psk_len);
}

static void test_nvme_auth_derive_tls_psk_hmac_sha256(struct kunit *test)
{
	static const struct nvme_auth_test_values vals = {
		.hmac_id = NVME_AUTH_HASH_SHA256,
		.hash_len = SHA256_DIGEST_SIZE,
		.expected_psk = {
			0x17, 0x33, 0xc5, 0x9f, 0xa7, 0xf4, 0x8f, 0xcf,
			0x37, 0xf5, 0xf2, 0x6f, 0xc4, 0xff, 0x02, 0x68,
			0xad, 0x4f, 0x78, 0xe0, 0x30, 0xf4, 0xf3, 0xb0,
			0xbf, 0xd1, 0xd4, 0x7e, 0x7b, 0xb1, 0x44, 0x7a,
		},
		.expected_psk_digest = "OldoKuTfKddMuyCznAZojkWD7P4D9/AtzDzLimtOxqI=",
		.expected_tls_psk = {
			0x3c, 0x17, 0xda, 0x62, 0x84, 0x74, 0xa0, 0x4d,
			0x22, 0x47, 0xc4, 0xca, 0xb4, 0x79, 0x68, 0xc9,

Annotation

Implementation Notes