1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * NVMe over Fabrics DH-HMAC-CHAP authentication.
4 * Copyright (c) 2020 Hannes Reinecke, SUSE Software Solutions.
5 * All rights reserved.
6 */
7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/slab.h>
11 #include <linux/err.h>
12 #include <crypto/hash.h>
13 #include <linux/crc32.h>
14 #include <linux/base64.h>
15 #include <linux/ctype.h>
16 #include <linux/random.h>
17 #include <linux/nvme-auth.h>
18 #include <asm/unaligned.h>
19
20 #include "nvmet.h"
21
nvmet_auth_set_key(struct nvmet_host * host,const char * secret,bool set_ctrl)22 int nvmet_auth_set_key(struct nvmet_host *host, const char *secret,
23 bool set_ctrl)
24 {
25 unsigned char key_hash;
26 char *dhchap_secret;
27
28 if (sscanf(secret, "DHHC-1:%hhd:%*s", &key_hash) != 1)
29 return -EINVAL;
30 if (key_hash > 3) {
31 pr_warn("Invalid DH-HMAC-CHAP hash id %d\n",
32 key_hash);
33 return -EINVAL;
34 }
35 if (key_hash > 0) {
36 /* Validate selected hash algorithm */
37 const char *hmac = nvme_auth_hmac_name(key_hash);
38
39 if (!crypto_has_shash(hmac, 0, 0)) {
40 pr_err("DH-HMAC-CHAP hash %s unsupported\n", hmac);
41 return -ENOTSUPP;
42 }
43 }
44 dhchap_secret = kstrdup(secret, GFP_KERNEL);
45 if (!dhchap_secret)
46 return -ENOMEM;
47 if (set_ctrl) {
48 kfree(host->dhchap_ctrl_secret);
49 host->dhchap_ctrl_secret = strim(dhchap_secret);
50 host->dhchap_ctrl_key_hash = key_hash;
51 } else {
52 kfree(host->dhchap_secret);
53 host->dhchap_secret = strim(dhchap_secret);
54 host->dhchap_key_hash = key_hash;
55 }
56 return 0;
57 }
58
nvmet_setup_dhgroup(struct nvmet_ctrl * ctrl,u8 dhgroup_id)59 int nvmet_setup_dhgroup(struct nvmet_ctrl *ctrl, u8 dhgroup_id)
60 {
61 const char *dhgroup_kpp;
62 int ret = 0;
63
64 pr_debug("%s: ctrl %d selecting dhgroup %d\n",
65 __func__, ctrl->cntlid, dhgroup_id);
66
67 if (ctrl->dh_tfm) {
68 if (ctrl->dh_gid == dhgroup_id) {
69 pr_debug("%s: ctrl %d reuse existing DH group %d\n",
70 __func__, ctrl->cntlid, dhgroup_id);
71 return 0;
72 }
73 crypto_free_kpp(ctrl->dh_tfm);
74 ctrl->dh_tfm = NULL;
75 ctrl->dh_gid = 0;
76 }
77
78 if (dhgroup_id == NVME_AUTH_DHGROUP_NULL)
79 return 0;
80
81 dhgroup_kpp = nvme_auth_dhgroup_kpp(dhgroup_id);
82 if (!dhgroup_kpp) {
83 pr_debug("%s: ctrl %d invalid DH group %d\n",
84 __func__, ctrl->cntlid, dhgroup_id);
85 return -EINVAL;
86 }
87 ctrl->dh_tfm = crypto_alloc_kpp(dhgroup_kpp, 0, 0);
88 if (IS_ERR(ctrl->dh_tfm)) {
89 pr_debug("%s: ctrl %d failed to setup DH group %d, err %ld\n",
90 __func__, ctrl->cntlid, dhgroup_id,
91 PTR_ERR(ctrl->dh_tfm));
92 ret = PTR_ERR(ctrl->dh_tfm);
93 ctrl->dh_tfm = NULL;
94 ctrl->dh_gid = 0;
95 } else {
96 ctrl->dh_gid = dhgroup_id;
97 pr_debug("%s: ctrl %d setup DH group %d\n",
98 __func__, ctrl->cntlid, ctrl->dh_gid);
99 ret = nvme_auth_gen_privkey(ctrl->dh_tfm, ctrl->dh_gid);
100 if (ret < 0) {
101 pr_debug("%s: ctrl %d failed to generate private key, err %d\n",
102 __func__, ctrl->cntlid, ret);
103 kfree_sensitive(ctrl->dh_key);
104 return ret;
105 }
106 ctrl->dh_keysize = crypto_kpp_maxsize(ctrl->dh_tfm);
107 kfree_sensitive(ctrl->dh_key);
108 ctrl->dh_key = kzalloc(ctrl->dh_keysize, GFP_KERNEL);
109 if (!ctrl->dh_key) {
110 pr_warn("ctrl %d failed to allocate public key\n",
111 ctrl->cntlid);
112 return -ENOMEM;
113 }
114 ret = nvme_auth_gen_pubkey(ctrl->dh_tfm, ctrl->dh_key,
115 ctrl->dh_keysize);
116 if (ret < 0) {
117 pr_warn("ctrl %d failed to generate public key\n",
118 ctrl->cntlid);
119 kfree(ctrl->dh_key);
120 ctrl->dh_key = NULL;
121 }
122 }
123
124 return ret;
125 }
126
nvmet_setup_auth(struct nvmet_ctrl * ctrl)127 int nvmet_setup_auth(struct nvmet_ctrl *ctrl)
128 {
129 int ret = 0;
130 struct nvmet_host_link *p;
131 struct nvmet_host *host = NULL;
132 const char *hash_name;
133
134 down_read(&nvmet_config_sem);
135 if (nvmet_is_disc_subsys(ctrl->subsys))
136 goto out_unlock;
137
138 if (ctrl->subsys->allow_any_host)
139 goto out_unlock;
140
141 list_for_each_entry(p, &ctrl->subsys->hosts, entry) {
142 pr_debug("check %s\n", nvmet_host_name(p->host));
143 if (strcmp(nvmet_host_name(p->host), ctrl->hostnqn))
144 continue;
145 host = p->host;
146 break;
147 }
148 if (!host) {
149 pr_debug("host %s not found\n", ctrl->hostnqn);
150 ret = -EPERM;
151 goto out_unlock;
152 }
153
154 ret = nvmet_setup_dhgroup(ctrl, host->dhchap_dhgroup_id);
155 if (ret < 0)
156 pr_warn("Failed to setup DH group");
157
158 if (!host->dhchap_secret) {
159 pr_debug("No authentication provided\n");
160 goto out_unlock;
161 }
162
163 if (host->dhchap_hash_id == ctrl->shash_id) {
164 pr_debug("Re-use existing hash ID %d\n",
165 ctrl->shash_id);
166 } else {
167 hash_name = nvme_auth_hmac_name(host->dhchap_hash_id);
168 if (!hash_name) {
169 pr_warn("Hash ID %d invalid\n", host->dhchap_hash_id);
170 ret = -EINVAL;
171 goto out_unlock;
172 }
173 ctrl->shash_id = host->dhchap_hash_id;
174 }
175
176 /* Skip the 'DHHC-1:XX:' prefix */
177 nvme_auth_free_key(ctrl->host_key);
178 ctrl->host_key = nvme_auth_extract_key(host->dhchap_secret + 10,
179 host->dhchap_key_hash);
180 if (IS_ERR(ctrl->host_key)) {
181 ret = PTR_ERR(ctrl->host_key);
182 ctrl->host_key = NULL;
183 goto out_free_hash;
184 }
185 pr_debug("%s: using hash %s key %*ph\n", __func__,
186 ctrl->host_key->hash > 0 ?
187 nvme_auth_hmac_name(ctrl->host_key->hash) : "none",
188 (int)ctrl->host_key->len, ctrl->host_key->key);
189
190 nvme_auth_free_key(ctrl->ctrl_key);
191 if (!host->dhchap_ctrl_secret) {
192 ctrl->ctrl_key = NULL;
193 goto out_unlock;
194 }
195
196 ctrl->ctrl_key = nvme_auth_extract_key(host->dhchap_ctrl_secret + 10,
197 host->dhchap_ctrl_key_hash);
198 if (IS_ERR(ctrl->ctrl_key)) {
199 ret = PTR_ERR(ctrl->ctrl_key);
200 ctrl->ctrl_key = NULL;
201 goto out_free_hash;
202 }
203 pr_debug("%s: using ctrl hash %s key %*ph\n", __func__,
204 ctrl->ctrl_key->hash > 0 ?
205 nvme_auth_hmac_name(ctrl->ctrl_key->hash) : "none",
206 (int)ctrl->ctrl_key->len, ctrl->ctrl_key->key);
207
208 out_free_hash:
209 if (ret) {
210 if (ctrl->host_key) {
211 nvme_auth_free_key(ctrl->host_key);
212 ctrl->host_key = NULL;
213 }
214 ctrl->shash_id = 0;
215 }
216 out_unlock:
217 up_read(&nvmet_config_sem);
218
219 return ret;
220 }
221
nvmet_auth_sq_free(struct nvmet_sq * sq)222 void nvmet_auth_sq_free(struct nvmet_sq *sq)
223 {
224 cancel_delayed_work(&sq->auth_expired_work);
225 kfree(sq->dhchap_c1);
226 sq->dhchap_c1 = NULL;
227 kfree(sq->dhchap_c2);
228 sq->dhchap_c2 = NULL;
229 kfree(sq->dhchap_skey);
230 sq->dhchap_skey = NULL;
231 }
232
nvmet_destroy_auth(struct nvmet_ctrl * ctrl)233 void nvmet_destroy_auth(struct nvmet_ctrl *ctrl)
234 {
235 ctrl->shash_id = 0;
236
237 if (ctrl->dh_tfm) {
238 crypto_free_kpp(ctrl->dh_tfm);
239 ctrl->dh_tfm = NULL;
240 ctrl->dh_gid = 0;
241 }
242 kfree_sensitive(ctrl->dh_key);
243 ctrl->dh_key = NULL;
244
245 if (ctrl->host_key) {
246 nvme_auth_free_key(ctrl->host_key);
247 ctrl->host_key = NULL;
248 }
249 if (ctrl->ctrl_key) {
250 nvme_auth_free_key(ctrl->ctrl_key);
251 ctrl->ctrl_key = NULL;
252 }
253 }
254
nvmet_check_auth_status(struct nvmet_req * req)255 bool nvmet_check_auth_status(struct nvmet_req *req)
256 {
257 if (req->sq->ctrl->host_key &&
258 !req->sq->authenticated)
259 return false;
260 return true;
261 }
262
nvmet_auth_host_hash(struct nvmet_req * req,u8 * response,unsigned int shash_len)263 int nvmet_auth_host_hash(struct nvmet_req *req, u8 *response,
264 unsigned int shash_len)
265 {
266 struct crypto_shash *shash_tfm;
267 struct shash_desc *shash;
268 struct nvmet_ctrl *ctrl = req->sq->ctrl;
269 const char *hash_name;
270 u8 *challenge = req->sq->dhchap_c1, *host_response;
271 u8 buf[4];
272 int ret;
273
274 hash_name = nvme_auth_hmac_name(ctrl->shash_id);
275 if (!hash_name) {
276 pr_warn("Hash ID %d invalid\n", ctrl->shash_id);
277 return -EINVAL;
278 }
279
280 shash_tfm = crypto_alloc_shash(hash_name, 0, 0);
281 if (IS_ERR(shash_tfm)) {
282 pr_err("failed to allocate shash %s\n", hash_name);
283 return PTR_ERR(shash_tfm);
284 }
285
286 if (shash_len != crypto_shash_digestsize(shash_tfm)) {
287 pr_err("%s: hash len mismatch (len %d digest %d)\n",
288 __func__, shash_len,
289 crypto_shash_digestsize(shash_tfm));
290 ret = -EINVAL;
291 goto out_free_tfm;
292 }
293
294 host_response = nvme_auth_transform_key(ctrl->host_key, ctrl->hostnqn);
295 if (IS_ERR(host_response)) {
296 ret = PTR_ERR(host_response);
297 goto out_free_tfm;
298 }
299
300 ret = crypto_shash_setkey(shash_tfm, host_response,
301 ctrl->host_key->len);
302 if (ret)
303 goto out_free_response;
304
305 if (ctrl->dh_gid != NVME_AUTH_DHGROUP_NULL) {
306 challenge = kmalloc(shash_len, GFP_KERNEL);
307 if (!challenge) {
308 ret = -ENOMEM;
309 goto out_free_response;
310 }
311 ret = nvme_auth_augmented_challenge(ctrl->shash_id,
312 req->sq->dhchap_skey,
313 req->sq->dhchap_skey_len,
314 req->sq->dhchap_c1,
315 challenge, shash_len);
316 if (ret)
317 goto out_free_challenge;
318 }
319
320 pr_debug("ctrl %d qid %d host response seq %u transaction %d\n",
321 ctrl->cntlid, req->sq->qid, req->sq->dhchap_s1,
322 req->sq->dhchap_tid);
323
324 shash = kzalloc(sizeof(*shash) + crypto_shash_descsize(shash_tfm),
325 GFP_KERNEL);
326 if (!shash) {
327 ret = -ENOMEM;
328 goto out_free_challenge;
329 }
330 shash->tfm = shash_tfm;
331 ret = crypto_shash_init(shash);
332 if (ret)
333 goto out;
334 ret = crypto_shash_update(shash, challenge, shash_len);
335 if (ret)
336 goto out;
337 put_unaligned_le32(req->sq->dhchap_s1, buf);
338 ret = crypto_shash_update(shash, buf, 4);
339 if (ret)
340 goto out;
341 put_unaligned_le16(req->sq->dhchap_tid, buf);
342 ret = crypto_shash_update(shash, buf, 2);
343 if (ret)
344 goto out;
345 memset(buf, 0, 4);
346 ret = crypto_shash_update(shash, buf, 1);
347 if (ret)
348 goto out;
349 ret = crypto_shash_update(shash, "HostHost", 8);
350 if (ret)
351 goto out;
352 ret = crypto_shash_update(shash, ctrl->hostnqn, strlen(ctrl->hostnqn));
353 if (ret)
354 goto out;
355 ret = crypto_shash_update(shash, buf, 1);
356 if (ret)
357 goto out;
358 ret = crypto_shash_update(shash, ctrl->subsysnqn,
359 strlen(ctrl->subsysnqn));
360 if (ret)
361 goto out;
362 ret = crypto_shash_final(shash, response);
363 out:
364 kfree(shash);
365 out_free_challenge:
366 if (challenge != req->sq->dhchap_c1)
367 kfree(challenge);
368 out_free_response:
369 kfree_sensitive(host_response);
370 out_free_tfm:
371 crypto_free_shash(shash_tfm);
372 return ret;
373 }
374
nvmet_auth_ctrl_hash(struct nvmet_req * req,u8 * response,unsigned int shash_len)375 int nvmet_auth_ctrl_hash(struct nvmet_req *req, u8 *response,
376 unsigned int shash_len)
377 {
378 struct crypto_shash *shash_tfm;
379 struct shash_desc *shash;
380 struct nvmet_ctrl *ctrl = req->sq->ctrl;
381 const char *hash_name;
382 u8 *challenge = req->sq->dhchap_c2, *ctrl_response;
383 u8 buf[4];
384 int ret;
385
386 hash_name = nvme_auth_hmac_name(ctrl->shash_id);
387 if (!hash_name) {
388 pr_warn("Hash ID %d invalid\n", ctrl->shash_id);
389 return -EINVAL;
390 }
391
392 shash_tfm = crypto_alloc_shash(hash_name, 0, 0);
393 if (IS_ERR(shash_tfm)) {
394 pr_err("failed to allocate shash %s\n", hash_name);
395 return PTR_ERR(shash_tfm);
396 }
397
398 if (shash_len != crypto_shash_digestsize(shash_tfm)) {
399 pr_debug("%s: hash len mismatch (len %d digest %d)\n",
400 __func__, shash_len,
401 crypto_shash_digestsize(shash_tfm));
402 ret = -EINVAL;
403 goto out_free_tfm;
404 }
405
406 ctrl_response = nvme_auth_transform_key(ctrl->ctrl_key,
407 ctrl->subsysnqn);
408 if (IS_ERR(ctrl_response)) {
409 ret = PTR_ERR(ctrl_response);
410 goto out_free_tfm;
411 }
412
413 ret = crypto_shash_setkey(shash_tfm, ctrl_response,
414 ctrl->ctrl_key->len);
415 if (ret)
416 goto out_free_response;
417
418 if (ctrl->dh_gid != NVME_AUTH_DHGROUP_NULL) {
419 challenge = kmalloc(shash_len, GFP_KERNEL);
420 if (!challenge) {
421 ret = -ENOMEM;
422 goto out_free_response;
423 }
424 ret = nvme_auth_augmented_challenge(ctrl->shash_id,
425 req->sq->dhchap_skey,
426 req->sq->dhchap_skey_len,
427 req->sq->dhchap_c2,
428 challenge, shash_len);
429 if (ret)
430 goto out_free_challenge;
431 }
432
433 shash = kzalloc(sizeof(*shash) + crypto_shash_descsize(shash_tfm),
434 GFP_KERNEL);
435 if (!shash) {
436 ret = -ENOMEM;
437 goto out_free_challenge;
438 }
439 shash->tfm = shash_tfm;
440
441 ret = crypto_shash_init(shash);
442 if (ret)
443 goto out;
444 ret = crypto_shash_update(shash, challenge, shash_len);
445 if (ret)
446 goto out;
447 put_unaligned_le32(req->sq->dhchap_s2, buf);
448 ret = crypto_shash_update(shash, buf, 4);
449 if (ret)
450 goto out;
451 put_unaligned_le16(req->sq->dhchap_tid, buf);
452 ret = crypto_shash_update(shash, buf, 2);
453 if (ret)
454 goto out;
455 memset(buf, 0, 4);
456 ret = crypto_shash_update(shash, buf, 1);
457 if (ret)
458 goto out;
459 ret = crypto_shash_update(shash, "Controller", 10);
460 if (ret)
461 goto out;
462 ret = crypto_shash_update(shash, ctrl->subsysnqn,
463 strlen(ctrl->subsysnqn));
464 if (ret)
465 goto out;
466 ret = crypto_shash_update(shash, buf, 1);
467 if (ret)
468 goto out;
469 ret = crypto_shash_update(shash, ctrl->hostnqn, strlen(ctrl->hostnqn));
470 if (ret)
471 goto out;
472 ret = crypto_shash_final(shash, response);
473 out:
474 kfree(shash);
475 out_free_challenge:
476 if (challenge != req->sq->dhchap_c2)
477 kfree(challenge);
478 out_free_response:
479 kfree_sensitive(ctrl_response);
480 out_free_tfm:
481 crypto_free_shash(shash_tfm);
482 return 0;
483 }
484
nvmet_auth_ctrl_exponential(struct nvmet_req * req,u8 * buf,int buf_size)485 int nvmet_auth_ctrl_exponential(struct nvmet_req *req,
486 u8 *buf, int buf_size)
487 {
488 struct nvmet_ctrl *ctrl = req->sq->ctrl;
489 int ret = 0;
490
491 if (!ctrl->dh_key) {
492 pr_warn("ctrl %d no DH public key!\n", ctrl->cntlid);
493 return -ENOKEY;
494 }
495 if (buf_size != ctrl->dh_keysize) {
496 pr_warn("ctrl %d DH public key size mismatch, need %zu is %d\n",
497 ctrl->cntlid, ctrl->dh_keysize, buf_size);
498 ret = -EINVAL;
499 } else {
500 memcpy(buf, ctrl->dh_key, buf_size);
501 pr_debug("%s: ctrl %d public key %*ph\n", __func__,
502 ctrl->cntlid, (int)buf_size, buf);
503 }
504
505 return ret;
506 }
507
nvmet_auth_ctrl_sesskey(struct nvmet_req * req,u8 * pkey,int pkey_size)508 int nvmet_auth_ctrl_sesskey(struct nvmet_req *req,
509 u8 *pkey, int pkey_size)
510 {
511 struct nvmet_ctrl *ctrl = req->sq->ctrl;
512 int ret;
513
514 req->sq->dhchap_skey_len = ctrl->dh_keysize;
515 req->sq->dhchap_skey = kzalloc(req->sq->dhchap_skey_len, GFP_KERNEL);
516 if (!req->sq->dhchap_skey)
517 return -ENOMEM;
518 ret = nvme_auth_gen_shared_secret(ctrl->dh_tfm,
519 pkey, pkey_size,
520 req->sq->dhchap_skey,
521 req->sq->dhchap_skey_len);
522 if (ret)
523 pr_debug("failed to compute shared secret, err %d\n", ret);
524 else
525 pr_debug("%s: shared secret %*ph\n", __func__,
526 (int)req->sq->dhchap_skey_len,
527 req->sq->dhchap_skey);
528
529 return ret;
530 }
531