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