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