projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Add full SMP BR/EDR support
[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
1c1def09
VCG		 1611 smp->preq[0] = SMP_CMD_PAIRING_REQ;
1612 memcpy(&smp->preq[1], req, sizeof(*req));
3158c50c 1613 skb_pull(skb, sizeof(*req));
88ba43b6 1614
b5ae344d
JH		 1615 /* SMP over BR/EDR requires special treatment */
1616 if (conn->hcon->type == ACL_LINK) {
1617 /* We must have a BR/EDR SC link */
1618 if (!test_bit(HCI_CONN_AES_CCM, &conn->hcon->flags))
1619 return SMP_CROSS_TRANSP_NOT_ALLOWED;
1620
1621 set_bit(SMP_FLAG_SC, &smp->flags);
1622
1623 build_bredr_pairing_cmd(smp, req, &rsp);
1624
1625 key_size = min(req->max_key_size, rsp.max_key_size);
1626 if (check_enc_key_size(conn, key_size))
1627 return SMP_ENC_KEY_SIZE;
1628
1629 /* Clear bits which are generated but not distributed */
1630 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1631
1632 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1633 memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
1634 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
1635
1636 smp_distribute_keys(smp);
1637 return 0;
1638 }
1639
5e3d3d9b
JH		 1640 build_pairing_cmd(conn, req, &rsp, auth);
1641
1642 if (rsp.auth_req & SMP_AUTH_SC)
1643 set_bit(SMP_FLAG_SC, &smp->flags);
1644
5be5e275 1645 if (conn->hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
1afc2a1a
JH		 1646 sec_level = BT_SECURITY_MEDIUM;
1647 else
1648 sec_level = authreq_to_seclevel(auth);
1649
c7262e71
JH		 1650 if (sec_level > conn->hcon->pending_sec_level)
1651 conn->hcon->pending_sec_level = sec_level;
fdde0a26 1652
49c922bb 1653 /* If we need MITM check that it can be achieved */
2ed8f65c
JH		 1654 if (conn->hcon->pending_sec_level >= BT_SECURITY_HIGH) {
1655 u8 method;
1656
1657 method = get_auth_method(smp, conn->hcon->io_capability,
1658 req->io_capability);
1659 if (method == JUST_WORKS || method == JUST_CFM)
1660 return SMP_AUTH_REQUIREMENTS;
1661 }
1662
3158c50c
VCG		 1663 key_size = min(req->max_key_size, rsp.max_key_size);
1664 if (check_enc_key_size(conn, key_size))
1665 return SMP_ENC_KEY_SIZE;
88ba43b6 1666
e84a6b13 1667 get_random_bytes(smp->prnd, sizeof(smp->prnd));
8aab4757 1668
1c1def09
VCG		 1669 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1670 memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
f01ead31 1671
3158c50c 1672 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
3b19146d
JH		 1673
1674 clear_bit(SMP_FLAG_INITIATOR, &smp->flags);
1675
1676 if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1677 SMP_ALLOW_CMD(smp, SMP_CMD_PUBLIC_KEY);
1678 /* Clear bits which are generated but not distributed */
1679 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1680 /* Wait for Public Key from Initiating Device */
1681 return 0;
1682 } else {
1683 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
1684 }
da85e5e5 1685
2b64d153
BG		 1686 /* Request setup of TK */
1687 ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
1688 if (ret)
1689 return SMP_UNSPECIFIED;
1690
da85e5e5 1691 return 0;
88ba43b6
AB		 1692}
1693
3b19146d
JH		 1694static u8 sc_send_public_key(struct smp_chan *smp)
1695{
70157ef5
JH		 1696 struct hci_dev *hdev = smp->conn->hcon->hdev;
1697
3b19146d
JH		 1698 BT_DBG("");
1699
70157ef5
JH		 1700 if (test_bit(HCI_USE_DEBUG_KEYS, &hdev->dev_flags)) {
1701 BT_DBG("Using debug keys");
1702 memcpy(smp->local_pk, debug_pk, 64);
1703 memcpy(smp->local_sk, debug_sk, 32);
1704 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
1705 } else {
1706 while (true) {
1707 /* Generate local key pair for Secure Connections */
1708 if (!ecc_make_key(smp->local_pk, smp->local_sk))
1709 return SMP_UNSPECIFIED;
6c0dcc50 1710
70157ef5
JH		 1711 /* This is unlikely, but we need to check that
1712 * we didn't accidentially generate a debug key.
1713 */
1714 if (memcmp(smp->local_sk, debug_sk, 32))
1715 break;
1716 }
6c0dcc50 1717 }
3b19146d
JH		 1718
1719 BT_DBG("Local Public Key X: %32phN", smp->local_pk);
1720 BT_DBG("Local Public Key Y: %32phN", &smp->local_pk[32]);
1721 BT_DBG("Local Private Key: %32phN", smp->local_sk);
1722
1723 smp_send_cmd(smp->conn, SMP_CMD_PUBLIC_KEY, 64, smp->local_pk);
1724
1725 return 0;
1726}
1727
da85e5e5 1728static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 1729{
3158c50c 1730 struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
5d88cc73
JH		 1731 struct l2cap_chan *chan = conn->smp;
1732 struct smp_chan *smp = chan->data;
0edb14de 1733 struct hci_dev *hdev = conn->hcon->hdev;
3a7dbfb8 1734 u8 key_size, auth;
7d24ddcc 1735 int ret;
88ba43b6
AB		 1736
1737 BT_DBG("conn %p", conn);
1738
c46b98be 1739 if (skb->len < sizeof(*rsp))
38e4a915 1740 return SMP_INVALID_PARAMS;
c46b98be 1741
40bef302 1742 if (conn->hcon->role != HCI_ROLE_MASTER)
2b64d153
BG		 1743 return SMP_CMD_NOTSUPP;
1744
3158c50c
VCG		 1745 skb_pull(skb, sizeof(*rsp));
1746
1c1def09 1747 req = (void *) &smp->preq[1];
da85e5e5 1748
3158c50c
VCG		 1749 key_size = min(req->max_key_size, rsp->max_key_size);
1750 if (check_enc_key_size(conn, key_size))
1751 return SMP_ENC_KEY_SIZE;
1752
0edb14de 1753 auth = rsp->auth_req & AUTH_REQ_MASK(hdev);
c05b9339 1754
b5ae344d
JH		 1755 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
1756 memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
1757
1758 /* Update remote key distribution in case the remote cleared
1759 * some bits that we had enabled in our request.
1760 */
1761 smp->remote_key_dist &= rsp->resp_key_dist;
1762
1763 /* For BR/EDR this means we're done and can start phase 3 */
1764 if (conn->hcon->type == ACL_LINK) {
1765 /* Clear bits which are generated but not distributed */
1766 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1767 smp_distribute_keys(smp);
1768 return 0;
1769 }
1770
65668776
JH		 1771 if ((req->auth_req & SMP_AUTH_SC) && (auth & SMP_AUTH_SC))
1772 set_bit(SMP_FLAG_SC, &smp->flags);
d2eb9e10
JH		 1773 else if (conn->hcon->pending_sec_level > BT_SECURITY_HIGH)
1774 conn->hcon->pending_sec_level = BT_SECURITY_HIGH;
65668776 1775
49c922bb 1776 /* If we need MITM check that it can be achieved */
2ed8f65c
JH		 1777 if (conn->hcon->pending_sec_level >= BT_SECURITY_HIGH) {
1778 u8 method;
1779
1780 method = get_auth_method(smp, req->io_capability,
1781 rsp->io_capability);
1782 if (method == JUST_WORKS || method == JUST_CFM)
1783 return SMP_AUTH_REQUIREMENTS;
1784 }
1785
e84a6b13 1786 get_random_bytes(smp->prnd, sizeof(smp->prnd));
7d24ddcc 1787
fdcc4bec
JH		 1788 /* Update remote key distribution in case the remote cleared
1789 * some bits that we had enabled in our request.
1790 */
1791 smp->remote_key_dist &= rsp->resp_key_dist;
1792
3b19146d
JH		 1793 if (test_bit(SMP_FLAG_SC, &smp->flags)) {
1794 /* Clear bits which are generated but not distributed */
1795 smp->remote_key_dist &= ~SMP_SC_NO_DIST;
1796 SMP_ALLOW_CMD(smp, SMP_CMD_PUBLIC_KEY);
1797 return sc_send_public_key(smp);
1798 }
1799
c05b9339 1800 auth |= req->auth_req;
2b64d153 1801
476585ec 1802 ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
2b64d153
BG		 1803 if (ret)
1804 return SMP_UNSPECIFIED;
1805
4a74d658 1806 set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
2b64d153
BG		 1807
1808 /* Can't compose response until we have been confirmed */
4a74d658 1809 if (test_bit(SMP_FLAG_TK_VALID, &smp->flags))
1cc61144 1810 return smp_confirm(smp);
da85e5e5
VCG		 1811
1812 return 0;
88ba43b6
AB		 1813}
1814
dcee2b32
JH		 1815static u8 sc_check_confirm(struct smp_chan *smp)
1816{
1817 struct l2cap_conn *conn = smp->conn;
1818
1819 BT_DBG("");
1820
1821 /* Public Key exchange must happen before any other steps */
1822 if (!test_bit(SMP_FLAG_REMOTE_PK, &smp->flags))
1823 return SMP_UNSPECIFIED;
1824
38606f14
JH		 1825 if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
1826 return sc_passkey_round(smp, SMP_CMD_PAIRING_CONFIRM);
1827
dcee2b32
JH		 1828 if (conn->hcon->out) {
1829 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
1830 smp->prnd);
1831 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
1832 }
1833
1834 return 0;
1835}
1836
da85e5e5 1837static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 1838{
5d88cc73
JH		 1839 struct l2cap_chan *chan = conn->smp;
1840 struct smp_chan *smp = chan->data;
7d24ddcc 1841
88ba43b6
AB		 1842 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
1843
c46b98be 1844 if (skb->len < sizeof(smp->pcnf))
38e4a915 1845 return SMP_INVALID_PARAMS;
c46b98be 1846
1c1def09
VCG		 1847 memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
1848 skb_pull(skb, sizeof(smp->pcnf));
88ba43b6 1849
dcee2b32
JH		 1850 if (test_bit(SMP_FLAG_SC, &smp->flags))
1851 return sc_check_confirm(smp);
1852
b28b4943 1853 if (conn->hcon->out) {
943a732a
JH		 1854 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
1855 smp->prnd);
b28b4943
JH		 1856 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
1857 return 0;
1858 }
1859
1860 if (test_bit(SMP_FLAG_TK_VALID, &smp->flags))
1cc61144 1861 return smp_confirm(smp);
943a732a 1862 else
4a74d658 1863 set_bit(SMP_FLAG_CFM_PENDING, &smp->flags);
da85e5e5
VCG		 1864
1865 return 0;
88ba43b6
AB		 1866}
1867
da85e5e5 1868static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 1869{
5d88cc73
JH		 1870 struct l2cap_chan *chan = conn->smp;
1871 struct smp_chan *smp = chan->data;
191dc7fe
JH		 1872 struct hci_conn *hcon = conn->hcon;
1873 u8 *pkax, *pkbx, *na, *nb;
1874 u32 passkey;
1875 int err;
7d24ddcc 1876
8aab4757 1877 BT_DBG("conn %p", conn);
3158c50c 1878
c46b98be 1879 if (skb->len < sizeof(smp->rrnd))
38e4a915 1880 return SMP_INVALID_PARAMS;
c46b98be 1881
943a732a 1882 memcpy(smp->rrnd, skb->data, sizeof(smp->rrnd));
8aab4757 1883 skb_pull(skb, sizeof(smp->rrnd));
e7e62c85 1884
191dc7fe
JH		 1885 if (!test_bit(SMP_FLAG_SC, &smp->flags))
1886 return smp_random(smp);
1887
38606f14
JH		 1888 /* Passkey entry has special treatment */
1889 if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
1890 return sc_passkey_round(smp, SMP_CMD_PAIRING_RANDOM);
1891
191dc7fe
JH		 1892 if (hcon->out) {
1893 u8 cfm[16];
1894
1895 err = smp_f4(smp->tfm_cmac, smp->remote_pk, smp->local_pk,
1896 smp->rrnd, 0, cfm);
1897 if (err)
1898 return SMP_UNSPECIFIED;
1899
1900 if (memcmp(smp->pcnf, cfm, 16))
1901 return SMP_CONFIRM_FAILED;
1902
1903 pkax = smp->local_pk;
1904 pkbx = smp->remote_pk;
1905 na = smp->prnd;
1906 nb = smp->rrnd;
1907 } else {
1908 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
1909 smp->prnd);
1910 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1911
1912 pkax = smp->remote_pk;
1913 pkbx = smp->local_pk;
1914 na = smp->rrnd;
1915 nb = smp->prnd;
1916 }
1917
760b018b
JH		 1918 /* Generate MacKey and LTK */
1919 err = sc_mackey_and_ltk(smp, smp->mackey, smp->tk);
1920 if (err)
1921 return SMP_UNSPECIFIED;
1922
dddd3059
JH		 1923 if (smp->method == JUST_WORKS) {
1924 if (hcon->out) {
38606f14 1925 sc_dhkey_check(smp);
dddd3059
JH		 1926 SMP_ALLOW_CMD(smp, SMP_CMD_DHKEY_CHECK);
1927 }
1928 return 0;
1929 }
1930
38606f14
JH		 1931 err = smp_g2(smp->tfm_cmac, pkax, pkbx, na, nb, &passkey);
1932 if (err)
1933 return SMP_UNSPECIFIED;
1934
1935 err = mgmt_user_confirm_request(hcon->hdev, &hcon->dst, hcon->type,
1936 hcon->dst_type, passkey, 0);
191dc7fe
JH		 1937 if (err)
1938 return SMP_UNSPECIFIED;
1939
38606f14
JH		 1940 set_bit(SMP_FLAG_WAIT_USER, &smp->flags);
1941
191dc7fe 1942 return 0;
88ba43b6
AB		 1943}
1944
f81cd823 1945static bool smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
988c5997 1946{
c9839a11 1947 struct smp_ltk *key;
988c5997
VCG		 1948 struct hci_conn *hcon = conn->hcon;
1949
f3a73d97 1950 key = hci_find_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, hcon->role);
988c5997 1951 if (!key)
f81cd823 1952 return false;
988c5997 1953
a6f7833c 1954 if (smp_ltk_sec_level(key) < sec_level)
f81cd823 1955 return false;
4dab7864 1956
51a8efd7 1957 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
f81cd823 1958 return true;
988c5997 1959
c9839a11
VCG		 1960 hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
1961 hcon->enc_key_size = key->enc_size;
988c5997 1962
fe59a05f
JH		 1963 /* We never store STKs for master role, so clear this flag */
1964 clear_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags);
1965
f81cd823 1966 return true;
988c5997 1967}
f1560463 1968
35dc6f83
JH		 1969bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level,
1970 enum smp_key_pref key_pref)
854f4727
JH		 1971{
1972 if (sec_level == BT_SECURITY_LOW)
1973 return true;
1974
35dc6f83
JH		 1975 /* If we're encrypted with an STK but the caller prefers using
1976 * LTK claim insufficient security. This way we allow the
1977 * connection to be re-encrypted with an LTK, even if the LTK
1978 * provides the same level of security. Only exception is if we
1979 * don't have an LTK (e.g. because of key distribution bits).
9ab65d60 1980 */
35dc6f83
JH		 1981 if (key_pref == SMP_USE_LTK &&
1982 test_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags) &&
f3a73d97 1983 hci_find_ltk(hcon->hdev, &hcon->dst, hcon->dst_type, hcon->role))
9ab65d60
JH		 1984 return false;
1985
854f4727
JH		 1986 if (hcon->sec_level >= sec_level)
1987 return true;
1988
1989 return false;
1990}
1991
da85e5e5 1992static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6
AB		 1993{
1994 struct smp_cmd_security_req *rp = (void *) skb->data;
1995 struct smp_cmd_pairing cp;
f1cb9af5 1996 struct hci_conn *hcon = conn->hcon;
0edb14de 1997 struct hci_dev *hdev = hcon->hdev;
8aab4757 1998 struct smp_chan *smp;
c05b9339 1999 u8 sec_level, auth;
88ba43b6
AB		 2000
2001 BT_DBG("conn %p", conn);
2002
c46b98be 2003 if (skb->len < sizeof(*rp))
38e4a915 2004 return SMP_INVALID_PARAMS;
c46b98be 2005
40bef302 2006 if (hcon->role != HCI_ROLE_MASTER)
86ca9eac
JH		 2007 return SMP_CMD_NOTSUPP;
2008
0edb14de 2009 auth = rp->auth_req & AUTH_REQ_MASK(hdev);
c05b9339 2010
5be5e275 2011 if (hcon->io_capability == HCI_IO_NO_INPUT_OUTPUT)
1afc2a1a
JH		 2012 sec_level = BT_SECURITY_MEDIUM;
2013 else
2014 sec_level = authreq_to_seclevel(auth);
2015
35dc6f83 2016 if (smp_sufficient_security(hcon, sec_level, SMP_USE_LTK))
854f4727
JH		 2017 return 0;
2018
c7262e71
JH		 2019 if (sec_level > hcon->pending_sec_level)
2020 hcon->pending_sec_level = sec_level;
feb45eb5 2021
4dab7864 2022 if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
988c5997
VCG		 2023 return 0;
2024
8aab4757 2025 smp = smp_chan_create(conn);
c29d2444
JH		 2026 if (!smp)
2027 return SMP_UNSPECIFIED;
d26a2345 2028
b6ae8457 2029 if (!test_bit(HCI_BONDABLE, &hcon->hdev->dev_flags) &&
c05b9339 2030 (auth & SMP_AUTH_BONDING))
616d55be
JH		 2031 return SMP_PAIRING_NOTSUPP;
2032
88ba43b6 2033 skb_pull(skb, sizeof(*rp));
88ba43b6 2034
da85e5e5 2035 memset(&cp, 0, sizeof(cp));
c05b9339 2036 build_pairing_cmd(conn, &cp, NULL, auth);
88ba43b6 2037
1c1def09
VCG		 2038 smp->preq[0] = SMP_CMD_PAIRING_REQ;
2039 memcpy(&smp->preq[1], &cp, sizeof(cp));
f01ead31 2040
88ba43b6 2041 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
b28b4943 2042 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
f1cb9af5 2043
da85e5e5 2044 return 0;
88ba43b6
AB		 2045}
2046
cc110922 2047int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
eb492e01 2048{
cc110922 2049 struct l2cap_conn *conn = hcon->l2cap_data;
c68b7f12 2050 struct l2cap_chan *chan;
0a66cf20 2051 struct smp_chan *smp;
2b64d153 2052 __u8 authreq;
fc75cc86 2053 int ret;
eb492e01 2054
3a0259bb
VCG		 2055 BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
2056
0a66cf20
JH		 2057 /* This may be NULL if there's an unexpected disconnection */
2058 if (!conn)
2059 return 1;
2060
c68b7f12
JH		 2061 chan = conn->smp;
2062
757aee0f 2063 if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags))
2e65c9d2
AG		 2064 return 1;
2065
35dc6f83 2066 if (smp_sufficient_security(hcon, sec_level, SMP_USE_LTK))
eb492e01 2067 return 1;
f1cb9af5 2068
c7262e71
JH		 2069 if (sec_level > hcon->pending_sec_level)
2070 hcon->pending_sec_level = sec_level;
2071
40bef302 2072 if (hcon->role == HCI_ROLE_MASTER)
c7262e71
JH		 2073 if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
2074 return 0;
d26a2345 2075
fc75cc86
JH		 2076 l2cap_chan_lock(chan);
2077
2078 /* If SMP is already in progress ignore this request */
2079 if (chan->data) {
2080 ret = 0;
2081 goto unlock;
2082 }
d26a2345 2083
8aab4757 2084 smp = smp_chan_create(conn);
fc75cc86
JH		 2085 if (!smp) {
2086 ret = 1;
2087 goto unlock;
2088 }
2b64d153
BG		 2089
2090 authreq = seclevel_to_authreq(sec_level);
d26a2345 2091
d2eb9e10
JH		 2092 if (test_bit(HCI_SC_ENABLED, &hcon->hdev->dev_flags))
2093 authreq |= SMP_AUTH_SC;
2094
79897d20
JH		 2095 /* Require MITM if IO Capability allows or the security level
2096 * requires it.
2e233644 2097 */
79897d20 2098 if (hcon->io_capability != HCI_IO_NO_INPUT_OUTPUT ||
c7262e71 2099 hcon->pending_sec_level > BT_SECURITY_MEDIUM)
2e233644
JH		 2100 authreq |= SMP_AUTH_MITM;
2101
40bef302 2102 if (hcon->role == HCI_ROLE_MASTER) {
d26a2345 2103 struct smp_cmd_pairing cp;
f01ead31 2104
2b64d153 2105 build_pairing_cmd(conn, &cp, NULL, authreq);
1c1def09
VCG		 2106 smp->preq[0] = SMP_CMD_PAIRING_REQ;
2107 memcpy(&smp->preq[1], &cp, sizeof(cp));
f01ead31 2108
eb492e01 2109 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
b28b4943 2110 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
eb492e01
AB		 2111 } else {
2112 struct smp_cmd_security_req cp;
2b64d153 2113 cp.auth_req = authreq;
eb492e01 2114 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
b28b4943 2115 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_REQ);
eb492e01
AB		 2116 }
2117
4a74d658 2118 set_bit(SMP_FLAG_INITIATOR, &smp->flags);
fc75cc86 2119 ret = 0;
edca792c 2120
fc75cc86
JH		 2121unlock:
2122 l2cap_chan_unlock(chan);
2123 return ret;
eb492e01
AB		 2124}
2125
7034b911
VCG		 2126static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
2127{
16b90839 2128 struct smp_cmd_encrypt_info *rp = (void *) skb->data;
5d88cc73
JH		 2129 struct l2cap_chan *chan = conn->smp;
2130 struct smp_chan *smp = chan->data;
16b90839 2131
c46b98be
JH		 2132 BT_DBG("conn %p", conn);
2133
2134 if (skb->len < sizeof(*rp))
38e4a915 2135 return SMP_INVALID_PARAMS;
c46b98be 2136
b28b4943 2137 SMP_ALLOW_CMD(smp, SMP_CMD_MASTER_IDENT);
6131ddc8 2138
16b90839
VCG		 2139 skb_pull(skb, sizeof(*rp));
2140
1c1def09 2141 memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
16b90839 2142
7034b911
VCG		 2143 return 0;
2144}
2145
2146static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
2147{
16b90839 2148 struct smp_cmd_master_ident *rp = (void *) skb->data;
5d88cc73
JH		 2149 struct l2cap_chan *chan = conn->smp;
2150 struct smp_chan *smp = chan->data;
c9839a11
VCG		 2151 struct hci_dev *hdev = conn->hcon->hdev;
2152 struct hci_conn *hcon = conn->hcon;
23d0e128 2153 struct smp_ltk *ltk;
c9839a11 2154 u8 authenticated;
16b90839 2155
c46b98be
JH		 2156 BT_DBG("conn %p", conn);
2157
2158 if (skb->len < sizeof(*rp))
38e4a915 2159 return SMP_INVALID_PARAMS;
c46b98be 2160
9747a9f3
JH		 2161 /* Mark the information as received */
2162 smp->remote_key_dist &= ~SMP_DIST_ENC_KEY;
2163
b28b4943
JH		 2164 if (smp->remote_key_dist & SMP_DIST_ID_KEY)
2165 SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_INFO);
196332f5
JH		 2166 else if (smp->remote_key_dist & SMP_DIST_SIGN)
2167 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
b28b4943 2168
16b90839 2169 skb_pull(skb, sizeof(*rp));
7034b911 2170
ce39fb4e 2171 authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
2ceba539 2172 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, SMP_LTK,
23d0e128
JH		 2173 authenticated, smp->tk, smp->enc_key_size,
2174 rp->ediv, rp->rand);
2175 smp->ltk = ltk;
c6e81e9a 2176 if (!(smp->remote_key_dist & KEY_DIST_MASK))
d6268e86 2177 smp_distribute_keys(smp);
7034b911
VCG		 2178
2179 return 0;
2180}
2181
fd349c02
JH		 2182static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb)
2183{
2184 struct smp_cmd_ident_info *info = (void *) skb->data;
5d88cc73
JH		 2185 struct l2cap_chan *chan = conn->smp;
2186 struct smp_chan *smp = chan->data;
fd349c02
JH		 2187
2188 BT_DBG("");
2189
2190 if (skb->len < sizeof(*info))
38e4a915 2191 return SMP_INVALID_PARAMS;
fd349c02 2192
b28b4943 2193 SMP_ALLOW_CMD(smp, SMP_CMD_IDENT_ADDR_INFO);
6131ddc8 2194
fd349c02
JH		 2195 skb_pull(skb, sizeof(*info));
2196
2197 memcpy(smp->irk, info->irk, 16);
2198
2199 return 0;
2200}
2201
2202static int smp_cmd_ident_addr_info(struct l2cap_conn *conn,
2203 struct sk_buff *skb)
2204{
2205 struct smp_cmd_ident_addr_info *info = (void *) skb->data;
5d88cc73
JH		 2206 struct l2cap_chan *chan = conn->smp;
2207 struct smp_chan *smp = chan->data;
fd349c02
JH		 2208 struct hci_conn *hcon = conn->hcon;
2209 bdaddr_t rpa;
2210
2211 BT_DBG("");
2212
2213 if (skb->len < sizeof(*info))
38e4a915 2214 return SMP_INVALID_PARAMS;
fd349c02 2215
9747a9f3
JH		 2216 /* Mark the information as received */
2217 smp->remote_key_dist &= ~SMP_DIST_ID_KEY;
2218
b28b4943
JH		 2219 if (smp->remote_key_dist & SMP_DIST_SIGN)
2220 SMP_ALLOW_CMD(smp, SMP_CMD_SIGN_INFO);
2221
fd349c02
JH		 2222 skb_pull(skb, sizeof(*info));
2223
a9a58f86
JH		 2224 /* Strictly speaking the Core Specification (4.1) allows sending
2225 * an empty address which would force us to rely on just the IRK
2226 * as "identity information". However, since such
2227 * implementations are not known of and in order to not over
2228 * complicate our implementation, simply pretend that we never
2229 * received an IRK for such a device.
2230 */
2231 if (!bacmp(&info->bdaddr, BDADDR_ANY)) {
2232 BT_ERR("Ignoring IRK with no identity address");
31dd624e 2233 goto distribute;
a9a58f86
JH		 2234 }
2235
fd349c02
JH		 2236 bacpy(&smp->id_addr, &info->bdaddr);
2237 smp->id_addr_type = info->addr_type;
2238
2239 if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))
2240 bacpy(&rpa, &hcon->dst);
2241 else
2242 bacpy(&rpa, BDADDR_ANY);
2243
23d0e128
JH		 2244 smp->remote_irk = hci_add_irk(conn->hcon->hdev, &smp->id_addr,
2245 smp->id_addr_type, smp->irk, &rpa);
fd349c02 2246
31dd624e 2247distribute:
c6e81e9a
JH		 2248 if (!(smp->remote_key_dist & KEY_DIST_MASK))
2249 smp_distribute_keys(smp);
fd349c02
JH		 2250
2251 return 0;
2252}
2253
7ee4ea36
MH		 2254static int smp_cmd_sign_info(struct l2cap_conn *conn, struct sk_buff *skb)
2255{
2256 struct smp_cmd_sign_info *rp = (void *) skb->data;
5d88cc73
JH		 2257 struct l2cap_chan *chan = conn->smp;
2258 struct smp_chan *smp = chan->data;
7ee4ea36
MH		 2259 struct smp_csrk *csrk;
2260
2261 BT_DBG("conn %p", conn);
2262
2263 if (skb->len < sizeof(*rp))
38e4a915 2264 return SMP_INVALID_PARAMS;
7ee4ea36 2265
7ee4ea36
MH		 2266 /* Mark the information as received */
2267 smp->remote_key_dist &= ~SMP_DIST_SIGN;
2268
2269 skb_pull(skb, sizeof(*rp));
2270
7ee4ea36
MH		 2271 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
2272 if (csrk) {
2273 csrk->master = 0x01;
2274 memcpy(csrk->val, rp->csrk, sizeof(csrk->val));
2275 }
2276 smp->csrk = csrk;
d6268e86 2277 smp_distribute_keys(smp);
7ee4ea36
MH		 2278
2279 return 0;
2280}
2281
5e3d3d9b
JH		 2282static u8 sc_select_method(struct smp_chan *smp)
2283{
2284 struct l2cap_conn *conn = smp->conn;
2285 struct hci_conn *hcon = conn->hcon;
2286 struct smp_cmd_pairing *local, *remote;
2287 u8 local_mitm, remote_mitm, local_io, remote_io, method;
2288
2289 /* The preq/prsp contain the raw Pairing Request/Response PDUs
2290 * which are needed as inputs to some crypto functions. To get
2291 * the "struct smp_cmd_pairing" from them we need to skip the
2292 * first byte which contains the opcode.
2293 */
2294 if (hcon->out) {
2295 local = (void *) &smp->preq[1];
2296 remote = (void *) &smp->prsp[1];
2297 } else {
2298 local = (void *) &smp->prsp[1];
2299 remote = (void *) &smp->preq[1];
2300 }
2301
2302 local_io = local->io_capability;
2303 remote_io = remote->io_capability;
2304
2305 local_mitm = (local->auth_req & SMP_AUTH_MITM);
2306 remote_mitm = (remote->auth_req & SMP_AUTH_MITM);
2307
2308 /* If either side wants MITM, look up the method from the table,
2309 * otherwise use JUST WORKS.
2310 */
2311 if (local_mitm || remote_mitm)
2312 method = get_auth_method(smp, local_io, remote_io);
2313 else
2314 method = JUST_WORKS;
2315
2316 /* Don't confirm locally initiated pairing attempts */
2317 if (method == JUST_CFM && test_bit(SMP_FLAG_INITIATOR, &smp->flags))
2318 method = JUST_WORKS;
2319
2320 return method;
2321}
2322
d8f8edbe
JH		 2323static int smp_cmd_public_key(struct l2cap_conn *conn, struct sk_buff *skb)
2324{
2325 struct smp_cmd_public_key *key = (void *) skb->data;
2326 struct hci_conn *hcon = conn->hcon;
2327 struct l2cap_chan *chan = conn->smp;
2328 struct smp_chan *smp = chan->data;
5e3d3d9b 2329 struct hci_dev *hdev = hcon->hdev;
cbbbe3e2 2330 struct smp_cmd_pairing_confirm cfm;
d8f8edbe
JH		 2331 int err;
2332
2333 BT_DBG("conn %p", conn);
2334
2335 if (skb->len < sizeof(*key))
2336 return SMP_INVALID_PARAMS;
2337
2338 memcpy(smp->remote_pk, key, 64);
2339
2340 /* Non-initiating device sends its public key after receiving
2341 * the key from the initiating device.
2342 */
2343 if (!hcon->out) {
2344 err = sc_send_public_key(smp);
2345 if (err)
2346 return err;
2347 }
2348
2349 BT_DBG("Remote Public Key X: %32phN", smp->remote_pk);
2350 BT_DBG("Remote Public Key Y: %32phN", &smp->remote_pk[32]);
2351
2352 if (!ecdh_shared_secret(smp->remote_pk, smp->local_sk, smp->dhkey))
2353 return SMP_UNSPECIFIED;
2354
2355 BT_DBG("DHKey %32phN", smp->dhkey);
2356
2357 set_bit(SMP_FLAG_REMOTE_PK, &smp->flags);
2358
5e3d3d9b
JH		 2359 smp->method = sc_select_method(smp);
2360
2361 BT_DBG("%s selected method 0x%02x", hdev->name, smp->method);
2362
2363 /* JUST_WORKS and JUST_CFM result in an unauthenticated key */
2364 if (smp->method == JUST_WORKS || smp->method == JUST_CFM)
2365 hcon->pending_sec_level = BT_SECURITY_MEDIUM;
2366 else
2367 hcon->pending_sec_level = BT_SECURITY_FIPS;
2368
aeb7d461
JH		 2369 if (!memcmp(debug_pk, smp->remote_pk, 64))
2370 set_bit(SMP_FLAG_DEBUG_KEY, &smp->flags);
2371
38606f14
JH		 2372 if (smp->method == DSP_PASSKEY) {
2373 get_random_bytes(&hcon->passkey_notify,
2374 sizeof(hcon->passkey_notify));
2375 hcon->passkey_notify %= 1000000;
2376 hcon->passkey_entered = 0;
2377 smp->passkey_round = 0;
2378 if (mgmt_user_passkey_notify(hdev, &hcon->dst, hcon->type,
2379 hcon->dst_type,
2380 hcon->passkey_notify,
2381 hcon->passkey_entered))
2382 return SMP_UNSPECIFIED;
2383 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2384 return sc_passkey_round(smp, SMP_CMD_PUBLIC_KEY);
2385 }
2386
2387 if (hcon->out)
2388 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2389
2390 if (smp->method == REQ_PASSKEY) {
2391 if (mgmt_user_passkey_request(hdev, &hcon->dst, hcon->type,
2392 hcon->dst_type))
2393 return SMP_UNSPECIFIED;
2394 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_CONFIRM);
2395 set_bit(SMP_FLAG_WAIT_USER, &smp->flags);
2396 return 0;
2397 }
2398
cbbbe3e2
JH		 2399 /* The Initiating device waits for the non-initiating device to
2400 * send the confirm value.
2401 */
2402 if (conn->hcon->out)
2403 return 0;
2404
2405 err = smp_f4(smp->tfm_cmac, smp->local_pk, smp->remote_pk, smp->prnd,
2406 0, cfm.confirm_val);
2407 if (err)
2408 return SMP_UNSPECIFIED;
2409
2410 smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cfm), &cfm);
2411 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RANDOM);
2412
d8f8edbe
JH		 2413 return 0;
2414}
2415
6433a9a2
JH		 2416static int smp_cmd_dhkey_check(struct l2cap_conn *conn, struct sk_buff *skb)
2417{
2418 struct smp_cmd_dhkey_check *check = (void *) skb->data;
2419 struct l2cap_chan *chan = conn->smp;
2420 struct hci_conn *hcon = conn->hcon;
2421 struct smp_chan *smp = chan->data;
2422 u8 a[7], b[7], *local_addr, *remote_addr;
2423 u8 io_cap[3], r[16], e[16];
2424 int err;
2425
2426 BT_DBG("conn %p", conn);
2427
2428 if (skb->len < sizeof(*check))
2429 return SMP_INVALID_PARAMS;
2430
2431 memcpy(a, &hcon->init_addr, 6);
2432 memcpy(b, &hcon->resp_addr, 6);
2433 a[6] = hcon->init_addr_type;
2434 b[6] = hcon->resp_addr_type;
2435
2436 if (hcon->out) {
2437 local_addr = a;
2438 remote_addr = b;
2439 memcpy(io_cap, &smp->prsp[1], 3);
2440 } else {
2441 local_addr = b;
2442 remote_addr = a;
2443 memcpy(io_cap, &smp->preq[1], 3);
2444 }
2445
2446 memset(r, 0, sizeof(r));
2447
38606f14
JH		 2448 if (smp->method == REQ_PASSKEY || smp->method == DSP_PASSKEY)
2449 put_unaligned_le32(hcon->passkey_notify, r);
2450
6433a9a2
JH		 2451 err = smp_f6(smp->tfm_cmac, smp->mackey, smp->rrnd, smp->prnd, r,
2452 io_cap, remote_addr, local_addr, e);
2453 if (err)
2454 return SMP_UNSPECIFIED;
2455
2456 if (memcmp(check->e, e, 16))
2457 return SMP_DHKEY_CHECK_FAILED;
2458
d3e54a87
JH		 2459 if (!hcon->out) {
2460 if (test_bit(SMP_FLAG_WAIT_USER, &smp->flags)) {
2461 set_bit(SMP_FLAG_DHKEY_PENDING, &smp->flags);
2462 return 0;
2463 }
d378a2d7 2464
d3e54a87
JH		 2465 /* Slave sends DHKey check as response to master */
2466 sc_dhkey_check(smp);
2467 }
d378a2d7 2468
d3e54a87 2469 sc_add_ltk(smp);
6433a9a2
JH		 2470
2471 if (hcon->out) {
2472 hci_le_start_enc(hcon, 0, 0, smp->tk);
2473 hcon->enc_key_size = smp->enc_key_size;
2474 }
2475
2476 return 0;
2477}
2478
1408bb6e
JH		 2479static int smp_cmd_keypress_notify(struct l2cap_conn *conn,
2480 struct sk_buff *skb)
2481{
2482 struct smp_cmd_keypress_notify *kp = (void *) skb->data;
2483
2484 BT_DBG("value 0x%02x", kp->value);
2485
2486 return 0;
2487}
2488
4befb867 2489static int smp_sig_channel(struct l2cap_chan *chan, struct sk_buff *skb)
eb492e01 2490{
5d88cc73 2491 struct l2cap_conn *conn = chan->conn;
7b9899db 2492 struct hci_conn *hcon = conn->hcon;
b28b4943 2493 struct smp_chan *smp;
92381f5c 2494 __u8 code, reason;
eb492e01
AB		 2495 int err = 0;
2496
8ae9b984 2497 if (skb->len < 1)
92381f5c 2498 return -EILSEQ;
92381f5c 2499
06ae3314 2500 if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) {
2e65c9d2
AG		 2501 reason = SMP_PAIRING_NOTSUPP;
2502 goto done;
2503 }
2504
92381f5c 2505 code = skb->data[0];
eb492e01
AB		 2506 skb_pull(skb, sizeof(code));
2507
b28b4943
JH		 2508 smp = chan->data;
2509
2510 if (code > SMP_CMD_MAX)
2511 goto drop;
2512
24bd0bd9 2513 if (smp && !test_and_clear_bit(code, &smp->allow_cmd))
b28b4943
JH		 2514 goto drop;
2515
2516 /* If we don't have a context the only allowed commands are
2517 * pairing request and security request.
8cf9fa12 2518 */
b28b4943
JH		 2519 if (!smp && code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ)
2520 goto drop;
8cf9fa12 2521
eb492e01
AB		 2522 switch (code) {
2523 case SMP_CMD_PAIRING_REQ:
da85e5e5 2524 reason = smp_cmd_pairing_req(conn, skb);
eb492e01
AB		 2525 break;
2526
2527 case SMP_CMD_PAIRING_FAIL:
84794e11 2528 smp_failure(conn, 0);
da85e5e5 2529 err = -EPERM;
eb492e01
AB		 2530 break;
2531
2532 case SMP_CMD_PAIRING_RSP:
da85e5e5 2533 reason = smp_cmd_pairing_rsp(conn, skb);
88ba43b6
AB		 2534 break;
2535
2536 case SMP_CMD_SECURITY_REQ:
da85e5e5 2537 reason = smp_cmd_security_req(conn, skb);
88ba43b6
AB		 2538 break;
2539
eb492e01 2540 case SMP_CMD_PAIRING_CONFIRM:
da85e5e5 2541 reason = smp_cmd_pairing_confirm(conn, skb);
88ba43b6
AB		 2542 break;
2543
eb492e01 2544 case SMP_CMD_PAIRING_RANDOM:
da85e5e5 2545 reason = smp_cmd_pairing_random(conn, skb);
88ba43b6
AB		 2546 break;
2547
eb492e01 2548 case SMP_CMD_ENCRYPT_INFO:
7034b911
VCG		 2549 reason = smp_cmd_encrypt_info(conn, skb);
2550 break;
2551
eb492e01 2552 case SMP_CMD_MASTER_IDENT:
7034b911
VCG		 2553 reason = smp_cmd_master_ident(conn, skb);
2554 break;
2555
eb492e01 2556 case SMP_CMD_IDENT_INFO:
fd349c02
JH		 2557 reason = smp_cmd_ident_info(conn, skb);
2558 break;
2559
eb492e01 2560 case SMP_CMD_IDENT_ADDR_INFO:
fd349c02
JH		 2561 reason = smp_cmd_ident_addr_info(conn, skb);
2562 break;
2563
eb492e01 2564 case SMP_CMD_SIGN_INFO:
7ee4ea36 2565 reason = smp_cmd_sign_info(conn, skb);
7034b911
VCG		 2566 break;
2567
d8f8edbe
JH		 2568 case SMP_CMD_PUBLIC_KEY:
2569 reason = smp_cmd_public_key(conn, skb);
2570 break;
2571
6433a9a2
JH		 2572 case SMP_CMD_DHKEY_CHECK:
2573 reason = smp_cmd_dhkey_check(conn, skb);
2574 break;
2575
1408bb6e
JH		 2576 case SMP_CMD_KEYPRESS_NOTIFY:
2577 reason = smp_cmd_keypress_notify(conn, skb);
2578 break;
2579
eb492e01
AB		 2580 default:
2581 BT_DBG("Unknown command code 0x%2.2x", code);
eb492e01 2582 reason = SMP_CMD_NOTSUPP;
3a0259bb 2583 goto done;
eb492e01
AB		 2584 }
2585
3a0259bb 2586done:
9b7b18ef
JH		 2587 if (!err) {
2588 if (reason)
2589 smp_failure(conn, reason);
8ae9b984 2590 kfree_skb(skb);
9b7b18ef
JH		 2591 }
2592
eb492e01 2593 return err;
b28b4943
JH		 2594
2595drop:
2596 BT_ERR("%s unexpected SMP command 0x%02x from %pMR", hcon->hdev->name,
2597 code, &hcon->dst);
2598 kfree_skb(skb);
2599 return 0;
eb492e01 2600}
7034b911 2601
70db83c4
JH		 2602static void smp_teardown_cb(struct l2cap_chan *chan, int err)
2603{
2604 struct l2cap_conn *conn = chan->conn;
2605
2606 BT_DBG("chan %p", chan);
2607
fc75cc86 2608 if (chan->data)
5d88cc73 2609 smp_chan_destroy(conn);
5d88cc73 2610
70db83c4
JH		 2611 conn->smp = NULL;
2612 l2cap_chan_put(chan);
2613}
2614
b5ae344d
JH		 2615static void bredr_pairing(struct l2cap_chan *chan)
2616{
2617 struct l2cap_conn *conn = chan->conn;
2618 struct hci_conn *hcon = conn->hcon;
2619 struct hci_dev *hdev = hcon->hdev;
2620 struct smp_cmd_pairing req;
2621 struct smp_chan *smp;
2622
2623 BT_DBG("chan %p", chan);
2624
2625 /* Only new pairings are interesting */
2626 if (!test_bit(HCI_CONN_NEW_LINK_KEY, &hcon->flags))
2627 return;
2628
2629 /* Don't bother if we're not encrypted */
2630 if (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
2631 return;
2632
2633 /* Only master may initiate SMP over BR/EDR */
2634 if (hcon->role != HCI_ROLE_MASTER)
2635 return;
2636
2637 /* Secure Connections support must be enabled */
2638 if (!test_bit(HCI_SC_ENABLED, &hdev->dev_flags))
2639 return;
2640
2641 /* BR/EDR must use Secure Connections for SMP */
2642 if (!test_bit(HCI_CONN_AES_CCM, &hcon->flags) &&
2643 !test_bit(HCI_FORCE_LESC, &hdev->dbg_flags))
2644 return;
2645
2646 /* If our LE support is not enabled don't do anything */
2647 if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags))
2648 return;
2649
2650 /* Don't bother if remote LE support is not enabled */
2651 if (!lmp_host_le_capable(hcon))
2652 return;
2653
2654 /* Remote must support SMP fixed chan for BR/EDR */
2655 if (!(conn->remote_fixed_chan & L2CAP_FC_SMP_BREDR))
2656 return;
2657
2658 /* Don't bother if SMP is already ongoing */
2659 if (chan->data)
2660 return;
2661
2662 smp = smp_chan_create(conn);
2663 if (!smp) {
2664 BT_ERR("%s unable to create SMP context for BR/EDR",
2665 hdev->name);
2666 return;
2667 }
2668
2669 set_bit(SMP_FLAG_SC, &smp->flags);
2670
2671 BT_DBG("%s starting SMP over BR/EDR", hdev->name);
2672
2673 /* Prepare and send the BR/EDR SMP Pairing Request */
2674 build_bredr_pairing_cmd(smp, &req, NULL);
2675
2676 smp->preq[0] = SMP_CMD_PAIRING_REQ;
2677 memcpy(&smp->preq[1], &req, sizeof(req));
2678
2679 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(req), &req);
2680 SMP_ALLOW_CMD(smp, SMP_CMD_PAIRING_RSP);
2681}
2682
44f1a7ab
JH		 2683static void smp_resume_cb(struct l2cap_chan *chan)
2684{
b68fda68 2685 struct smp_chan *smp = chan->data;
44f1a7ab
JH		 2686 struct l2cap_conn *conn = chan->conn;
2687 struct hci_conn *hcon = conn->hcon;
2688
2689 BT_DBG("chan %p", chan);
2690
b5ae344d
JH		 2691 if (hcon->type == ACL_LINK) {
2692 bredr_pairing(chan);
ef8efe4b 2693 return;
b5ae344d 2694 }
ef8efe4b 2695
86d1407c
JH		 2696 if (!smp)
2697 return;
b68fda68 2698
84bc0db5
JH		 2699 if (!test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
2700 return;
2701
86d1407c
JH		 2702 cancel_delayed_work(&smp->security_timer);
2703
d6268e86 2704 smp_distribute_keys(smp);
44f1a7ab
JH		 2705}
2706
70db83c4
JH		 2707static void smp_ready_cb(struct l2cap_chan *chan)
2708{
2709 struct l2cap_conn *conn = chan->conn;
b5ae344d 2710 struct hci_conn *hcon = conn->hcon;
70db83c4
JH		 2711
2712 BT_DBG("chan %p", chan);
2713
2714 conn->smp = chan;
2715 l2cap_chan_hold(chan);
b5ae344d
JH		 2716
2717 if (hcon->type == ACL_LINK && test_bit(HCI_CONN_ENCRYPT, &hcon->flags))
2718 bredr_pairing(chan);
70db83c4
JH		 2719}
2720
4befb867
JH		 2721static int smp_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
2722{
2723 int err;
2724
2725 BT_DBG("chan %p", chan);
2726
2727 err = smp_sig_channel(chan, skb);
2728 if (err) {
b68fda68 2729 struct smp_chan *smp = chan->data;
4befb867 2730
b68fda68
JH		 2731 if (smp)
2732 cancel_delayed_work_sync(&smp->security_timer);
4befb867 2733
1e91c29e 2734 hci_disconnect(chan->conn->hcon, HCI_ERROR_AUTH_FAILURE);
4befb867
JH		 2735 }
2736
2737 return err;
2738}
2739
70db83c4
JH		 2740static struct sk_buff *smp_alloc_skb_cb(struct l2cap_chan *chan,
2741 unsigned long hdr_len,
2742 unsigned long len, int nb)
2743{
2744 struct sk_buff *skb;
2745
2746 skb = bt_skb_alloc(hdr_len + len, GFP_KERNEL);
2747 if (!skb)
2748 return ERR_PTR(-ENOMEM);
2749
2750 skb->priority = HCI_PRIO_MAX;
2751 bt_cb(skb)->chan = chan;
2752
2753 return skb;
2754}
2755
2756static const struct l2cap_ops smp_chan_ops = {
2757 .name = "Security Manager",
2758 .ready = smp_ready_cb,
5d88cc73 2759 .recv = smp_recv_cb,
70db83c4
JH		 2760 .alloc_skb = smp_alloc_skb_cb,
2761 .teardown = smp_teardown_cb,
44f1a7ab 2762 .resume = smp_resume_cb,
70db83c4
JH		 2763
2764 .new_connection = l2cap_chan_no_new_connection,
70db83c4
JH		 2765 .state_change = l2cap_chan_no_state_change,
2766 .close = l2cap_chan_no_close,
2767 .defer = l2cap_chan_no_defer,
2768 .suspend = l2cap_chan_no_suspend,
70db83c4
JH		 2769 .set_shutdown = l2cap_chan_no_set_shutdown,
2770 .get_sndtimeo = l2cap_chan_no_get_sndtimeo,
2771 .memcpy_fromiovec = l2cap_chan_no_memcpy_fromiovec,
2772};
2773
2774static inline struct l2cap_chan *smp_new_conn_cb(struct l2cap_chan *pchan)
2775{
2776 struct l2cap_chan *chan;
2777
2778 BT_DBG("pchan %p", pchan);
2779
2780 chan = l2cap_chan_create();
2781 if (!chan)
2782 return NULL;
2783
2784 chan->chan_type = pchan->chan_type;
2785 chan->ops = &smp_chan_ops;
2786 chan->scid = pchan->scid;
2787 chan->dcid = chan->scid;
2788 chan->imtu = pchan->imtu;
2789 chan->omtu = pchan->omtu;
2790 chan->mode = pchan->mode;
2791
abe84903
JH		 2792 /* Other L2CAP channels may request SMP routines in order to
2793 * change the security level. This means that the SMP channel
2794 * lock must be considered in its own category to avoid lockdep
2795 * warnings.
2796 */
2797 atomic_set(&chan->nesting, L2CAP_NESTING_SMP);
2798
70db83c4
JH		 2799 BT_DBG("created chan %p", chan);
2800
2801 return chan;
2802}
2803
2804static const struct l2cap_ops smp_root_chan_ops = {
2805 .name = "Security Manager Root",
2806 .new_connection = smp_new_conn_cb,
2807
2808 /* None of these are implemented for the root channel */
2809 .close = l2cap_chan_no_close,
2810 .alloc_skb = l2cap_chan_no_alloc_skb,
2811 .recv = l2cap_chan_no_recv,
2812 .state_change = l2cap_chan_no_state_change,
2813 .teardown = l2cap_chan_no_teardown,
2814 .ready = l2cap_chan_no_ready,
2815 .defer = l2cap_chan_no_defer,
2816 .suspend = l2cap_chan_no_suspend,
2817 .resume = l2cap_chan_no_resume,
2818 .set_shutdown = l2cap_chan_no_set_shutdown,
2819 .get_sndtimeo = l2cap_chan_no_get_sndtimeo,
2820 .memcpy_fromiovec = l2cap_chan_no_memcpy_fromiovec,
2821};
2822
ef8efe4b 2823static struct l2cap_chan *smp_add_cid(struct hci_dev *hdev, u16 cid)
711eafe3 2824{
70db83c4 2825 struct l2cap_chan *chan;
defce9e8 2826 struct crypto_blkcipher *tfm_aes;
70db83c4 2827
ef8efe4b
JH		 2828 if (cid == L2CAP_CID_SMP_BREDR) {
2829 tfm_aes = NULL;
2830 goto create_chan;
2831 }
711eafe3 2832
adae20cb 2833 tfm_aes = crypto_alloc_blkcipher("ecb(aes)", 0, 0);
defce9e8 2834 if (IS_ERR(tfm_aes)) {
711eafe3 2835 BT_ERR("Unable to create crypto context");
ef8efe4b 2836 return ERR_PTR(PTR_ERR(tfm_aes));
711eafe3
JH		 2837 }
2838
ef8efe4b 2839create_chan:
70db83c4
JH		 2840 chan = l2cap_chan_create();
2841 if (!chan) {
defce9e8 2842 crypto_free_blkcipher(tfm_aes);
ef8efe4b 2843 return ERR_PTR(-ENOMEM);
70db83c4
JH		 2844 }
2845
defce9e8
JH		 2846 chan->data = tfm_aes;
2847
ef8efe4b 2848 l2cap_add_scid(chan, cid);
70db83c4
JH		 2849
2850 l2cap_chan_set_defaults(chan);
2851
2852 bacpy(&chan->src, &hdev->bdaddr);
ef8efe4b
JH		 2853 if (cid == L2CAP_CID_SMP)
2854 chan->src_type = BDADDR_LE_PUBLIC;
2855 else
2856 chan->src_type = BDADDR_BREDR;
70db83c4
JH		 2857 chan->state = BT_LISTEN;
2858 chan->mode = L2CAP_MODE_BASIC;
2859 chan->imtu = L2CAP_DEFAULT_MTU;
2860 chan->ops = &smp_root_chan_ops;
2861
abe84903
JH		 2862 /* Set correct nesting level for a parent/listening channel */
2863 atomic_set(&chan->nesting, L2CAP_NESTING_PARENT);
2864
ef8efe4b 2865 return chan;
711eafe3
JH		 2866}
2867
ef8efe4b 2868static void smp_del_chan(struct l2cap_chan *chan)
711eafe3 2869{
ef8efe4b 2870 struct crypto_blkcipher *tfm_aes;
70db83c4 2871
ef8efe4b 2872 BT_DBG("chan %p", chan);
711eafe3 2873
defce9e8
JH		 2874 tfm_aes = chan->data;
2875 if (tfm_aes) {
2876 chan->data = NULL;
2877 crypto_free_blkcipher(tfm_aes);
711eafe3 2878 }
70db83c4 2879
70db83c4 2880 l2cap_chan_put(chan);
711eafe3 2881}
ef8efe4b
JH		 2882
2883int smp_register(struct hci_dev *hdev)
2884{
2885 struct l2cap_chan *chan;
2886
2887 BT_DBG("%s", hdev->name);
2888
2889 chan = smp_add_cid(hdev, L2CAP_CID_SMP);
2890 if (IS_ERR(chan))
2891 return PTR_ERR(chan);
2892
2893 hdev->smp_data = chan;
2894
2895 if (!lmp_sc_capable(hdev) &&
2896 !test_bit(HCI_FORCE_LESC, &hdev->dbg_flags))
2897 return 0;
2898
2899 chan = smp_add_cid(hdev, L2CAP_CID_SMP_BREDR);
2900 if (IS_ERR(chan)) {
2901 int err = PTR_ERR(chan);
2902 chan = hdev->smp_data;
2903 hdev->smp_data = NULL;
2904 smp_del_chan(chan);
2905 return err;
2906 }
2907
2908 hdev->smp_bredr_data = chan;
2909
2910 return 0;
2911}
2912
2913void smp_unregister(struct hci_dev *hdev)
2914{
2915 struct l2cap_chan *chan;
2916
2917 if (hdev->smp_bredr_data) {
2918 chan = hdev->smp_bredr_data;
2919 hdev->smp_bredr_data = NULL;
2920 smp_del_chan(chan);
2921 }
2922
2923 if (hdev->smp_data) {
2924 chan = hdev->smp_data;
2925 hdev->smp_data = NULL;
2926 smp_del_chan(chan);
2927 }
2928}
Linux kernel - Deliverables
This page took 0.567099 seconds and 5 git commands to generate.