projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
MIPS: smp-cps: Clear Status IPL field when using EIC
[linux-2.6-block.git] / net / bluetooth / smp.c
CommitLineData
eb492e01
AB		 1/*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License version 2 as
7 published by the Free Software Foundation;
8
9 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
10 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
11 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
12 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
13 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
14 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17
18 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
19 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
20 SOFTWARE IS DISCLAIMED.
21*/
22
300acfde 23#include <linux/debugfs.h>
8c520a59
GP		 24#include <linux/scatterlist.h>
25#include <crypto/b128ops.h>
71af2f6b
HX		 26#include <crypto/hash.h>
27#include <crypto/skcipher.h>
8c520a59 28
eb492e01
AB		 29#include <net/bluetooth/bluetooth.h>
30#include <net/bluetooth/hci_core.h>
31#include <net/bluetooth/l2cap.h>
2b64d153 32#include <net/bluetooth/mgmt.h>
ac4b7236 33
3b19146d 34#include "ecc.h"
ac4b7236 35#include "smp.h"
d22ef0bc 36
2fd36558
JH		 37#define SMP_DEV(hdev) \
38 ((struct smp_dev *)((struct l2cap_chan *)((hdev)->smp_data))->data)
39
c7a3d57d
JH		 40/* Low-level debug macros to be used for stuff that we don't want
41 * accidentially in dmesg, i.e. the values of the various crypto keys
42 * and the inputs & outputs of crypto functions.
43 */
44#ifdef DEBUG
45#define SMP_DBG(fmt, ...) printk(KERN_DEBUG "%s: " fmt, __func__, \
46 ##__VA_ARGS__)
47#else
48#define SMP_DBG(fmt, ...) no_printk(KERN_DEBUG "%s: " fmt, __func__, \
49 ##__VA_ARGS__)
50#endif
51
b28b4943 52#define SMP_ALLOW_CMD(smp, code) set_bit(code, &smp->allow_cmd)
b28b4943 53
3b19146d
JH		 54/* Keys which are not distributed with Secure Connections */
55#define SMP_SC_NO_DIST (SMP_DIST_ENC_KEY | SMP_DIST_LINK_KEY);
56
17b02e62 57#define SMP_TIMEOUT msecs_to_jiffies(30000)
5d3de7df 58
d7a5a11d 59#define AUTH_REQ_MASK(dev) (hci_dev_test_flag(dev, HCI_SC_ENABLED) ? \
0edb14de
JH		 60 0x1f : 0x07)
61#define KEY_DIST_MASK 0x07
065a13e2 62
cbbbe3e2
JH		 63/* Maximum message length that can be passed to aes_cmac */
64#define CMAC_MSG_MAX 80
65
533e35d4
JH		 66enum {
67 SMP_FLAG_TK_VALID,
68 SMP_FLAG_CFM_PENDING,
69 SMP_FLAG_MITM_AUTH,
70 SMP_FLAG_COMPLETE,
71 SMP_FLAG_INITIATOR,
65668776 72 SMP_FLAG_SC,
d8f8edbe 73 SMP_FLAG_REMOTE_PK,
aeb7d461 74 SMP_FLAG_DEBUG_KEY,
38606f14 75 SMP_FLAG_WAIT_USER,
d3e54a87 76 SMP_FLAG_DHKEY_PENDING,
1a8bab4f
JH		 77 SMP_FLAG_REMOTE_OOB,
78 SMP_FLAG_LOCAL_OOB,
533e35d4 79};
4bc58f51 80
88a479d9 81struct smp_dev {
60a27d65
MH		 82 /* Secure Connections OOB data */
83 u8 local_pk[64];
84 u8 local_sk[32];
fb334fee 85 u8 local_rand[16];
60a27d65
MH		 86 bool debug_key;
87
b1f663c9 88 u8 min_key_size;
2fd36558
JH		 89 u8 max_key_size;
90
71af2f6b
HX		 91 struct crypto_skcipher *tfm_aes;
92 struct crypto_shash *tfm_cmac;
88a479d9
MH		 93};
94
4bc58f51 95struct smp_chan {
b68fda68
JH		 96 struct l2cap_conn *conn;
97 struct delayed_work security_timer;
b28b4943 98 unsigned long allow_cmd; /* Bitmask of allowed commands */
b68fda68 99
4bc58f51
JH		 100 u8 preq[7]; /* SMP Pairing Request */
101 u8 prsp[7]; /* SMP Pairing Response */
102 u8 prnd[16]; /* SMP Pairing Random (local) */
103 u8 rrnd[16]; /* SMP Pairing Random (remote) */
104 u8 pcnf[16]; /* SMP Pairing Confirm */
105 u8 tk[16]; /* SMP Temporary Key */
882fafad
JH		 106 u8 rr[16]; /* Remote OOB ra/rb value */
107 u8 lr[16]; /* Local OOB ra/rb value */
4bc58f51
JH		 108 u8 enc_key_size;
109 u8 remote_key_dist;
110 bdaddr_t id_addr;
111 u8 id_addr_type;
112 u8 irk[16];
113 struct smp_csrk *csrk;
114 struct smp_csrk *slave_csrk;
115 struct smp_ltk *ltk;
116 struct smp_ltk *slave_ltk;
117 struct smp_irk *remote_irk;
6a77083a 118 u8 *link_key;
4a74d658 119 unsigned long flags;
783e0574 120 u8 method;
38606f14 121 u8 passkey_round;
6a7bd103 122
3b19146d
JH		 123 /* Secure Connections variables */
124 u8 local_pk[64];
125 u8 local_sk[32];
d8f8edbe
JH		 126 u8 remote_pk[64];
127 u8 dhkey[32];
760b018b 128 u8 mackey[16];
3b19146d 129
71af2f6b
HX		 130 struct crypto_skcipher *tfm_aes;
131 struct crypto_shash *tfm_cmac;
4bc58f51
JH		 132};
133
aeb7d461
JH		 134/* These debug key values are defined in the SMP section of the core
135 * specification. debug_pk is the public debug key and debug_sk the
136 * private debug key.
137 */
138static const u8 debug_pk[64] = {
139 0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
140 0xdb, 0xfd, 0xf4, 0xac, 0x11, 0x91, 0xf4, 0xef,
141 0xb9, 0xa5, 0xf9, 0xe9, 0xa7, 0x83, 0x2c, 0x5e,
142 0x2c, 0xbe, 0x97, 0xf2, 0xd2, 0x03, 0xb0, 0x20,
143
144 0x8b, 0xd2, 0x89, 0x15, 0xd0, 0x8e, 0x1c, 0x74,
145 0x24, 0x30, 0xed, 0x8f, 0xc2, 0x45, 0x63, 0x76,
146 0x5c, 0x15, 0x52, 0x5a, 0xbf, 0x9a, 0x32, 0x63,
147 0x6d, 0xeb, 0x2a, 0x65, 0x49, 0x9c, 0x80, 0xdc,
148};
149
150static const u8 debug_sk[32] = {
151 0xbd, 0x1a, 0x3c, 0xcd, 0xa6, 0xb8, 0x99, 0x58,
152 0x99, 0xb7, 0x40, 0xeb, 0x7b, 0x60, 0xff, 0x4a,
153 0x50, 0x3f, 0x10, 0xd2, 0xe3, 0xb3, 0xc9, 0x74,
154 0x38, 0x5f, 0xc5, 0xa3, 0xd4, 0xf6, 0x49, 0x3f,
155};
156
8a2936f4 157static inline void swap_buf(const u8 *src, u8 *dst, size_t len)
d22ef0bc 158{
8a2936f4 159 size_t i;
d22ef0bc 160
8a2936f4
JH		 161 for (i = 0; i < len; i++)
162 dst[len - 1 - i] = src[i];
d22ef0bc
AB		 163}
164
06edf8de
JH		 165/* The following functions map to the LE SC SMP crypto functions
166 * AES-CMAC, f4, f5, f6, g2 and h6.
167 */
168
71af2f6b 169static int aes_cmac(struct crypto_shash *tfm, const u8 k[16], const u8 *m,
cbbbe3e2
JH		 170 size_t len, u8 mac[16])
171{
172 uint8_t tmp[16], mac_msb[16], msg_msb[CMAC_MSG_MAX];
71af2f6b 173 SHASH_DESC_ON_STACK(desc, tfm);
cbbbe3e2
JH		 174 int err;
175
176 if (len > CMAC_MSG_MAX)
177 return -EFBIG;
178
179 if (!tfm) {
180 BT_ERR("tfm %p", tfm);
181 return -EINVAL;
182 }
183
71af2f6b
HX		 184 desc->tfm = tfm;
185 desc->flags = 0;
cbbbe3e2
JH		 186
187 /* Swap key and message from LSB to MSB */
188 swap_buf(k, tmp, 16);
189 swap_buf(m, msg_msb, len);
190
c7a3d57d
JH		 191 SMP_DBG("msg (len %zu) %*phN", len, (int) len, m);
192 SMP_DBG("key %16phN", k);
cbbbe3e2 193
71af2f6b 194 err = crypto_shash_setkey(tfm, tmp, 16);
cbbbe3e2
JH		 195 if (err) {
196 BT_ERR("cipher setkey failed: %d", err);
197 return err;
198 }
199
71af2f6b
HX		 200 err = crypto_shash_digest(desc, msg_msb, len, mac_msb);
201 shash_desc_zero(desc);
cbbbe3e2 202 if (err) {
71af2f6b 203 BT_ERR("Hash computation error %d", err);
cbbbe3e2
JH		 204 return err;
205 }
206
207 swap_buf(mac_msb, mac, 16);
208
c7a3d57d 209 SMP_DBG("mac %16phN", mac);
cbbbe3e2
JH		 210
211 return 0;
212}
213
71af2f6b
HX		 214static int smp_f4(struct crypto_shash *tfm_cmac, const u8 u[32],
215 const u8 v[32], const u8 x[16], u8 z, u8 res[16])
cbbbe3e2
JH		 216{
217 u8 m[65];
218 int err;
219
c7a3d57d
JH		 220 SMP_DBG("u %32phN", u);
221 SMP_DBG("v %32phN", v);
222 SMP_DBG("x %16phN z %02x", x, z);
cbbbe3e2
JH		 223
224 m[0] = z;
225 memcpy(m + 1, v, 32);
226 memcpy(m + 33, u, 32);
227
228 err = aes_cmac(tfm_cmac, x, m, sizeof(m), res);
229 if (err)
230 return err;
231
c7a3d57d 232 SMP_DBG("res %16phN", res);
cbbbe3e2
JH		 233
234 return err;
235}
236
71af2f6b 237static int smp_f5(struct crypto_shash *tfm_cmac, const u8 w[32],
4da50de8
JH		 238 const u8 n1[16], const u8 n2[16], const u8 a1[7],
239 const u8 a2[7], u8 mackey[16], u8 ltk[16])
760b018b
JH		 240{
241 /* The btle, salt and length "magic" values are as defined in
242 * the SMP section of the Bluetooth core specification. In ASCII
243 * the btle value ends up being 'btle'. The salt is just a
244 * random number whereas length is the value 256 in little
245 * endian format.
246 */
247 const u8 btle[4] = { 0x65, 0x6c, 0x74, 0x62 };
248 const u8 salt[16] = { 0xbe, 0x83, 0x60, 0x5a, 0xdb, 0x0b, 0x37, 0x60,
249 0x38, 0xa5, 0xf5, 0xaa, 0x91, 0x83, 0x88, 0x6c };
250 const u8 length[2] = { 0x00, 0x01 };
251 u8 m[53], t[16];
252 int err;
253
c7a3d57d
JH		 254 SMP_DBG("w %32phN", w);
255 SMP_DBG("n1 %16phN n2 %16phN", n1, n2);
256 SMP_DBG("a1 %7phN a2 %7phN", a1, a2);
760b018b
JH		 257
258 err = aes_cmac(tfm_cmac, salt, w, 32, t);
259 if (err)
260 return err;
261
c7a3d57d 262 SMP_DBG("t %16phN", t);
760b018b
JH		 263
264 memcpy(m, length, 2);
265 memcpy(m + 2, a2, 7);
266 memcpy(m + 9, a1, 7);
267 memcpy(m + 16, n2, 16);
268 memcpy(m + 32, n1, 16);
269 memcpy(m + 48, btle, 4);
270
271 m[52] = 0; /* Counter */
272
273 err = aes_cmac(tfm_cmac, t, m, sizeof(m), mackey);
274 if (err)
275 return err;
276
c7a3d57d 277 SMP_DBG("mackey %16phN", mackey);
760b018b
JH		 278
279 m[52] = 1; /* Counter */
280
281 err = aes_cmac(tfm_cmac, t, m, sizeof(m), ltk);
282 if (err)
283 return err;
284
c7a3d57d 285 SMP_DBG("ltk %16phN", ltk);
760b018b
JH		 286
287 return 0;
288}
289
71af2f6b 290static int smp_f6(struct crypto_shash *tfm_cmac, const u8 w[16],
4da50de8 291 const u8 n1[16], const u8 n2[16], const u8 r[16],
760b018b
JH		 292 const u8 io_cap[3], const u8 a1[7], const u8 a2[7],
293 u8 res[16])
294{
295 u8 m[65];
296 int err;
297
c7a3d57d
JH		 298 SMP_DBG("w %16phN", w);
299 SMP_DBG("n1 %16phN n2 %16phN", n1, n2);
300 SMP_DBG("r %16phN io_cap %3phN a1 %7phN a2 %7phN", r, io_cap, a1, a2);
760b018b
JH		 301
302 memcpy(m, a2, 7);
303 memcpy(m + 7, a1, 7);
304 memcpy(m + 14, io_cap, 3);
305 memcpy(m + 17, r, 16);
306 memcpy(m + 33, n2, 16);
307 memcpy(m + 49, n1, 16);
308
309 err = aes_cmac(tfm_cmac, w, m, sizeof(m), res);
310 if (err)
311 return err;
312
203de21b 313 SMP_DBG("res %16phN", res);
760b018b
JH		 314
315 return err;
316}
317
71af2f6b 318static int smp_g2(struct crypto_shash *tfm_cmac, const u8 u[32], const u8 v[32],
191dc7fe
JH		 319 const u8 x[16], const u8 y[16], u32 *val)
320{
321 u8 m[80], tmp[16];
322 int err;
323
c7a3d57d
JH		 324 SMP_DBG("u %32phN", u);
325 SMP_DBG("v %32phN", v);
326 SMP_DBG("x %16phN y %16phN", x, y);
191dc7fe
JH		 327
328 memcpy(m, y, 16);
329 memcpy(m + 16, v, 32);
330 memcpy(m + 48, u, 32);
331
332 err = aes_cmac(tfm_cmac, x, m, sizeof(m), tmp);
333 if (err)
334 return err;
335
336 *val = get_unaligned_le32(tmp);
337 *val %= 1000000;
338
c7a3d57d 339 SMP_DBG("val %06u", *val);
191dc7fe
JH		 340
341 return 0;
342}
343
71af2f6b 344static int smp_h6(struct crypto_shash *tfm_cmac, const u8 w[16],
06edf8de
JH		 345 const u8 key_id[4], u8 res[16])
346{
347 int err;
348
349 SMP_DBG("w %16phN key_id %4phN", w, key_id);
350
351 err = aes_cmac(tfm_cmac, w, key_id, 4, res);
352 if (err)
353 return err;
354
355 SMP_DBG("res %16phN", res);
356
357 return err;
358}
359
360/* The following functions map to the legacy SMP crypto functions e, c1,
361 * s1 and ah.
362 */
363
71af2f6b 364static int smp_e(struct crypto_skcipher *tfm, const u8 *k, u8 *r)
d22ef0bc 365{
71af2f6b 366 SKCIPHER_REQUEST_ON_STACK(req, tfm);
d22ef0bc 367 struct scatterlist sg;
943a732a 368 uint8_t tmp[16], data[16];
201a5929 369 int err;
d22ef0bc 370
011c391a
JH		 371 SMP_DBG("k %16phN r %16phN", k, r);
372
7f376cd6 373 if (!tfm) {
d22ef0bc
AB		 374 BT_ERR("tfm %p", tfm);
375 return -EINVAL;
376 }
377
943a732a 378 /* The most significant octet of key corresponds to k[0] */
8a2936f4 379 swap_buf(k, tmp, 16);
943a732a 380
71af2f6b 381 err = crypto_skcipher_setkey(tfm, tmp, 16);
d22ef0bc
AB		 382 if (err) {
383 BT_ERR("cipher setkey failed: %d", err);
384 return err;
385 }
386
943a732a 387 /* Most significant octet of plaintextData corresponds to data[0] */
8a2936f4 388 swap_buf(r, data, 16);
943a732a
JH		 389
390 sg_init_one(&sg, data, 16);
d22ef0bc 391
71af2f6b
HX		 392 skcipher_request_set_tfm(req, tfm);
393 skcipher_request_set_callback(req, 0, NULL, NULL);
394 skcipher_request_set_crypt(req, &sg, &sg, 16, NULL);
395
396 err = crypto_skcipher_encrypt(req);
397 skcipher_request_zero(req);
d22ef0bc
AB		 398 if (err)
399 BT_ERR("Encrypt data error %d", err);
400
943a732a 401 /* Most significant octet of encryptedData corresponds to data[0] */
8a2936f4 402 swap_buf(data, r, 16);
943a732a 403
011c391a
JH		 404 SMP_DBG("r %16phN", r);
405
d22ef0bc
AB		 406 return err;
407}
408
71af2f6b 409static int smp_c1(struct crypto_skcipher *tfm_aes, const u8 k[16],
06edf8de
JH		 410 const u8 r[16], const u8 preq[7], const u8 pres[7], u8 _iat,
411 const bdaddr_t *ia, u8 _rat, const bdaddr_t *ra, u8 res[16])
6a77083a 412{
06edf8de 413 u8 p1[16], p2[16];
6a77083a
JH		 414 int err;
415
011c391a
JH		 416 SMP_DBG("k %16phN r %16phN", k, r);
417 SMP_DBG("iat %u ia %6phN rat %u ra %6phN", _iat, ia, _rat, ra);
418 SMP_DBG("preq %7phN pres %7phN", preq, pres);
419
06edf8de 420 memset(p1, 0, 16);
6a77083a 421
06edf8de
JH		 422 /* p1 = pres || preq || _rat || _iat */
423 p1[0] = _iat;
424 p1[1] = _rat;
425 memcpy(p1 + 2, preq, 7);
426 memcpy(p1 + 9, pres, 7);
427
011c391a 428 SMP_DBG("p1 %16phN", p1);
06edf8de
JH		 429
430 /* res = r XOR p1 */
431 u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);
432
433 /* res = e(k, res) */
434 err = smp_e(tfm_aes, k, res);
435 if (err) {
436 BT_ERR("Encrypt data error");
6a77083a 437 return err;
06edf8de 438 }
6a77083a 439
011c391a
JH		 440 /* p2 = padding || ia || ra */
441 memcpy(p2, ra, 6);
442 memcpy(p2 + 6, ia, 6);
443 memset(p2 + 12, 0, 4);
444
445 SMP_DBG("p2 %16phN", p2);
446
06edf8de
JH		 447 /* res = res XOR p2 */
448 u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);
449
450 /* res = e(k, res) */
451 err = smp_e(tfm_aes, k, res);
452 if (err)
453 BT_ERR("Encrypt data error");
454
455 return err;
456}
457
71af2f6b 458static int smp_s1(struct crypto_skcipher *tfm_aes, const u8 k[16],
06edf8de
JH		 459 const u8 r1[16], const u8 r2[16], u8 _r[16])
460{
461 int err;
462
463 /* Just least significant octets from r1 and r2 are considered */
464 memcpy(_r, r2, 8);
465 memcpy(_r + 8, r1, 8);
466
467 err = smp_e(tfm_aes, k, _r);
468 if (err)
469 BT_ERR("Encrypt data error");
6a77083a
JH		 470
471 return err;
472}
473
71af2f6b 474static int smp_ah(struct crypto_skcipher *tfm, const u8 irk[16],
cd082797 475 const u8 r[3], u8 res[3])
60478054 476{
943a732a 477 u8 _res[16];
60478054
JH		 478 int err;
479
480 /* r' = padding || r */
943a732a
JH		 481 memcpy(_res, r, 3);
482 memset(_res + 3, 0, 13);
60478054 483
943a732a 484 err = smp_e(tfm, irk, _res);
60478054
JH		 485 if (err) {
486 BT_ERR("Encrypt error");
487 return err;
488 }
489
490 /* The output of the random address function ah is:
c5080d42 491 * ah(k, r) = e(k, r') mod 2^24
60478054
JH		 492 * The output of the security function e is then truncated to 24 bits
493 * by taking the least significant 24 bits of the output of e as the
494 * result of ah.
495 */
943a732a 496 memcpy(res, _res, 3);
60478054
JH		 497
498 return 0;
499}
500
cd082797
JH		 501bool smp_irk_matches(struct hci_dev *hdev, const u8 irk[16],
502 const bdaddr_t *bdaddr)
60478054 503{
defce9e8 504 struct l2cap_chan *chan = hdev->smp_data;
88a479d9 505 struct smp_dev *smp;
60478054
JH		 506 u8 hash[3];
507 int err;
508
defce9e8
JH		 509 if (!chan || !chan->data)
510 return false;
511
88a479d9 512 smp = chan->data;
defce9e8 513
60478054
JH		 514 BT_DBG("RPA %pMR IRK %*phN", bdaddr, 16, irk);
515
88a479d9 516 err = smp_ah(smp->tfm_aes, irk, &bdaddr->b[3], hash);
60478054
JH		 517 if (err)
518 return false;
519
520 return !memcmp(bdaddr->b, hash, 3);
521}
522
cd082797 523int smp_generate_rpa(struct hci_dev *hdev, const u8 irk[16], bdaddr_t *rpa)
b1e2b3ae 524{
defce9e8 525 struct l2cap_chan *chan = hdev->smp_data;
88a479d9 526 struct smp_dev *smp;
b1e2b3ae
JH		 527 int err;
528
defce9e8
JH		 529 if (!chan || !chan->data)
530 return -EOPNOTSUPP;
531
88a479d9 532 smp = chan->data;
defce9e8 533
b1e2b3ae
JH		 534 get_random_bytes(&rpa->b[3], 3);
535
536 rpa->b[5] &= 0x3f; /* Clear two most significant bits */
537 rpa->b[5] |= 0x40; /* Set second most significant bit */
538
88a479d9 539 err = smp_ah(smp->tfm_aes, irk, &rpa->b[3], rpa->b);
b1e2b3ae
JH		 540 if (err < 0)
541 return err;
542
543 BT_DBG("RPA %pMR", rpa);
544
545 return 0;
546}
547
60a27d65
MH		 548int smp_generate_oob(struct hci_dev *hdev, u8 hash[16], u8 rand[16])
549{
550 struct l2cap_chan *chan = hdev->smp_data;
551 struct smp_dev *smp;
552 int err;
553
554 if (!chan || !chan->data)
555 return -EOPNOTSUPP;
556
557 smp = chan->data;
558
559 if (hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS)) {
560 BT_DBG("Using debug keys");
561 memcpy(smp->local_pk, debug_pk, 64);
562 memcpy(smp->local_sk, debug_sk, 32);
563 smp->debug_key = true;
564 } else {
565 while (true) {
566 /* Generate local key pair for Secure Connections */
567 if (!ecc_make_key(smp->local_pk, smp->local_sk))
568 return -EIO;
569
570 /* This is unlikely, but we need to check that
571 * we didn't accidentially generate a debug key.
572 */
573 if (memcmp(smp->local_sk, debug_sk, 32))
574 break;
575 }
576 smp->debug_key = false;
577 }
578
579 SMP_DBG("OOB Public Key X: %32phN", smp->local_pk);
580 SMP_DBG("OOB Public Key Y: %32phN", smp->local_pk + 32);
581 SMP_DBG("OOB Private Key: %32phN", smp->local_sk);
582
fb334fee 583 get_random_bytes(smp->local_rand, 16);
60a27d65
MH		 584
585 err = smp_f4(smp->tfm_cmac, smp->local_pk, smp->local_pk,
fb334fee 586 smp->local_rand, 0, hash);
60a27d65
MH		 587 if (err < 0)
588 return err;
589
fb334fee 590 memcpy(rand, smp->local_rand, 16);
60a27d65
MH		 591
592 return 0;
593}
594
5d88cc73 595static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
eb492e01 596{
5d88cc73 597 struct l2cap_chan *chan = conn->smp;
b68fda68 598 struct smp_chan *smp;
5d88cc73
JH		 599 struct kvec iv[2];
600 struct msghdr msg;
eb492e01 601
5d88cc73
JH		 602 if (!chan)
603 return;
eb492e01 604
5d88cc73 605 BT_DBG("code 0x%2.2x", code);
eb492e01 606
5d88cc73
JH		 607 iv[0].iov_base = &code;
608 iv[0].iov_len = 1;
eb492e01 609
5d88cc73
JH		 610 iv[1].iov_base = data;
611 iv[1].iov_len = len;
eb492e01 612
5d88cc73 613 memset(&msg, 0, sizeof(msg));
eb492e01 614
17836394 615 iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, iv, 2, 1 + len);
eb492e01 616
5d88cc73 617 l2cap_chan_send(chan, &msg, 1 + len);
e2dcd113 618
b68fda68
JH		 619 if (!chan->data)
620 return;
621
622 smp = chan->data;
623
624 cancel_delayed_work_sync(&smp->security_timer);
1b0921d6 625 schedule_delayed_work(&smp->security_timer, SMP_TIMEOUT);
eb492e01
AB		 626}
627
d2eb9e10 628static u8 authreq_to_seclevel(u8 authreq)
2b64d153 629{
d2eb9e10
JH		 630 if (authreq & SMP_AUTH_MITM) {
631 if (authreq & SMP_AUTH_SC)
632 return BT_SECURITY_FIPS;
633 else
634 return BT_SECURITY_HIGH;
635 } else {
2b64d153 636 return BT_SECURITY_MEDIUM;
d2eb9e10 637 }
2b64d153
BG		 638}
639
640static __u8 seclevel_to_authreq(__u8 sec_level)
641{
642 switch (sec_level) {
d2eb9e10 643 case BT_SECURITY_FIPS:
2b64d153
BG		 644 case BT_SECURITY_HIGH:
645 return SMP_AUTH_MITM | SMP_AUTH_BONDING;
646 case BT_SECURITY_MEDIUM:
647 return SMP_AUTH_BONDING;
648 default:
649 return SMP_AUTH_NONE;
650 }
651}
652
b8e66eac 653static void build_pairing_cmd(struct l2cap_conn *conn,
f1560463
MH		 654 struct smp_cmd_pairing *req,
655 struct smp_cmd_pairing *rsp, __u8 authreq)
b8e66eac 656{
5d88cc73
JH		 657 struct l2cap_chan *chan = conn->smp;
658 struct smp_chan *smp = chan->data;
fd349c02
JH		 659 struct hci_conn *hcon = conn->hcon;
660 struct hci_dev *hdev = hcon->hdev;
02b05bd8 661 u8 local_dist = 0, remote_dist = 0, oob_flag = SMP_OOB_NOT_PRESENT;
54790f73 662
d7a5a11d 663 if (hci_dev_test_flag(hdev, HCI_BONDABLE)) {
7ee4ea36
MH		 664 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
665 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
54790f73 666 authreq |= SMP_AUTH_BONDING;
2b64d153
BG		 667 } else {
668 authreq &= ~SMP_AUTH_BONDING;
54790f73
VCG		 669 }
670
d7a5a11d 671 if (hci_dev_test_flag(hdev, HCI_RPA_RESOLVING))
fd349c02
JH		 672 remote_dist |= SMP_DIST_ID_KEY;
673
d7a5a11d 674 if (hci_dev_test_flag(hdev, HCI_PRIVACY))
863efaf2
JH		 675 local_dist |= SMP_DIST_ID_KEY;
676
d7a5a11d 677 if (hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
02b05bd8
JH		 678 (authreq & SMP_AUTH_SC)) {
679 struct oob_data *oob_data;
680 u8 bdaddr_type;
681
d7a5a11d 682 if (hci_dev_test_flag(hdev, HCI_SSP_ENABLED)) {
df8e1a4c
JH		 683 local_dist |= SMP_DIST_LINK_KEY;
684 remote_dist |= SMP_DIST_LINK_KEY;
685 }
02b05bd8
JH		 686
687 if (hcon->dst_type == ADDR_LE_DEV_PUBLIC)
688 bdaddr_type = BDADDR_LE_PUBLIC;
689 else
690 bdaddr_type = BDADDR_LE_RANDOM;
691
692 oob_data = hci_find_remote_oob_data(hdev, &hcon->dst,
693 bdaddr_type);
4775a4ea 694 if (oob_data && oob_data->present) {
1a8bab4f 695 set_bit(SMP_FLAG_REMOTE_OOB, &smp->flags);
02b05bd8 696 oob_flag = SMP_OOB_PRESENT;
a29b0733 697 memcpy(smp->rr, oob_data->rand256, 16);
02b05bd8 698 memcpy(smp->pcnf, oob_data->hash256, 16);
bc07cd69
MH		 699 SMP_DBG("OOB Remote Confirmation: %16phN", smp->pcnf);
700 SMP_DBG("OOB Remote Random: %16phN", smp->rr);
02b05bd8
JH		 701 }
702
df8e1a4c
JH		 703 } else {
704 authreq &= ~SMP_AUTH_SC;
705 }
706
54790f73
VCG		 707 if (rsp == NULL) {
708 req->io_capability = conn->hcon->io_capability;
02b05bd8 709 req->oob_flag = oob_flag;
2fd36558 710 req->max_key_size = SMP_DEV(hdev)->max_key_size;
fd349c02
JH		 711 req->init_key_dist = local_dist;
712 req->resp_key_dist = remote_dist;
0edb14de 713 req->auth_req = (authreq & AUTH_REQ_MASK(hdev));
fd349c02
JH		 714
715 smp->remote_key_dist = remote_dist;
54790f73
VCG		 716 return;
717 }
718
719 rsp->io_capability = conn->hcon->io_capability;
02b05bd8 720 rsp->oob_flag = oob_flag;
2fd36558 721 rsp->max_key_size = SMP_DEV(hdev)->max_key_size;
fd349c02
JH		 722 rsp->init_key_dist = req->init_key_dist & remote_dist;
723 rsp->resp_key_dist = req->resp_key_dist & local_dist;
0edb14de 724 rsp->auth_req = (authreq & AUTH_REQ_MASK(hdev));
fd349c02
JH		 725
726 smp->remote_key_dist = rsp->init_key_dist;
b8e66eac
VCG		 727}
728
3158c50c
VCG		 729static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
730{
5d88cc73 731 struct l2cap_chan *chan = conn->smp;
2fd36558 732 struct hci_dev *hdev = conn->hcon->hdev;
5d88cc73 733 struct smp_chan *smp = chan->data;
1c1def09 734
2fd36558
JH		 735 if (max_key_size > SMP_DEV(hdev)->max_key_size ||
736 max_key_size < SMP_MIN_ENC_KEY_SIZE)
3158c50c
VCG		 737 return SMP_ENC_KEY_SIZE;
738
f7aa611a 739 smp->enc_key_size = max_key_size;
3158c50c
VCG		 740
741 return 0;
742}
743
6f48e260
JH		 744static void smp_chan_destroy(struct l2cap_conn *conn)
745{
746 struct l2cap_chan *chan = conn->smp;
747 struct smp_chan *smp = chan->data;
923e2414 748 struct hci_conn *hcon = conn->hcon;
6f48e260
JH		 749 bool complete;
750
751 BUG_ON(!smp);
752
753 cancel_delayed_work_sync(&smp->security_timer);
6f48e260 754
6f48e260 755 complete = test_bit(SMP_FLAG_COMPLETE, &smp->flags);
923e2414 756 mgmt_smp_complete(hcon, complete);
6f48e260 757
276812ec
MH		 758 kzfree(smp->csrk);
759 kzfree(smp->slave_csrk);
760 kzfree(smp->link_key);
6f48e260 761
71af2f6b
HX		 762 crypto_free_skcipher(smp->tfm_aes);
763 crypto_free_shash(smp->tfm_cmac);
6f48e260 764
923e2414
JH		 765 /* Ensure that we don't leave any debug key around if debug key
766 * support hasn't been explicitly enabled.
767 */
768 if (smp->ltk && smp->ltk->type == SMP_LTK_P256_DEBUG &&
d7a5a11d 769 !hci_dev_test_flag(hcon->hdev, HCI_KEEP_DEBUG_KEYS)) {
923e2414
JH		 770 list_del_rcu(&smp->ltk->list);
771 kfree_rcu(smp->ltk, rcu);
772 smp->ltk = NULL;
773 }
774
6f48e260
JH		 775 /* If pairing failed clean up any keys we might have */
776 if (!complete) {
777 if (smp->ltk) {
970d0f1b
JH		 778 list_del_rcu(&smp->ltk->list);
779 kfree_rcu(smp->ltk, rcu);
6f48e260
JH		 780 }
781
782 if (smp->slave_ltk) {
970d0f1b
JH		 783 list_del_rcu(&smp->slave_ltk->list);
784 kfree_rcu(smp->slave_ltk, rcu);
6f48e260
JH		 785 }
786
787 if (smp->remote_irk) {
adae20cb
JH		 788 list_del_rcu(&smp->remote_irk->list);
789 kfree_rcu(smp->remote_irk, rcu);
6f48e260
JH		 790 }
791 }
792
793 chan->data = NULL;
276812ec 794 kzfree(smp);
923e2414 795 hci_conn_drop(hcon);
6f48e260
JH		 796}
797
84794e11 798static void smp_failure(struct l2cap_conn *conn, u8 reason)
4f957a76 799{
bab73cb6 800 struct hci_conn *hcon = conn->hcon;
b68fda68 801 struct l2cap_chan *chan = conn->smp;
bab73cb6 802
84794e11 803 if (reason)
4f957a76 804 smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason),
f1560463 805 &reason);
4f957a76 806
e1e930f5 807 mgmt_auth_failed(hcon, HCI_ERROR_AUTH_FAILURE);
f1c09c07 808
fc75cc86 809 if (chan->data)
f1c09c07 810 smp_chan_destroy(conn);
4f957a76
BG		 811}
812
2b64d153
BG		 813#define JUST_WORKS 0x00
814#define JUST_CFM 0x01
815#define REQ_PASSKEY 0x02
816#define CFM_PASSKEY 0x03
817#define REQ_OOB 0x04
5e3d3d9b 818#define DSP_PASSKEY 0x05
2b64d153
BG		 819#define OVERLAP 0xFF
820
821static const u8 gen_method[5][5] = {
822 { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
823 { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
824 { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
825 { JUST_WORKS, JUST_CFM, JUST_WORKS, JUST_WORKS, JUST_CFM },
826 { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP },
827};
828
5e3d3d9b
JH		 829static const u8 sc_method[5][5] = {
830 { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
831 { JUST_WORKS, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
832 { DSP_PASSKEY, DSP_PASSKEY, REQ_PASSKEY, JUST_WORKS, DSP_PASSKEY },
833 { JUST_WORKS, JUST_CFM, JUST_WORKS, JUST_WORKS, JUST_CFM },
834 { DSP_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
835};
836
581370cc
JH		 837static u8 get_auth_method(struct smp_chan *smp, u8 local_io, u8 remote_io)
838{
2bcd4003
JH		 839 /* If either side has unknown io_caps, use JUST_CFM (which gets
840 * converted later to JUST_WORKS if we're initiators.
841 */
581370cc
JH		 842 if (local_io > SMP_IO_KEYBOARD_DISPLAY ||
843 remote_io > SMP_IO_KEYBOARD_DISPLAY)
2bcd4003 844 return JUST_CFM;
581370cc 845
5e3d3d9b
JH		 846 if (test_bit(SMP_FLAG_SC, &smp->flags))
847 return sc_method[remote_io][local_io];
848
581370cc
JH		 849 return gen_method[remote_io][local_io];
850}
851
2b64d153
BG		 852static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth,
853 u8 local_io, u8 remote_io)
854{
855 struct hci_conn *hcon = conn->hcon;
5d88cc73
JH		 856 struct l2cap_chan *chan = conn->smp;
857 struct smp_chan *smp = chan->data;
2b64d153
BG		 858 u32 passkey = 0;
859 int ret = 0;
860
861 /* Initialize key for JUST WORKS */
862 memset(smp->tk, 0, sizeof(smp->tk));
4a74d658 863 clear_bit(SMP_FLAG_TK_VALID, &smp->flags);
2b64d153
BG		 864
865 BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io);
866
2bcd4003
JH		 867 /* If neither side wants MITM, either "just" confirm an incoming
868 * request or use just-works for outgoing ones. The JUST_CFM
869 * will be converted to JUST_WORKS if necessary later in this
870 * function. If either side has MITM look up the method from the
871 * table.
872 */
581370cc 873 if (!(auth & SMP_AUTH_MITM))
783e0574 874 smp->method = JUST_CFM;
2b64d153 875 else
783e0574 876 smp->method = get_auth_method(smp, local_io, remote_io);
2b64d153 877
a82505c7 878 /* Don't confirm locally initiated pairing attempts */
783e0574
JH		 879 if (smp->method == JUST_CFM && test_bit(SMP_FLAG_INITIATOR,
880 &smp->flags))
881 smp->method = JUST_WORKS;
a82505c7 882
02f3e254 883 /* Don't bother user space with no IO capabilities */
783e0574
JH		 884 if (smp->method == JUST_CFM &&
885 hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
886 smp->method = JUST_WORKS;
02f3e254 887
2b64d153 888 /* If Just Works, Continue with Zero TK */
783e0574 889 if (smp->method == JUST_WORKS) {
4a74d658 890 set_bit(SMP_FLAG_TK_VALID, &smp->flags);
2b64d153
BG		 891 return 0;
892 }
893
19c5ce9c
JH		 894 /* If this function is used for SC -> legacy fallback we
895 * can only recover the just-works case.
896 */
897 if (test_bit(SMP_FLAG_SC, &smp->flags))
898 return -EINVAL;
899
2b64d153 900 /* Not Just Works/Confirm results in MITM Authentication */
783e0574 901 if (smp->method != JUST_CFM) {
4a74d658 902 set_bit(SMP_FLAG_MITM_AUTH, &smp->flags);
5eb596f5
JH		 903 if (hcon->pending_sec_level < BT_SECURITY_HIGH)
904 hcon->pending_sec_level = BT_SECURITY_HIGH;
905 }
2b64d153
BG		 906
907 /* If both devices have Keyoard-Display I/O, the master
908 * Confirms and the slave Enters the passkey.
909 */
783e0574 910 if (smp->method == OVERLAP) {
40bef302 911 if (hcon->role == HCI_ROLE_MASTER)
783e0574 912 smp->method = CFM_PASSKEY;
2b64d153 913 else
783e0574 914 smp->method = REQ_PASSKEY;
2b64d153
BG		 915 }
916
01ad34d2 917 /* Generate random passkey. */
783e0574 918 if (smp->method == CFM_PASSKEY) {
943a732a 919 memset(smp->tk, 0, sizeof(smp->tk));
2b64d153
BG		 920 get_random_bytes(&passkey, sizeof(passkey));
921 passkey %= 1000000;
943a732a 922 put_unaligned_le32(passkey, smp->tk);
2b64d153 923 BT_DBG("PassKey: %d", passkey);
4a74d658 924 set_bit(SMP_FLAG_TK_VALID, &smp->flags);
2b64d153
BG		 925 }
926
783e0574 927 if (smp->method == REQ_PASSKEY)
ce39fb4e 928 ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst,
272d90df 929 hcon->type, hcon->dst_type);
783e0574 930 else if (smp->method == JUST_CFM)
4eb65e66
JH		 931 ret = mgmt_user_confirm_request(hcon->hdev, &hcon->dst,
932 hcon->type, hcon->dst_type,
933 passkey, 1);
2b64d153 934 else
01ad34d2 935 ret = mgmt_user_passkey_notify(hcon->hdev, &hcon->dst,
272d90df 936 hcon->type, hcon->dst_type,
39adbffe 937 passkey, 0);
2b64d153 938
2b64d153
BG		 939 return ret;
940}
941
1cc61144 942static u8 smp_confirm(struct smp_chan *smp)
8aab4757 943{
8aab4757 944 struct l2cap_conn *conn = smp->conn;
8aab4757
VCG		 945 struct smp_cmd_pairing_confirm cp;
946 int ret;
8aab4757
VCG		 947
948 BT_DBG("conn %p", conn);
949
e491eaf3 950 ret = smp_c1(smp->tfm_aes, smp->tk, smp->prnd, smp->preq, smp->prsp,
b1cd5fd9 951 conn->hcon->init_addr_type, &conn->hcon->init_addr,
943a732a
JH		 952 conn->hcon->resp_addr_type, &conn->hcon->resp_addr,
953 cp.confirm_val);
1cc61144
JH		 954 if (ret)
955 return SMP_UNSPECIFIED;
8aab4757 956
4a74d658 957 clear_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
2b64d153 958
8aab4757
VCG		 959 smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
960
b28b4943
JH		 961 if (conn->hcon->out)
962 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
963 else
964 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
965
1cc61144 966 return 0;
8aab4757
VCG		 967}
968
861580a9 969static u8 smp_random(struct smp_chan *smp)
8aab4757 970{
8aab4757
VCG		 971 struct l2cap_conn *conn = smp->conn;
972 struct hci_conn *hcon = conn->hcon;
861580a9 973 u8 confirm[16];
8aab4757
VCG		 974 int ret;
975
ec70f36f 976 if (IS_ERR_OR_NULL(smp->tfm_aes))
861580a9 977 return SMP_UNSPECIFIED;
8aab4757
VCG		 978
979 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
980
e491eaf3 981 ret = smp_c1(smp->tfm_aes, smp->tk, smp->rrnd, smp->preq, smp->prsp,
b1cd5fd9 982 hcon->init_addr_type, &hcon->init_addr,
943a732a 983 hcon->resp_addr_type, &hcon->resp_addr, confirm);
861580a9
JH		 984 if (ret)
985 return SMP_UNSPECIFIED;
8aab4757 986
8aab4757
VCG		 987 if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) {
988 BT_ERR("Pairing failed (confirmation values mismatch)");
861580a9 989 return SMP_CONFIRM_FAILED;
8aab4757
VCG		 990 }
991
992 if (hcon->out) {
fe39c7b2
MH		 993 u8 stk[16];
994 __le64 rand = 0;
995 __le16 ediv = 0;
8aab4757 996
e491eaf3 997 smp_s1(smp->tfm_aes, smp->tk, smp->rrnd, smp->prnd, stk);
8aab4757 998
861580a9
JH		 999 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
1000 return SMP_UNSPECIFIED;
8aab4757 1001
8b76ce34 1002 hci_le_start_enc(hcon, ediv, rand, stk, smp->enc_key_size);
f7aa611a 1003 hcon->enc_key_size = smp->enc_key_size;
fe59a05f 1004 set_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags);
8aab4757 1005 } else {
fff3490f 1006 u8 stk[16], auth;
fe39c7b2
MH		 1007 __le64 rand = 0;
1008 __le16 ediv = 0;
8aab4757 1009
943a732a
JH		 1010 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
1011 smp->prnd);
8aab4757 1012
e491eaf3 1013 smp_s1(smp->tfm_aes, smp->tk, smp->prnd, smp->rrnd, stk);
8aab4757 1014
fff3490f
JH		 1015 if (hcon->pending_sec_level == BT_SECURITY_HIGH)
1016 auth = 1;
1017 else
1018 auth = 0;
1019
7d5843b7
JH		 1020 /* Even though there's no _SLAVE suffix this is the
1021 * slave STK we're adding for later lookup (the master
1022 * STK never needs to be stored).
1023 */
ce39fb4e 1024 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
2ceba539 1025 SMP_STK, auth, stk, smp->enc_key_size, ediv, rand);
8aab4757
VCG		 1026 }
1027
861580a9 1028 return 0;
8aab4757
VCG		 1029}
1030
44f1a7ab
JH		 1031static void smp_notify_keys(struct l2cap_conn *conn)
1032{
1033 struct l2cap_chan *chan = conn->smp;
1034 struct smp_chan *smp = chan->data;
1035 struct hci_conn *hcon = conn->hcon;
1036 struct hci_dev *hdev = hcon->hdev;
1037 struct smp_cmd_pairing *req = (void *) &smp->preq[1];
1038 struct smp_cmd_pairing *rsp = (void *) &smp->prsp[1];
1039 bool persistent;
1040
cad20c27
JH		 1041 if (hcon->type == ACL_LINK) {
1042 if (hcon->key_type == HCI_LK_DEBUG_COMBINATION)
1043 persistent = false;
1044 else
1045 persistent = !test_bit(HCI_CONN_FLUSH_KEY,
1046 &hcon->flags);
1047 } else {
1048 /* The LTKs, IRKs and CSRKs should be persistent only if
1049 * both sides had the bonding bit set in their
1050 * authentication requests.
1051 */
1052 persistent = !!((req->auth_req & rsp->auth_req) &
1053 SMP_AUTH_BONDING);
1054 }
1055
44f1a7ab 1056 if (smp->remote_irk) {
cad20c27
JH		 1057 mgmt_new_irk(hdev, smp->remote_irk, persistent);
1058
44f1a7ab
JH		 1059 /* Now that user space can be considered to know the
1060 * identity address track the connection based on it
b5ae344d 1061 * from now on (assuming this is an LE link).
44f1a7ab 1062 */
b5ae344d
JH		 1063 if (hcon->type == LE_LINK) {
1064 bacpy(&hcon->dst, &smp->remote_irk->bdaddr);
1065 hcon->dst_type = smp->remote_irk->addr_type;
1066 queue_work(hdev->workqueue, &conn->id_addr_update_work);
1067 }
44f1a7ab
JH		 1068 }
1069
44f1a7ab
JH		 1070 if (smp->csrk) {
1071 smp->csrk->bdaddr_type = hcon->dst_type;
1072 bacpy(&smp->csrk->bdaddr, &hcon->dst);
1073 mgmt_new_csrk(hdev, smp->csrk, persistent);
1074 }
1075
1076 if (smp->slave_csrk) {
1077 smp->slave_csrk->bdaddr_type = hcon->dst_type;
1078 bacpy(&smp->slave_csrk->bdaddr, &hcon->dst);
1079 mgmt_new_csrk(hdev, smp->slave_csrk, persistent);
1080 }
1081
1082 if (smp->ltk) {
1083 smp->ltk->bdaddr_type = hcon->dst_type;
1084 bacpy(&smp->ltk->bdaddr, &hcon->dst);
1085 mgmt_new_ltk(hdev, smp->ltk, persistent);
1086 }
1087
1088 if (smp->slave_ltk) {
1089 smp->slave_ltk->bdaddr_type = hcon->dst_type;
1090 bacpy(&smp->slave_ltk->bdaddr, &hcon->dst);
1091 mgmt_new_ltk(hdev, smp->slave_ltk, persistent);
1092 }
6a77083a
JH		 1093
1094 if (smp->link_key) {
e3befab9
JH		 1095 struct link_key *key;
1096 u8 type;
1097
1098 if (test_bit(SMP_FLAG_DEBUG_KEY, &smp->flags))
1099 type = HCI_LK_DEBUG_COMBINATION;
1100 else if (hcon->sec_level == BT_SECURITY_FIPS)
1101 type = HCI_LK_AUTH_COMBINATION_P256;
1102 else
1103 type = HCI_LK_UNAUTH_COMBINATION_P256;
1104
1105 key = hci_add_link_key(hdev, smp->conn->hcon, &hcon->dst,
1106 smp->link_key, type, 0, &persistent);
1107 if (key) {
1108 mgmt_new_link_key(hdev, key, persistent);
1109
1110 /* Don't keep debug keys around if the relevant
1111 * flag is not set.
1112 */
d7a5a11d 1113 if (!hci_dev_test_flag(hdev, HCI_KEEP_DEBUG_KEYS) &&
e3befab9
JH		 1114 key->type == HCI_LK_DEBUG_COMBINATION) {
1115 list_del_rcu(&key->list);
1116 kfree_rcu(key, rcu);
1117 }
1118 }
6a77083a
JH		 1119 }
1120}
1121
d3e54a87
JH		 1122static void sc_add_ltk(struct smp_chan *smp)
1123{
1124 struct hci_conn *hcon = smp->conn->hcon;
1125 u8 key_type, auth;
1126
1127 if (test_bit(SMP_FLAG_DEBUG_KEY, &smp->flags))
1128 key_type = SMP_LTK_P256_DEBUG;
1129 else
1130 key_type = SMP_LTK_P256;
1131
1132 if (hcon->pending_sec_level == BT_SECURITY_FIPS)
1133 auth = 1;
1134 else
1135 auth = 0;
1136
d3e54a87
JH		 1137 smp->ltk = hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
1138 key_type, auth, smp->tk, smp->enc_key_size,
1139 0, 0);
1140}
1141
6a77083a
JH		 1142static void sc_generate_link_key(struct smp_chan *smp)
1143{
1144 /* These constants are as specified in the core specification.
1145 * In ASCII they spell out to 'tmp1' and 'lebr'.
1146 */
1147 const u8 tmp1[4] = { 0x31, 0x70, 0x6d, 0x74 };
1148 const u8 lebr[4] = { 0x72, 0x62, 0x65, 0x6c };
1149
1150 smp->link_key = kzalloc(16, GFP_KERNEL);
1151 if (!smp->link_key)
1152 return;
1153
1154 if (smp_h6(smp->tfm_cmac, smp->tk, tmp1, smp->link_key)) {
276812ec 1155 kzfree(smp->link_key);
6a77083a
JH		 1156 smp->link_key = NULL;
1157 return;
1158 }
1159
1160 if (smp_h6(smp->tfm_cmac, smp->link_key, lebr, smp->link_key)) {
276812ec 1161 kzfree(smp->link_key);
6a77083a
JH		 1162 smp->link_key = NULL;
1163 return;
1164 }
44f1a7ab
JH		 1165}
1166
b28b4943
JH		 1167static void smp_allow_key_dist(struct smp_chan *smp)
1168{
1169 /* Allow the first expected phase 3 PDU. The rest of the PDUs
1170 * will be allowed in each PDU handler to ensure we receive
1171 * them in the correct order.
1172 */
1173 if (smp->remote_key_dist & SMP_DIST_ENC_KEY)
1174 SMP_ALLOW_CMD(smp, SMP_CMD_ENCRYPT_INFO);
1175 else if (smp->remote_key_dist & SMP_DIST_ID_KEY)
1176 SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_INFO);
1177 else if (smp->remote_key_dist & SMP_DIST_SIGN)
1178 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
1179}
1180
b5ae344d
JH		 1181static void sc_generate_ltk(struct smp_chan *smp)
1182{
1183 /* These constants are as specified in the core specification.
1184 * In ASCII they spell out to 'tmp2' and 'brle'.
1185 */
1186 const u8 tmp2[4] = { 0x32, 0x70, 0x6d, 0x74 };
1187 const u8 brle[4] = { 0x65, 0x6c, 0x72, 0x62 };
1188 struct hci_conn *hcon = smp->conn->hcon;
1189 struct hci_dev *hdev = hcon->hdev;
1190 struct link_key *key;
1191
1192 key = hci_find_link_key(hdev, &hcon->dst);
1193 if (!key) {
1194 BT_ERR("%s No Link Key found to generate LTK", hdev->name);
1195 return;
1196 }
1197
1198 if (key->type == HCI_LK_DEBUG_COMBINATION)
1199 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
1200
1201 if (smp_h6(smp->tfm_cmac, key->val, tmp2, smp->tk))
1202 return;
1203
1204 if (smp_h6(smp->tfm_cmac, smp->tk, brle, smp->tk))
1205 return;
1206
1207 sc_add_ltk(smp);
1208}
1209
d6268e86 1210static void smp_distribute_keys(struct smp_chan *smp)
44f1a7ab
JH		 1211{
1212 struct smp_cmd_pairing *req, *rsp;
86d1407c 1213 struct l2cap_conn *conn = smp->conn;
44f1a7ab
JH		 1214 struct hci_conn *hcon = conn->hcon;
1215 struct hci_dev *hdev = hcon->hdev;
1216 __u8 *keydist;
1217
1218 BT_DBG("conn %p", conn);
1219
44f1a7ab
JH		 1220 rsp = (void *) &smp->prsp[1];
1221
1222 /* The responder sends its keys first */
b28b4943
JH		 1223 if (hcon->out && (smp->remote_key_dist & KEY_DIST_MASK)) {
1224 smp_allow_key_dist(smp);
86d1407c 1225 return;
b28b4943 1226 }
44f1a7ab
JH		 1227
1228 req = (void *) &smp->preq[1];
1229
1230 if (hcon->out) {
1231 keydist = &rsp->init_key_dist;
1232 *keydist &= req->init_key_dist;
1233 } else {
1234 keydist = &rsp->resp_key_dist;
1235 *keydist &= req->resp_key_dist;
1236 }
1237
6a77083a 1238 if (test_bit(SMP_FLAG_SC, &smp->flags)) {
b5ae344d 1239 if (hcon->type == LE_LINK && (*keydist & SMP_DIST_LINK_KEY))
6a77083a 1240 sc_generate_link_key(smp);
b5ae344d
JH		 1241 if (hcon->type == ACL_LINK && (*keydist & SMP_DIST_ENC_KEY))
1242 sc_generate_ltk(smp);
6a77083a
JH		 1243
1244 /* Clear the keys which are generated but not distributed */
1245 *keydist &= ~SMP_SC_NO_DIST;
1246 }
1247
44f1a7ab
JH		 1248 BT_DBG("keydist 0x%x", *keydist);
1249
1250 if (*keydist & SMP_DIST_ENC_KEY) {
1251 struct smp_cmd_encrypt_info enc;
1252 struct smp_cmd_master_ident ident;
1253 struct smp_ltk *ltk;
1254 u8 authenticated;
1255 __le16 ediv;
1256 __le64 rand;
1257
1fc62c52
JH		 1258 /* Make sure we generate only the significant amount of
1259 * bytes based on the encryption key size, and set the rest
1260 * of the value to zeroes.
1261 */
1262 get_random_bytes(enc.ltk, smp->enc_key_size);
1263 memset(enc.ltk + smp->enc_key_size, 0,
1264 sizeof(enc.ltk) - smp->enc_key_size);
1265
44f1a7ab
JH		 1266 get_random_bytes(&ediv, sizeof(ediv));
1267 get_random_bytes(&rand, sizeof(rand));
1268
1269 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);
1270
1271 authenticated = hcon->sec_level == BT_SECURITY_HIGH;
1272 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type,
1273 SMP_LTK_SLAVE, authenticated, enc.ltk,
1274 smp->enc_key_size, ediv, rand);
1275 smp->slave_ltk = ltk;
1276
1277 ident.ediv = ediv;
1278 ident.rand = rand;
1279
1280 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);
1281
1282 *keydist &= ~SMP_DIST_ENC_KEY;
1283 }
1284
1285 if (*keydist & SMP_DIST_ID_KEY) {
1286 struct smp_cmd_ident_addr_info addrinfo;
1287 struct smp_cmd_ident_info idinfo;
1288
1289 memcpy(idinfo.irk, hdev->irk, sizeof(idinfo.irk));
1290
1291 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
1292
1293 /* The hci_conn contains the local identity address
1294 * after the connection has been established.
1295 *
1296 * This is true even when the connection has been
1297 * established using a resolvable random address.
1298 */
1299 bacpy(&addrinfo.bdaddr, &hcon->src);
1300 addrinfo.addr_type = hcon->src_type;
1301
1302 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
1303 &addrinfo);
1304
1305 *keydist &= ~SMP_DIST_ID_KEY;
1306 }
1307
1308 if (*keydist & SMP_DIST_SIGN) {
1309 struct smp_cmd_sign_info sign;
1310 struct smp_csrk *csrk;
1311
1312 /* Generate a new random key */
1313 get_random_bytes(sign.csrk, sizeof(sign.csrk));
1314
1315 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1316 if (csrk) {
4cd3928a
JH		 1317 if (hcon->sec_level > BT_SECURITY_MEDIUM)
1318 csrk->type = MGMT_CSRK_LOCAL_AUTHENTICATED;
1319 else
1320 csrk->type = MGMT_CSRK_LOCAL_UNAUTHENTICATED;
44f1a7ab
JH		 1321 memcpy(csrk->val, sign.csrk, sizeof(csrk->val));
1322 }
1323 smp->slave_csrk = csrk;
1324
1325 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
1326
1327 *keydist &= ~SMP_DIST_SIGN;
1328 }
1329
1330 /* If there are still keys to be received wait for them */
b28b4943
JH		 1331 if (smp->remote_key_dist & KEY_DIST_MASK) {
1332 smp_allow_key_dist(smp);
86d1407c 1333 return;
b28b4943 1334 }
44f1a7ab 1335
44f1a7ab
JH		 1336 set_bit(SMP_FLAG_COMPLETE, &smp->flags);
1337 smp_notify_keys(conn);
1338
1339 smp_chan_destroy(conn);
44f1a7ab
JH		 1340}
1341
b68fda68
JH		 1342static void smp_timeout(struct work_struct *work)
1343{
1344 struct smp_chan *smp = container_of(work, struct smp_chan,
1345 security_timer.work);
1346 struct l2cap_conn *conn = smp->conn;
1347
1348 BT_DBG("conn %p", conn);
1349
1e91c29e 1350 hci_disconnect(conn->hcon, HCI_ERROR_REMOTE_USER_TERM);
b68fda68
JH		 1351}
1352
8aab4757
VCG		 1353static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
1354{
5d88cc73 1355 struct l2cap_chan *chan = conn->smp;
8aab4757
VCG		 1356 struct smp_chan *smp;
1357
f1560463 1358 smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
fc75cc86 1359 if (!smp)
8aab4757
VCG		 1360 return NULL;
1361
71af2f6b 1362 smp->tfm_aes = crypto_alloc_skcipher("ecb(aes)", 0, CRYPTO_ALG_ASYNC);
6a7bd103
JH		 1363 if (IS_ERR(smp->tfm_aes)) {
1364 BT_ERR("Unable to create ECB crypto context");
276812ec 1365 kzfree(smp);
6a7bd103
JH		 1366 return NULL;
1367 }
1368
71af2f6b 1369 smp->tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, 0);
407cecf6
JH		 1370 if (IS_ERR(smp->tfm_cmac)) {
1371 BT_ERR("Unable to create CMAC crypto context");
71af2f6b 1372 crypto_free_skcipher(smp->tfm_aes);
276812ec 1373 kzfree(smp);
407cecf6
JH		 1374 return NULL;
1375 }
1376
8aab4757 1377 smp->conn = conn;
5d88cc73 1378 chan->data = smp;
8aab4757 1379
b28b4943
JH		 1380 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_FAIL);
1381
b68fda68
JH		 1382 INIT_DELAYED_WORK(&smp->security_timer, smp_timeout);
1383
8aab4757
VCG		 1384 hci_conn_hold(conn->hcon);
1385
1386 return smp;
1387}
1388
760b018b
JH		 1389static int sc_mackey_and_ltk(struct smp_chan *smp, u8 mackey[16], u8 ltk[16])
1390{
1391 struct hci_conn *hcon = smp->conn->hcon;
1392 u8 *na, *nb, a[7], b[7];
1393
1394 if (hcon->out) {
1395 na = smp->prnd;
1396 nb = smp->rrnd;
1397 } else {
1398 na = smp->rrnd;
1399 nb = smp->prnd;
1400 }
1401
1402 memcpy(a, &hcon->init_addr, 6);
1403 memcpy(b, &hcon->resp_addr, 6);
1404 a[6] = hcon->init_addr_type;
1405 b[6] = hcon->resp_addr_type;
1406
1407 return smp_f5(smp->tfm_cmac, smp->dhkey, na, nb, a, b, mackey, ltk);
1408}
1409
38606f14 1410static void sc_dhkey_check(struct smp_chan *smp)
760b018b
JH		 1411{
1412 struct hci_conn *hcon = smp->conn->hcon;
1413 struct smp_cmd_dhkey_check check;
1414 u8 a[7], b[7], *local_addr, *remote_addr;
1415 u8 io_cap[3], r[16];
1416
760b018b
JH		 1417 memcpy(a, &hcon->init_addr, 6);
1418 memcpy(b, &hcon->resp_addr, 6);
1419 a[6] = hcon->init_addr_type;
1420 b[6] = hcon->resp_addr_type;
1421
1422 if (hcon->out) {
1423 local_addr = a;
1424 remote_addr = b;
1425 memcpy(io_cap, &smp->preq[1], 3);
1426 } else {
1427 local_addr = b;
1428 remote_addr = a;
1429 memcpy(io_cap, &smp->prsp[1], 3);
1430 }
1431
dddd3059
JH		 1432 memset(r, 0, sizeof(r));
1433
1434 if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
38606f14 1435 put_unaligned_le32(hcon->passkey_notify, r);
760b018b 1436
a29b0733
JH		 1437 if (smp->method == REQ_OOB)
1438 memcpy(r, smp->rr, 16);
1439
760b018b
JH		 1440 smp_f6(smp->tfm_cmac, smp->mackey, smp->prnd, smp->rrnd, r, io_cap,
1441 local_addr, remote_addr, check.e);
1442
1443 smp_send_cmd(smp->conn, SMP_CMD_DHKEY_CHECK, sizeof(check), &check);
dddd3059
JH		 1444}
1445
38606f14
JH		 1446static u8 sc_passkey_send_confirm(struct smp_chan *smp)
1447{
1448 struct l2cap_conn *conn = smp->conn;
1449 struct hci_conn *hcon = conn->hcon;
1450 struct smp_cmd_pairing_confirm cfm;
1451 u8 r;
1452
1453 r = ((hcon->passkey_notify >> smp->passkey_round) & 0x01);
1454 r |= 0x80;
1455
1456 get_random_bytes(smp->prnd, sizeof(smp->prnd));
1457
1458 if (smp_f4(smp->tfm_cmac, smp->local_pk, smp->remote_pk, smp->prnd, r,
1459 cfm.confirm_val))
1460 return SMP_UNSPECIFIED;
1461
1462 smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cfm), &cfm);
1463
1464 return 0;
1465}
1466
1467static u8 sc_passkey_round(struct smp_chan *smp, u8 smp_op)
1468{
1469 struct l2cap_conn *conn = smp->conn;
1470 struct hci_conn *hcon = conn->hcon;
1471 struct hci_dev *hdev = hcon->hdev;
1472 u8 cfm[16], r;
1473
1474 /* Ignore the PDU if we've already done 20 rounds (0 - 19) */
1475 if (smp->passkey_round >= 20)
1476 return 0;
1477
1478 switch (smp_op) {
1479 case SMP_CMD_PAIRING_RANDOM:
1480 r = ((hcon->passkey_notify >> smp->passkey_round) & 0x01);
1481 r |= 0x80;
1482
1483 if (smp_f4(smp->tfm_cmac, smp->remote_pk, smp->local_pk,
1484 smp->rrnd, r, cfm))
1485 return SMP_UNSPECIFIED;
1486
1487 if (memcmp(smp->pcnf, cfm, 16))
1488 return SMP_CONFIRM_FAILED;
1489
1490 smp->passkey_round++;
1491
1492 if (smp->passkey_round == 20) {
1493 /* Generate MacKey and LTK */
1494 if (sc_mackey_and_ltk(smp, smp->mackey, smp->tk))
1495 return SMP_UNSPECIFIED;
1496 }
1497
1498 /* The round is only complete when the initiator
1499 * receives pairing random.
1500 */
1501 if (!hcon->out) {
1502 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
1503 sizeof(smp->prnd), smp->prnd);
d3e54a87 1504 if (smp->passkey_round == 20)
38606f14 1505 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
d3e54a87 1506 else
38606f14 1507 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
38606f14
JH		 1508 return 0;
1509 }
1510
1511 /* Start the next round */
1512 if (smp->passkey_round != 20)
1513 return sc_passkey_round(smp, 0);
1514
1515 /* Passkey rounds are complete - start DHKey Check */
1516 sc_dhkey_check(smp);
1517 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1518
1519 break;
1520
1521 case SMP_CMD_PAIRING_CONFIRM:
1522 if (test_bit(SMP_FLAG_WAIT_USER, &smp->flags)) {
1523 set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
1524 return 0;
1525 }
1526
1527 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
1528
1529 if (hcon->out) {
1530 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
1531 sizeof(smp->prnd), smp->prnd);
1532 return 0;
1533 }
1534
1535 return sc_passkey_send_confirm(smp);
1536
1537 case SMP_CMD_PUBLIC_KEY:
1538 default:
1539 /* Initiating device starts the round */
1540 if (!hcon->out)
1541 return 0;
1542
1543 BT_DBG("%s Starting passkey round %u", hdev->name,
1544 smp->passkey_round + 1);
1545
1546 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
1547
1548 return sc_passkey_send_confirm(smp);
1549 }
1550
1551 return 0;
1552}
1553
dddd3059
JH		 1554static int sc_user_reply(struct smp_chan *smp, u16 mgmt_op, __le32 passkey)
1555{
38606f14
JH		 1556 struct l2cap_conn *conn = smp->conn;
1557 struct hci_conn *hcon = conn->hcon;
1558 u8 smp_op;
1559
1560 clear_bit(SMP_FLAG_WAIT_USER, &smp->flags);
1561
dddd3059
JH		 1562 switch (mgmt_op) {
1563 case MGMT_OP_USER_PASSKEY_NEG_REPLY:
1564 smp_failure(smp->conn, SMP_PASSKEY_ENTRY_FAILED);
1565 return 0;
1566 case MGMT_OP_USER_CONFIRM_NEG_REPLY:
1567 smp_failure(smp->conn, SMP_NUMERIC_COMP_FAILED);
1568 return 0;
38606f14
JH		 1569 case MGMT_OP_USER_PASSKEY_REPLY:
1570 hcon->passkey_notify = le32_to_cpu(passkey);
1571 smp->passkey_round = 0;
1572
1573 if (test_and_clear_bit(SMP_FLAG_CFM_PENDING, &smp->flags))
1574 smp_op = SMP_CMD_PAIRING_CONFIRM;
1575 else
1576 smp_op = 0;
1577
1578 if (sc_passkey_round(smp, smp_op))
1579 return -EIO;
1580
1581 return 0;
dddd3059
JH		 1582 }
1583
d3e54a87
JH		 1584 /* Initiator sends DHKey check first */
1585 if (hcon->out) {
1586 sc_dhkey_check(smp);
1587 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1588 } else if (test_and_clear_bit(SMP_FLAG_DHKEY_PENDING, &smp->flags)) {
1589 sc_dhkey_check(smp);
1590 sc_add_ltk(smp);
1591 }
760b018b
JH		 1592
1593 return 0;
1594}
1595
2b64d153
BG		 1596int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey)
1597{
b10e8017 1598 struct l2cap_conn *conn = hcon->l2cap_data;
5d88cc73 1599 struct l2cap_chan *chan;
2b64d153
BG		 1600 struct smp_chan *smp;
1601 u32 value;
fc75cc86 1602 int err;
2b64d153
BG		 1603
1604 BT_DBG("");
1605
fc75cc86 1606 if (!conn)
2b64d153
BG		 1607 return -ENOTCONN;
1608
5d88cc73
JH		 1609 chan = conn->smp;
1610 if (!chan)
1611 return -ENOTCONN;
1612
fc75cc86
JH		 1613 l2cap_chan_lock(chan);
1614 if (!chan->data) {
1615 err = -ENOTCONN;
1616 goto unlock;
1617 }
1618
5d88cc73 1619 smp = chan->data;
2b64d153 1620
760b018b
JH		 1621 if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1622 err = sc_user_reply(smp, mgmt_op, passkey);
1623 goto unlock;
1624 }
1625
2b64d153
BG		 1626 switch (mgmt_op) {
1627 case MGMT_OP_USER_PASSKEY_REPLY:
1628 value = le32_to_cpu(passkey);
943a732a 1629 memset(smp->tk, 0, sizeof(smp->tk));
2b64d153 1630 BT_DBG("PassKey: %d", value);
943a732a 1631 put_unaligned_le32(value, smp->tk);
2b64d153
BG		 1632 /* Fall Through */
1633 case MGMT_OP_USER_CONFIRM_REPLY:
4a74d658 1634 set_bit(SMP_FLAG_TK_VALID, &smp->flags);
2b64d153
BG		 1635 break;
1636 case MGMT_OP_USER_PASSKEY_NEG_REPLY:
1637 case MGMT_OP_USER_CONFIRM_NEG_REPLY:
84794e11 1638 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
fc75cc86
JH		 1639 err = 0;
1640 goto unlock;
2b64d153 1641 default:
84794e11 1642 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
fc75cc86
JH		 1643 err = -EOPNOTSUPP;
1644 goto unlock;
2b64d153
BG		 1645 }
1646
fc75cc86
JH		 1647 err = 0;
1648
2b64d153 1649 /* If it is our turn to send Pairing Confirm, do so now */
1cc61144
JH		 1650 if (test_bit(SMP_FLAG_CFM_PENDING, &smp->flags)) {
1651 u8 rsp = smp_confirm(smp);
1652 if (rsp)
1653 smp_failure(conn, rsp);
1654 }
2b64d153 1655
fc75cc86
JH		 1656unlock:
1657 l2cap_chan_unlock(chan);
1658 return err;
2b64d153
BG		 1659}
1660
b5ae344d
JH		 1661static void build_bredr_pairing_cmd(struct smp_chan *smp,
1662 struct smp_cmd_pairing *req,
1663 struct smp_cmd_pairing *rsp)
1664{
1665 struct l2cap_conn *conn = smp->conn;
1666 struct hci_dev *hdev = conn->hcon->hdev;
1667 u8 local_dist = 0, remote_dist = 0;
1668
d7a5a11d 1669 if (hci_dev_test_flag(hdev, HCI_BONDABLE)) {
b5ae344d
JH		 1670 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
1671 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
1672 }
1673
d7a5a11d 1674 if (hci_dev_test_flag(hdev, HCI_RPA_RESOLVING))
b5ae344d
JH		 1675 remote_dist |= SMP_DIST_ID_KEY;
1676
d7a5a11d 1677 if (hci_dev_test_flag(hdev, HCI_PRIVACY))
b5ae344d
JH		 1678 local_dist |= SMP_DIST_ID_KEY;
1679
1680 if (!rsp) {
1681 memset(req, 0, sizeof(*req));
1682
1683 req->init_key_dist = local_dist;
1684 req->resp_key_dist = remote_dist;
e3f6a257 1685 req->max_key_size = conn->hcon->enc_key_size;
b5ae344d
JH		 1686
1687 smp->remote_key_dist = remote_dist;
1688
1689 return;
1690 }
1691
1692 memset(rsp, 0, sizeof(*rsp));
1693
e3f6a257 1694 rsp->max_key_size = conn->hcon->enc_key_size;
b5ae344d
JH		 1695 rsp->init_key_dist = req->init_key_dist & remote_dist;
1696 rsp->resp_key_dist = req->resp_key_dist & local_dist;
1697
1698 smp->remote_key_dist = rsp->init_key_dist;
1699}
1700
da85e5e5 1701static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 1702{
3158c50c 1703 struct smp_cmd_pairing rsp, *req = (void *) skb->data;
fc75cc86 1704 struct l2cap_chan *chan = conn->smp;
b3c6410b 1705 struct hci_dev *hdev = conn->hcon->hdev;
8aab4757 1706 struct smp_chan *smp;
c7262e71 1707 u8 key_size, auth, sec_level;
8aab4757 1708 int ret;
88ba43b6
AB		 1709
1710 BT_DBG("conn %p", conn);
1711
c46b98be 1712 if (skb->len < sizeof(*req))
38e4a915 1713 return SMP_INVALID_PARAMS;
c46b98be 1714
40bef302 1715 if (conn->hcon->role != HCI_ROLE_SLAVE)
2b64d153
BG		 1716 return SMP_CMD_NOTSUPP;
1717
fc75cc86 1718 if (!chan->data)
8aab4757 1719 smp = smp_chan_create(conn);
fc75cc86 1720 else
5d88cc73 1721 smp = chan->data;
8aab4757 1722
d08fd0e7
AE		 1723 if (!smp)
1724 return SMP_UNSPECIFIED;
d26a2345 1725
c05b9339 1726 /* We didn't start the pairing, so match remote */
0edb14de 1727 auth = req->auth_req & AUTH_REQ_MASK(hdev);
c05b9339 1728
d7a5a11d 1729 if (!hci_dev_test_flag(hdev, HCI_BONDABLE) &&
c05b9339 1730 (auth & SMP_AUTH_BONDING))
b3c6410b
JH		 1731 return SMP_PAIRING_NOTSUPP;
1732
d7a5a11d 1733 if (hci_dev_test_flag(hdev, HCI_SC_ONLY) && !(auth & SMP_AUTH_SC))
903b71c7
JH		 1734 return SMP_AUTH_REQUIREMENTS;
1735
1c1def09
VCG		 1736 smp->preq[0] = SMP_CMD_PAIRING_REQ;
1737 memcpy(&smp->preq[1], req, sizeof(*req));
3158c50c 1738 skb_pull(skb, sizeof(*req));
88ba43b6 1739
cb06d366
JH		 1740 /* If the remote side's OOB flag is set it means it has
1741 * successfully received our local OOB data - therefore set the
1742 * flag to indicate that local OOB is in use.
1743 */
58428563
JH		 1744 if (req->oob_flag == SMP_OOB_PRESENT)
1745 set_bit(SMP_FLAG_LOCAL_OOB, &smp->flags);
1746
b5ae344d
JH		 1747 /* SMP over BR/EDR requires special treatment */
1748 if (conn->hcon->type == ACL_LINK) {
1749 /* We must have a BR/EDR SC link */
08f63cc5 1750 if (!test_bit(HCI_CONN_AES_CCM, &conn->hcon->flags) &&
b7cb93e5 1751 !hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP))
b5ae344d
JH		 1752 return SMP_CROSS_TRANSP_NOT_ALLOWED;
1753
1754 set_bit(SMP_FLAG_SC, &smp->flags);
1755
1756 build_bredr_pairing_cmd(smp, req, &rsp);
1757
1758 key_size = min(req->max_key_size, rsp.max_key_size);
1759 if (check_enc_key_size(conn, key_size))
1760 return SMP_ENC_KEY_SIZE;
1761
1762 /* Clear bits which are generated but not distributed */
1763 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1764
1765 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1766 memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
1767 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
1768
1769 smp_distribute_keys(smp);
1770 return 0;
1771 }
1772
5e3d3d9b
JH		 1773 build_pairing_cmd(conn, req, &rsp, auth);
1774
1775 if (rsp.auth_req & SMP_AUTH_SC)
1776 set_bit(SMP_FLAG_SC, &smp->flags);
1777
5be5e275 1778 if (conn->hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
1afc2a1a
JH		 1779 sec_level = BT_SECURITY_MEDIUM;
1780 else
1781 sec_level = authreq_to_seclevel(auth);
1782
c7262e71
JH		 1783 if (sec_level > conn->hcon->pending_sec_level)
1784 conn->hcon->pending_sec_level = sec_level;
fdde0a26 1785
49c922bb 1786 /* If we need MITM check that it can be achieved */
2ed8f65c
JH		 1787 if (conn->hcon->pending_sec_level >= BT_SECURITY_HIGH) {
1788 u8 method;
1789
1790 method = get_auth_method(smp, conn->hcon->io_capability,
1791 req->io_capability);
1792 if (method == JUST_WORKS || method == JUST_CFM)
1793 return SMP_AUTH_REQUIREMENTS;
1794 }
1795
3158c50c
VCG		 1796 key_size = min(req->max_key_size, rsp.max_key_size);
1797 if (check_enc_key_size(conn, key_size))
1798 return SMP_ENC_KEY_SIZE;
88ba43b6 1799
e84a6b13 1800 get_random_bytes(smp->prnd, sizeof(smp->prnd));
8aab4757 1801
1c1def09
VCG		 1802 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1803 memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
f01ead31 1804
3158c50c 1805 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
3b19146d
JH		 1806
1807 clear_bit(SMP_FLAG_INITIATOR, &smp->flags);
1808
19c5ce9c
JH		 1809 /* Strictly speaking we shouldn't allow Pairing Confirm for the
1810 * SC case, however some implementations incorrectly copy RFU auth
1811 * req bits from our security request, which may create a false
1812 * positive SC enablement.
1813 */
1814 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
1815
3b19146d
JH		 1816 if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1817 SMP_ALLOW_CMD(smp, SMP_CMD_PUBLIC_KEY);
1818 /* Clear bits which are generated but not distributed */
1819 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1820 /* Wait for Public Key from Initiating Device */
1821 return 0;
3b19146d 1822 }
da85e5e5 1823
2b64d153
BG		 1824 /* Request setup of TK */
1825 ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
1826 if (ret)
1827 return SMP_UNSPECIFIED;
1828
da85e5e5 1829 return 0;
88ba43b6
AB		 1830}
1831
3b19146d
JH		 1832static u8 sc_send_public_key(struct smp_chan *smp)
1833{
70157ef5
JH		 1834 struct hci_dev *hdev = smp->conn->hcon->hdev;
1835
3b19146d
JH		 1836 BT_DBG("");
1837
1a8bab4f 1838 if (test_bit(SMP_FLAG_LOCAL_OOB, &smp->flags)) {
33d0c030
MH		 1839 struct l2cap_chan *chan = hdev->smp_data;
1840 struct smp_dev *smp_dev;
1841
1842 if (!chan || !chan->data)
1843 return SMP_UNSPECIFIED;
1844
1845 smp_dev = chan->data;
1846
1847 memcpy(smp->local_pk, smp_dev->local_pk, 64);
1848 memcpy(smp->local_sk, smp_dev->local_sk, 32);
fb334fee 1849 memcpy(smp->lr, smp_dev->local_rand, 16);
33d0c030
MH		 1850
1851 if (smp_dev->debug_key)
1852 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
1853
1854 goto done;
1855 }
1856
d7a5a11d 1857 if (hci_dev_test_flag(hdev, HCI_USE_DEBUG_KEYS)) {
70157ef5
JH		 1858 BT_DBG("Using debug keys");
1859 memcpy(smp->local_pk, debug_pk, 64);
1860 memcpy(smp->local_sk, debug_sk, 32);
1861 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
1862 } else {
1863 while (true) {
1864 /* Generate local key pair for Secure Connections */
1865 if (!ecc_make_key(smp->local_pk, smp->local_sk))
1866 return SMP_UNSPECIFIED;
6c0dcc50 1867
70157ef5
JH		 1868 /* This is unlikely, but we need to check that
1869 * we didn't accidentially generate a debug key.
1870 */
1871 if (memcmp(smp->local_sk, debug_sk, 32))
1872 break;
1873 }
6c0dcc50 1874 }
3b19146d 1875
33d0c030 1876done:
c7a3d57d 1877 SMP_DBG("Local Public Key X: %32phN", smp->local_pk);
8e4e2ee5 1878 SMP_DBG("Local Public Key Y: %32phN", smp->local_pk + 32);
c7a3d57d 1879 SMP_DBG("Local Private Key: %32phN", smp->local_sk);
3b19146d
JH		 1880
1881 smp_send_cmd(smp->conn, SMP_CMD_PUBLIC_KEY, 64, smp->local_pk);
1882
1883 return 0;
1884}
1885
da85e5e5 1886static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 1887{
3158c50c 1888 struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
5d88cc73
JH		 1889 struct l2cap_chan *chan = conn->smp;
1890 struct smp_chan *smp = chan->data;
0edb14de 1891 struct hci_dev *hdev = conn->hcon->hdev;
3a7dbfb8 1892 u8 key_size, auth;
7d24ddcc 1893 int ret;
88ba43b6
AB		 1894
1895 BT_DBG("conn %p", conn);
1896
c46b98be 1897 if (skb->len < sizeof(*rsp))
38e4a915 1898 return SMP_INVALID_PARAMS;
c46b98be 1899
40bef302 1900 if (conn->hcon->role != HCI_ROLE_MASTER)
2b64d153
BG		 1901 return SMP_CMD_NOTSUPP;
1902
3158c50c
VCG		 1903 skb_pull(skb, sizeof(*rsp));
1904
1c1def09 1905 req = (void *) &smp->preq[1];
da85e5e5 1906
3158c50c
VCG		 1907 key_size = min(req->max_key_size, rsp->max_key_size);
1908 if (check_enc_key_size(conn, key_size))
1909 return SMP_ENC_KEY_SIZE;
1910
0edb14de 1911 auth = rsp->auth_req & AUTH_REQ_MASK(hdev);
c05b9339 1912
d7a5a11d 1913 if (hci_dev_test_flag(hdev, HCI_SC_ONLY) && !(auth & SMP_AUTH_SC))
903b71c7
JH		 1914 return SMP_AUTH_REQUIREMENTS;
1915
cb06d366
JH		 1916 /* If the remote side's OOB flag is set it means it has
1917 * successfully received our local OOB data - therefore set the
1918 * flag to indicate that local OOB is in use.
1919 */
58428563
JH		 1920 if (rsp->oob_flag == SMP_OOB_PRESENT)
1921 set_bit(SMP_FLAG_LOCAL_OOB, &smp->flags);
1922
b5ae344d
JH		 1923 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1924 memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
1925
1926 /* Update remote key distribution in case the remote cleared
1927 * some bits that we had enabled in our request.
1928 */
1929 smp->remote_key_dist &= rsp->resp_key_dist;
1930
1931 /* For BR/EDR this means we're done and can start phase 3 */
1932 if (conn->hcon->type == ACL_LINK) {
1933 /* Clear bits which are generated but not distributed */
1934 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1935 smp_distribute_keys(smp);
1936 return 0;
1937 }
1938
65668776
JH		 1939 if ((req->auth_req & SMP_AUTH_SC) && (auth & SMP_AUTH_SC))
1940 set_bit(SMP_FLAG_SC, &smp->flags);
d2eb9e10
JH		 1941 else if (conn->hcon->pending_sec_level > BT_SECURITY_HIGH)
1942 conn->hcon->pending_sec_level = BT_SECURITY_HIGH;
65668776 1943
49c922bb 1944 /* If we need MITM check that it can be achieved */
2ed8f65c
JH		 1945 if (conn->hcon->pending_sec_level >= BT_SECURITY_HIGH) {
1946 u8 method;
1947
1948 method = get_auth_method(smp, req->io_capability,
1949 rsp->io_capability);
1950 if (method == JUST_WORKS || method == JUST_CFM)
1951 return SMP_AUTH_REQUIREMENTS;
1952 }
1953
e84a6b13 1954 get_random_bytes(smp->prnd, sizeof(smp->prnd));
7d24ddcc 1955
fdcc4bec
JH		 1956 /* Update remote key distribution in case the remote cleared
1957 * some bits that we had enabled in our request.
1958 */
1959 smp->remote_key_dist &= rsp->resp_key_dist;
1960
3b19146d
JH		 1961 if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1962 /* Clear bits which are generated but not distributed */
1963 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1964 SMP_ALLOW_CMD(smp, SMP_CMD_PUBLIC_KEY);
1965 return sc_send_public_key(smp);
1966 }
1967
c05b9339 1968 auth |= req->auth_req;
2b64d153 1969
476585ec 1970 ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
2b64d153
BG		 1971 if (ret)
1972 return SMP_UNSPECIFIED;
1973
4a74d658 1974 set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
2b64d153
BG		 1975
1976 /* Can't compose response until we have been confirmed */
4a74d658 1977 if (test_bit(SMP_FLAG_TK_VALID, &smp->flags))
1cc61144 1978 return smp_confirm(smp);
da85e5e5
VCG		 1979
1980 return 0;
88ba43b6
AB		 1981}
1982
dcee2b32
JH		 1983static u8 sc_check_confirm(struct smp_chan *smp)
1984{
1985 struct l2cap_conn *conn = smp->conn;
1986
1987 BT_DBG("");
1988
38606f14
JH		 1989 if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
1990 return sc_passkey_round(smp, SMP_CMD_PAIRING_CONFIRM);
1991
dcee2b32
JH		 1992 if (conn->hcon->out) {
1993 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
1994 smp->prnd);
1995 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
1996 }
1997
1998 return 0;
1999}
2000
19c5ce9c
JH		 2001/* Work-around for some implementations that incorrectly copy RFU bits
2002 * from our security request and thereby create the impression that
2003 * we're doing SC when in fact the remote doesn't support it.
2004 */
2005static int fixup_sc_false_positive(struct smp_chan *smp)
2006{
2007 struct l2cap_conn *conn = smp->conn;
2008 struct hci_conn *hcon = conn->hcon;
2009 struct hci_dev *hdev = hcon->hdev;
2010 struct smp_cmd_pairing *req, *rsp;
2011 u8 auth;
2012
2013 /* The issue is only observed when we're in slave role */
2014 if (hcon->out)
2015 return SMP_UNSPECIFIED;
2016
2017 if (hci_dev_test_flag(hdev, HCI_SC_ONLY)) {
2018 BT_ERR("Refusing SMP SC -> legacy fallback in SC-only mode");
2019 return SMP_UNSPECIFIED;
2020 }
2021
2022 BT_ERR("Trying to fall back to legacy SMP");
2023
2024 req = (void *) &smp->preq[1];
2025 rsp = (void *) &smp->prsp[1];
2026
2027 /* Rebuild key dist flags which may have been cleared for SC */
2028 smp->remote_key_dist = (req->init_key_dist & rsp->resp_key_dist);
2029
2030 auth = req->auth_req & AUTH_REQ_MASK(hdev);
2031
2032 if (tk_request(conn, 0, auth, rsp->io_capability, req->io_capability)) {
2033 BT_ERR("Failed to fall back to legacy SMP");
2034 return SMP_UNSPECIFIED;
2035 }
2036
2037 clear_bit(SMP_FLAG_SC, &smp->flags);
2038
2039 return 0;
2040}
2041
da85e5e5 2042static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 2043{
5d88cc73
JH		 2044 struct l2cap_chan *chan = conn->smp;
2045 struct smp_chan *smp = chan->data;
7d24ddcc 2046
88ba43b6
AB		 2047 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
2048
c46b98be 2049 if (skb->len < sizeof(smp->pcnf))
38e4a915 2050 return SMP_INVALID_PARAMS;
c46b98be 2051
1c1def09
VCG		 2052 memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
2053 skb_pull(skb, sizeof(smp->pcnf));
88ba43b6 2054
19c5ce9c
JH		 2055 if (test_bit(SMP_FLAG_SC, &smp->flags)) {
2056 int ret;
2057
2058 /* Public Key exchange must happen before any other steps */
2059 if (test_bit(SMP_FLAG_REMOTE_PK, &smp->flags))
2060 return sc_check_confirm(smp);
2061
2062 BT_ERR("Unexpected SMP Pairing Confirm");
2063
2064 ret = fixup_sc_false_positive(smp);
2065 if (ret)
2066 return ret;
2067 }
dcee2b32 2068
b28b4943 2069 if (conn->hcon->out) {
943a732a
JH		 2070 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
2071 smp->prnd);
b28b4943
JH		 2072 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2073 return 0;
2074 }
2075
2076 if (test_bit(SMP_FLAG_TK_VALID, &smp->flags))
1cc61144 2077 return smp_confirm(smp);
983f9814
MH		 2078
2079 set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
da85e5e5
VCG		 2080
2081 return 0;
88ba43b6
AB		 2082}
2083
da85e5e5 2084static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 2085{
5d88cc73
JH		 2086 struct l2cap_chan *chan = conn->smp;
2087 struct smp_chan *smp = chan->data;
191dc7fe
JH		 2088 struct hci_conn *hcon = conn->hcon;
2089 u8 *pkax, *pkbx, *na, *nb;
2090 u32 passkey;
2091 int err;
7d24ddcc 2092
8aab4757 2093 BT_DBG("conn %p", conn);
3158c50c 2094
c46b98be 2095 if (skb->len < sizeof(smp->rrnd))
38e4a915 2096 return SMP_INVALID_PARAMS;
c46b98be 2097
943a732a 2098 memcpy(smp->rrnd, skb->data, sizeof(smp->rrnd));
8aab4757 2099 skb_pull(skb, sizeof(smp->rrnd));
e7e62c85 2100
191dc7fe
JH		 2101 if (!test_bit(SMP_FLAG_SC, &smp->flags))
2102 return smp_random(smp);
2103
580039e8
JH		 2104 if (hcon->out) {
2105 pkax = smp->local_pk;
2106 pkbx = smp->remote_pk;
2107 na = smp->prnd;
2108 nb = smp->rrnd;
2109 } else {
2110 pkax = smp->remote_pk;
2111 pkbx = smp->local_pk;
2112 na = smp->rrnd;
2113 nb = smp->prnd;
2114 }
2115
a29b0733
JH		 2116 if (smp->method == REQ_OOB) {
2117 if (!hcon->out)
2118 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
2119 sizeof(smp->prnd), smp->prnd);
2120 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
2121 goto mackey_and_ltk;
2122 }
2123
38606f14
JH		 2124 /* Passkey entry has special treatment */
2125 if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
2126 return sc_passkey_round(smp, SMP_CMD_PAIRING_RANDOM);
2127
191dc7fe
JH		 2128 if (hcon->out) {
2129 u8 cfm[16];
2130
2131 err = smp_f4(smp->tfm_cmac, smp->remote_pk, smp->local_pk,
2132 smp->rrnd, 0, cfm);
2133 if (err)
2134 return SMP_UNSPECIFIED;
2135
2136 if (memcmp(smp->pcnf, cfm, 16))
2137 return SMP_CONFIRM_FAILED;
191dc7fe
JH		 2138 } else {
2139 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
2140 smp->prnd);
2141 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
191dc7fe
JH		 2142 }
2143
a29b0733 2144mackey_and_ltk:
760b018b
JH		 2145 /* Generate MacKey and LTK */
2146 err = sc_mackey_and_ltk(smp, smp->mackey, smp->tk);
2147 if (err)
2148 return SMP_UNSPECIFIED;
2149
a29b0733 2150 if (smp->method == JUST_WORKS || smp->method == REQ_OOB) {
dddd3059 2151 if (hcon->out) {
38606f14 2152 sc_dhkey_check(smp);
dddd3059
JH		 2153 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
2154 }
2155 return 0;
2156 }
2157
38606f14
JH		 2158 err = smp_g2(smp->tfm_cmac, pkax, pkbx, na, nb, &passkey);
2159 if (err)
2160 return SMP_UNSPECIFIED;
2161
2162 err = mgmt_user_confirm_request(hcon->hdev, &hcon->dst, hcon->type,
2163 hcon->dst_type, passkey, 0);
191dc7fe
JH		 2164 if (err)
2165 return SMP_UNSPECIFIED;
2166
38606f14
JH		 2167 set_bit(SMP_FLAG_WAIT_USER, &smp->flags);
2168
191dc7fe 2169 return 0;
88ba43b6
AB		 2170}
2171
f81cd823 2172static bool smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
988c5997 2173{
c9839a11 2174 struct smp_ltk *key;
988c5997
VCG		 2175 struct hci_conn *hcon = conn->hcon;
2176
f3a73d97 2177 key = hci_find_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, hcon->role);
988c5997 2178 if (!key)
f81cd823 2179 return false;
988c5997 2180
a6f7833c 2181 if (smp_ltk_sec_level(key) < sec_level)
f81cd823 2182 return false;
4dab7864 2183
51a8efd7 2184 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
f81cd823 2185 return true;
988c5997 2186
8b76ce34 2187 hci_le_start_enc(hcon, key->ediv, key->rand, key->val, key->enc_size);
c9839a11 2188 hcon->enc_key_size = key->enc_size;
988c5997 2189
fe59a05f
JH		 2190 /* We never store STKs for master role, so clear this flag */
2191 clear_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags);
2192
f81cd823 2193 return true;
988c5997 2194}
f1560463 2195
35dc6f83
JH		 2196bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level,
2197 enum smp_key_pref key_pref)
854f4727
JH		 2198{
2199 if (sec_level == BT_SECURITY_LOW)
2200 return true;
2201
35dc6f83
JH		 2202 /* If we're encrypted with an STK but the caller prefers using
2203 * LTK claim insufficient security. This way we allow the
2204 * connection to be re-encrypted with an LTK, even if the LTK
2205 * provides the same level of security. Only exception is if we
2206 * don't have an LTK (e.g. because of key distribution bits).
9ab65d60 2207 */
35dc6f83
JH		 2208 if (key_pref == SMP_USE_LTK &&
2209 test_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags) &&
f3a73d97 2210 hci_find_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, hcon->role))
9ab65d60
JH		 2211 return false;
2212
854f4727
JH		 2213 if (hcon->sec_level >= sec_level)
2214 return true;
2215
2216 return false;
2217}
2218
da85e5e5 2219static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6
AB		 2220{
2221 struct smp_cmd_security_req *rp = (void *) skb->data;
2222 struct smp_cmd_pairing cp;
f1cb9af5 2223 struct hci_conn *hcon = conn->hcon;
0edb14de 2224 struct hci_dev *hdev = hcon->hdev;
8aab4757 2225 struct smp_chan *smp;
c05b9339 2226 u8 sec_level, auth;
88ba43b6
AB		 2227
2228 BT_DBG("conn %p", conn);
2229
c46b98be 2230 if (skb->len < sizeof(*rp))
38e4a915 2231 return SMP_INVALID_PARAMS;
c46b98be 2232
40bef302 2233 if (hcon->role != HCI_ROLE_MASTER)
86ca9eac
JH		 2234 return SMP_CMD_NOTSUPP;
2235
0edb14de 2236 auth = rp->auth_req & AUTH_REQ_MASK(hdev);
c05b9339 2237
d7a5a11d 2238 if (hci_dev_test_flag(hdev, HCI_SC_ONLY) && !(auth & SMP_AUTH_SC))
903b71c7
JH		 2239 return SMP_AUTH_REQUIREMENTS;
2240
5be5e275 2241 if (hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
1afc2a1a
JH		 2242 sec_level = BT_SECURITY_MEDIUM;
2243 else
2244 sec_level = authreq_to_seclevel(auth);
2245
35dc6f83 2246 if (smp_sufficient_security(hcon, sec_level, SMP_USE_LTK))
854f4727
JH		 2247 return 0;
2248
c7262e71
JH		 2249 if (sec_level > hcon->pending_sec_level)
2250 hcon->pending_sec_level = sec_level;
feb45eb5 2251
4dab7864 2252 if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
988c5997
VCG		 2253 return 0;
2254
8aab4757 2255 smp = smp_chan_create(conn);
c29d2444
JH		 2256 if (!smp)
2257 return SMP_UNSPECIFIED;
d26a2345 2258
d7a5a11d 2259 if (!hci_dev_test_flag(hdev, HCI_BONDABLE) &&
c05b9339 2260 (auth & SMP_AUTH_BONDING))
616d55be
JH		 2261 return SMP_PAIRING_NOTSUPP;
2262
88ba43b6 2263 skb_pull(skb, sizeof(*rp));
88ba43b6 2264
da85e5e5 2265 memset(&cp, 0, sizeof(cp));
c05b9339 2266 build_pairing_cmd(conn, &cp, NULL, auth);
88ba43b6 2267
1c1def09
VCG		 2268 smp->preq[0] = SMP_CMD_PAIRING_REQ;
2269 memcpy(&smp->preq[1], &cp, sizeof(cp));
f01ead31 2270
88ba43b6 2271 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
b28b4943 2272 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
f1cb9af5 2273
da85e5e5 2274 return 0;
88ba43b6
AB		 2275}
2276
cc110922 2277int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
eb492e01 2278{
cc110922 2279 struct l2cap_conn *conn = hcon->l2cap_data;
c68b7f12 2280 struct l2cap_chan *chan;
0a66cf20 2281 struct smp_chan *smp;
2b64d153 2282 __u8 authreq;
fc75cc86 2283 int ret;
eb492e01 2284
3a0259bb
VCG		 2285 BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
2286
0a66cf20
JH		 2287 /* This may be NULL if there's an unexpected disconnection */
2288 if (!conn)
2289 return 1;
2290
d7a5a11d 2291 if (!hci_dev_test_flag(hcon->hdev, HCI_LE_ENABLED))
2e65c9d2
AG		 2292 return 1;
2293
35dc6f83 2294 if (smp_sufficient_security(hcon, sec_level, SMP_USE_LTK))
eb492e01 2295 return 1;
f1cb9af5 2296
c7262e71
JH		 2297 if (sec_level > hcon->pending_sec_level)
2298 hcon->pending_sec_level = sec_level;
2299
40bef302 2300 if (hcon->role == HCI_ROLE_MASTER)
c7262e71
JH		 2301 if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
2302 return 0;
d26a2345 2303
d8949aad
JH		 2304 chan = conn->smp;
2305 if (!chan) {
2306 BT_ERR("SMP security requested but not available");
2307 return 1;
2308 }
2309
fc75cc86
JH		 2310 l2cap_chan_lock(chan);
2311
2312 /* If SMP is already in progress ignore this request */
2313 if (chan->data) {
2314 ret = 0;
2315 goto unlock;
2316 }
d26a2345 2317
8aab4757 2318 smp = smp_chan_create(conn);
fc75cc86
JH		 2319 if (!smp) {
2320 ret = 1;
2321 goto unlock;
2322 }
2b64d153
BG		 2323
2324 authreq = seclevel_to_authreq(sec_level);
d26a2345 2325
d7a5a11d 2326 if (hci_dev_test_flag(hcon->hdev, HCI_SC_ENABLED))
d2eb9e10
JH		 2327 authreq |= SMP_AUTH_SC;
2328
79897d20
JH		 2329 /* Require MITM if IO Capability allows or the security level
2330 * requires it.
2e233644 2331 */
79897d20 2332 if (hcon->io_capability != HCI_IO_NO_INPUT_OUTPUT ||
c7262e71 2333 hcon->pending_sec_level > BT_SECURITY_MEDIUM)
2e233644
JH		 2334 authreq |= SMP_AUTH_MITM;
2335
40bef302 2336 if (hcon->role == HCI_ROLE_MASTER) {
d26a2345 2337 struct smp_cmd_pairing cp;
f01ead31 2338
2b64d153 2339 build_pairing_cmd(conn, &cp, NULL, authreq);
1c1def09
VCG		 2340 smp->preq[0] = SMP_CMD_PAIRING_REQ;
2341 memcpy(&smp->preq[1], &cp, sizeof(cp));
f01ead31 2342
eb492e01 2343 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
b28b4943 2344 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
eb492e01
AB		 2345 } else {
2346 struct smp_cmd_security_req cp;
2b64d153 2347 cp.auth_req = authreq;
eb492e01 2348 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
b28b4943 2349 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_REQ);
eb492e01
AB		 2350 }
2351
4a74d658 2352 set_bit(SMP_FLAG_INITIATOR, &smp->flags);
fc75cc86 2353 ret = 0;
edca792c 2354
fc75cc86
JH		 2355unlock:
2356 l2cap_chan_unlock(chan);
2357 return ret;
eb492e01
AB		 2358}
2359
c81d555a
JH		 2360void smp_cancel_pairing(struct hci_conn *hcon)
2361{
2362 struct l2cap_conn *conn = hcon->l2cap_data;
2363 struct l2cap_chan *chan;
2364 struct smp_chan *smp;
2365
2366 if (!conn)
2367 return;
2368
2369 chan = conn->smp;
2370 if (!chan)
2371 return;
2372
2373 l2cap_chan_lock(chan);
2374
2375 smp = chan->data;
2376 if (smp) {
2377 if (test_bit(SMP_FLAG_COMPLETE, &smp->flags))
2378 smp_failure(conn, 0);
2379 else
2380 smp_failure(conn, SMP_UNSPECIFIED);
2381 }
2382
2383 l2cap_chan_unlock(chan);
2384}
2385
7034b911
VCG		 2386static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
2387{
16b90839 2388 struct smp_cmd_encrypt_info *rp = (void *) skb->data;
5d88cc73
JH		 2389 struct l2cap_chan *chan = conn->smp;
2390 struct smp_chan *smp = chan->data;
16b90839 2391
c46b98be
JH		 2392 BT_DBG("conn %p", conn);
2393
2394 if (skb->len < sizeof(*rp))
38e4a915 2395 return SMP_INVALID_PARAMS;
c46b98be 2396
b28b4943 2397 SMP_ALLOW_CMD(smp, SMP_CMD_MASTER_IDENT);
6131ddc8 2398
16b90839
VCG		 2399 skb_pull(skb, sizeof(*rp));
2400
1c1def09 2401 memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
16b90839 2402
7034b911
VCG		 2403 return 0;
2404}
2405
2406static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
2407{
16b90839 2408 struct smp_cmd_master_ident *rp = (void *) skb->data;
5d88cc73
JH		 2409 struct l2cap_chan *chan = conn->smp;
2410 struct smp_chan *smp = chan->data;
c9839a11
VCG		 2411 struct hci_dev *hdev = conn->hcon->hdev;
2412 struct hci_conn *hcon = conn->hcon;
23d0e128 2413 struct smp_ltk *ltk;
c9839a11 2414 u8 authenticated;
16b90839 2415
c46b98be
JH		 2416 BT_DBG("conn %p", conn);
2417
2418 if (skb->len < sizeof(*rp))
38e4a915 2419 return SMP_INVALID_PARAMS;
c46b98be 2420
9747a9f3
JH		 2421 /* Mark the information as received */
2422 smp->remote_key_dist &= ~SMP_DIST_ENC_KEY;
2423
b28b4943
JH		 2424 if (smp->remote_key_dist & SMP_DIST_ID_KEY)
2425 SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_INFO);
196332f5
JH		 2426 else if (smp->remote_key_dist & SMP_DIST_SIGN)
2427 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
b28b4943 2428
16b90839 2429 skb_pull(skb, sizeof(*rp));
7034b911 2430
ce39fb4e 2431 authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
2ceba539 2432 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, SMP_LTK,
23d0e128
JH		 2433 authenticated, smp->tk, smp->enc_key_size,
2434 rp->ediv, rp->rand);
2435 smp->ltk = ltk;
c6e81e9a 2436 if (!(smp->remote_key_dist & KEY_DIST_MASK))
d6268e86 2437 smp_distribute_keys(smp);
7034b911
VCG		 2438
2439 return 0;
2440}
2441
fd349c02
JH		 2442static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb)
2443{
2444 struct smp_cmd_ident_info *info = (void *) skb->data;
5d88cc73
JH		 2445 struct l2cap_chan *chan = conn->smp;
2446 struct smp_chan *smp = chan->data;
fd349c02
JH		 2447
2448 BT_DBG("");
2449
2450 if (skb->len < sizeof(*info))
38e4a915 2451 return SMP_INVALID_PARAMS;
fd349c02 2452
b28b4943 2453 SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_ADDR_INFO);
6131ddc8 2454
fd349c02
JH		 2455 skb_pull(skb, sizeof(*info));
2456
2457 memcpy(smp->irk, info->irk, 16);
2458
2459 return 0;
2460}
2461
2462static int smp_cmd_ident_addr_info(struct l2cap_conn *conn,
2463 struct sk_buff *skb)
2464{
2465 struct smp_cmd_ident_addr_info *info = (void *) skb->data;
5d88cc73
JH		 2466 struct l2cap_chan *chan = conn->smp;
2467 struct smp_chan *smp = chan->data;
fd349c02
JH		 2468 struct hci_conn *hcon = conn->hcon;
2469 bdaddr_t rpa;
2470
2471 BT_DBG("");
2472
2473 if (skb->len < sizeof(*info))
38e4a915 2474 return SMP_INVALID_PARAMS;
fd349c02 2475
9747a9f3
JH		 2476 /* Mark the information as received */
2477 smp->remote_key_dist &= ~SMP_DIST_ID_KEY;
2478
b28b4943
JH		 2479 if (smp->remote_key_dist & SMP_DIST_SIGN)
2480 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
2481
fd349c02
JH		 2482 skb_pull(skb, sizeof(*info));
2483
a9a58f86
JH		 2484 /* Strictly speaking the Core Specification (4.1) allows sending
2485 * an empty address which would force us to rely on just the IRK
2486 * as "identity information". However, since such
2487 * implementations are not known of and in order to not over
2488 * complicate our implementation, simply pretend that we never
2489 * received an IRK for such a device.
e12af489
JH		 2490 *
2491 * The Identity Address must also be a Static Random or Public
2492 * Address, which hci_is_identity_address() checks for.
a9a58f86 2493 */
e12af489
JH		 2494 if (!bacmp(&info->bdaddr, BDADDR_ANY) ||
2495 !hci_is_identity_address(&info->bdaddr, info->addr_type)) {
a9a58f86 2496 BT_ERR("Ignoring IRK with no identity address");
31dd624e 2497 goto distribute;
a9a58f86
JH		 2498 }
2499
fd349c02
JH		 2500 bacpy(&smp->id_addr, &info->bdaddr);
2501 smp->id_addr_type = info->addr_type;
2502
2503 if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))
2504 bacpy(&rpa, &hcon->dst);
2505 else
2506 bacpy(&rpa, BDADDR_ANY);
2507
23d0e128
JH		 2508 smp->remote_irk = hci_add_irk(conn->hcon->hdev, &smp->id_addr,
2509 smp->id_addr_type, smp->irk, &rpa);
fd349c02 2510
31dd624e 2511distribute:
c6e81e9a
JH		 2512 if (!(smp->remote_key_dist & KEY_DIST_MASK))
2513 smp_distribute_keys(smp);
fd349c02
JH		 2514
2515 return 0;
2516}
2517
7ee4ea36
MH		 2518static int smp_cmd_sign_info(struct l2cap_conn *conn, struct sk_buff *skb)
2519{
2520 struct smp_cmd_sign_info *rp = (void *) skb->data;
5d88cc73
JH		 2521 struct l2cap_chan *chan = conn->smp;
2522 struct smp_chan *smp = chan->data;
7ee4ea36
MH		 2523 struct smp_csrk *csrk;
2524
2525 BT_DBG("conn %p", conn);
2526
2527 if (skb->len < sizeof(*rp))
38e4a915 2528 return SMP_INVALID_PARAMS;
7ee4ea36 2529
7ee4ea36
MH		 2530 /* Mark the information as received */
2531 smp->remote_key_dist &= ~SMP_DIST_SIGN;
2532
2533 skb_pull(skb, sizeof(*rp));
2534
7ee4ea36
MH		 2535 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
2536 if (csrk) {
4cd3928a
JH		 2537 if (conn->hcon->sec_level > BT_SECURITY_MEDIUM)
2538 csrk->type = MGMT_CSRK_REMOTE_AUTHENTICATED;
2539 else
2540 csrk->type = MGMT_CSRK_REMOTE_UNAUTHENTICATED;
7ee4ea36
MH		 2541 memcpy(csrk->val, rp->csrk, sizeof(csrk->val));
2542 }
2543 smp->csrk = csrk;
d6268e86 2544 smp_distribute_keys(smp);
7ee4ea36
MH		 2545
2546 return 0;
2547}
2548
5e3d3d9b
JH		 2549static u8 sc_select_method(struct smp_chan *smp)
2550{
2551 struct l2cap_conn *conn = smp->conn;
2552 struct hci_conn *hcon = conn->hcon;
2553 struct smp_cmd_pairing *local, *remote;
2554 u8 local_mitm, remote_mitm, local_io, remote_io, method;
2555
1a8bab4f
JH		 2556 if (test_bit(SMP_FLAG_REMOTE_OOB, &smp->flags) ||
2557 test_bit(SMP_FLAG_LOCAL_OOB, &smp->flags))
a29b0733
JH		 2558 return REQ_OOB;
2559
5e3d3d9b
JH		 2560 /* The preq/prsp contain the raw Pairing Request/Response PDUs
2561 * which are needed as inputs to some crypto functions. To get
2562 * the "struct smp_cmd_pairing" from them we need to skip the
2563 * first byte which contains the opcode.
2564 */
2565 if (hcon->out) {
2566 local = (void *) &smp->preq[1];
2567 remote = (void *) &smp->prsp[1];
2568 } else {
2569 local = (void *) &smp->prsp[1];
2570 remote = (void *) &smp->preq[1];
2571 }
2572
2573 local_io = local->io_capability;
2574 remote_io = remote->io_capability;
2575
2576 local_mitm = (local->auth_req & SMP_AUTH_MITM);
2577 remote_mitm = (remote->auth_req & SMP_AUTH_MITM);
2578
2579 /* If either side wants MITM, look up the method from the table,
2580 * otherwise use JUST WORKS.
2581 */
2582 if (local_mitm || remote_mitm)
2583 method = get_auth_method(smp, local_io, remote_io);
2584 else
2585 method = JUST_WORKS;
2586
2587 /* Don't confirm locally initiated pairing attempts */
2588 if (method == JUST_CFM && test_bit(SMP_FLAG_INITIATOR, &smp->flags))
2589 method = JUST_WORKS;
2590
2591 return method;
2592}
2593
d8f8edbe
JH		 2594static int smp_cmd_public_key(struct l2cap_conn *conn, struct sk_buff *skb)
2595{
2596 struct smp_cmd_public_key *key = (void *) skb->data;
2597 struct hci_conn *hcon = conn->hcon;
2598 struct l2cap_chan *chan = conn->smp;
2599 struct smp_chan *smp = chan->data;
5e3d3d9b 2600 struct hci_dev *hdev = hcon->hdev;
cbbbe3e2 2601 struct smp_cmd_pairing_confirm cfm;
d8f8edbe
JH		 2602 int err;
2603
2604 BT_DBG("conn %p", conn);
2605
2606 if (skb->len < sizeof(*key))
2607 return SMP_INVALID_PARAMS;
2608
2609 memcpy(smp->remote_pk, key, 64);
2610
a8ca617c
JH		 2611 if (test_bit(SMP_FLAG_REMOTE_OOB, &smp->flags)) {
2612 err = smp_f4(smp->tfm_cmac, smp->remote_pk, smp->remote_pk,
2613 smp->rr, 0, cfm.confirm_val);
2614 if (err)
2615 return SMP_UNSPECIFIED;
2616
2617 if (memcmp(cfm.confirm_val, smp->pcnf, 16))
2618 return SMP_CONFIRM_FAILED;
2619 }
2620
d8f8edbe
JH		 2621 /* Non-initiating device sends its public key after receiving
2622 * the key from the initiating device.
2623 */
2624 if (!hcon->out) {
2625 err = sc_send_public_key(smp);
2626 if (err)
2627 return err;
2628 }
2629
c7a3d57d 2630 SMP_DBG("Remote Public Key X: %32phN", smp->remote_pk);
e091526d 2631 SMP_DBG("Remote Public Key Y: %32phN", smp->remote_pk + 32);
d8f8edbe
JH		 2632
2633 if (!ecdh_shared_secret(smp->remote_pk, smp->local_sk, smp->dhkey))
2634 return SMP_UNSPECIFIED;
2635
c7a3d57d 2636 SMP_DBG("DHKey %32phN", smp->dhkey);
d8f8edbe
JH		 2637
2638 set_bit(SMP_FLAG_REMOTE_PK, &smp->flags);
2639
5e3d3d9b
JH		 2640 smp->method = sc_select_method(smp);
2641
2642 BT_DBG("%s selected method 0x%02x", hdev->name, smp->method);
2643
2644 /* JUST_WORKS and JUST_CFM result in an unauthenticated key */
2645 if (smp->method == JUST_WORKS || smp->method == JUST_CFM)
2646 hcon->pending_sec_level = BT_SECURITY_MEDIUM;
2647 else
2648 hcon->pending_sec_level = BT_SECURITY_FIPS;
2649
aeb7d461
JH		 2650 if (!memcmp(debug_pk, smp->remote_pk, 64))
2651 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
2652
38606f14
JH		 2653 if (smp->method == DSP_PASSKEY) {
2654 get_random_bytes(&hcon->passkey_notify,
2655 sizeof(hcon->passkey_notify));
2656 hcon->passkey_notify %= 1000000;
2657 hcon->passkey_entered = 0;
2658 smp->passkey_round = 0;
2659 if (mgmt_user_passkey_notify(hdev, &hcon->dst, hcon->type,
2660 hcon->dst_type,
2661 hcon->passkey_notify,
2662 hcon->passkey_entered))
2663 return SMP_UNSPECIFIED;
2664 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2665 return sc_passkey_round(smp, SMP_CMD_PUBLIC_KEY);
2666 }
2667
94ea7257 2668 if (smp->method == REQ_OOB) {
a29b0733
JH		 2669 if (hcon->out)
2670 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM,
2671 sizeof(smp->prnd), smp->prnd);
2672
2673 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2674
2675 return 0;
2676 }
2677
38606f14
JH		 2678 if (hcon->out)
2679 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2680
2681 if (smp->method == REQ_PASSKEY) {
2682 if (mgmt_user_passkey_request(hdev, &hcon->dst, hcon->type,
2683 hcon->dst_type))
2684 return SMP_UNSPECIFIED;
2685 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2686 set_bit(SMP_FLAG_WAIT_USER, &smp->flags);
2687 return 0;
2688 }
2689
cbbbe3e2
JH		 2690 /* The Initiating device waits for the non-initiating device to
2691 * send the confirm value.
2692 */
2693 if (conn->hcon->out)
2694 return 0;
2695
2696 err = smp_f4(smp->tfm_cmac, smp->local_pk, smp->remote_pk, smp->prnd,
2697 0, cfm.confirm_val);
2698 if (err)
2699 return SMP_UNSPECIFIED;
2700
2701 smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cfm), &cfm);
2702 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2703
d8f8edbe
JH		 2704 return 0;
2705}
2706
6433a9a2
JH		 2707static int smp_cmd_dhkey_check(struct l2cap_conn *conn, struct sk_buff *skb)
2708{
2709 struct smp_cmd_dhkey_check *check = (void *) skb->data;
2710 struct l2cap_chan *chan = conn->smp;
2711 struct hci_conn *hcon = conn->hcon;
2712 struct smp_chan *smp = chan->data;
2713 u8 a[7], b[7], *local_addr, *remote_addr;
2714 u8 io_cap[3], r[16], e[16];
2715 int err;
2716
2717 BT_DBG("conn %p", conn);
2718
2719 if (skb->len < sizeof(*check))
2720 return SMP_INVALID_PARAMS;
2721
2722 memcpy(a, &hcon->init_addr, 6);
2723 memcpy(b, &hcon->resp_addr, 6);
2724 a[6] = hcon->init_addr_type;
2725 b[6] = hcon->resp_addr_type;
2726
2727 if (hcon->out) {
2728 local_addr = a;
2729 remote_addr = b;
2730 memcpy(io_cap, &smp->prsp[1], 3);
2731 } else {
2732 local_addr = b;
2733 remote_addr = a;
2734 memcpy(io_cap, &smp->preq[1], 3);
2735 }
2736
2737 memset(r, 0, sizeof(r));
2738
38606f14
JH		 2739 if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
2740 put_unaligned_le32(hcon->passkey_notify, r);
882fafad
JH		 2741 else if (smp->method == REQ_OOB)
2742 memcpy(r, smp->lr, 16);
38606f14 2743
6433a9a2
JH		 2744 err = smp_f6(smp->tfm_cmac, smp->mackey, smp->rrnd, smp->prnd, r,
2745 io_cap, remote_addr, local_addr, e);
2746 if (err)
2747 return SMP_UNSPECIFIED;
2748
2749 if (memcmp(check->e, e, 16))
2750 return SMP_DHKEY_CHECK_FAILED;
2751
d3e54a87
JH		 2752 if (!hcon->out) {
2753 if (test_bit(SMP_FLAG_WAIT_USER, &smp->flags)) {
2754 set_bit(SMP_FLAG_DHKEY_PENDING, &smp->flags);
2755 return 0;
2756 }
d378a2d7 2757
d3e54a87
JH		 2758 /* Slave sends DHKey check as response to master */
2759 sc_dhkey_check(smp);
2760 }
d378a2d7 2761
d3e54a87 2762 sc_add_ltk(smp);
6433a9a2
JH		 2763
2764 if (hcon->out) {
8b76ce34 2765 hci_le_start_enc(hcon, 0, 0, smp->tk, smp->enc_key_size);
6433a9a2
JH		 2766 hcon->enc_key_size = smp->enc_key_size;
2767 }
2768
2769 return 0;
2770}
2771
1408bb6e
JH		 2772static int smp_cmd_keypress_notify(struct l2cap_conn *conn,
2773 struct sk_buff *skb)
2774{
2775 struct smp_cmd_keypress_notify *kp = (void *) skb->data;
2776
2777 BT_DBG("value 0x%02x", kp->value);
2778
2779 return 0;
2780}
2781
4befb867 2782static int smp_sig_channel(struct l2cap_chan *chan, struct sk_buff *skb)
eb492e01 2783{
5d88cc73 2784 struct l2cap_conn *conn = chan->conn;
7b9899db 2785 struct hci_conn *hcon = conn->hcon;
b28b4943 2786 struct smp_chan *smp;
92381f5c 2787 __u8 code, reason;
eb492e01
AB		 2788 int err = 0;
2789
8ae9b984 2790 if (skb->len < 1)
92381f5c 2791 return -EILSEQ;
92381f5c 2792
d7a5a11d 2793 if (!hci_dev_test_flag(hcon->hdev, HCI_LE_ENABLED)) {
2e65c9d2
AG		 2794 reason = SMP_PAIRING_NOTSUPP;
2795 goto done;
2796 }
2797
92381f5c 2798 code = skb->data[0];
eb492e01
AB		 2799 skb_pull(skb, sizeof(code));
2800
b28b4943
JH		 2801 smp = chan->data;
2802
2803 if (code > SMP_CMD_MAX)
2804 goto drop;
2805
24bd0bd9 2806 if (smp && !test_and_clear_bit(code, &smp->allow_cmd))
b28b4943
JH		 2807 goto drop;
2808
2809 /* If we don't have a context the only allowed commands are
2810 * pairing request and security request.
8cf9fa12 2811 */
b28b4943
JH		 2812 if (!smp && code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ)
2813 goto drop;
8cf9fa12 2814
eb492e01
AB		 2815 switch (code) {
2816 case SMP_CMD_PAIRING_REQ:
da85e5e5 2817 reason = smp_cmd_pairing_req(conn, skb);
eb492e01
AB		 2818 break;
2819
2820 case SMP_CMD_PAIRING_FAIL:
84794e11 2821 smp_failure(conn, 0);
da85e5e5 2822 err = -EPERM;
eb492e01
AB		 2823 break;
2824
2825 case SMP_CMD_PAIRING_RSP:
da85e5e5 2826 reason = smp_cmd_pairing_rsp(conn, skb);
88ba43b6
AB		 2827 break;
2828
2829 case SMP_CMD_SECURITY_REQ:
da85e5e5 2830 reason = smp_cmd_security_req(conn, skb);
88ba43b6
AB		 2831 break;
2832
eb492e01 2833 case SMP_CMD_PAIRING_CONFIRM:
da85e5e5 2834 reason = smp_cmd_pairing_confirm(conn, skb);
88ba43b6
AB		 2835 break;
2836
eb492e01 2837 case SMP_CMD_PAIRING_RANDOM:
da85e5e5 2838 reason = smp_cmd_pairing_random(conn, skb);
88ba43b6
AB		 2839 break;
2840
eb492e01 2841 case SMP_CMD_ENCRYPT_INFO:
7034b911
VCG		 2842 reason = smp_cmd_encrypt_info(conn, skb);
2843 break;
2844
eb492e01 2845 case SMP_CMD_MASTER_IDENT:
7034b911
VCG		 2846 reason = smp_cmd_master_ident(conn, skb);
2847 break;
2848
eb492e01 2849 case SMP_CMD_IDENT_INFO:
fd349c02
JH		 2850 reason = smp_cmd_ident_info(conn, skb);
2851 break;
2852
eb492e01 2853 case SMP_CMD_IDENT_ADDR_INFO:
fd349c02
JH		 2854 reason = smp_cmd_ident_addr_info(conn, skb);
2855 break;
2856
eb492e01 2857 case SMP_CMD_SIGN_INFO:
7ee4ea36 2858 reason = smp_cmd_sign_info(conn, skb);
7034b911
VCG		 2859 break;
2860
d8f8edbe
JH		 2861 case SMP_CMD_PUBLIC_KEY:
2862 reason = smp_cmd_public_key(conn, skb);
2863 break;
2864
6433a9a2
JH		 2865 case SMP_CMD_DHKEY_CHECK:
2866 reason = smp_cmd_dhkey_check(conn, skb);
2867 break;
2868
1408bb6e
JH		 2869 case SMP_CMD_KEYPRESS_NOTIFY:
2870 reason = smp_cmd_keypress_notify(conn, skb);
2871 break;
2872
eb492e01
AB		 2873 default:
2874 BT_DBG("Unknown command code 0x%2.2x", code);
eb492e01 2875 reason = SMP_CMD_NOTSUPP;
3a0259bb 2876 goto done;
eb492e01
AB		 2877 }
2878
3a0259bb 2879done:
9b7b18ef
JH		 2880 if (!err) {
2881 if (reason)
2882 smp_failure(conn, reason);
8ae9b984 2883 kfree_skb(skb);
9b7b18ef
JH		 2884 }
2885
eb492e01 2886 return err;
b28b4943
JH		 2887
2888drop:
2889 BT_ERR("%s unexpected SMP command 0x%02x from %pMR", hcon->hdev->name,
2890 code, &hcon->dst);
2891 kfree_skb(skb);
2892 return 0;
eb492e01 2893}
7034b911 2894
70db83c4
JH		 2895static void smp_teardown_cb(struct l2cap_chan *chan, int err)
2896{
2897 struct l2cap_conn *conn = chan->conn;
2898
2899 BT_DBG("chan %p", chan);
2900
fc75cc86 2901 if (chan->data)
5d88cc73 2902 smp_chan_destroy(conn);
5d88cc73 2903
70db83c4
JH		 2904 conn->smp = NULL;
2905 l2cap_chan_put(chan);
2906}
2907
b5ae344d
JH		 2908static void bredr_pairing(struct l2cap_chan *chan)
2909{
2910 struct l2cap_conn *conn = chan->conn;
2911 struct hci_conn *hcon = conn->hcon;
2912 struct hci_dev *hdev = hcon->hdev;
2913 struct smp_cmd_pairing req;
2914 struct smp_chan *smp;
2915
2916 BT_DBG("chan %p", chan);
2917
2918 /* Only new pairings are interesting */
2919 if (!test_bit(HCI_CONN_NEW_LINK_KEY, &hcon->flags))
2920 return;
2921
2922 /* Don't bother if we're not encrypted */
2923 if (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
2924 return;
2925
2926 /* Only master may initiate SMP over BR/EDR */
2927 if (hcon->role != HCI_ROLE_MASTER)
2928 return;
2929
2930 /* Secure Connections support must be enabled */
d7a5a11d 2931 if (!hci_dev_test_flag(hdev, HCI_SC_ENABLED))
b5ae344d
JH		 2932 return;
2933
2934 /* BR/EDR must use Secure Connections for SMP */
2935 if (!test_bit(HCI_CONN_AES_CCM, &hcon->flags) &&
b7cb93e5 2936 !hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP))
b5ae344d
JH		 2937 return;
2938
2939 /* If our LE support is not enabled don't do anything */
d7a5a11d 2940 if (!hci_dev_test_flag(hdev, HCI_LE_ENABLED))
b5ae344d
JH		 2941 return;
2942
2943 /* Don't bother if remote LE support is not enabled */
2944 if (!lmp_host_le_capable(hcon))
2945 return;
2946
2947 /* Remote must support SMP fixed chan for BR/EDR */
2948 if (!(conn->remote_fixed_chan & L2CAP_FC_SMP_BREDR))
2949 return;
2950
2951 /* Don't bother if SMP is already ongoing */
2952 if (chan->data)
2953 return;
2954
2955 smp = smp_chan_create(conn);
2956 if (!smp) {
2957 BT_ERR("%s unable to create SMP context for BR/EDR",
2958 hdev->name);
2959 return;
2960 }
2961
2962 set_bit(SMP_FLAG_SC, &smp->flags);
2963
2964 BT_DBG("%s starting SMP over BR/EDR", hdev->name);
2965
2966 /* Prepare and send the BR/EDR SMP Pairing Request */
2967 build_bredr_pairing_cmd(smp, &req, NULL);
2968
2969 smp->preq[0] = SMP_CMD_PAIRING_REQ;
2970 memcpy(&smp->preq[1], &req, sizeof(req));
2971
2972 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(req), &req);
2973 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
2974}
2975
44f1a7ab
JH		 2976static void smp_resume_cb(struct l2cap_chan *chan)
2977{
b68fda68 2978 struct smp_chan *smp = chan->data;
44f1a7ab
JH		 2979 struct l2cap_conn *conn = chan->conn;
2980 struct hci_conn *hcon = conn->hcon;
2981
2982 BT_DBG("chan %p", chan);
2983
b5ae344d
JH		 2984 if (hcon->type == ACL_LINK) {
2985 bredr_pairing(chan);
ef8efe4b 2986 return;
b5ae344d 2987 }
ef8efe4b 2988
86d1407c
JH		 2989 if (!smp)
2990 return;
b68fda68 2991
84bc0db5
JH		 2992 if (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
2993 return;
2994
86d1407c
JH		 2995 cancel_delayed_work(&smp->security_timer);
2996
d6268e86 2997 smp_distribute_keys(smp);
44f1a7ab
JH		 2998}
2999
70db83c4
JH		 3000static void smp_ready_cb(struct l2cap_chan *chan)
3001{
3002 struct l2cap_conn *conn = chan->conn;
b5ae344d 3003 struct hci_conn *hcon = conn->hcon;
70db83c4
JH		 3004
3005 BT_DBG("chan %p", chan);
3006
7883746b
JH		 3007 /* No need to call l2cap_chan_hold() here since we already own
3008 * the reference taken in smp_new_conn_cb(). This is just the
3009 * first time that we tie it to a specific pointer. The code in
3010 * l2cap_core.c ensures that there's no risk this function wont
3011 * get called if smp_new_conn_cb was previously called.
3012 */
70db83c4 3013 conn->smp = chan;
b5ae344d
JH		 3014
3015 if (hcon->type == ACL_LINK && test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
3016 bredr_pairing(chan);
70db83c4
JH		 3017}
3018
4befb867
JH		 3019static int smp_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
3020{
3021 int err;
3022
3023 BT_DBG("chan %p", chan);
3024
3025 err = smp_sig_channel(chan, skb);
3026 if (err) {
b68fda68 3027 struct smp_chan *smp = chan->data;
4befb867 3028
b68fda68
JH		 3029 if (smp)
3030 cancel_delayed_work_sync(&smp->security_timer);
4befb867 3031
1e91c29e 3032 hci_disconnect(chan->conn->hcon, HCI_ERROR_AUTH_FAILURE);
4befb867
JH		 3033 }
3034
3035 return err;
3036}
3037
70db83c4
JH		 3038static struct sk_buff *smp_alloc_skb_cb(struct l2cap_chan *chan,
3039 unsigned long hdr_len,
3040 unsigned long len, int nb)
3041{
3042 struct sk_buff *skb;
3043
3044 skb = bt_skb_alloc(hdr_len + len, GFP_KERNEL);
3045 if (!skb)
3046 return ERR_PTR(-ENOMEM);
3047
3048 skb->priority = HCI_PRIO_MAX;
a4368ff3 3049 bt_cb(skb)->l2cap.chan = chan;
70db83c4
JH		 3050
3051 return skb;
3052}
3053
3054static const struct l2cap_ops smp_chan_ops = {
3055 .name = "Security Manager",
3056 .ready = smp_ready_cb,
5d88cc73 3057 .recv = smp_recv_cb,
70db83c4
JH		 3058 .alloc_skb = smp_alloc_skb_cb,
3059 .teardown = smp_teardown_cb,
44f1a7ab 3060 .resume = smp_resume_cb,
70db83c4
JH		 3061
3062 .new_connection = l2cap_chan_no_new_connection,
70db83c4
JH		 3063 .state_change = l2cap_chan_no_state_change,
3064 .close = l2cap_chan_no_close,
3065 .defer = l2cap_chan_no_defer,
3066 .suspend = l2cap_chan_no_suspend,
70db83c4
JH		 3067 .set_shutdown = l2cap_chan_no_set_shutdown,
3068 .get_sndtimeo = l2cap_chan_no_get_sndtimeo,
70db83c4
JH		 3069};
3070
3071static inline struct l2cap_chan *smp_new_conn_cb(struct l2cap_chan *pchan)
3072{
3073 struct l2cap_chan *chan;
3074
3075 BT_DBG("pchan %p", pchan);
3076
3077 chan = l2cap_chan_create();
3078 if (!chan)
3079 return NULL;
3080
3081 chan->chan_type = pchan->chan_type;
3082 chan->ops = &smp_chan_ops;
3083 chan->scid = pchan->scid;
3084 chan->dcid = chan->scid;
3085 chan->imtu = pchan->imtu;
3086 chan->omtu = pchan->omtu;
3087 chan->mode = pchan->mode;
3088
abe84903
JH		 3089 /* Other L2CAP channels may request SMP routines in order to
3090 * change the security level. This means that the SMP channel
3091 * lock must be considered in its own category to avoid lockdep
3092 * warnings.
3093 */
3094 atomic_set(&chan->nesting, L2CAP_NESTING_SMP);
3095
70db83c4
JH		 3096 BT_DBG("created chan %p", chan);
3097
3098 return chan;
3099}
3100
3101static const struct l2cap_ops smp_root_chan_ops = {
3102 .name = "Security Manager Root",
3103 .new_connection = smp_new_conn_cb,
3104
3105 /* None of these are implemented for the root channel */
3106 .close = l2cap_chan_no_close,
3107 .alloc_skb = l2cap_chan_no_alloc_skb,
3108 .recv = l2cap_chan_no_recv,
3109 .state_change = l2cap_chan_no_state_change,
3110 .teardown = l2cap_chan_no_teardown,
3111 .ready = l2cap_chan_no_ready,
3112 .defer = l2cap_chan_no_defer,
3113 .suspend = l2cap_chan_no_suspend,
3114 .resume = l2cap_chan_no_resume,
3115 .set_shutdown = l2cap_chan_no_set_shutdown,
3116 .get_sndtimeo = l2cap_chan_no_get_sndtimeo,
70db83c4
JH		 3117};
3118
ef8efe4b 3119static struct l2cap_chan *smp_add_cid(struct hci_dev *hdev, u16 cid)
711eafe3 3120{
70db83c4 3121 struct l2cap_chan *chan;
88a479d9 3122 struct smp_dev *smp;
71af2f6b
HX		 3123 struct crypto_skcipher *tfm_aes;
3124 struct crypto_shash *tfm_cmac;
70db83c4 3125
ef8efe4b 3126 if (cid == L2CAP_CID_SMP_BREDR) {
88a479d9 3127 smp = NULL;
ef8efe4b
JH		 3128 goto create_chan;
3129 }
711eafe3 3130
88a479d9
MH		 3131 smp = kzalloc(sizeof(*smp), GFP_KERNEL);
3132 if (!smp)
3133 return ERR_PTR(-ENOMEM);
3134
71af2f6b 3135 tfm_aes = crypto_alloc_skcipher("ecb(aes)", 0, CRYPTO_ALG_ASYNC);
defce9e8 3136 if (IS_ERR(tfm_aes)) {
88a479d9
MH		 3137 BT_ERR("Unable to create ECB crypto context");
3138 kzfree(smp);
fe700771 3139 return ERR_CAST(tfm_aes);
711eafe3
JH		 3140 }
3141
71af2f6b 3142 tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, 0);
6e2dc6d1
MH		 3143 if (IS_ERR(tfm_cmac)) {
3144 BT_ERR("Unable to create CMAC crypto context");
71af2f6b 3145 crypto_free_skcipher(tfm_aes);
6e2dc6d1
MH		 3146 kzfree(smp);
3147 return ERR_CAST(tfm_cmac);
3148 }
3149
88a479d9 3150 smp->tfm_aes = tfm_aes;
6e2dc6d1 3151 smp->tfm_cmac = tfm_cmac;
b1f663c9 3152 smp->min_key_size = SMP_MIN_ENC_KEY_SIZE;
2fd36558 3153 smp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
88a479d9 3154
ef8efe4b 3155create_chan:
70db83c4
JH		 3156 chan = l2cap_chan_create();
3157 if (!chan) {
63511f6d 3158 if (smp) {
71af2f6b
HX		 3159 crypto_free_skcipher(smp->tfm_aes);
3160 crypto_free_shash(smp->tfm_cmac);
63511f6d
MH		 3161 kzfree(smp);
3162 }
ef8efe4b 3163 return ERR_PTR(-ENOMEM);
70db83c4
JH		 3164 }
3165
88a479d9 3166 chan->data = smp;
defce9e8 3167
ef8efe4b 3168 l2cap_add_scid(chan, cid);
70db83c4
JH		 3169
3170 l2cap_chan_set_defaults(chan);
3171
157029ba 3172 if (cid == L2CAP_CID_SMP) {
39e3e744
JH		 3173 u8 bdaddr_type;
3174
3175 hci_copy_identity_address(hdev, &chan->src, &bdaddr_type);
3176
3177 if (bdaddr_type == ADDR_LE_DEV_PUBLIC)
157029ba 3178 chan->src_type = BDADDR_LE_PUBLIC;
39e3e744
JH		 3179 else
3180 chan->src_type = BDADDR_LE_RANDOM;
157029ba
MH		 3181 } else {
3182 bacpy(&chan->src, &hdev->bdaddr);
ef8efe4b 3183 chan->src_type = BDADDR_BREDR;
157029ba
MH		 3184 }
3185
70db83c4
JH		 3186 chan->state = BT_LISTEN;
3187 chan->mode = L2CAP_MODE_BASIC;
3188 chan->imtu = L2CAP_DEFAULT_MTU;
3189 chan->ops = &smp_root_chan_ops;
3190
abe84903
JH		 3191 /* Set correct nesting level for a parent/listening channel */
3192 atomic_set(&chan->nesting, L2CAP_NESTING_PARENT);
3193
ef8efe4b 3194 return chan;
711eafe3
JH		 3195}
3196
ef8efe4b 3197static void smp_del_chan(struct l2cap_chan *chan)
711eafe3 3198{
88a479d9 3199 struct smp_dev *smp;
70db83c4 3200
ef8efe4b 3201 BT_DBG("chan %p", chan);
711eafe3 3202
88a479d9
MH		 3203 smp = chan->data;
3204 if (smp) {
defce9e8 3205 chan->data = NULL;
71af2f6b
HX		 3206 crypto_free_skcipher(smp->tfm_aes);
3207 crypto_free_shash(smp->tfm_cmac);
88a479d9 3208 kzfree(smp);
711eafe3 3209 }
70db83c4 3210
70db83c4 3211 l2cap_chan_put(chan);
711eafe3 3212}
ef8efe4b 3213
300acfde
MH		 3214static ssize_t force_bredr_smp_read(struct file *file,
3215 char __user *user_buf,
3216 size_t count, loff_t *ppos)
3217{
3218 struct hci_dev *hdev = file->private_data;
3219 char buf[3];
3220
b7cb93e5 3221 buf[0] = hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP) ? 'Y': 'N';
300acfde
MH		 3222 buf[1] = '\n';
3223 buf[2] = '\0';
3224 return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
3225}
3226
3227static ssize_t force_bredr_smp_write(struct file *file,
3228 const char __user *user_buf,
3229 size_t count, loff_t *ppos)
3230{
3231 struct hci_dev *hdev = file->private_data;
3232 char buf[32];
3233 size_t buf_size = min(count, (sizeof(buf)-1));
3234 bool enable;
3235
3236 if (copy_from_user(buf, user_buf, buf_size))
3237 return -EFAULT;
3238
3239 buf[buf_size] = '\0';
3240 if (strtobool(buf, &enable))
3241 return -EINVAL;
3242
b7cb93e5 3243 if (enable == hci_dev_test_flag(hdev, HCI_FORCE_BREDR_SMP))
300acfde
MH		 3244 return -EALREADY;
3245
3246 if (enable) {
3247 struct l2cap_chan *chan;
3248
3249 chan = smp_add_cid(hdev, L2CAP_CID_SMP_BREDR);
3250 if (IS_ERR(chan))
3251 return PTR_ERR(chan);
3252
3253 hdev->smp_bredr_data = chan;
3254 } else {
3255 struct l2cap_chan *chan;
3256
3257 chan = hdev->smp_bredr_data;
3258 hdev->smp_bredr_data = NULL;
3259 smp_del_chan(chan);
3260 }
3261
b7cb93e5 3262 hci_dev_change_flag(hdev, HCI_FORCE_BREDR_SMP);
300acfde
MH		 3263
3264 return count;
3265}
3266
3267static const struct file_operations force_bredr_smp_fops = {
3268 .open = simple_open,
3269 .read = force_bredr_smp_read,
3270 .write = force_bredr_smp_write,
3271 .llseek = default_llseek,
3272};
3273
b1f663c9
JH		 3274static ssize_t le_min_key_size_read(struct file *file,
3275 char __user *user_buf,
3276 size_t count, loff_t *ppos)
3277{
3278 struct hci_dev *hdev = file->private_data;
3279 char buf[4];
3280
3281 snprintf(buf, sizeof(buf), "%2u\n", SMP_DEV(hdev)->min_key_size);
3282
3283 return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
3284}
3285
3286static ssize_t le_min_key_size_write(struct file *file,
3287 const char __user *user_buf,
3288 size_t count, loff_t *ppos)
3289{
3290 struct hci_dev *hdev = file->private_data;
3291 char buf[32];
3292 size_t buf_size = min(count, (sizeof(buf) - 1));
3293 u8 key_size;
3294
3295 if (copy_from_user(buf, user_buf, buf_size))
3296 return -EFAULT;
3297
3298 buf[buf_size] = '\0';
3299
3300 sscanf(buf, "%hhu", &key_size);
3301
3302 if (key_size > SMP_DEV(hdev)->max_key_size ||
3303 key_size < SMP_MIN_ENC_KEY_SIZE)
3304 return -EINVAL;
3305
3306 SMP_DEV(hdev)->min_key_size = key_size;
3307
3308 return count;
3309}
3310
3311static const struct file_operations le_min_key_size_fops = {
3312 .open = simple_open,
3313 .read = le_min_key_size_read,
3314 .write = le_min_key_size_write,
3315 .llseek = default_llseek,
3316};
3317
2fd36558
JH		 3318static ssize_t le_max_key_size_read(struct file *file,
3319 char __user *user_buf,
3320 size_t count, loff_t *ppos)
3321{
3322 struct hci_dev *hdev = file->private_data;
3323 char buf[4];
3324
3325 snprintf(buf, sizeof(buf), "%2u\n", SMP_DEV(hdev)->max_key_size);
3326
3327 return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
3328}
3329
3330static ssize_t le_max_key_size_write(struct file *file,
3331 const char __user *user_buf,
3332 size_t count, loff_t *ppos)
3333{
3334 struct hci_dev *hdev = file->private_data;
3335 char buf[32];
3336 size_t buf_size = min(count, (sizeof(buf) - 1));
3337 u8 key_size;
3338
3339 if (copy_from_user(buf, user_buf, buf_size))
3340 return -EFAULT;
3341
3342 buf[buf_size] = '\0';
3343
3344 sscanf(buf, "%hhu", &key_size);
3345
b1f663c9
JH		 3346 if (key_size > SMP_MAX_ENC_KEY_SIZE ||
3347 key_size < SMP_DEV(hdev)->min_key_size)
2fd36558
JH		 3348 return -EINVAL;
3349
3350 SMP_DEV(hdev)->max_key_size = key_size;
3351
3352 return count;
3353}
3354
3355static const struct file_operations le_max_key_size_fops = {
3356 .open = simple_open,
3357 .read = le_max_key_size_read,
3358 .write = le_max_key_size_write,
3359 .llseek = default_llseek,
3360};
3361
ef8efe4b
JH		 3362int smp_register(struct hci_dev *hdev)
3363{
3364 struct l2cap_chan *chan;
3365
3366 BT_DBG("%s", hdev->name);
3367
7e7ec445
MH		 3368 /* If the controller does not support Low Energy operation, then
3369 * there is also no need to register any SMP channel.
3370 */
3371 if (!lmp_le_capable(hdev))
3372 return 0;
3373
2b8df323
MH		 3374 if (WARN_ON(hdev->smp_data)) {
3375 chan = hdev->smp_data;
3376 hdev->smp_data = NULL;
3377 smp_del_chan(chan);
3378 }
3379
ef8efe4b
JH		 3380 chan = smp_add_cid(hdev, L2CAP_CID_SMP);
3381 if (IS_ERR(chan))
3382 return PTR_ERR(chan);
3383
3384 hdev->smp_data = chan;
3385
b1f663c9
JH		 3386 debugfs_create_file("le_min_key_size", 0644, hdev->debugfs, hdev,
3387 &le_min_key_size_fops);
2fd36558
JH		 3388 debugfs_create_file("le_max_key_size", 0644, hdev->debugfs, hdev,
3389 &le_max_key_size_fops);
3390
300acfde
MH		 3391 /* If the controller does not support BR/EDR Secure Connections
3392 * feature, then the BR/EDR SMP channel shall not be present.
3393 *
3394 * To test this with Bluetooth 4.0 controllers, create a debugfs
3395 * switch that allows forcing BR/EDR SMP support and accepting
3396 * cross-transport pairing on non-AES encrypted connections.
3397 */
3398 if (!lmp_sc_capable(hdev)) {
3399 debugfs_create_file("force_bredr_smp", 0644, hdev->debugfs,
3400 hdev, &force_bredr_smp_fops);
ef8efe4b 3401 return 0;
300acfde 3402 }
ef8efe4b 3403
2b8df323
MH		 3404 if (WARN_ON(hdev->smp_bredr_data)) {
3405 chan = hdev->smp_bredr_data;
3406 hdev->smp_bredr_data = NULL;
3407 smp_del_chan(chan);
3408 }
3409
ef8efe4b
JH		 3410 chan = smp_add_cid(hdev, L2CAP_CID_SMP_BREDR);
3411 if (IS_ERR(chan)) {
3412 int err = PTR_ERR(chan);
3413 chan = hdev->smp_data;
3414 hdev->smp_data = NULL;
3415 smp_del_chan(chan);
3416 return err;
3417 }
3418
3419 hdev->smp_bredr_data = chan;
3420
3421 return 0;
3422}
3423
3424void smp_unregister(struct hci_dev *hdev)
3425{
3426 struct l2cap_chan *chan;
3427
3428 if (hdev->smp_bredr_data) {
3429 chan = hdev->smp_bredr_data;
3430 hdev->smp_bredr_data = NULL;
3431 smp_del_chan(chan);
3432 }
3433
3434 if (hdev->smp_data) {
3435 chan = hdev->smp_data;
3436 hdev->smp_data = NULL;
3437 smp_del_chan(chan);
3438 }
3439}
0a2b0f04
JH		 3440
3441#if IS_ENABLED(CONFIG_BT_SELFTEST_SMP)
3442
71af2f6b 3443static int __init test_ah(struct crypto_skcipher *tfm_aes)
cfc4198e
JH		 3444{
3445 const u8 irk[16] = {
3446 0x9b, 0x7d, 0x39, 0x0a, 0xa6, 0x10, 0x10, 0x34,
3447 0x05, 0xad, 0xc8, 0x57, 0xa3, 0x34, 0x02, 0xec };
3448 const u8 r[3] = { 0x94, 0x81, 0x70 };
3449 const u8 exp[3] = { 0xaa, 0xfb, 0x0d };
3450 u8 res[3];
3451 int err;
3452
3453 err = smp_ah(tfm_aes, irk, r, res);
3454 if (err)
3455 return err;
3456
3457 if (memcmp(res, exp, 3))
3458 return -EINVAL;
3459
3460 return 0;
3461}
3462
71af2f6b 3463static int __init test_c1(struct crypto_skcipher *tfm_aes)
cfc4198e
JH		 3464{
3465 const u8 k[16] = {
3466 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3467 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
3468 const u8 r[16] = {
3469 0xe0, 0x2e, 0x70, 0xc6, 0x4e, 0x27, 0x88, 0x63,
3470 0x0e, 0x6f, 0xad, 0x56, 0x21, 0xd5, 0x83, 0x57 };
3471 const u8 preq[7] = { 0x01, 0x01, 0x00, 0x00, 0x10, 0x07, 0x07 };
3472 const u8 pres[7] = { 0x02, 0x03, 0x00, 0x00, 0x08, 0x00, 0x05 };
3473 const u8 _iat = 0x01;
3474 const u8 _rat = 0x00;
3475 const bdaddr_t ra = { { 0xb6, 0xb5, 0xb4, 0xb3, 0xb2, 0xb1 } };
3476 const bdaddr_t ia = { { 0xa6, 0xa5, 0xa4, 0xa3, 0xa2, 0xa1 } };
3477 const u8 exp[16] = {
3478 0x86, 0x3b, 0xf1, 0xbe, 0xc5, 0x4d, 0xa7, 0xd2,
3479 0xea, 0x88, 0x89, 0x87, 0xef, 0x3f, 0x1e, 0x1e };
3480 u8 res[16];
3481 int err;
3482
3483 err = smp_c1(tfm_aes, k, r, preq, pres, _iat, &ia, _rat, &ra, res);
3484 if (err)
3485 return err;
3486
3487 if (memcmp(res, exp, 16))
3488 return -EINVAL;
3489
3490 return 0;
3491}
3492
71af2f6b 3493static int __init test_s1(struct crypto_skcipher *tfm_aes)
cfc4198e
JH		 3494{
3495 const u8 k[16] = {
3496 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3497 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
3498 const u8 r1[16] = {
3499 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11 };
3500 const u8 r2[16] = {
3501 0x00, 0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99 };
3502 const u8 exp[16] = {
3503 0x62, 0xa0, 0x6d, 0x79, 0xae, 0x16, 0x42, 0x5b,
3504 0x9b, 0xf4, 0xb0, 0xe8, 0xf0, 0xe1, 0x1f, 0x9a };
3505 u8 res[16];
3506 int err;
3507
3508 err = smp_s1(tfm_aes, k, r1, r2, res);
3509 if (err)
3510 return err;
3511
3512 if (memcmp(res, exp, 16))
3513 return -EINVAL;
3514
3515 return 0;
3516}
3517
71af2f6b 3518static int __init test_f4(struct crypto_shash *tfm_cmac)
fb2969a3
JH		 3519{
3520 const u8 u[32] = {
3521 0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
3522 0xdb, 0xfd, 0xf4, 0xac, 0x11, 0x91, 0xf4, 0xef,
3523 0xb9, 0xa5, 0xf9, 0xe9, 0xa7, 0x83, 0x2c, 0x5e,
3524 0x2c, 0xbe, 0x97, 0xf2, 0xd2, 0x03, 0xb0, 0x20 };
3525 const u8 v[32] = {
3526 0xfd, 0xc5, 0x7f, 0xf4, 0x49, 0xdd, 0x4f, 0x6b,
3527 0xfb, 0x7c, 0x9d, 0xf1, 0xc2, 0x9a, 0xcb, 0x59,
3528 0x2a, 0xe7, 0xd4, 0xee, 0xfb, 0xfc, 0x0a, 0x90,
3529 0x9a, 0xbb, 0xf6, 0x32, 0x3d, 0x8b, 0x18, 0x55 };
3530 const u8 x[16] = {
3531 0xab, 0xae, 0x2b, 0x71, 0xec, 0xb2, 0xff, 0xff,
3532 0x3e, 0x73, 0x77, 0xd1, 0x54, 0x84, 0xcb, 0xd5 };
3533 const u8 z = 0x00;
3534 const u8 exp[16] = {
3535 0x2d, 0x87, 0x74, 0xa9, 0xbe, 0xa1, 0xed, 0xf1,
3536 0x1c, 0xbd, 0xa9, 0x07, 0xf1, 0x16, 0xc9, 0xf2 };
3537 u8 res[16];
3538 int err;
3539
3540 err = smp_f4(tfm_cmac, u, v, x, z, res);
3541 if (err)
3542 return err;
3543
3544 if (memcmp(res, exp, 16))
3545 return -EINVAL;
3546
3547 return 0;
3548}
3549
71af2f6b 3550static int __init test_f5(struct crypto_shash *tfm_cmac)
fb2969a3
JH		 3551{
3552 const u8 w[32] = {
3553 0x98, 0xa6, 0xbf, 0x73, 0xf3, 0x34, 0x8d, 0x86,
3554 0xf1, 0x66, 0xf8, 0xb4, 0x13, 0x6b, 0x79, 0x99,
3555 0x9b, 0x7d, 0x39, 0x0a, 0xa6, 0x10, 0x10, 0x34,
3556 0x05, 0xad, 0xc8, 0x57, 0xa3, 0x34, 0x02, 0xec };
3557 const u8 n1[16] = {
3558 0xab, 0xae, 0x2b, 0x71, 0xec, 0xb2, 0xff, 0xff,
3559 0x3e, 0x73, 0x77, 0xd1, 0x54, 0x84, 0xcb, 0xd5 };
3560 const u8 n2[16] = {
3561 0xcf, 0xc4, 0x3d, 0xff, 0xf7, 0x83, 0x65, 0x21,
3562 0x6e, 0x5f, 0xa7, 0x25, 0xcc, 0xe7, 0xe8, 0xa6 };
3563 const u8 a1[7] = { 0xce, 0xbf, 0x37, 0x37, 0x12, 0x56, 0x00 };
3564 const u8 a2[7] = { 0xc1, 0xcf, 0x2d, 0x70, 0x13, 0xa7, 0x00 };
3565 const u8 exp_ltk[16] = {
3566 0x38, 0x0a, 0x75, 0x94, 0xb5, 0x22, 0x05, 0x98,
3567 0x23, 0xcd, 0xd7, 0x69, 0x11, 0x79, 0x86, 0x69 };
3568 const u8 exp_mackey[16] = {
3569 0x20, 0x6e, 0x63, 0xce, 0x20, 0x6a, 0x3f, 0xfd,
3570 0x02, 0x4a, 0x08, 0xa1, 0x76, 0xf1, 0x65, 0x29 };
3571 u8 mackey[16], ltk[16];
3572 int err;
3573
3574 err = smp_f5(tfm_cmac, w, n1, n2, a1, a2, mackey, ltk);
3575 if (err)
3576 return err;
3577
3578 if (memcmp(mackey, exp_mackey, 16))
3579 return -EINVAL;
3580
3581 if (memcmp(ltk, exp_ltk, 16))
3582 return -EINVAL;
3583
3584 return 0;
3585}
3586
71af2f6b 3587static int __init test_f6(struct crypto_shash *tfm_cmac)
fb2969a3
JH		 3588{
3589 const u8 w[16] = {
3590 0x20, 0x6e, 0x63, 0xce, 0x20, 0x6a, 0x3f, 0xfd,
3591 0x02, 0x4a, 0x08, 0xa1, 0x76, 0xf1, 0x65, 0x29 };
3592 const u8 n1[16] = {
3593 0xab, 0xae, 0x2b, 0x71, 0xec, 0xb2, 0xff, 0xff,
3594 0x3e, 0x73, 0x77, 0xd1, 0x54, 0x84, 0xcb, 0xd5 };
3595 const u8 n2[16] = {
3596 0xcf, 0xc4, 0x3d, 0xff, 0xf7, 0x83, 0x65, 0x21,
3597 0x6e, 0x5f, 0xa7, 0x25, 0xcc, 0xe7, 0xe8, 0xa6 };
3598 const u8 r[16] = {
3599 0xc8, 0x0f, 0x2d, 0x0c, 0xd2, 0x42, 0xda, 0x08,
3600 0x54, 0xbb, 0x53, 0xb4, 0x3b, 0x34, 0xa3, 0x12 };
3601 const u8 io_cap[3] = { 0x02, 0x01, 0x01 };
3602 const u8 a1[7] = { 0xce, 0xbf, 0x37, 0x37, 0x12, 0x56, 0x00 };
3603 const u8 a2[7] = { 0xc1, 0xcf, 0x2d, 0x70, 0x13, 0xa7, 0x00 };
3604 const u8 exp[16] = {
3605 0x61, 0x8f, 0x95, 0xda, 0x09, 0x0b, 0x6c, 0xd2,
3606 0xc5, 0xe8, 0xd0, 0x9c, 0x98, 0x73, 0xc4, 0xe3 };
3607 u8 res[16];
3608 int err;
3609
3610 err = smp_f6(tfm_cmac, w, n1, n2, r, io_cap, a1, a2, res);
3611 if (err)
3612 return err;
3613
3614 if (memcmp(res, exp, 16))
3615 return -EINVAL;
3616
3617 return 0;
3618}
3619
71af2f6b 3620static int __init test_g2(struct crypto_shash *tfm_cmac)
fb2969a3
JH		 3621{
3622 const u8 u[32] = {
3623 0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
3624 0xdb, 0xfd, 0xf4, 0xac, 0x11, 0x91, 0xf4, 0xef,
3625 0xb9, 0xa5, 0xf9, 0xe9, 0xa7, 0x83, 0x2c, 0x5e,
3626 0x2c, 0xbe, 0x97, 0xf2, 0xd2, 0x03, 0xb0, 0x20 };
3627 const u8 v[32] = {
3628 0xfd, 0xc5, 0x7f, 0xf4, 0x49, 0xdd, 0x4f, 0x6b,
3629 0xfb, 0x7c, 0x9d, 0xf1, 0xc2, 0x9a, 0xcb, 0x59,
3630 0x2a, 0xe7, 0xd4, 0xee, 0xfb, 0xfc, 0x0a, 0x90,
3631 0x9a, 0xbb, 0xf6, 0x32, 0x3d, 0x8b, 0x18, 0x55 };
3632 const u8 x[16] = {
3633 0xab, 0xae, 0x2b, 0x71, 0xec, 0xb2, 0xff, 0xff,
3634 0x3e, 0x73, 0x77, 0xd1, 0x54, 0x84, 0xcb, 0xd5 };
3635 const u8 y[16] = {
3636 0xcf, 0xc4, 0x3d, 0xff, 0xf7, 0x83, 0x65, 0x21,
3637 0x6e, 0x5f, 0xa7, 0x25, 0xcc, 0xe7, 0xe8, 0xa6 };
3638 const u32 exp_val = 0x2f9ed5ba % 1000000;
3639 u32 val;
3640 int err;
3641
3642 err = smp_g2(tfm_cmac, u, v, x, y, &val);
3643 if (err)
3644 return err;
3645
3646 if (val != exp_val)
3647 return -EINVAL;
3648
3649 return 0;
3650}
3651
71af2f6b 3652static int __init test_h6(struct crypto_shash *tfm_cmac)
fb2969a3
JH		 3653{
3654 const u8 w[16] = {
3655 0x9b, 0x7d, 0x39, 0x0a, 0xa6, 0x10, 0x10, 0x34,
3656 0x05, 0xad, 0xc8, 0x57, 0xa3, 0x34, 0x02, 0xec };
3657 const u8 key_id[4] = { 0x72, 0x62, 0x65, 0x6c };
3658 const u8 exp[16] = {
3659 0x99, 0x63, 0xb1, 0x80, 0xe2, 0xa9, 0xd3, 0xe8,
3660 0x1c, 0xc9, 0x6d, 0xe7, 0x02, 0xe1, 0x9a, 0x2d };
3661 u8 res[16];
3662 int err;
3663
3664 err = smp_h6(tfm_cmac, w, key_id, res);
3665 if (err)
3666 return err;
3667
3668 if (memcmp(res, exp, 16))
3669 return -EINVAL;
3670
3671 return 0;
3672}
3673
64dd374e
MH		 3674static char test_smp_buffer[32];
3675
3676static ssize_t test_smp_read(struct file *file, char __user *user_buf,
3677 size_t count, loff_t *ppos)
3678{
3679 return simple_read_from_buffer(user_buf, count, ppos, test_smp_buffer,
3680 strlen(test_smp_buffer));
3681}
3682
3683static const struct file_operations test_smp_fops = {
3684 .open = simple_open,
3685 .read = test_smp_read,
3686 .llseek = default_llseek,
3687};
3688
71af2f6b
HX		 3689static int __init run_selftests(struct crypto_skcipher *tfm_aes,
3690 struct crypto_shash *tfm_cmac)
0a2b0f04 3691{
255047b0
MH		 3692 ktime_t calltime, delta, rettime;
3693 unsigned long long duration;
cfc4198e
JH		 3694 int err;
3695
255047b0
MH		 3696 calltime = ktime_get();
3697
cfc4198e
JH		 3698 err = test_ah(tfm_aes);
3699 if (err) {
3700 BT_ERR("smp_ah test failed");
64dd374e 3701 goto done;
cfc4198e
JH		 3702 }
3703
3704 err = test_c1(tfm_aes);
3705 if (err) {
3706 BT_ERR("smp_c1 test failed");
64dd374e 3707 goto done;
cfc4198e
JH		 3708 }
3709
3710 err = test_s1(tfm_aes);
3711 if (err) {
3712 BT_ERR("smp_s1 test failed");
64dd374e 3713 goto done;
cfc4198e
JH		 3714 }
3715
fb2969a3
JH		 3716 err = test_f4(tfm_cmac);
3717 if (err) {
3718 BT_ERR("smp_f4 test failed");
64dd374e 3719 goto done;
fb2969a3
JH		 3720 }
3721
3722 err = test_f5(tfm_cmac);
3723 if (err) {
3724 BT_ERR("smp_f5 test failed");
64dd374e 3725 goto done;
fb2969a3
JH		 3726 }
3727
3728 err = test_f6(tfm_cmac);
3729 if (err) {
3730 BT_ERR("smp_f6 test failed");
64dd374e 3731 goto done;
fb2969a3
JH		 3732 }
3733
3734 err = test_g2(tfm_cmac);
3735 if (err) {
3736 BT_ERR("smp_g2 test failed");
64dd374e 3737 goto done;
fb2969a3
JH		 3738 }
3739
3740 err = test_h6(tfm_cmac);
3741 if (err) {
3742 BT_ERR("smp_h6 test failed");
64dd374e 3743 goto done;
fb2969a3
JH		 3744 }
3745
255047b0
MH		 3746 rettime = ktime_get();
3747 delta = ktime_sub(rettime, calltime);
3748 duration = (unsigned long long) ktime_to_ns(delta) >> 10;
3749
5ced2464 3750 BT_INFO("SMP test passed in %llu usecs", duration);
0a2b0f04 3751
64dd374e
MH		 3752done:
3753 if (!err)
3754 snprintf(test_smp_buffer, sizeof(test_smp_buffer),
3755 "PASS (%llu usecs)\n", duration);
3756 else
3757 snprintf(test_smp_buffer, sizeof(test_smp_buffer), "FAIL\n");
3758
3759 debugfs_create_file("selftest_smp", 0444, bt_debugfs, NULL,
3760 &test_smp_fops);
3761
3762 return err;
0a2b0f04
JH		 3763}
3764
3765int __init bt_selftest_smp(void)
3766{
71af2f6b
HX		 3767 struct crypto_skcipher *tfm_aes;
3768 struct crypto_shash *tfm_cmac;
0a2b0f04
JH		 3769 int err;
3770
71af2f6b 3771 tfm_aes = crypto_alloc_skcipher("ecb(aes)", 0, CRYPTO_ALG_ASYNC);
0a2b0f04
JH		 3772 if (IS_ERR(tfm_aes)) {
3773 BT_ERR("Unable to create ECB crypto context");
3774 return PTR_ERR(tfm_aes);
3775 }
3776
71af2f6b 3777 tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, CRYPTO_ALG_ASYNC);
0a2b0f04
JH		 3778 if (IS_ERR(tfm_cmac)) {
3779 BT_ERR("Unable to create CMAC crypto context");
71af2f6b 3780 crypto_free_skcipher(tfm_aes);
0a2b0f04
JH		 3781 return PTR_ERR(tfm_cmac);
3782 }
3783
3784 err = run_selftests(tfm_aes, tfm_cmac);
3785
71af2f6b
HX		 3786 crypto_free_shash(tfm_cmac);
3787 crypto_free_skcipher(tfm_aes);
0a2b0f04
JH		 3788
3789 return err;
3790}
3791
3792#endif
Linux 6.x block layer and io_uring tree(s)