forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1017 lines
27 KiB
1017 lines
27 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Copyright (c) 2020 Hannes Reinecke, SUSE Linux |
|
*/ |
|
|
|
#include <linux/crc32.h> |
|
#include <linux/base64.h> |
|
#include <linux/prandom.h> |
|
#include <asm/unaligned.h> |
|
#include <crypto/hash.h> |
|
#include <crypto/dh.h> |
|
#include "nvme.h" |
|
#include "fabrics.h" |
|
#include <linux/nvme-auth.h> |
|
|
|
struct nvme_dhchap_queue_context { |
|
struct list_head entry; |
|
struct work_struct auth_work; |
|
struct nvme_ctrl *ctrl; |
|
struct crypto_shash *shash_tfm; |
|
struct crypto_kpp *dh_tfm; |
|
void *buf; |
|
size_t buf_size; |
|
int qid; |
|
int error; |
|
u32 s1; |
|
u32 s2; |
|
u16 transaction; |
|
u8 status; |
|
u8 hash_id; |
|
size_t hash_len; |
|
u8 dhgroup_id; |
|
u8 c1[64]; |
|
u8 c2[64]; |
|
u8 response[64]; |
|
u8 *host_response; |
|
u8 *ctrl_key; |
|
int ctrl_key_len; |
|
u8 *host_key; |
|
int host_key_len; |
|
u8 *sess_key; |
|
int sess_key_len; |
|
}; |
|
|
|
#define nvme_auth_flags_from_qid(qid) \ |
|
(qid == 0) ? 0 : BLK_MQ_REQ_NOWAIT | BLK_MQ_REQ_RESERVED |
|
#define nvme_auth_queue_from_qid(ctrl, qid) \ |
|
(qid == 0) ? (ctrl)->fabrics_q : (ctrl)->connect_q |
|
|
|
static int nvme_auth_submit(struct nvme_ctrl *ctrl, int qid, |
|
void *data, size_t data_len, bool auth_send) |
|
{ |
|
struct nvme_command cmd = {}; |
|
blk_mq_req_flags_t flags = nvme_auth_flags_from_qid(qid); |
|
struct request_queue *q = nvme_auth_queue_from_qid(ctrl, qid); |
|
int ret; |
|
|
|
cmd.auth_common.opcode = nvme_fabrics_command; |
|
cmd.auth_common.secp = NVME_AUTH_DHCHAP_PROTOCOL_IDENTIFIER; |
|
cmd.auth_common.spsp0 = 0x01; |
|
cmd.auth_common.spsp1 = 0x01; |
|
if (auth_send) { |
|
cmd.auth_send.fctype = nvme_fabrics_type_auth_send; |
|
cmd.auth_send.tl = cpu_to_le32(data_len); |
|
} else { |
|
cmd.auth_receive.fctype = nvme_fabrics_type_auth_receive; |
|
cmd.auth_receive.al = cpu_to_le32(data_len); |
|
} |
|
|
|
ret = __nvme_submit_sync_cmd(q, &cmd, NULL, data, data_len, |
|
qid == 0 ? NVME_QID_ANY : qid, |
|
0, flags); |
|
if (ret > 0) |
|
dev_warn(ctrl->device, |
|
"qid %d auth_send failed with status %d\n", qid, ret); |
|
else if (ret < 0) |
|
dev_err(ctrl->device, |
|
"qid %d auth_send failed with error %d\n", qid, ret); |
|
return ret; |
|
} |
|
|
|
static int nvme_auth_receive_validate(struct nvme_ctrl *ctrl, int qid, |
|
struct nvmf_auth_dhchap_failure_data *data, |
|
u16 transaction, u8 expected_msg) |
|
{ |
|
dev_dbg(ctrl->device, "%s: qid %d auth_type %d auth_id %x\n", |
|
__func__, qid, data->auth_type, data->auth_id); |
|
|
|
if (data->auth_type == NVME_AUTH_COMMON_MESSAGES && |
|
data->auth_id == NVME_AUTH_DHCHAP_MESSAGE_FAILURE1) { |
|
return data->rescode_exp; |
|
} |
|
if (data->auth_type != NVME_AUTH_DHCHAP_MESSAGES || |
|
data->auth_id != expected_msg) { |
|
dev_warn(ctrl->device, |
|
"qid %d invalid message %02x/%02x\n", |
|
qid, data->auth_type, data->auth_id); |
|
return NVME_AUTH_DHCHAP_FAILURE_INCORRECT_MESSAGE; |
|
} |
|
if (le16_to_cpu(data->t_id) != transaction) { |
|
dev_warn(ctrl->device, |
|
"qid %d invalid transaction ID %d\n", |
|
qid, le16_to_cpu(data->t_id)); |
|
return NVME_AUTH_DHCHAP_FAILURE_INCORRECT_MESSAGE; |
|
} |
|
return 0; |
|
} |
|
|
|
static int nvme_auth_set_dhchap_negotiate_data(struct nvme_ctrl *ctrl, |
|
struct nvme_dhchap_queue_context *chap) |
|
{ |
|
struct nvmf_auth_dhchap_negotiate_data *data = chap->buf; |
|
size_t size = sizeof(*data) + sizeof(union nvmf_auth_protocol); |
|
|
|
if (chap->buf_size < size) { |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_INCORRECT_PAYLOAD; |
|
return -EINVAL; |
|
} |
|
memset((u8 *)chap->buf, 0, size); |
|
data->auth_type = NVME_AUTH_COMMON_MESSAGES; |
|
data->auth_id = NVME_AUTH_DHCHAP_MESSAGE_NEGOTIATE; |
|
data->t_id = cpu_to_le16(chap->transaction); |
|
data->sc_c = 0; /* No secure channel concatenation */ |
|
data->napd = 1; |
|
data->auth_protocol[0].dhchap.authid = NVME_AUTH_DHCHAP_AUTH_ID; |
|
data->auth_protocol[0].dhchap.halen = 3; |
|
data->auth_protocol[0].dhchap.dhlen = 6; |
|
data->auth_protocol[0].dhchap.idlist[0] = NVME_AUTH_HASH_SHA256; |
|
data->auth_protocol[0].dhchap.idlist[1] = NVME_AUTH_HASH_SHA384; |
|
data->auth_protocol[0].dhchap.idlist[2] = NVME_AUTH_HASH_SHA512; |
|
data->auth_protocol[0].dhchap.idlist[30] = NVME_AUTH_DHGROUP_NULL; |
|
data->auth_protocol[0].dhchap.idlist[31] = NVME_AUTH_DHGROUP_2048; |
|
data->auth_protocol[0].dhchap.idlist[32] = NVME_AUTH_DHGROUP_3072; |
|
data->auth_protocol[0].dhchap.idlist[33] = NVME_AUTH_DHGROUP_4096; |
|
data->auth_protocol[0].dhchap.idlist[34] = NVME_AUTH_DHGROUP_6144; |
|
data->auth_protocol[0].dhchap.idlist[35] = NVME_AUTH_DHGROUP_8192; |
|
|
|
return size; |
|
} |
|
|
|
static int nvme_auth_process_dhchap_challenge(struct nvme_ctrl *ctrl, |
|
struct nvme_dhchap_queue_context *chap) |
|
{ |
|
struct nvmf_auth_dhchap_challenge_data *data = chap->buf; |
|
u16 dhvlen = le16_to_cpu(data->dhvlen); |
|
size_t size = sizeof(*data) + data->hl + dhvlen; |
|
const char *gid_name = nvme_auth_dhgroup_name(data->dhgid); |
|
const char *hmac_name, *kpp_name; |
|
|
|
if (chap->buf_size < size) { |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_INCORRECT_PAYLOAD; |
|
return NVME_SC_INVALID_FIELD; |
|
} |
|
|
|
hmac_name = nvme_auth_hmac_name(data->hashid); |
|
if (!hmac_name) { |
|
dev_warn(ctrl->device, |
|
"qid %d: invalid HASH ID %d\n", |
|
chap->qid, data->hashid); |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_HASH_UNUSABLE; |
|
return NVME_SC_INVALID_FIELD; |
|
} |
|
|
|
if (chap->hash_id == data->hashid && chap->shash_tfm && |
|
!strcmp(crypto_shash_alg_name(chap->shash_tfm), hmac_name) && |
|
crypto_shash_digestsize(chap->shash_tfm) == data->hl) { |
|
dev_dbg(ctrl->device, |
|
"qid %d: reuse existing hash %s\n", |
|
chap->qid, hmac_name); |
|
goto select_kpp; |
|
} |
|
|
|
/* Reset if hash cannot be reused */ |
|
if (chap->shash_tfm) { |
|
crypto_free_shash(chap->shash_tfm); |
|
chap->hash_id = 0; |
|
chap->hash_len = 0; |
|
} |
|
chap->shash_tfm = crypto_alloc_shash(hmac_name, 0, |
|
CRYPTO_ALG_ALLOCATES_MEMORY); |
|
if (IS_ERR(chap->shash_tfm)) { |
|
dev_warn(ctrl->device, |
|
"qid %d: failed to allocate hash %s, error %ld\n", |
|
chap->qid, hmac_name, PTR_ERR(chap->shash_tfm)); |
|
chap->shash_tfm = NULL; |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_FAILED; |
|
return NVME_SC_AUTH_REQUIRED; |
|
} |
|
|
|
if (crypto_shash_digestsize(chap->shash_tfm) != data->hl) { |
|
dev_warn(ctrl->device, |
|
"qid %d: invalid hash length %d\n", |
|
chap->qid, data->hl); |
|
crypto_free_shash(chap->shash_tfm); |
|
chap->shash_tfm = NULL; |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_HASH_UNUSABLE; |
|
return NVME_SC_AUTH_REQUIRED; |
|
} |
|
|
|
/* Reset host response if the hash had been changed */ |
|
if (chap->hash_id != data->hashid) { |
|
kfree(chap->host_response); |
|
chap->host_response = NULL; |
|
} |
|
|
|
chap->hash_id = data->hashid; |
|
chap->hash_len = data->hl; |
|
dev_dbg(ctrl->device, "qid %d: selected hash %s\n", |
|
chap->qid, hmac_name); |
|
|
|
select_kpp: |
|
kpp_name = nvme_auth_dhgroup_kpp(data->dhgid); |
|
if (!kpp_name) { |
|
dev_warn(ctrl->device, |
|
"qid %d: invalid DH group id %d\n", |
|
chap->qid, data->dhgid); |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_DHGROUP_UNUSABLE; |
|
/* Leave previous dh_tfm intact */ |
|
return NVME_SC_AUTH_REQUIRED; |
|
} |
|
|
|
/* Clear host and controller key to avoid accidental reuse */ |
|
kfree_sensitive(chap->host_key); |
|
chap->host_key = NULL; |
|
chap->host_key_len = 0; |
|
kfree_sensitive(chap->ctrl_key); |
|
chap->ctrl_key = NULL; |
|
chap->ctrl_key_len = 0; |
|
|
|
if (chap->dhgroup_id == data->dhgid && |
|
(data->dhgid == NVME_AUTH_DHGROUP_NULL || chap->dh_tfm)) { |
|
dev_dbg(ctrl->device, |
|
"qid %d: reuse existing DH group %s\n", |
|
chap->qid, gid_name); |
|
goto skip_kpp; |
|
} |
|
|
|
/* Reset dh_tfm if it can't be reused */ |
|
if (chap->dh_tfm) { |
|
crypto_free_kpp(chap->dh_tfm); |
|
chap->dh_tfm = NULL; |
|
} |
|
|
|
if (data->dhgid != NVME_AUTH_DHGROUP_NULL) { |
|
if (dhvlen == 0) { |
|
dev_warn(ctrl->device, |
|
"qid %d: empty DH value\n", |
|
chap->qid); |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_DHGROUP_UNUSABLE; |
|
return NVME_SC_INVALID_FIELD; |
|
} |
|
|
|
chap->dh_tfm = crypto_alloc_kpp(kpp_name, 0, 0); |
|
if (IS_ERR(chap->dh_tfm)) { |
|
int ret = PTR_ERR(chap->dh_tfm); |
|
|
|
dev_warn(ctrl->device, |
|
"qid %d: error %d initializing DH group %s\n", |
|
chap->qid, ret, gid_name); |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_DHGROUP_UNUSABLE; |
|
chap->dh_tfm = NULL; |
|
return NVME_SC_AUTH_REQUIRED; |
|
} |
|
dev_dbg(ctrl->device, "qid %d: selected DH group %s\n", |
|
chap->qid, gid_name); |
|
} else if (dhvlen != 0) { |
|
dev_warn(ctrl->device, |
|
"qid %d: invalid DH value for NULL DH\n", |
|
chap->qid); |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_INCORRECT_PAYLOAD; |
|
return NVME_SC_INVALID_FIELD; |
|
} |
|
chap->dhgroup_id = data->dhgid; |
|
|
|
skip_kpp: |
|
chap->s1 = le32_to_cpu(data->seqnum); |
|
memcpy(chap->c1, data->cval, chap->hash_len); |
|
if (dhvlen) { |
|
chap->ctrl_key = kmalloc(dhvlen, GFP_KERNEL); |
|
if (!chap->ctrl_key) { |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_FAILED; |
|
return NVME_SC_AUTH_REQUIRED; |
|
} |
|
chap->ctrl_key_len = dhvlen; |
|
memcpy(chap->ctrl_key, data->cval + chap->hash_len, |
|
dhvlen); |
|
dev_dbg(ctrl->device, "ctrl public key %*ph\n", |
|
(int)chap->ctrl_key_len, chap->ctrl_key); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int nvme_auth_set_dhchap_reply_data(struct nvme_ctrl *ctrl, |
|
struct nvme_dhchap_queue_context *chap) |
|
{ |
|
struct nvmf_auth_dhchap_reply_data *data = chap->buf; |
|
size_t size = sizeof(*data); |
|
|
|
size += 2 * chap->hash_len; |
|
|
|
if (chap->host_key_len) |
|
size += chap->host_key_len; |
|
|
|
if (chap->buf_size < size) { |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_INCORRECT_PAYLOAD; |
|
return -EINVAL; |
|
} |
|
|
|
memset(chap->buf, 0, size); |
|
data->auth_type = NVME_AUTH_DHCHAP_MESSAGES; |
|
data->auth_id = NVME_AUTH_DHCHAP_MESSAGE_REPLY; |
|
data->t_id = cpu_to_le16(chap->transaction); |
|
data->hl = chap->hash_len; |
|
data->dhvlen = cpu_to_le16(chap->host_key_len); |
|
memcpy(data->rval, chap->response, chap->hash_len); |
|
if (ctrl->ctrl_key) { |
|
get_random_bytes(chap->c2, chap->hash_len); |
|
data->cvalid = 1; |
|
chap->s2 = nvme_auth_get_seqnum(); |
|
memcpy(data->rval + chap->hash_len, chap->c2, |
|
chap->hash_len); |
|
dev_dbg(ctrl->device, "%s: qid %d ctrl challenge %*ph\n", |
|
__func__, chap->qid, (int)chap->hash_len, chap->c2); |
|
} else { |
|
memset(chap->c2, 0, chap->hash_len); |
|
chap->s2 = 0; |
|
} |
|
data->seqnum = cpu_to_le32(chap->s2); |
|
if (chap->host_key_len) { |
|
dev_dbg(ctrl->device, "%s: qid %d host public key %*ph\n", |
|
__func__, chap->qid, |
|
chap->host_key_len, chap->host_key); |
|
memcpy(data->rval + 2 * chap->hash_len, chap->host_key, |
|
chap->host_key_len); |
|
} |
|
|
|
return size; |
|
} |
|
|
|
static int nvme_auth_process_dhchap_success1(struct nvme_ctrl *ctrl, |
|
struct nvme_dhchap_queue_context *chap) |
|
{ |
|
struct nvmf_auth_dhchap_success1_data *data = chap->buf; |
|
size_t size = sizeof(*data); |
|
|
|
if (ctrl->ctrl_key) |
|
size += chap->hash_len; |
|
|
|
if (chap->buf_size < size) { |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_INCORRECT_PAYLOAD; |
|
return NVME_SC_INVALID_FIELD; |
|
} |
|
|
|
if (data->hl != chap->hash_len) { |
|
dev_warn(ctrl->device, |
|
"qid %d: invalid hash length %u\n", |
|
chap->qid, data->hl); |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_HASH_UNUSABLE; |
|
return NVME_SC_INVALID_FIELD; |
|
} |
|
|
|
/* Just print out information for the admin queue */ |
|
if (chap->qid == 0) |
|
dev_info(ctrl->device, |
|
"qid 0: authenticated with hash %s dhgroup %s\n", |
|
nvme_auth_hmac_name(chap->hash_id), |
|
nvme_auth_dhgroup_name(chap->dhgroup_id)); |
|
|
|
if (!data->rvalid) |
|
return 0; |
|
|
|
/* Validate controller response */ |
|
if (memcmp(chap->response, data->rval, data->hl)) { |
|
dev_dbg(ctrl->device, "%s: qid %d ctrl response %*ph\n", |
|
__func__, chap->qid, (int)chap->hash_len, data->rval); |
|
dev_dbg(ctrl->device, "%s: qid %d host response %*ph\n", |
|
__func__, chap->qid, (int)chap->hash_len, |
|
chap->response); |
|
dev_warn(ctrl->device, |
|
"qid %d: controller authentication failed\n", |
|
chap->qid); |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_FAILED; |
|
return NVME_SC_AUTH_REQUIRED; |
|
} |
|
|
|
/* Just print out information for the admin queue */ |
|
if (chap->qid == 0) |
|
dev_info(ctrl->device, |
|
"qid 0: controller authenticated\n"); |
|
return 0; |
|
} |
|
|
|
static int nvme_auth_set_dhchap_success2_data(struct nvme_ctrl *ctrl, |
|
struct nvme_dhchap_queue_context *chap) |
|
{ |
|
struct nvmf_auth_dhchap_success2_data *data = chap->buf; |
|
size_t size = sizeof(*data); |
|
|
|
memset(chap->buf, 0, size); |
|
data->auth_type = NVME_AUTH_DHCHAP_MESSAGES; |
|
data->auth_id = NVME_AUTH_DHCHAP_MESSAGE_SUCCESS2; |
|
data->t_id = cpu_to_le16(chap->transaction); |
|
|
|
return size; |
|
} |
|
|
|
static int nvme_auth_set_dhchap_failure2_data(struct nvme_ctrl *ctrl, |
|
struct nvme_dhchap_queue_context *chap) |
|
{ |
|
struct nvmf_auth_dhchap_failure_data *data = chap->buf; |
|
size_t size = sizeof(*data); |
|
|
|
memset(chap->buf, 0, size); |
|
data->auth_type = NVME_AUTH_COMMON_MESSAGES; |
|
data->auth_id = NVME_AUTH_DHCHAP_MESSAGE_FAILURE2; |
|
data->t_id = cpu_to_le16(chap->transaction); |
|
data->rescode = NVME_AUTH_DHCHAP_FAILURE_REASON_FAILED; |
|
data->rescode_exp = chap->status; |
|
|
|
return size; |
|
} |
|
|
|
static int nvme_auth_dhchap_setup_host_response(struct nvme_ctrl *ctrl, |
|
struct nvme_dhchap_queue_context *chap) |
|
{ |
|
SHASH_DESC_ON_STACK(shash, chap->shash_tfm); |
|
u8 buf[4], *challenge = chap->c1; |
|
int ret; |
|
|
|
dev_dbg(ctrl->device, "%s: qid %d host response seq %u transaction %d\n", |
|
__func__, chap->qid, chap->s1, chap->transaction); |
|
|
|
if (!chap->host_response) { |
|
chap->host_response = nvme_auth_transform_key(ctrl->host_key, |
|
ctrl->opts->host->nqn); |
|
if (IS_ERR(chap->host_response)) { |
|
ret = PTR_ERR(chap->host_response); |
|
chap->host_response = NULL; |
|
return ret; |
|
} |
|
} else { |
|
dev_dbg(ctrl->device, "%s: qid %d re-using host response\n", |
|
__func__, chap->qid); |
|
} |
|
|
|
ret = crypto_shash_setkey(chap->shash_tfm, |
|
chap->host_response, ctrl->host_key->len); |
|
if (ret) { |
|
dev_warn(ctrl->device, "qid %d: failed to set key, error %d\n", |
|
chap->qid, ret); |
|
goto out; |
|
} |
|
|
|
if (chap->dh_tfm) { |
|
challenge = kmalloc(chap->hash_len, GFP_KERNEL); |
|
if (!challenge) { |
|
ret = -ENOMEM; |
|
goto out; |
|
} |
|
ret = nvme_auth_augmented_challenge(chap->hash_id, |
|
chap->sess_key, |
|
chap->sess_key_len, |
|
chap->c1, challenge, |
|
chap->hash_len); |
|
if (ret) |
|
goto out; |
|
} |
|
|
|
shash->tfm = chap->shash_tfm; |
|
ret = crypto_shash_init(shash); |
|
if (ret) |
|
goto out; |
|
ret = crypto_shash_update(shash, challenge, chap->hash_len); |
|
if (ret) |
|
goto out; |
|
put_unaligned_le32(chap->s1, buf); |
|
ret = crypto_shash_update(shash, buf, 4); |
|
if (ret) |
|
goto out; |
|
put_unaligned_le16(chap->transaction, buf); |
|
ret = crypto_shash_update(shash, buf, 2); |
|
if (ret) |
|
goto out; |
|
memset(buf, 0, sizeof(buf)); |
|
ret = crypto_shash_update(shash, buf, 1); |
|
if (ret) |
|
goto out; |
|
ret = crypto_shash_update(shash, "HostHost", 8); |
|
if (ret) |
|
goto out; |
|
ret = crypto_shash_update(shash, ctrl->opts->host->nqn, |
|
strlen(ctrl->opts->host->nqn)); |
|
if (ret) |
|
goto out; |
|
ret = crypto_shash_update(shash, buf, 1); |
|
if (ret) |
|
goto out; |
|
ret = crypto_shash_update(shash, ctrl->opts->subsysnqn, |
|
strlen(ctrl->opts->subsysnqn)); |
|
if (ret) |
|
goto out; |
|
ret = crypto_shash_final(shash, chap->response); |
|
out: |
|
if (challenge != chap->c1) |
|
kfree(challenge); |
|
return ret; |
|
} |
|
|
|
static int nvme_auth_dhchap_setup_ctrl_response(struct nvme_ctrl *ctrl, |
|
struct nvme_dhchap_queue_context *chap) |
|
{ |
|
SHASH_DESC_ON_STACK(shash, chap->shash_tfm); |
|
u8 *ctrl_response; |
|
u8 buf[4], *challenge = chap->c2; |
|
int ret; |
|
|
|
ctrl_response = nvme_auth_transform_key(ctrl->ctrl_key, |
|
ctrl->opts->subsysnqn); |
|
if (IS_ERR(ctrl_response)) { |
|
ret = PTR_ERR(ctrl_response); |
|
return ret; |
|
} |
|
ret = crypto_shash_setkey(chap->shash_tfm, |
|
ctrl_response, ctrl->ctrl_key->len); |
|
if (ret) { |
|
dev_warn(ctrl->device, "qid %d: failed to set key, error %d\n", |
|
chap->qid, ret); |
|
goto out; |
|
} |
|
|
|
if (chap->dh_tfm) { |
|
challenge = kmalloc(chap->hash_len, GFP_KERNEL); |
|
if (!challenge) { |
|
ret = -ENOMEM; |
|
goto out; |
|
} |
|
ret = nvme_auth_augmented_challenge(chap->hash_id, |
|
chap->sess_key, |
|
chap->sess_key_len, |
|
chap->c2, challenge, |
|
chap->hash_len); |
|
if (ret) |
|
goto out; |
|
} |
|
dev_dbg(ctrl->device, "%s: qid %d ctrl response seq %u transaction %d\n", |
|
__func__, chap->qid, chap->s2, chap->transaction); |
|
dev_dbg(ctrl->device, "%s: qid %d challenge %*ph\n", |
|
__func__, chap->qid, (int)chap->hash_len, challenge); |
|
dev_dbg(ctrl->device, "%s: qid %d subsysnqn %s\n", |
|
__func__, chap->qid, ctrl->opts->subsysnqn); |
|
dev_dbg(ctrl->device, "%s: qid %d hostnqn %s\n", |
|
__func__, chap->qid, ctrl->opts->host->nqn); |
|
shash->tfm = chap->shash_tfm; |
|
ret = crypto_shash_init(shash); |
|
if (ret) |
|
goto out; |
|
ret = crypto_shash_update(shash, challenge, chap->hash_len); |
|
if (ret) |
|
goto out; |
|
put_unaligned_le32(chap->s2, buf); |
|
ret = crypto_shash_update(shash, buf, 4); |
|
if (ret) |
|
goto out; |
|
put_unaligned_le16(chap->transaction, buf); |
|
ret = crypto_shash_update(shash, buf, 2); |
|
if (ret) |
|
goto out; |
|
memset(buf, 0, 4); |
|
ret = crypto_shash_update(shash, buf, 1); |
|
if (ret) |
|
goto out; |
|
ret = crypto_shash_update(shash, "Controller", 10); |
|
if (ret) |
|
goto out; |
|
ret = crypto_shash_update(shash, ctrl->opts->subsysnqn, |
|
strlen(ctrl->opts->subsysnqn)); |
|
if (ret) |
|
goto out; |
|
ret = crypto_shash_update(shash, buf, 1); |
|
if (ret) |
|
goto out; |
|
ret = crypto_shash_update(shash, ctrl->opts->host->nqn, |
|
strlen(ctrl->opts->host->nqn)); |
|
if (ret) |
|
goto out; |
|
ret = crypto_shash_final(shash, chap->response); |
|
out: |
|
if (challenge != chap->c2) |
|
kfree(challenge); |
|
kfree(ctrl_response); |
|
return ret; |
|
} |
|
|
|
static int nvme_auth_dhchap_exponential(struct nvme_ctrl *ctrl, |
|
struct nvme_dhchap_queue_context *chap) |
|
{ |
|
int ret; |
|
|
|
if (chap->host_key && chap->host_key_len) { |
|
dev_dbg(ctrl->device, |
|
"qid %d: reusing host key\n", chap->qid); |
|
goto gen_sesskey; |
|
} |
|
ret = nvme_auth_gen_privkey(chap->dh_tfm, chap->dhgroup_id); |
|
if (ret < 0) { |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_INCORRECT_PAYLOAD; |
|
return ret; |
|
} |
|
|
|
chap->host_key_len = crypto_kpp_maxsize(chap->dh_tfm); |
|
|
|
chap->host_key = kzalloc(chap->host_key_len, GFP_KERNEL); |
|
if (!chap->host_key) { |
|
chap->host_key_len = 0; |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_FAILED; |
|
return -ENOMEM; |
|
} |
|
ret = nvme_auth_gen_pubkey(chap->dh_tfm, |
|
chap->host_key, chap->host_key_len); |
|
if (ret) { |
|
dev_dbg(ctrl->device, |
|
"failed to generate public key, error %d\n", ret); |
|
kfree(chap->host_key); |
|
chap->host_key = NULL; |
|
chap->host_key_len = 0; |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_INCORRECT_PAYLOAD; |
|
return ret; |
|
} |
|
|
|
gen_sesskey: |
|
chap->sess_key_len = chap->host_key_len; |
|
chap->sess_key = kmalloc(chap->sess_key_len, GFP_KERNEL); |
|
if (!chap->sess_key) { |
|
chap->sess_key_len = 0; |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_FAILED; |
|
return -ENOMEM; |
|
} |
|
|
|
ret = nvme_auth_gen_shared_secret(chap->dh_tfm, |
|
chap->ctrl_key, chap->ctrl_key_len, |
|
chap->sess_key, chap->sess_key_len); |
|
if (ret) { |
|
dev_dbg(ctrl->device, |
|
"failed to generate shared secret, error %d\n", ret); |
|
kfree_sensitive(chap->sess_key); |
|
chap->sess_key = NULL; |
|
chap->sess_key_len = 0; |
|
chap->status = NVME_AUTH_DHCHAP_FAILURE_INCORRECT_PAYLOAD; |
|
return ret; |
|
} |
|
dev_dbg(ctrl->device, "shared secret %*ph\n", |
|
(int)chap->sess_key_len, chap->sess_key); |
|
return 0; |
|
} |
|
|
|
static void __nvme_auth_reset(struct nvme_dhchap_queue_context *chap) |
|
{ |
|
kfree_sensitive(chap->host_response); |
|
chap->host_response = NULL; |
|
kfree_sensitive(chap->host_key); |
|
chap->host_key = NULL; |
|
chap->host_key_len = 0; |
|
kfree_sensitive(chap->ctrl_key); |
|
chap->ctrl_key = NULL; |
|
chap->ctrl_key_len = 0; |
|
kfree_sensitive(chap->sess_key); |
|
chap->sess_key = NULL; |
|
chap->sess_key_len = 0; |
|
chap->status = 0; |
|
chap->error = 0; |
|
chap->s1 = 0; |
|
chap->s2 = 0; |
|
chap->transaction = 0; |
|
memset(chap->c1, 0, sizeof(chap->c1)); |
|
memset(chap->c2, 0, sizeof(chap->c2)); |
|
} |
|
|
|
static void __nvme_auth_free(struct nvme_dhchap_queue_context *chap) |
|
{ |
|
__nvme_auth_reset(chap); |
|
if (chap->shash_tfm) |
|
crypto_free_shash(chap->shash_tfm); |
|
if (chap->dh_tfm) |
|
crypto_free_kpp(chap->dh_tfm); |
|
kfree_sensitive(chap->ctrl_key); |
|
kfree_sensitive(chap->host_key); |
|
kfree_sensitive(chap->sess_key); |
|
kfree_sensitive(chap->host_response); |
|
kfree(chap->buf); |
|
kfree(chap); |
|
} |
|
|
|
static void __nvme_auth_work(struct work_struct *work) |
|
{ |
|
struct nvme_dhchap_queue_context *chap = |
|
container_of(work, struct nvme_dhchap_queue_context, auth_work); |
|
struct nvme_ctrl *ctrl = chap->ctrl; |
|
size_t tl; |
|
int ret = 0; |
|
|
|
chap->transaction = ctrl->transaction++; |
|
|
|
/* DH-HMAC-CHAP Step 1: send negotiate */ |
|
dev_dbg(ctrl->device, "%s: qid %d send negotiate\n", |
|
__func__, chap->qid); |
|
ret = nvme_auth_set_dhchap_negotiate_data(ctrl, chap); |
|
if (ret < 0) { |
|
chap->error = ret; |
|
return; |
|
} |
|
tl = ret; |
|
ret = nvme_auth_submit(ctrl, chap->qid, chap->buf, tl, true); |
|
if (ret) { |
|
chap->error = ret; |
|
return; |
|
} |
|
|
|
/* DH-HMAC-CHAP Step 2: receive challenge */ |
|
dev_dbg(ctrl->device, "%s: qid %d receive challenge\n", |
|
__func__, chap->qid); |
|
|
|
memset(chap->buf, 0, chap->buf_size); |
|
ret = nvme_auth_submit(ctrl, chap->qid, chap->buf, chap->buf_size, false); |
|
if (ret) { |
|
dev_warn(ctrl->device, |
|
"qid %d failed to receive challenge, %s %d\n", |
|
chap->qid, ret < 0 ? "error" : "nvme status", ret); |
|
chap->error = ret; |
|
return; |
|
} |
|
ret = nvme_auth_receive_validate(ctrl, chap->qid, chap->buf, chap->transaction, |
|
NVME_AUTH_DHCHAP_MESSAGE_CHALLENGE); |
|
if (ret) { |
|
chap->status = ret; |
|
chap->error = NVME_SC_AUTH_REQUIRED; |
|
return; |
|
} |
|
|
|
ret = nvme_auth_process_dhchap_challenge(ctrl, chap); |
|
if (ret) { |
|
/* Invalid challenge parameters */ |
|
chap->error = ret; |
|
goto fail2; |
|
} |
|
|
|
if (chap->ctrl_key_len) { |
|
dev_dbg(ctrl->device, |
|
"%s: qid %d DH exponential\n", |
|
__func__, chap->qid); |
|
ret = nvme_auth_dhchap_exponential(ctrl, chap); |
|
if (ret) { |
|
chap->error = ret; |
|
goto fail2; |
|
} |
|
} |
|
|
|
dev_dbg(ctrl->device, "%s: qid %d host response\n", |
|
__func__, chap->qid); |
|
ret = nvme_auth_dhchap_setup_host_response(ctrl, chap); |
|
if (ret) { |
|
chap->error = ret; |
|
goto fail2; |
|
} |
|
|
|
/* DH-HMAC-CHAP Step 3: send reply */ |
|
dev_dbg(ctrl->device, "%s: qid %d send reply\n", |
|
__func__, chap->qid); |
|
ret = nvme_auth_set_dhchap_reply_data(ctrl, chap); |
|
if (ret < 0) { |
|
chap->error = ret; |
|
goto fail2; |
|
} |
|
|
|
tl = ret; |
|
ret = nvme_auth_submit(ctrl, chap->qid, chap->buf, tl, true); |
|
if (ret) { |
|
chap->error = ret; |
|
goto fail2; |
|
} |
|
|
|
/* DH-HMAC-CHAP Step 4: receive success1 */ |
|
dev_dbg(ctrl->device, "%s: qid %d receive success1\n", |
|
__func__, chap->qid); |
|
|
|
memset(chap->buf, 0, chap->buf_size); |
|
ret = nvme_auth_submit(ctrl, chap->qid, chap->buf, chap->buf_size, false); |
|
if (ret) { |
|
dev_warn(ctrl->device, |
|
"qid %d failed to receive success1, %s %d\n", |
|
chap->qid, ret < 0 ? "error" : "nvme status", ret); |
|
chap->error = ret; |
|
return; |
|
} |
|
ret = nvme_auth_receive_validate(ctrl, chap->qid, |
|
chap->buf, chap->transaction, |
|
NVME_AUTH_DHCHAP_MESSAGE_SUCCESS1); |
|
if (ret) { |
|
chap->status = ret; |
|
chap->error = NVME_SC_AUTH_REQUIRED; |
|
return; |
|
} |
|
|
|
if (ctrl->ctrl_key) { |
|
dev_dbg(ctrl->device, |
|
"%s: qid %d controller response\n", |
|
__func__, chap->qid); |
|
ret = nvme_auth_dhchap_setup_ctrl_response(ctrl, chap); |
|
if (ret) { |
|
chap->error = ret; |
|
goto fail2; |
|
} |
|
} |
|
|
|
ret = nvme_auth_process_dhchap_success1(ctrl, chap); |
|
if (ret) { |
|
/* Controller authentication failed */ |
|
chap->error = NVME_SC_AUTH_REQUIRED; |
|
goto fail2; |
|
} |
|
|
|
if (ctrl->ctrl_key) { |
|
/* DH-HMAC-CHAP Step 5: send success2 */ |
|
dev_dbg(ctrl->device, "%s: qid %d send success2\n", |
|
__func__, chap->qid); |
|
tl = nvme_auth_set_dhchap_success2_data(ctrl, chap); |
|
ret = nvme_auth_submit(ctrl, chap->qid, chap->buf, tl, true); |
|
if (ret) |
|
chap->error = ret; |
|
} |
|
if (!ret) { |
|
chap->error = 0; |
|
return; |
|
} |
|
|
|
fail2: |
|
dev_dbg(ctrl->device, "%s: qid %d send failure2, status %x\n", |
|
__func__, chap->qid, chap->status); |
|
tl = nvme_auth_set_dhchap_failure2_data(ctrl, chap); |
|
ret = nvme_auth_submit(ctrl, chap->qid, chap->buf, tl, true); |
|
/* |
|
* only update error if send failure2 failed and no other |
|
* error had been set during authentication. |
|
*/ |
|
if (ret && !chap->error) |
|
chap->error = ret; |
|
} |
|
|
|
int nvme_auth_negotiate(struct nvme_ctrl *ctrl, int qid) |
|
{ |
|
struct nvme_dhchap_queue_context *chap; |
|
|
|
if (!ctrl->host_key) { |
|
dev_warn(ctrl->device, "qid %d: no key\n", qid); |
|
return -ENOKEY; |
|
} |
|
|
|
if (ctrl->opts->dhchap_ctrl_secret && !ctrl->ctrl_key) { |
|
dev_warn(ctrl->device, "qid %d: invalid ctrl key\n", qid); |
|
return -ENOKEY; |
|
} |
|
|
|
mutex_lock(&ctrl->dhchap_auth_mutex); |
|
/* Check if the context is already queued */ |
|
list_for_each_entry(chap, &ctrl->dhchap_auth_list, entry) { |
|
WARN_ON(!chap->buf); |
|
if (chap->qid == qid) { |
|
dev_dbg(ctrl->device, "qid %d: re-using context\n", qid); |
|
mutex_unlock(&ctrl->dhchap_auth_mutex); |
|
flush_work(&chap->auth_work); |
|
__nvme_auth_reset(chap); |
|
queue_work(nvme_wq, &chap->auth_work); |
|
return 0; |
|
} |
|
} |
|
chap = kzalloc(sizeof(*chap), GFP_KERNEL); |
|
if (!chap) { |
|
mutex_unlock(&ctrl->dhchap_auth_mutex); |
|
return -ENOMEM; |
|
} |
|
chap->qid = (qid == NVME_QID_ANY) ? 0 : qid; |
|
chap->ctrl = ctrl; |
|
|
|
/* |
|
* Allocate a large enough buffer for the entire negotiation: |
|
* 4k should be enough to ffdhe8192. |
|
*/ |
|
chap->buf_size = 4096; |
|
chap->buf = kzalloc(chap->buf_size, GFP_KERNEL); |
|
if (!chap->buf) { |
|
mutex_unlock(&ctrl->dhchap_auth_mutex); |
|
kfree(chap); |
|
return -ENOMEM; |
|
} |
|
|
|
INIT_WORK(&chap->auth_work, __nvme_auth_work); |
|
list_add(&chap->entry, &ctrl->dhchap_auth_list); |
|
mutex_unlock(&ctrl->dhchap_auth_mutex); |
|
queue_work(nvme_wq, &chap->auth_work); |
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(nvme_auth_negotiate); |
|
|
|
int nvme_auth_wait(struct nvme_ctrl *ctrl, int qid) |
|
{ |
|
struct nvme_dhchap_queue_context *chap; |
|
int ret; |
|
|
|
mutex_lock(&ctrl->dhchap_auth_mutex); |
|
list_for_each_entry(chap, &ctrl->dhchap_auth_list, entry) { |
|
if (chap->qid != qid) |
|
continue; |
|
mutex_unlock(&ctrl->dhchap_auth_mutex); |
|
flush_work(&chap->auth_work); |
|
ret = chap->error; |
|
return ret; |
|
} |
|
mutex_unlock(&ctrl->dhchap_auth_mutex); |
|
return -ENXIO; |
|
} |
|
EXPORT_SYMBOL_GPL(nvme_auth_wait); |
|
|
|
void nvme_auth_reset(struct nvme_ctrl *ctrl) |
|
{ |
|
struct nvme_dhchap_queue_context *chap; |
|
|
|
mutex_lock(&ctrl->dhchap_auth_mutex); |
|
list_for_each_entry(chap, &ctrl->dhchap_auth_list, entry) { |
|
mutex_unlock(&ctrl->dhchap_auth_mutex); |
|
flush_work(&chap->auth_work); |
|
__nvme_auth_reset(chap); |
|
} |
|
mutex_unlock(&ctrl->dhchap_auth_mutex); |
|
} |
|
EXPORT_SYMBOL_GPL(nvme_auth_reset); |
|
|
|
static void nvme_dhchap_auth_work(struct work_struct *work) |
|
{ |
|
struct nvme_ctrl *ctrl = |
|
container_of(work, struct nvme_ctrl, dhchap_auth_work); |
|
int ret, q; |
|
|
|
/* Authenticate admin queue first */ |
|
ret = nvme_auth_negotiate(ctrl, 0); |
|
if (ret) { |
|
dev_warn(ctrl->device, |
|
"qid 0: error %d setting up authentication\n", ret); |
|
return; |
|
} |
|
ret = nvme_auth_wait(ctrl, 0); |
|
if (ret) { |
|
dev_warn(ctrl->device, |
|
"qid 0: authentication failed\n"); |
|
return; |
|
} |
|
|
|
for (q = 1; q < ctrl->queue_count; q++) { |
|
ret = nvme_auth_negotiate(ctrl, q); |
|
if (ret) { |
|
dev_warn(ctrl->device, |
|
"qid %d: error %d setting up authentication\n", |
|
q, ret); |
|
break; |
|
} |
|
} |
|
|
|
/* |
|
* Failure is a soft-state; credentials remain valid until |
|
* the controller terminates the connection. |
|
*/ |
|
} |
|
|
|
void nvme_auth_init_ctrl(struct nvme_ctrl *ctrl) |
|
{ |
|
INIT_LIST_HEAD(&ctrl->dhchap_auth_list); |
|
INIT_WORK(&ctrl->dhchap_auth_work, nvme_dhchap_auth_work); |
|
mutex_init(&ctrl->dhchap_auth_mutex); |
|
if (!ctrl->opts) |
|
return; |
|
nvme_auth_generate_key(ctrl->opts->dhchap_secret, &ctrl->host_key); |
|
nvme_auth_generate_key(ctrl->opts->dhchap_ctrl_secret, &ctrl->ctrl_key); |
|
} |
|
EXPORT_SYMBOL_GPL(nvme_auth_init_ctrl); |
|
|
|
void nvme_auth_stop(struct nvme_ctrl *ctrl) |
|
{ |
|
struct nvme_dhchap_queue_context *chap = NULL, *tmp; |
|
|
|
cancel_work_sync(&ctrl->dhchap_auth_work); |
|
mutex_lock(&ctrl->dhchap_auth_mutex); |
|
list_for_each_entry_safe(chap, tmp, &ctrl->dhchap_auth_list, entry) |
|
cancel_work_sync(&chap->auth_work); |
|
mutex_unlock(&ctrl->dhchap_auth_mutex); |
|
} |
|
EXPORT_SYMBOL_GPL(nvme_auth_stop); |
|
|
|
void nvme_auth_free(struct nvme_ctrl *ctrl) |
|
{ |
|
struct nvme_dhchap_queue_context *chap = NULL, *tmp; |
|
|
|
mutex_lock(&ctrl->dhchap_auth_mutex); |
|
list_for_each_entry_safe(chap, tmp, &ctrl->dhchap_auth_list, entry) { |
|
list_del_init(&chap->entry); |
|
flush_work(&chap->auth_work); |
|
__nvme_auth_free(chap); |
|
} |
|
mutex_unlock(&ctrl->dhchap_auth_mutex); |
|
if (ctrl->host_key) { |
|
nvme_auth_free_key(ctrl->host_key); |
|
ctrl->host_key = NULL; |
|
} |
|
if (ctrl->ctrl_key) { |
|
nvme_auth_free_key(ctrl->ctrl_key); |
|
ctrl->ctrl_key = NULL; |
|
} |
|
} |
|
EXPORT_SYMBOL_GPL(nvme_auth_free);
|
|
|