Bluetooth: bluecard: Use del_timer_sync() in teardown path
[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
MH
31
32#include "smp.h"
d22ef0bc 33
17b02e62 34#define SMP_TIMEOUT msecs_to_jiffies(30000)
5d3de7df 35
065a13e2
JH
36#define AUTH_REQ_MASK 0x07
37
66bed1a2 38static inline void swap128(const u8 src[16], u8 dst[16])
d22ef0bc
AB
39{
40 int i;
41 for (i = 0; i < 16; i++)
42 dst[15 - i] = src[i];
43}
44
66bed1a2 45static inline void swap56(const u8 src[7], u8 dst[7])
d22ef0bc
AB
46{
47 int i;
48 for (i = 0; i < 7; i++)
49 dst[6 - i] = src[i];
50}
51
52static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r)
53{
54 struct blkcipher_desc desc;
55 struct scatterlist sg;
943a732a 56 uint8_t tmp[16], data[16];
201a5929 57 int err;
d22ef0bc
AB
58
59 if (tfm == NULL) {
60 BT_ERR("tfm %p", tfm);
61 return -EINVAL;
62 }
63
64 desc.tfm = tfm;
65 desc.flags = 0;
66
943a732a
JH
67 /* The most significant octet of key corresponds to k[0] */
68 swap128(k, tmp);
69
70 err = crypto_blkcipher_setkey(tfm, tmp, 16);
d22ef0bc
AB
71 if (err) {
72 BT_ERR("cipher setkey failed: %d", err);
73 return err;
74 }
75
943a732a
JH
76 /* Most significant octet of plaintextData corresponds to data[0] */
77 swap128(r, data);
78
79 sg_init_one(&sg, data, 16);
d22ef0bc 80
d22ef0bc
AB
81 err = crypto_blkcipher_encrypt(&desc, &sg, &sg, 16);
82 if (err)
83 BT_ERR("Encrypt data error %d", err);
84
943a732a
JH
85 /* Most significant octet of encryptedData corresponds to data[0] */
86 swap128(data, r);
87
d22ef0bc
AB
88 return err;
89}
90
60478054
JH
91static int smp_ah(struct crypto_blkcipher *tfm, u8 irk[16], u8 r[3], u8 res[3])
92{
943a732a 93 u8 _res[16];
60478054
JH
94 int err;
95
96 /* r' = padding || r */
943a732a
JH
97 memcpy(_res, r, 3);
98 memset(_res + 3, 0, 13);
60478054 99
943a732a 100 err = smp_e(tfm, irk, _res);
60478054
JH
101 if (err) {
102 BT_ERR("Encrypt error");
103 return err;
104 }
105
106 /* The output of the random address function ah is:
107 * ah(h, r) = e(k, r') mod 2^24
108 * The output of the security function e is then truncated to 24 bits
109 * by taking the least significant 24 bits of the output of e as the
110 * result of ah.
111 */
943a732a 112 memcpy(res, _res, 3);
60478054
JH
113
114 return 0;
115}
116
117bool smp_irk_matches(struct crypto_blkcipher *tfm, u8 irk[16],
118 bdaddr_t *bdaddr)
119{
120 u8 hash[3];
121 int err;
122
123 BT_DBG("RPA %pMR IRK %*phN", bdaddr, 16, irk);
124
125 err = smp_ah(tfm, irk, &bdaddr->b[3], hash);
126 if (err)
127 return false;
128
129 return !memcmp(bdaddr->b, hash, 3);
130}
131
b1e2b3ae
JH
132int smp_generate_rpa(struct crypto_blkcipher *tfm, u8 irk[16], bdaddr_t *rpa)
133{
134 int err;
135
136 get_random_bytes(&rpa->b[3], 3);
137
138 rpa->b[5] &= 0x3f; /* Clear two most significant bits */
139 rpa->b[5] |= 0x40; /* Set second most significant bit */
140
141 err = smp_ah(tfm, irk, &rpa->b[3], rpa->b);
142 if (err < 0)
143 return err;
144
145 BT_DBG("RPA %pMR", rpa);
146
147 return 0;
148}
149
d22ef0bc 150static int smp_c1(struct crypto_blkcipher *tfm, u8 k[16], u8 r[16],
f1560463
MH
151 u8 preq[7], u8 pres[7], u8 _iat, bdaddr_t *ia,
152 u8 _rat, bdaddr_t *ra, u8 res[16])
d22ef0bc
AB
153{
154 u8 p1[16], p2[16];
155 int err;
156
157 memset(p1, 0, 16);
158
159 /* p1 = pres || preq || _rat || _iat */
943a732a
JH
160 p1[0] = _iat;
161 p1[1] = _rat;
162 memcpy(p1 + 2, preq, 7);
163 memcpy(p1 + 9, pres, 7);
d22ef0bc
AB
164
165 /* p2 = padding || ia || ra */
943a732a
JH
166 memcpy(p2, ra, 6);
167 memcpy(p2 + 6, ia, 6);
168 memset(p2 + 12, 0, 4);
d22ef0bc
AB
169
170 /* res = r XOR p1 */
171 u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);
172
173 /* res = e(k, res) */
174 err = smp_e(tfm, k, res);
175 if (err) {
176 BT_ERR("Encrypt data error");
177 return err;
178 }
179
180 /* res = res XOR p2 */
181 u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);
182
183 /* res = e(k, res) */
184 err = smp_e(tfm, k, res);
185 if (err)
186 BT_ERR("Encrypt data error");
187
188 return err;
189}
190
f1560463
MH
191static int smp_s1(struct crypto_blkcipher *tfm, u8 k[16], u8 r1[16],
192 u8 r2[16], u8 _r[16])
d22ef0bc
AB
193{
194 int err;
195
196 /* Just least significant octets from r1 and r2 are considered */
943a732a
JH
197 memcpy(_r, r2, 8);
198 memcpy(_r + 8, r1, 8);
d22ef0bc
AB
199
200 err = smp_e(tfm, k, _r);
201 if (err)
202 BT_ERR("Encrypt data error");
203
204 return err;
205}
206
eb492e01 207static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code,
f1560463 208 u16 dlen, void *data)
eb492e01
AB
209{
210 struct sk_buff *skb;
211 struct l2cap_hdr *lh;
212 int len;
213
214 len = L2CAP_HDR_SIZE + sizeof(code) + dlen;
215
216 if (len > conn->mtu)
217 return NULL;
218
219 skb = bt_skb_alloc(len, GFP_ATOMIC);
220 if (!skb)
221 return NULL;
222
223 lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
224 lh->len = cpu_to_le16(sizeof(code) + dlen);
dcf4adbf 225 lh->cid = cpu_to_le16(L2CAP_CID_SMP);
eb492e01
AB
226
227 memcpy(skb_put(skb, sizeof(code)), &code, sizeof(code));
228
229 memcpy(skb_put(skb, dlen), data, dlen);
230
231 return skb;
232}
233
234static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
235{
236 struct sk_buff *skb = smp_build_cmd(conn, code, len, data);
237
238 BT_DBG("code 0x%2.2x", code);
239
240 if (!skb)
241 return;
242
73d80deb
LAD
243 skb->priority = HCI_PRIO_MAX;
244 hci_send_acl(conn->hchan, skb, 0);
e2dcd113 245
6c9d42a1 246 cancel_delayed_work_sync(&conn->security_timer);
17b02e62 247 schedule_delayed_work(&conn->security_timer, SMP_TIMEOUT);
eb492e01
AB
248}
249
2b64d153
BG
250static __u8 authreq_to_seclevel(__u8 authreq)
251{
252 if (authreq & SMP_AUTH_MITM)
253 return BT_SECURITY_HIGH;
254 else
255 return BT_SECURITY_MEDIUM;
256}
257
258static __u8 seclevel_to_authreq(__u8 sec_level)
259{
260 switch (sec_level) {
261 case BT_SECURITY_HIGH:
262 return SMP_AUTH_MITM | SMP_AUTH_BONDING;
263 case BT_SECURITY_MEDIUM:
264 return SMP_AUTH_BONDING;
265 default:
266 return SMP_AUTH_NONE;
267 }
268}
269
b8e66eac 270static void build_pairing_cmd(struct l2cap_conn *conn,
f1560463
MH
271 struct smp_cmd_pairing *req,
272 struct smp_cmd_pairing *rsp, __u8 authreq)
b8e66eac 273{
fd349c02
JH
274 struct smp_chan *smp = conn->smp_chan;
275 struct hci_conn *hcon = conn->hcon;
276 struct hci_dev *hdev = hcon->hdev;
277 u8 local_dist = 0, remote_dist = 0;
54790f73 278
a8b2d5c2 279 if (test_bit(HCI_PAIRABLE, &conn->hcon->hdev->dev_flags)) {
7ee4ea36
MH
280 local_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
281 remote_dist = SMP_DIST_ENC_KEY | SMP_DIST_SIGN;
54790f73 282 authreq |= SMP_AUTH_BONDING;
2b64d153
BG
283 } else {
284 authreq &= ~SMP_AUTH_BONDING;
54790f73
VCG
285 }
286
fd349c02
JH
287 if (test_bit(HCI_RPA_RESOLVING, &hdev->dev_flags))
288 remote_dist |= SMP_DIST_ID_KEY;
289
863efaf2
JH
290 if (test_bit(HCI_PRIVACY, &hdev->dev_flags))
291 local_dist |= SMP_DIST_ID_KEY;
292
54790f73
VCG
293 if (rsp == NULL) {
294 req->io_capability = conn->hcon->io_capability;
295 req->oob_flag = SMP_OOB_NOT_PRESENT;
296 req->max_key_size = SMP_MAX_ENC_KEY_SIZE;
fd349c02
JH
297 req->init_key_dist = local_dist;
298 req->resp_key_dist = remote_dist;
065a13e2 299 req->auth_req = (authreq & AUTH_REQ_MASK);
fd349c02
JH
300
301 smp->remote_key_dist = remote_dist;
54790f73
VCG
302 return;
303 }
304
305 rsp->io_capability = conn->hcon->io_capability;
306 rsp->oob_flag = SMP_OOB_NOT_PRESENT;
307 rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
fd349c02
JH
308 rsp->init_key_dist = req->init_key_dist & remote_dist;
309 rsp->resp_key_dist = req->resp_key_dist & local_dist;
065a13e2 310 rsp->auth_req = (authreq & AUTH_REQ_MASK);
fd349c02
JH
311
312 smp->remote_key_dist = rsp->init_key_dist;
b8e66eac
VCG
313}
314
3158c50c
VCG
315static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
316{
1c1def09
VCG
317 struct smp_chan *smp = conn->smp_chan;
318
3158c50c 319 if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) ||
f1560463 320 (max_key_size < SMP_MIN_ENC_KEY_SIZE))
3158c50c
VCG
321 return SMP_ENC_KEY_SIZE;
322
f7aa611a 323 smp->enc_key_size = max_key_size;
3158c50c
VCG
324
325 return 0;
326}
327
84794e11 328static void smp_failure(struct l2cap_conn *conn, u8 reason)
4f957a76 329{
bab73cb6
JH
330 struct hci_conn *hcon = conn->hcon;
331
84794e11 332 if (reason)
4f957a76 333 smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason),
f1560463 334 &reason);
4f957a76 335
ce39fb4e
MH
336 clear_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags);
337 mgmt_auth_failed(hcon->hdev, &hcon->dst, hcon->type, hcon->dst_type,
338 HCI_ERROR_AUTH_FAILURE);
f1c09c07 339
61a0cfb0
AG
340 cancel_delayed_work_sync(&conn->security_timer);
341
ce39fb4e 342 if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
f1c09c07 343 smp_chan_destroy(conn);
4f957a76
BG
344}
345
2b64d153
BG
346#define JUST_WORKS 0x00
347#define JUST_CFM 0x01
348#define REQ_PASSKEY 0x02
349#define CFM_PASSKEY 0x03
350#define REQ_OOB 0x04
351#define OVERLAP 0xFF
352
353static const u8 gen_method[5][5] = {
354 { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
355 { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
356 { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
357 { JUST_WORKS, JUST_CFM, JUST_WORKS, JUST_WORKS, JUST_CFM },
358 { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP },
359};
360
361static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth,
362 u8 local_io, u8 remote_io)
363{
364 struct hci_conn *hcon = conn->hcon;
365 struct smp_chan *smp = conn->smp_chan;
366 u8 method;
367 u32 passkey = 0;
368 int ret = 0;
369
370 /* Initialize key for JUST WORKS */
371 memset(smp->tk, 0, sizeof(smp->tk));
372 clear_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
373
374 BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io);
375
376 /* If neither side wants MITM, use JUST WORKS */
377 /* If either side has unknown io_caps, use JUST WORKS */
378 /* Otherwise, look up method from the table */
379 if (!(auth & SMP_AUTH_MITM) ||
f1560463
MH
380 local_io > SMP_IO_KEYBOARD_DISPLAY ||
381 remote_io > SMP_IO_KEYBOARD_DISPLAY)
2b64d153
BG
382 method = JUST_WORKS;
383 else
b3ff53ff 384 method = gen_method[remote_io][local_io];
2b64d153
BG
385
386 /* If not bonding, don't ask user to confirm a Zero TK */
387 if (!(auth & SMP_AUTH_BONDING) && method == JUST_CFM)
388 method = JUST_WORKS;
389
390 /* If Just Works, Continue with Zero TK */
391 if (method == JUST_WORKS) {
392 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
393 return 0;
394 }
395
396 /* Not Just Works/Confirm results in MITM Authentication */
397 if (method != JUST_CFM)
398 set_bit(SMP_FLAG_MITM_AUTH, &smp->smp_flags);
399
400 /* If both devices have Keyoard-Display I/O, the master
401 * Confirms and the slave Enters the passkey.
402 */
403 if (method == OVERLAP) {
404 if (hcon->link_mode & HCI_LM_MASTER)
405 method = CFM_PASSKEY;
406 else
407 method = REQ_PASSKEY;
408 }
409
01ad34d2 410 /* Generate random passkey. */
2b64d153 411 if (method == CFM_PASSKEY) {
943a732a 412 memset(smp->tk, 0, sizeof(smp->tk));
2b64d153
BG
413 get_random_bytes(&passkey, sizeof(passkey));
414 passkey %= 1000000;
943a732a 415 put_unaligned_le32(passkey, smp->tk);
2b64d153 416 BT_DBG("PassKey: %d", passkey);
01ad34d2 417 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
2b64d153
BG
418 }
419
420 hci_dev_lock(hcon->hdev);
421
422 if (method == REQ_PASSKEY)
ce39fb4e 423 ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst,
272d90df 424 hcon->type, hcon->dst_type);
2b64d153 425 else
01ad34d2 426 ret = mgmt_user_passkey_notify(hcon->hdev, &hcon->dst,
272d90df 427 hcon->type, hcon->dst_type,
39adbffe 428 passkey, 0);
2b64d153
BG
429
430 hci_dev_unlock(hcon->hdev);
431
432 return ret;
433}
434
8aab4757
VCG
435static void confirm_work(struct work_struct *work)
436{
437 struct smp_chan *smp = container_of(work, struct smp_chan, confirm);
438 struct l2cap_conn *conn = smp->conn;
893ce8b1
JH
439 struct hci_dev *hdev = conn->hcon->hdev;
440 struct crypto_blkcipher *tfm = hdev->tfm_aes;
8aab4757
VCG
441 struct smp_cmd_pairing_confirm cp;
442 int ret;
943a732a 443 u8 reason;
8aab4757
VCG
444
445 BT_DBG("conn %p", conn);
446
893ce8b1
JH
447 /* Prevent mutual access to hdev->tfm_aes */
448 hci_dev_lock(hdev);
8aab4757 449
b1cd5fd9
JH
450 ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp,
451 conn->hcon->init_addr_type, &conn->hcon->init_addr,
943a732a
JH
452 conn->hcon->resp_addr_type, &conn->hcon->resp_addr,
453 cp.confirm_val);
893ce8b1
JH
454
455 hci_dev_unlock(hdev);
456
8aab4757
VCG
457 if (ret) {
458 reason = SMP_UNSPECIFIED;
459 goto error;
460 }
461
2b64d153
BG
462 clear_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
463
8aab4757
VCG
464 smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
465
466 return;
467
468error:
84794e11 469 smp_failure(conn, reason);
8aab4757
VCG
470}
471
472static void random_work(struct work_struct *work)
473{
474 struct smp_chan *smp = container_of(work, struct smp_chan, random);
475 struct l2cap_conn *conn = smp->conn;
476 struct hci_conn *hcon = conn->hcon;
893ce8b1
JH
477 struct hci_dev *hdev = hcon->hdev;
478 struct crypto_blkcipher *tfm = hdev->tfm_aes;
943a732a 479 u8 reason, confirm[16];
8aab4757
VCG
480 int ret;
481
482 if (IS_ERR_OR_NULL(tfm)) {
483 reason = SMP_UNSPECIFIED;
484 goto error;
485 }
486
487 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
488
893ce8b1
JH
489 /* Prevent mutual access to hdev->tfm_aes */
490 hci_dev_lock(hdev);
491
b1cd5fd9
JH
492 ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp,
493 hcon->init_addr_type, &hcon->init_addr,
943a732a 494 hcon->resp_addr_type, &hcon->resp_addr, confirm);
893ce8b1
JH
495
496 hci_dev_unlock(hdev);
497
8aab4757
VCG
498 if (ret) {
499 reason = SMP_UNSPECIFIED;
500 goto error;
501 }
502
8aab4757
VCG
503 if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) {
504 BT_ERR("Pairing failed (confirmation values mismatch)");
505 reason = SMP_CONFIRM_FAILED;
506 goto error;
507 }
508
509 if (hcon->out) {
fe39c7b2
MH
510 u8 stk[16];
511 __le64 rand = 0;
512 __le16 ediv = 0;
8aab4757 513
943a732a 514 smp_s1(tfm, smp->tk, smp->rrnd, smp->prnd, stk);
8aab4757 515
f7aa611a 516 memset(stk + smp->enc_key_size, 0,
04124681 517 SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
8aab4757 518
51a8efd7 519 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags)) {
8aab4757
VCG
520 reason = SMP_UNSPECIFIED;
521 goto error;
522 }
523
524 hci_le_start_enc(hcon, ediv, rand, stk);
f7aa611a 525 hcon->enc_key_size = smp->enc_key_size;
8aab4757 526 } else {
943a732a 527 u8 stk[16];
fe39c7b2
MH
528 __le64 rand = 0;
529 __le16 ediv = 0;
8aab4757 530
943a732a
JH
531 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
532 smp->prnd);
8aab4757 533
943a732a 534 smp_s1(tfm, smp->tk, smp->prnd, smp->rrnd, stk);
8aab4757 535
f7aa611a 536 memset(stk + smp->enc_key_size, 0,
f1560463 537 SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
8aab4757 538
ce39fb4e 539 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
35d70271 540 HCI_SMP_STK_SLAVE, 0, stk, smp->enc_key_size,
04124681 541 ediv, rand);
8aab4757
VCG
542 }
543
544 return;
545
546error:
84794e11 547 smp_failure(conn, reason);
8aab4757
VCG
548}
549
e3098be4
JH
550static void smp_reencrypt(struct work_struct *work)
551{
552 struct smp_chan *smp = container_of(work, struct smp_chan,
553 reencrypt.work);
554 struct l2cap_conn *conn = smp->conn;
555 struct hci_conn *hcon = conn->hcon;
556 struct smp_ltk *ltk = smp->ltk;
557
558 BT_DBG("");
559
560 hci_le_start_enc(hcon, ltk->ediv, ltk->rand, ltk->val);
561 hcon->enc_key_size = ltk->enc_size;
562}
563
8aab4757
VCG
564static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
565{
566 struct smp_chan *smp;
567
f1560463 568 smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
8aab4757
VCG
569 if (!smp)
570 return NULL;
571
572 INIT_WORK(&smp->confirm, confirm_work);
573 INIT_WORK(&smp->random, random_work);
e3098be4 574 INIT_DELAYED_WORK(&smp->reencrypt, smp_reencrypt);
8aab4757
VCG
575
576 smp->conn = conn;
577 conn->smp_chan = smp;
2b64d153 578 conn->hcon->smp_conn = conn;
8aab4757
VCG
579
580 hci_conn_hold(conn->hcon);
581
582 return smp;
583}
584
585void smp_chan_destroy(struct l2cap_conn *conn)
586{
c8eb9690 587 struct smp_chan *smp = conn->smp_chan;
f4a407be 588 bool complete;
c8eb9690 589
f1c09c07 590 BUG_ON(!smp);
c8eb9690 591
e3098be4
JH
592 cancel_delayed_work_sync(&smp->reencrypt);
593
f4a407be
JH
594 complete = test_bit(SMP_FLAG_COMPLETE, &smp->smp_flags);
595 mgmt_smp_complete(conn->hcon, complete);
596
7ee4ea36
MH
597 kfree(smp->csrk);
598 kfree(smp->slave_csrk);
599
759331d7
JH
600 /* If pairing failed clean up any keys we might have */
601 if (!complete) {
602 if (smp->ltk) {
603 list_del(&smp->ltk->list);
604 kfree(smp->ltk);
605 }
606
607 if (smp->slave_ltk) {
608 list_del(&smp->slave_ltk->list);
609 kfree(smp->slave_ltk);
610 }
611
612 if (smp->remote_irk) {
613 list_del(&smp->remote_irk->list);
614 kfree(smp->remote_irk);
615 }
616 }
617
c8eb9690
BG
618 kfree(smp);
619 conn->smp_chan = NULL;
2b64d153 620 conn->hcon->smp_conn = NULL;
76a68ba0 621 hci_conn_drop(conn->hcon);
8aab4757
VCG
622}
623
2b64d153
BG
624int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey)
625{
626 struct l2cap_conn *conn = hcon->smp_conn;
627 struct smp_chan *smp;
628 u32 value;
2b64d153
BG
629
630 BT_DBG("");
631
632 if (!conn)
633 return -ENOTCONN;
634
635 smp = conn->smp_chan;
636
637 switch (mgmt_op) {
638 case MGMT_OP_USER_PASSKEY_REPLY:
639 value = le32_to_cpu(passkey);
943a732a 640 memset(smp->tk, 0, sizeof(smp->tk));
2b64d153 641 BT_DBG("PassKey: %d", value);
943a732a 642 put_unaligned_le32(value, smp->tk);
2b64d153
BG
643 /* Fall Through */
644 case MGMT_OP_USER_CONFIRM_REPLY:
645 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
646 break;
647 case MGMT_OP_USER_PASSKEY_NEG_REPLY:
648 case MGMT_OP_USER_CONFIRM_NEG_REPLY:
84794e11 649 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
2b64d153
BG
650 return 0;
651 default:
84794e11 652 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
2b64d153
BG
653 return -EOPNOTSUPP;
654 }
655
656 /* If it is our turn to send Pairing Confirm, do so now */
657 if (test_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags))
658 queue_work(hcon->hdev->workqueue, &smp->confirm);
659
660 return 0;
661}
662
da85e5e5 663static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 664{
3158c50c 665 struct smp_cmd_pairing rsp, *req = (void *) skb->data;
8aab4757 666 struct smp_chan *smp;
3158c50c 667 u8 key_size;
2b64d153 668 u8 auth = SMP_AUTH_NONE;
8aab4757 669 int ret;
88ba43b6
AB
670
671 BT_DBG("conn %p", conn);
672
c46b98be
JH
673 if (skb->len < sizeof(*req))
674 return SMP_UNSPECIFIED;
675
2b64d153
BG
676 if (conn->hcon->link_mode & HCI_LM_MASTER)
677 return SMP_CMD_NOTSUPP;
678
51a8efd7 679 if (!test_and_set_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags))
8aab4757 680 smp = smp_chan_create(conn);
d08fd0e7
AE
681 else
682 smp = conn->smp_chan;
8aab4757 683
d08fd0e7
AE
684 if (!smp)
685 return SMP_UNSPECIFIED;
d26a2345 686
1c1def09
VCG
687 smp->preq[0] = SMP_CMD_PAIRING_REQ;
688 memcpy(&smp->preq[1], req, sizeof(*req));
3158c50c 689 skb_pull(skb, sizeof(*req));
88ba43b6 690
2b64d153
BG
691 /* We didn't start the pairing, so match remote */
692 if (req->auth_req & SMP_AUTH_BONDING)
693 auth = req->auth_req;
da85e5e5 694
fdde0a26
IY
695 conn->hcon->pending_sec_level = authreq_to_seclevel(auth);
696
2b64d153 697 build_pairing_cmd(conn, req, &rsp, auth);
3158c50c
VCG
698
699 key_size = min(req->max_key_size, rsp.max_key_size);
700 if (check_enc_key_size(conn, key_size))
701 return SMP_ENC_KEY_SIZE;
88ba43b6 702
e84a6b13 703 get_random_bytes(smp->prnd, sizeof(smp->prnd));
8aab4757 704
1c1def09
VCG
705 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
706 memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
f01ead31 707
3158c50c 708 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
da85e5e5 709
2b64d153
BG
710 /* Request setup of TK */
711 ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
712 if (ret)
713 return SMP_UNSPECIFIED;
714
da85e5e5 715 return 0;
88ba43b6
AB
716}
717
da85e5e5 718static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 719{
3158c50c 720 struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
1c1def09 721 struct smp_chan *smp = conn->smp_chan;
8aab4757 722 struct hci_dev *hdev = conn->hcon->hdev;
2b64d153 723 u8 key_size, auth = SMP_AUTH_NONE;
7d24ddcc 724 int ret;
88ba43b6
AB
725
726 BT_DBG("conn %p", conn);
727
c46b98be
JH
728 if (skb->len < sizeof(*rsp))
729 return SMP_UNSPECIFIED;
730
2b64d153
BG
731 if (!(conn->hcon->link_mode & HCI_LM_MASTER))
732 return SMP_CMD_NOTSUPP;
733
3158c50c
VCG
734 skb_pull(skb, sizeof(*rsp));
735
1c1def09 736 req = (void *) &smp->preq[1];
da85e5e5 737
3158c50c
VCG
738 key_size = min(req->max_key_size, rsp->max_key_size);
739 if (check_enc_key_size(conn, key_size))
740 return SMP_ENC_KEY_SIZE;
741
e84a6b13 742 get_random_bytes(smp->prnd, sizeof(smp->prnd));
7d24ddcc 743
8aab4757
VCG
744 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
745 memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
7d24ddcc 746
fdcc4bec
JH
747 /* Update remote key distribution in case the remote cleared
748 * some bits that we had enabled in our request.
749 */
750 smp->remote_key_dist &= rsp->resp_key_dist;
751
2b64d153 752 if ((req->auth_req & SMP_AUTH_BONDING) &&
f1560463 753 (rsp->auth_req & SMP_AUTH_BONDING))
2b64d153
BG
754 auth = SMP_AUTH_BONDING;
755
756 auth |= (req->auth_req | rsp->auth_req) & SMP_AUTH_MITM;
757
476585ec 758 ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
2b64d153
BG
759 if (ret)
760 return SMP_UNSPECIFIED;
761
762 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
763
764 /* Can't compose response until we have been confirmed */
18e4aeb9
JH
765 if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
766 queue_work(hdev->workqueue, &smp->confirm);
da85e5e5
VCG
767
768 return 0;
88ba43b6
AB
769}
770
da85e5e5 771static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 772{
1c1def09 773 struct smp_chan *smp = conn->smp_chan;
8aab4757 774 struct hci_dev *hdev = conn->hcon->hdev;
7d24ddcc 775
88ba43b6
AB
776 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
777
c46b98be
JH
778 if (skb->len < sizeof(smp->pcnf))
779 return SMP_UNSPECIFIED;
780
1c1def09
VCG
781 memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
782 skb_pull(skb, sizeof(smp->pcnf));
88ba43b6 783
943a732a
JH
784 if (conn->hcon->out)
785 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
786 smp->prnd);
787 else if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
8aab4757 788 queue_work(hdev->workqueue, &smp->confirm);
943a732a 789 else
2b64d153 790 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
da85e5e5
VCG
791
792 return 0;
88ba43b6
AB
793}
794
da85e5e5 795static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 796{
1c1def09 797 struct smp_chan *smp = conn->smp_chan;
8aab4757 798 struct hci_dev *hdev = conn->hcon->hdev;
7d24ddcc 799
8aab4757 800 BT_DBG("conn %p", conn);
3158c50c 801
c46b98be
JH
802 if (skb->len < sizeof(smp->rrnd))
803 return SMP_UNSPECIFIED;
804
943a732a 805 memcpy(smp->rrnd, skb->data, sizeof(smp->rrnd));
8aab4757 806 skb_pull(skb, sizeof(smp->rrnd));
e7e62c85 807
8aab4757 808 queue_work(hdev->workqueue, &smp->random);
da85e5e5
VCG
809
810 return 0;
88ba43b6
AB
811}
812
4dab7864 813static u8 smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
988c5997 814{
c9839a11 815 struct smp_ltk *key;
988c5997
VCG
816 struct hci_conn *hcon = conn->hcon;
817
98a0b845
JH
818 key = hci_find_ltk_by_addr(hcon->hdev, &hcon->dst, hcon->dst_type,
819 hcon->out);
988c5997
VCG
820 if (!key)
821 return 0;
822
4dab7864
JH
823 if (sec_level > BT_SECURITY_MEDIUM && !key->authenticated)
824 return 0;
825
51a8efd7 826 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
988c5997
VCG
827 return 1;
828
c9839a11
VCG
829 hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
830 hcon->enc_key_size = key->enc_size;
988c5997
VCG
831
832 return 1;
988c5997 833}
f1560463 834
da85e5e5 835static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6
AB
836{
837 struct smp_cmd_security_req *rp = (void *) skb->data;
838 struct smp_cmd_pairing cp;
f1cb9af5 839 struct hci_conn *hcon = conn->hcon;
8aab4757 840 struct smp_chan *smp;
88ba43b6
AB
841
842 BT_DBG("conn %p", conn);
843
c46b98be
JH
844 if (skb->len < sizeof(*rp))
845 return SMP_UNSPECIFIED;
846
86ca9eac
JH
847 if (!(conn->hcon->link_mode & HCI_LM_MASTER))
848 return SMP_CMD_NOTSUPP;
849
2b64d153 850 hcon->pending_sec_level = authreq_to_seclevel(rp->auth_req);
feb45eb5 851
4dab7864 852 if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
988c5997
VCG
853 return 0;
854
51a8efd7 855 if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
da85e5e5 856 return 0;
f1cb9af5 857
8aab4757 858 smp = smp_chan_create(conn);
d26a2345 859
88ba43b6 860 skb_pull(skb, sizeof(*rp));
88ba43b6 861
da85e5e5 862 memset(&cp, 0, sizeof(cp));
54790f73 863 build_pairing_cmd(conn, &cp, NULL, rp->auth_req);
88ba43b6 864
1c1def09
VCG
865 smp->preq[0] = SMP_CMD_PAIRING_REQ;
866 memcpy(&smp->preq[1], &cp, sizeof(cp));
f01ead31 867
88ba43b6 868 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
f1cb9af5 869
da85e5e5 870 return 0;
88ba43b6
AB
871}
872
ad32a2f5
JH
873bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level)
874{
875 if (sec_level == BT_SECURITY_LOW)
876 return true;
877
878 if (hcon->sec_level >= sec_level)
879 return true;
880
881 return false;
882}
883
cc110922 884int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
eb492e01 885{
cc110922 886 struct l2cap_conn *conn = hcon->l2cap_data;
1c1def09 887 struct smp_chan *smp = conn->smp_chan;
2b64d153 888 __u8 authreq;
eb492e01 889
3a0259bb
VCG
890 BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
891
757aee0f 892 if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags))
2e65c9d2
AG
893 return 1;
894
ad32a2f5 895 if (smp_sufficient_security(hcon, sec_level))
eb492e01 896 return 1;
f1cb9af5 897
988c5997 898 if (hcon->link_mode & HCI_LM_MASTER)
4dab7864 899 if (smp_ltk_encrypt(conn, sec_level))
02bc7455 900 goto done;
d26a2345 901
51a8efd7 902 if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
d26a2345
VCG
903 return 0;
904
8aab4757 905 smp = smp_chan_create(conn);
2b64d153
BG
906 if (!smp)
907 return 1;
908
909 authreq = seclevel_to_authreq(sec_level);
d26a2345 910
2e233644
JH
911 /* hcon->auth_type is set by pair_device in mgmt.c. If the MITM
912 * flag is set we should also set it for the SMP request.
913 */
914 if ((hcon->auth_type & 0x01))
915 authreq |= SMP_AUTH_MITM;
916
d26a2345
VCG
917 if (hcon->link_mode & HCI_LM_MASTER) {
918 struct smp_cmd_pairing cp;
f01ead31 919
2b64d153 920 build_pairing_cmd(conn, &cp, NULL, authreq);
1c1def09
VCG
921 smp->preq[0] = SMP_CMD_PAIRING_REQ;
922 memcpy(&smp->preq[1], &cp, sizeof(cp));
f01ead31 923
eb492e01
AB
924 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
925 } else {
926 struct smp_cmd_security_req cp;
2b64d153 927 cp.auth_req = authreq;
eb492e01
AB
928 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
929 }
930
02bc7455 931done:
f1cb9af5 932 hcon->pending_sec_level = sec_level;
f1cb9af5 933
eb492e01
AB
934 return 0;
935}
936
7034b911
VCG
937static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
938{
16b90839 939 struct smp_cmd_encrypt_info *rp = (void *) skb->data;
1c1def09 940 struct smp_chan *smp = conn->smp_chan;
16b90839 941
c46b98be
JH
942 BT_DBG("conn %p", conn);
943
944 if (skb->len < sizeof(*rp))
945 return SMP_UNSPECIFIED;
946
6131ddc8
JH
947 /* Ignore this PDU if it wasn't requested */
948 if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
949 return 0;
950
16b90839
VCG
951 skb_pull(skb, sizeof(*rp));
952
1c1def09 953 memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
16b90839 954
7034b911
VCG
955 return 0;
956}
957
958static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
959{
16b90839 960 struct smp_cmd_master_ident *rp = (void *) skb->data;
1c1def09 961 struct smp_chan *smp = conn->smp_chan;
c9839a11
VCG
962 struct hci_dev *hdev = conn->hcon->hdev;
963 struct hci_conn *hcon = conn->hcon;
23d0e128 964 struct smp_ltk *ltk;
c9839a11 965 u8 authenticated;
16b90839 966
c46b98be
JH
967 BT_DBG("conn %p", conn);
968
969 if (skb->len < sizeof(*rp))
970 return SMP_UNSPECIFIED;
971
6131ddc8
JH
972 /* Ignore this PDU if it wasn't requested */
973 if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
974 return 0;
975
9747a9f3
JH
976 /* Mark the information as received */
977 smp->remote_key_dist &= ~SMP_DIST_ENC_KEY;
978
16b90839 979 skb_pull(skb, sizeof(*rp));
7034b911 980
c9839a11 981 hci_dev_lock(hdev);
ce39fb4e 982 authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
35d70271 983 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, HCI_SMP_LTK,
23d0e128
JH
984 authenticated, smp->tk, smp->enc_key_size,
985 rp->ediv, rp->rand);
986 smp->ltk = ltk;
fd349c02 987 if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
4bd6d38e 988 smp_distribute_keys(conn);
c9839a11 989 hci_dev_unlock(hdev);
7034b911
VCG
990
991 return 0;
992}
993
fd349c02
JH
994static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb)
995{
996 struct smp_cmd_ident_info *info = (void *) skb->data;
997 struct smp_chan *smp = conn->smp_chan;
998
999 BT_DBG("");
1000
1001 if (skb->len < sizeof(*info))
1002 return SMP_UNSPECIFIED;
1003
6131ddc8
JH
1004 /* Ignore this PDU if it wasn't requested */
1005 if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
1006 return 0;
1007
fd349c02
JH
1008 skb_pull(skb, sizeof(*info));
1009
1010 memcpy(smp->irk, info->irk, 16);
1011
1012 return 0;
1013}
1014
1015static int smp_cmd_ident_addr_info(struct l2cap_conn *conn,
1016 struct sk_buff *skb)
1017{
1018 struct smp_cmd_ident_addr_info *info = (void *) skb->data;
1019 struct smp_chan *smp = conn->smp_chan;
1020 struct hci_conn *hcon = conn->hcon;
1021 bdaddr_t rpa;
1022
1023 BT_DBG("");
1024
1025 if (skb->len < sizeof(*info))
1026 return SMP_UNSPECIFIED;
1027
6131ddc8
JH
1028 /* Ignore this PDU if it wasn't requested */
1029 if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
1030 return 0;
1031
9747a9f3
JH
1032 /* Mark the information as received */
1033 smp->remote_key_dist &= ~SMP_DIST_ID_KEY;
1034
fd349c02
JH
1035 skb_pull(skb, sizeof(*info));
1036
a9a58f86
JH
1037 /* Strictly speaking the Core Specification (4.1) allows sending
1038 * an empty address which would force us to rely on just the IRK
1039 * as "identity information". However, since such
1040 * implementations are not known of and in order to not over
1041 * complicate our implementation, simply pretend that we never
1042 * received an IRK for such a device.
1043 */
1044 if (!bacmp(&info->bdaddr, BDADDR_ANY)) {
1045 BT_ERR("Ignoring IRK with no identity address");
4bd6d38e 1046 smp_distribute_keys(conn);
a9a58f86
JH
1047 return 0;
1048 }
1049
fd349c02
JH
1050 bacpy(&smp->id_addr, &info->bdaddr);
1051 smp->id_addr_type = info->addr_type;
1052
1053 if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))
1054 bacpy(&rpa, &hcon->dst);
1055 else
1056 bacpy(&rpa, BDADDR_ANY);
1057
23d0e128
JH
1058 smp->remote_irk = hci_add_irk(conn->hcon->hdev, &smp->id_addr,
1059 smp->id_addr_type, smp->irk, &rpa);
fd349c02 1060
4bd6d38e 1061 smp_distribute_keys(conn);
fd349c02
JH
1062
1063 return 0;
1064}
1065
7ee4ea36
MH
1066static int smp_cmd_sign_info(struct l2cap_conn *conn, struct sk_buff *skb)
1067{
1068 struct smp_cmd_sign_info *rp = (void *) skb->data;
1069 struct smp_chan *smp = conn->smp_chan;
1070 struct hci_dev *hdev = conn->hcon->hdev;
1071 struct smp_csrk *csrk;
1072
1073 BT_DBG("conn %p", conn);
1074
1075 if (skb->len < sizeof(*rp))
1076 return SMP_UNSPECIFIED;
1077
1078 /* Ignore this PDU if it wasn't requested */
1079 if (!(smp->remote_key_dist & SMP_DIST_SIGN))
1080 return 0;
1081
1082 /* Mark the information as received */
1083 smp->remote_key_dist &= ~SMP_DIST_SIGN;
1084
1085 skb_pull(skb, sizeof(*rp));
1086
1087 hci_dev_lock(hdev);
1088 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1089 if (csrk) {
1090 csrk->master = 0x01;
1091 memcpy(csrk->val, rp->csrk, sizeof(csrk->val));
1092 }
1093 smp->csrk = csrk;
1094 if (!(smp->remote_key_dist & SMP_DIST_SIGN))
1095 smp_distribute_keys(conn);
1096 hci_dev_unlock(hdev);
1097
1098 return 0;
1099}
1100
eb492e01
AB
1101int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
1102{
7b9899db 1103 struct hci_conn *hcon = conn->hcon;
92381f5c 1104 __u8 code, reason;
eb492e01
AB
1105 int err = 0;
1106
7b9899db
MH
1107 if (hcon->type != LE_LINK) {
1108 kfree_skb(skb);
3432711f 1109 return 0;
7b9899db
MH
1110 }
1111
92381f5c
MH
1112 if (skb->len < 1) {
1113 kfree_skb(skb);
1114 return -EILSEQ;
1115 }
1116
06ae3314 1117 if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) {
2e65c9d2
AG
1118 err = -ENOTSUPP;
1119 reason = SMP_PAIRING_NOTSUPP;
1120 goto done;
1121 }
1122
92381f5c 1123 code = skb->data[0];
eb492e01
AB
1124 skb_pull(skb, sizeof(code));
1125
8cf9fa12
JH
1126 /*
1127 * The SMP context must be initialized for all other PDUs except
1128 * pairing and security requests. If we get any other PDU when
1129 * not initialized simply disconnect (done if this function
1130 * returns an error).
1131 */
1132 if (code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ &&
1133 !conn->smp_chan) {
1134 BT_ERR("Unexpected SMP command 0x%02x. Disconnecting.", code);
1135 kfree_skb(skb);
1136 return -ENOTSUPP;
1137 }
1138
eb492e01
AB
1139 switch (code) {
1140 case SMP_CMD_PAIRING_REQ:
da85e5e5 1141 reason = smp_cmd_pairing_req(conn, skb);
eb492e01
AB
1142 break;
1143
1144 case SMP_CMD_PAIRING_FAIL:
84794e11 1145 smp_failure(conn, 0);
da85e5e5
VCG
1146 reason = 0;
1147 err = -EPERM;
eb492e01
AB
1148 break;
1149
1150 case SMP_CMD_PAIRING_RSP:
da85e5e5 1151 reason = smp_cmd_pairing_rsp(conn, skb);
88ba43b6
AB
1152 break;
1153
1154 case SMP_CMD_SECURITY_REQ:
da85e5e5 1155 reason = smp_cmd_security_req(conn, skb);
88ba43b6
AB
1156 break;
1157
eb492e01 1158 case SMP_CMD_PAIRING_CONFIRM:
da85e5e5 1159 reason = smp_cmd_pairing_confirm(conn, skb);
88ba43b6
AB
1160 break;
1161
eb492e01 1162 case SMP_CMD_PAIRING_RANDOM:
da85e5e5 1163 reason = smp_cmd_pairing_random(conn, skb);
88ba43b6
AB
1164 break;
1165
eb492e01 1166 case SMP_CMD_ENCRYPT_INFO:
7034b911
VCG
1167 reason = smp_cmd_encrypt_info(conn, skb);
1168 break;
1169
eb492e01 1170 case SMP_CMD_MASTER_IDENT:
7034b911
VCG
1171 reason = smp_cmd_master_ident(conn, skb);
1172 break;
1173
eb492e01 1174 case SMP_CMD_IDENT_INFO:
fd349c02
JH
1175 reason = smp_cmd_ident_info(conn, skb);
1176 break;
1177
eb492e01 1178 case SMP_CMD_IDENT_ADDR_INFO:
fd349c02
JH
1179 reason = smp_cmd_ident_addr_info(conn, skb);
1180 break;
1181
eb492e01 1182 case SMP_CMD_SIGN_INFO:
7ee4ea36 1183 reason = smp_cmd_sign_info(conn, skb);
7034b911
VCG
1184 break;
1185
eb492e01
AB
1186 default:
1187 BT_DBG("Unknown command code 0x%2.2x", code);
1188
1189 reason = SMP_CMD_NOTSUPP;
eb492e01 1190 err = -EOPNOTSUPP;
3a0259bb 1191 goto done;
eb492e01
AB
1192 }
1193
3a0259bb
VCG
1194done:
1195 if (reason)
84794e11 1196 smp_failure(conn, reason);
3a0259bb 1197
eb492e01
AB
1198 kfree_skb(skb);
1199 return err;
1200}
7034b911 1201
35d70271
JH
1202static void smp_notify_keys(struct l2cap_conn *conn)
1203{
1204 struct smp_chan *smp = conn->smp_chan;
1205 struct hci_conn *hcon = conn->hcon;
1206 struct hci_dev *hdev = hcon->hdev;
53ac6ab6
MH
1207 struct smp_cmd_pairing *req = (void *) &smp->preq[1];
1208 struct smp_cmd_pairing *rsp = (void *) &smp->prsp[1];
1209 bool persistent;
35d70271 1210
61b1a7fb 1211 if (smp->remote_irk) {
95fbac8a 1212 mgmt_new_irk(hdev, smp->remote_irk);
61b1a7fb
JH
1213 /* Now that user space can be considered to know the
1214 * identity address track the connection based on it
1215 * from now on.
1216 */
1217 bacpy(&hcon->dst, &smp->remote_irk->bdaddr);
1218 hcon->dst_type = smp->remote_irk->addr_type;
1219 l2cap_conn_update_id_addr(hcon);
1220 }
95fbac8a 1221
53ac6ab6
MH
1222 /* The LTKs and CSRKs should be persistent only if both sides
1223 * had the bonding bit set in their authentication requests.
1224 */
1225 persistent = !!((req->auth_req & rsp->auth_req) & SMP_AUTH_BONDING);
1226
7ee4ea36
MH
1227 if (smp->csrk) {
1228 smp->csrk->bdaddr_type = hcon->dst_type;
1229 bacpy(&smp->csrk->bdaddr, &hcon->dst);
53ac6ab6 1230 mgmt_new_csrk(hdev, smp->csrk, persistent);
7ee4ea36
MH
1231 }
1232
1233 if (smp->slave_csrk) {
1234 smp->slave_csrk->bdaddr_type = hcon->dst_type;
1235 bacpy(&smp->slave_csrk->bdaddr, &hcon->dst);
53ac6ab6 1236 mgmt_new_csrk(hdev, smp->slave_csrk, persistent);
7ee4ea36
MH
1237 }
1238
35d70271
JH
1239 if (smp->ltk) {
1240 smp->ltk->bdaddr_type = hcon->dst_type;
1241 bacpy(&smp->ltk->bdaddr, &hcon->dst);
53ac6ab6 1242 mgmt_new_ltk(hdev, smp->ltk, persistent);
35d70271
JH
1243 }
1244
1245 if (smp->slave_ltk) {
1246 smp->slave_ltk->bdaddr_type = hcon->dst_type;
1247 bacpy(&smp->slave_ltk->bdaddr, &hcon->dst);
53ac6ab6 1248 mgmt_new_ltk(hdev, smp->slave_ltk, persistent);
35d70271
JH
1249 }
1250}
1251
4bd6d38e 1252int smp_distribute_keys(struct l2cap_conn *conn)
7034b911
VCG
1253{
1254 struct smp_cmd_pairing *req, *rsp;
1c1def09 1255 struct smp_chan *smp = conn->smp_chan;
524237cb
JH
1256 struct hci_conn *hcon = conn->hcon;
1257 struct hci_dev *hdev = hcon->hdev;
38ccdc93 1258 bool ltk_encrypt;
7034b911
VCG
1259 __u8 *keydist;
1260
4bd6d38e 1261 BT_DBG("conn %p", conn);
7034b911 1262
524237cb 1263 if (!test_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
d26a2345
VCG
1264 return 0;
1265
1c1def09 1266 rsp = (void *) &smp->prsp[1];
7034b911
VCG
1267
1268 /* The responder sends its keys first */
efabba37 1269 if (hcon->out && (smp->remote_key_dist & 0x07))
7034b911
VCG
1270 return 0;
1271
1c1def09 1272 req = (void *) &smp->preq[1];
7034b911 1273
524237cb 1274 if (hcon->out) {
7034b911
VCG
1275 keydist = &rsp->init_key_dist;
1276 *keydist &= req->init_key_dist;
1277 } else {
1278 keydist = &rsp->resp_key_dist;
1279 *keydist &= req->resp_key_dist;
1280 }
1281
7034b911
VCG
1282 BT_DBG("keydist 0x%x", *keydist);
1283
1284 if (*keydist & SMP_DIST_ENC_KEY) {
1285 struct smp_cmd_encrypt_info enc;
1286 struct smp_cmd_master_ident ident;
23d0e128 1287 struct smp_ltk *ltk;
c9839a11 1288 u8 authenticated;
7034b911 1289 __le16 ediv;
fe39c7b2 1290 __le64 rand;
7034b911
VCG
1291
1292 get_random_bytes(enc.ltk, sizeof(enc.ltk));
1293 get_random_bytes(&ediv, sizeof(ediv));
fe39c7b2 1294 get_random_bytes(&rand, sizeof(rand));
7034b911
VCG
1295
1296 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);
1297
c9839a11 1298 authenticated = hcon->sec_level == BT_SECURITY_HIGH;
524237cb 1299 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type,
35d70271 1300 HCI_SMP_LTK_SLAVE, authenticated, enc.ltk,
fe39c7b2 1301 smp->enc_key_size, ediv, rand);
23d0e128 1302 smp->slave_ltk = ltk;
16b90839 1303
58115373 1304 ident.ediv = ediv;
fe39c7b2 1305 ident.rand = rand;
7034b911
VCG
1306
1307 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);
1308
1309 *keydist &= ~SMP_DIST_ENC_KEY;
1310 }
1311
1312 if (*keydist & SMP_DIST_ID_KEY) {
1313 struct smp_cmd_ident_addr_info addrinfo;
1314 struct smp_cmd_ident_info idinfo;
1315
863efaf2 1316 memcpy(idinfo.irk, hdev->irk, sizeof(idinfo.irk));
7034b911
VCG
1317
1318 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
1319
82d4b359
JH
1320 /* The hci_conn contains the local identity address
1321 * after the connection has been established.
1322 *
1323 * This is true even when the connection has been
1324 * established using a resolvable random address.
1325 */
524237cb 1326 bacpy(&addrinfo.bdaddr, &hcon->src);
82d4b359 1327 addrinfo.addr_type = hcon->src_type;
7034b911
VCG
1328
1329 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
f1560463 1330 &addrinfo);
7034b911
VCG
1331
1332 *keydist &= ~SMP_DIST_ID_KEY;
1333 }
1334
1335 if (*keydist & SMP_DIST_SIGN) {
1336 struct smp_cmd_sign_info sign;
7ee4ea36 1337 struct smp_csrk *csrk;
7034b911 1338
7ee4ea36 1339 /* Generate a new random key */
7034b911
VCG
1340 get_random_bytes(sign.csrk, sizeof(sign.csrk));
1341
7ee4ea36
MH
1342 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1343 if (csrk) {
1344 csrk->master = 0x00;
1345 memcpy(csrk->val, sign.csrk, sizeof(csrk->val));
1346 }
1347 smp->slave_csrk = csrk;
1348
7034b911
VCG
1349 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
1350
1351 *keydist &= ~SMP_DIST_SIGN;
1352 }
1353
efabba37
JH
1354 /* If there are still keys to be received wait for them */
1355 if ((smp->remote_key_dist & 0x07))
1356 return 0;
1357
38ccdc93
JH
1358 /* Check if we should try to re-encrypt the link with the LTK.
1359 * SMP_FLAG_LTK_ENCRYPT flag is used to track whether we've
1360 * already tried this (in which case we shouldn't try again).
1361 *
1362 * The request will trigger an encryption key refresh event
1363 * which will cause a call to auth_cfm and eventually lead to
1364 * l2cap_core.c calling this smp_distribute_keys function again
1365 * and thereby completing the process.
1366 */
1367 if (smp->ltk)
1368 ltk_encrypt = !test_and_set_bit(SMP_FLAG_LTK_ENCRYPT,
1369 &smp->smp_flags);
1370 else
1371 ltk_encrypt = false;
efabba37 1372
38ccdc93
JH
1373 /* Re-encrypt the link with LTK if possible */
1374 if (ltk_encrypt && hcon->out) {
e3098be4
JH
1375 queue_delayed_work(hdev->req_workqueue, &smp->reencrypt,
1376 SMP_REENCRYPT_TIMEOUT);
38ccdc93
JH
1377 } else {
1378 clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags);
1379 cancel_delayed_work_sync(&conn->security_timer);
1380 set_bit(SMP_FLAG_COMPLETE, &smp->smp_flags);
1381 smp_notify_keys(conn);
1382 smp_chan_destroy(conn);
1383 }
d26a2345 1384
7034b911
VCG
1385 return 0;
1386}
This page took 0.25122 seconds and 5 git commands to generate.