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