projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Add SMP flag to track which side is the initiator
[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);
4eb65e66
JH		 425 else if (method == JUST_CFM)
426 ret = mgmt_user_confirm_request(hcon->hdev, &hcon->dst,
427 hcon->type, hcon->dst_type,
428 passkey, 1);
2b64d153 429 else
01ad34d2 430 ret = mgmt_user_passkey_notify(hcon->hdev, &hcon->dst,
272d90df 431 hcon->type, hcon->dst_type,
39adbffe 432 passkey, 0);
2b64d153
BG		 433
434 hci_dev_unlock(hcon->hdev);
435
436 return ret;
437}
438
8aab4757
VCG		 439static void confirm_work(struct work_struct *work)
440{
441 struct smp_chan *smp = container_of(work, struct smp_chan, confirm);
442 struct l2cap_conn *conn = smp->conn;
893ce8b1
JH		 443 struct hci_dev *hdev = conn->hcon->hdev;
444 struct crypto_blkcipher *tfm = hdev->tfm_aes;
8aab4757
VCG		 445 struct smp_cmd_pairing_confirm cp;
446 int ret;
943a732a 447 u8 reason;
8aab4757
VCG		 448
449 BT_DBG("conn %p", conn);
450
893ce8b1
JH		 451 /* Prevent mutual access to hdev->tfm_aes */
452 hci_dev_lock(hdev);
8aab4757 453
b1cd5fd9
JH		 454 ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp,
455 conn->hcon->init_addr_type, &conn->hcon->init_addr,
943a732a
JH		 456 conn->hcon->resp_addr_type, &conn->hcon->resp_addr,
457 cp.confirm_val);
893ce8b1
JH		 458
459 hci_dev_unlock(hdev);
460
8aab4757
VCG		 461 if (ret) {
462 reason = SMP_UNSPECIFIED;
463 goto error;
464 }
465
2b64d153
BG		 466 clear_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
467
8aab4757
VCG		 468 smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
469
470 return;
471
472error:
84794e11 473 smp_failure(conn, reason);
8aab4757
VCG		 474}
475
476static void random_work(struct work_struct *work)
477{
478 struct smp_chan *smp = container_of(work, struct smp_chan, random);
479 struct l2cap_conn *conn = smp->conn;
480 struct hci_conn *hcon = conn->hcon;
893ce8b1
JH		 481 struct hci_dev *hdev = hcon->hdev;
482 struct crypto_blkcipher *tfm = hdev->tfm_aes;
943a732a 483 u8 reason, confirm[16];
8aab4757
VCG		 484 int ret;
485
486 if (IS_ERR_OR_NULL(tfm)) {
487 reason = SMP_UNSPECIFIED;
488 goto error;
489 }
490
491 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
492
893ce8b1
JH		 493 /* Prevent mutual access to hdev->tfm_aes */
494 hci_dev_lock(hdev);
495
b1cd5fd9
JH		 496 ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp,
497 hcon->init_addr_type, &hcon->init_addr,
943a732a 498 hcon->resp_addr_type, &hcon->resp_addr, confirm);
893ce8b1
JH		 499
500 hci_dev_unlock(hdev);
501
8aab4757
VCG		 502 if (ret) {
503 reason = SMP_UNSPECIFIED;
504 goto error;
505 }
506
8aab4757
VCG		 507 if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) {
508 BT_ERR("Pairing failed (confirmation values mismatch)");
509 reason = SMP_CONFIRM_FAILED;
510 goto error;
511 }
512
513 if (hcon->out) {
fe39c7b2
MH		 514 u8 stk[16];
515 __le64 rand = 0;
516 __le16 ediv = 0;
8aab4757 517
943a732a 518 smp_s1(tfm, smp->tk, smp->rrnd, smp->prnd, stk);
8aab4757 519
f7aa611a 520 memset(stk + smp->enc_key_size, 0,
04124681 521 SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
8aab4757 522
51a8efd7 523 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags)) {
8aab4757
VCG		 524 reason = SMP_UNSPECIFIED;
525 goto error;
526 }
527
528 hci_le_start_enc(hcon, ediv, rand, stk);
f7aa611a 529 hcon->enc_key_size = smp->enc_key_size;
8aab4757 530 } else {
943a732a 531 u8 stk[16];
fe39c7b2
MH		 532 __le64 rand = 0;
533 __le16 ediv = 0;
8aab4757 534
943a732a
JH		 535 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
536 smp->prnd);
8aab4757 537
943a732a 538 smp_s1(tfm, smp->tk, smp->prnd, smp->rrnd, stk);
8aab4757 539
f7aa611a 540 memset(stk + smp->enc_key_size, 0,
f1560463 541 SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
8aab4757 542
ce39fb4e 543 hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
35d70271 544 HCI_SMP_STK_SLAVE, 0, stk, smp->enc_key_size,
04124681 545 ediv, rand);
8aab4757
VCG		 546 }
547
548 return;
549
550error:
84794e11 551 smp_failure(conn, reason);
8aab4757
VCG		 552}
553
e3098be4
JH		 554static void smp_reencrypt(struct work_struct *work)
555{
556 struct smp_chan *smp = container_of(work, struct smp_chan,
557 reencrypt.work);
558 struct l2cap_conn *conn = smp->conn;
559 struct hci_conn *hcon = conn->hcon;
560 struct smp_ltk *ltk = smp->ltk;
561
562 BT_DBG("");
563
564 hci_le_start_enc(hcon, ltk->ediv, ltk->rand, ltk->val);
565 hcon->enc_key_size = ltk->enc_size;
566}
567
8aab4757
VCG		 568static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
569{
570 struct smp_chan *smp;
571
f1560463 572 smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
8aab4757
VCG		 573 if (!smp)
574 return NULL;
575
576 INIT_WORK(&smp->confirm, confirm_work);
577 INIT_WORK(&smp->random, random_work);
e3098be4 578 INIT_DELAYED_WORK(&smp->reencrypt, smp_reencrypt);
8aab4757
VCG		 579
580 smp->conn = conn;
581 conn->smp_chan = smp;
2b64d153 582 conn->hcon->smp_conn = conn;
8aab4757
VCG		 583
584 hci_conn_hold(conn->hcon);
585
586 return smp;
587}
588
589void smp_chan_destroy(struct l2cap_conn *conn)
590{
c8eb9690 591 struct smp_chan *smp = conn->smp_chan;
f4a407be 592 bool complete;
c8eb9690 593
f1c09c07 594 BUG_ON(!smp);
c8eb9690 595
e3098be4
JH		 596 cancel_delayed_work_sync(&smp->reencrypt);
597
f4a407be
JH		 598 complete = test_bit(SMP_FLAG_COMPLETE, &smp->smp_flags);
599 mgmt_smp_complete(conn->hcon, complete);
600
7ee4ea36
MH		 601 kfree(smp->csrk);
602 kfree(smp->slave_csrk);
603
759331d7
JH		 604 /* If pairing failed clean up any keys we might have */
605 if (!complete) {
606 if (smp->ltk) {
607 list_del(&smp->ltk->list);
608 kfree(smp->ltk);
609 }
610
611 if (smp->slave_ltk) {
612 list_del(&smp->slave_ltk->list);
613 kfree(smp->slave_ltk);
614 }
615
616 if (smp->remote_irk) {
617 list_del(&smp->remote_irk->list);
618 kfree(smp->remote_irk);
619 }
620 }
621
c8eb9690
BG		 622 kfree(smp);
623 conn->smp_chan = NULL;
2b64d153 624 conn->hcon->smp_conn = NULL;
76a68ba0 625 hci_conn_drop(conn->hcon);
8aab4757
VCG		 626}
627
2b64d153
BG		 628int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey)
629{
630 struct l2cap_conn *conn = hcon->smp_conn;
631 struct smp_chan *smp;
632 u32 value;
2b64d153
BG		 633
634 BT_DBG("");
635
636 if (!conn)
637 return -ENOTCONN;
638
639 smp = conn->smp_chan;
640
641 switch (mgmt_op) {
642 case MGMT_OP_USER_PASSKEY_REPLY:
643 value = le32_to_cpu(passkey);
943a732a 644 memset(smp->tk, 0, sizeof(smp->tk));
2b64d153 645 BT_DBG("PassKey: %d", value);
943a732a 646 put_unaligned_le32(value, smp->tk);
2b64d153
BG		 647 /* Fall Through */
648 case MGMT_OP_USER_CONFIRM_REPLY:
649 set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
650 break;
651 case MGMT_OP_USER_PASSKEY_NEG_REPLY:
652 case MGMT_OP_USER_CONFIRM_NEG_REPLY:
84794e11 653 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
2b64d153
BG		 654 return 0;
655 default:
84794e11 656 smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED);
2b64d153
BG		 657 return -EOPNOTSUPP;
658 }
659
660 /* If it is our turn to send Pairing Confirm, do so now */
661 if (test_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags))
662 queue_work(hcon->hdev->workqueue, &smp->confirm);
663
664 return 0;
665}
666
da85e5e5 667static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 668{
3158c50c 669 struct smp_cmd_pairing rsp, *req = (void *) skb->data;
8aab4757 670 struct smp_chan *smp;
3158c50c 671 u8 key_size;
2b64d153 672 u8 auth = SMP_AUTH_NONE;
8aab4757 673 int ret;
88ba43b6
AB		 674
675 BT_DBG("conn %p", conn);
676
c46b98be
JH		 677 if (skb->len < sizeof(*req))
678 return SMP_UNSPECIFIED;
679
2b64d153
BG		 680 if (conn->hcon->link_mode & HCI_LM_MASTER)
681 return SMP_CMD_NOTSUPP;
682
51a8efd7 683 if (!test_and_set_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags))
8aab4757 684 smp = smp_chan_create(conn);
d08fd0e7
AE		 685 else
686 smp = conn->smp_chan;
8aab4757 687
d08fd0e7
AE		 688 if (!smp)
689 return SMP_UNSPECIFIED;
d26a2345 690
1c1def09
VCG		 691 smp->preq[0] = SMP_CMD_PAIRING_REQ;
692 memcpy(&smp->preq[1], req, sizeof(*req));
3158c50c 693 skb_pull(skb, sizeof(*req));
88ba43b6 694
2b64d153
BG		 695 /* We didn't start the pairing, so match remote */
696 if (req->auth_req & SMP_AUTH_BONDING)
697 auth = req->auth_req;
da85e5e5 698
fdde0a26
IY		 699 conn->hcon->pending_sec_level = authreq_to_seclevel(auth);
700
2b64d153 701 build_pairing_cmd(conn, req, &rsp, auth);
3158c50c
VCG		 702
703 key_size = min(req->max_key_size, rsp.max_key_size);
704 if (check_enc_key_size(conn, key_size))
705 return SMP_ENC_KEY_SIZE;
88ba43b6 706
e84a6b13 707 get_random_bytes(smp->prnd, sizeof(smp->prnd));
8aab4757 708
1c1def09
VCG		 709 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
710 memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
f01ead31 711
3158c50c 712 smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
da85e5e5 713
2b64d153
BG		 714 /* Request setup of TK */
715 ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
716 if (ret)
717 return SMP_UNSPECIFIED;
718
edca792c
JH		 719 clear_bit(SMP_FLAG_INITIATOR, &smp->smp_flags);
720
da85e5e5 721 return 0;
88ba43b6
AB		 722}
723
da85e5e5 724static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 725{
3158c50c 726 struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
1c1def09 727 struct smp_chan *smp = conn->smp_chan;
8aab4757 728 struct hci_dev *hdev = conn->hcon->hdev;
2b64d153 729 u8 key_size, auth = SMP_AUTH_NONE;
7d24ddcc 730 int ret;
88ba43b6
AB		 731
732 BT_DBG("conn %p", conn);
733
c46b98be
JH		 734 if (skb->len < sizeof(*rsp))
735 return SMP_UNSPECIFIED;
736
2b64d153
BG		 737 if (!(conn->hcon->link_mode & HCI_LM_MASTER))
738 return SMP_CMD_NOTSUPP;
739
3158c50c
VCG		 740 skb_pull(skb, sizeof(*rsp));
741
1c1def09 742 req = (void *) &smp->preq[1];
da85e5e5 743
3158c50c
VCG		 744 key_size = min(req->max_key_size, rsp->max_key_size);
745 if (check_enc_key_size(conn, key_size))
746 return SMP_ENC_KEY_SIZE;
747
e84a6b13 748 get_random_bytes(smp->prnd, sizeof(smp->prnd));
7d24ddcc 749
8aab4757
VCG		 750 smp->prsp[0] = SMP_CMD_PAIRING_RSP;
751 memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
7d24ddcc 752
fdcc4bec
JH		 753 /* Update remote key distribution in case the remote cleared
754 * some bits that we had enabled in our request.
755 */
756 smp->remote_key_dist &= rsp->resp_key_dist;
757
2b64d153 758 if ((req->auth_req & SMP_AUTH_BONDING) &&
f1560463 759 (rsp->auth_req & SMP_AUTH_BONDING))
2b64d153
BG		 760 auth = SMP_AUTH_BONDING;
761
762 auth |= (req->auth_req | rsp->auth_req) & SMP_AUTH_MITM;
763
476585ec 764 ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
2b64d153
BG		 765 if (ret)
766 return SMP_UNSPECIFIED;
767
768 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
769
770 /* Can't compose response until we have been confirmed */
18e4aeb9
JH		 771 if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
772 queue_work(hdev->workqueue, &smp->confirm);
da85e5e5
VCG		 773
774 return 0;
88ba43b6
AB		 775}
776
da85e5e5 777static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 778{
1c1def09 779 struct smp_chan *smp = conn->smp_chan;
8aab4757 780 struct hci_dev *hdev = conn->hcon->hdev;
7d24ddcc 781
88ba43b6
AB		 782 BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
783
c46b98be
JH		 784 if (skb->len < sizeof(smp->pcnf))
785 return SMP_UNSPECIFIED;
786
1c1def09
VCG		 787 memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
788 skb_pull(skb, sizeof(smp->pcnf));
88ba43b6 789
943a732a
JH		 790 if (conn->hcon->out)
791 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(smp->prnd),
792 smp->prnd);
793 else if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
8aab4757 794 queue_work(hdev->workqueue, &smp->confirm);
943a732a 795 else
2b64d153 796 set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
da85e5e5
VCG		 797
798 return 0;
88ba43b6
AB		 799}
800
da85e5e5 801static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6 802{
1c1def09 803 struct smp_chan *smp = conn->smp_chan;
8aab4757 804 struct hci_dev *hdev = conn->hcon->hdev;
7d24ddcc 805
8aab4757 806 BT_DBG("conn %p", conn);
3158c50c 807
c46b98be
JH		 808 if (skb->len < sizeof(smp->rrnd))
809 return SMP_UNSPECIFIED;
810
943a732a 811 memcpy(smp->rrnd, skb->data, sizeof(smp->rrnd));
8aab4757 812 skb_pull(skb, sizeof(smp->rrnd));
e7e62c85 813
8aab4757 814 queue_work(hdev->workqueue, &smp->random);
da85e5e5
VCG		 815
816 return 0;
88ba43b6
AB		 817}
818
4dab7864 819static u8 smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
988c5997 820{
c9839a11 821 struct smp_ltk *key;
988c5997
VCG		 822 struct hci_conn *hcon = conn->hcon;
823
98a0b845
JH		 824 key = hci_find_ltk_by_addr(hcon->hdev, &hcon->dst, hcon->dst_type,
825 hcon->out);
988c5997
VCG		 826 if (!key)
827 return 0;
828
4dab7864
JH		 829 if (sec_level > BT_SECURITY_MEDIUM && !key->authenticated)
830 return 0;
831
51a8efd7 832 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
988c5997
VCG		 833 return 1;
834
c9839a11
VCG		 835 hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
836 hcon->enc_key_size = key->enc_size;
988c5997
VCG		 837
838 return 1;
988c5997 839}
f1560463 840
da85e5e5 841static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
88ba43b6
AB		 842{
843 struct smp_cmd_security_req *rp = (void *) skb->data;
844 struct smp_cmd_pairing cp;
f1cb9af5 845 struct hci_conn *hcon = conn->hcon;
8aab4757 846 struct smp_chan *smp;
88ba43b6
AB		 847
848 BT_DBG("conn %p", conn);
849
c46b98be
JH		 850 if (skb->len < sizeof(*rp))
851 return SMP_UNSPECIFIED;
852
86ca9eac
JH		 853 if (!(conn->hcon->link_mode & HCI_LM_MASTER))
854 return SMP_CMD_NOTSUPP;
855
2b64d153 856 hcon->pending_sec_level = authreq_to_seclevel(rp->auth_req);
feb45eb5 857
4dab7864 858 if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
988c5997
VCG		 859 return 0;
860
51a8efd7 861 if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
da85e5e5 862 return 0;
f1cb9af5 863
8aab4757 864 smp = smp_chan_create(conn);
d26a2345 865
88ba43b6 866 skb_pull(skb, sizeof(*rp));
88ba43b6 867
da85e5e5 868 memset(&cp, 0, sizeof(cp));
54790f73 869 build_pairing_cmd(conn, &cp, NULL, rp->auth_req);
88ba43b6 870
1c1def09
VCG		 871 smp->preq[0] = SMP_CMD_PAIRING_REQ;
872 memcpy(&smp->preq[1], &cp, sizeof(cp));
f01ead31 873
88ba43b6 874 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
f1cb9af5 875
edca792c
JH		 876 clear_bit(SMP_FLAG_INITIATOR, &smp->smp_flags);
877
da85e5e5 878 return 0;
88ba43b6
AB		 879}
880
ad32a2f5
JH		 881bool smp_sufficient_security(struct hci_conn *hcon, u8 sec_level)
882{
883 if (sec_level == BT_SECURITY_LOW)
884 return true;
885
886 if (hcon->sec_level >= sec_level)
887 return true;
888
889 return false;
890}
891
cc110922 892int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
eb492e01 893{
cc110922 894 struct l2cap_conn *conn = hcon->l2cap_data;
0a66cf20 895 struct smp_chan *smp;
2b64d153 896 __u8 authreq;
eb492e01 897
3a0259bb
VCG		 898 BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
899
0a66cf20
JH		 900 /* This may be NULL if there's an unexpected disconnection */
901 if (!conn)
902 return 1;
903
904 smp = conn->smp_chan;
905
757aee0f 906 if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags))
2e65c9d2
AG		 907 return 1;
908
ad32a2f5 909 if (smp_sufficient_security(hcon, sec_level))
eb492e01 910 return 1;
f1cb9af5 911
988c5997 912 if (hcon->link_mode & HCI_LM_MASTER)
4dab7864 913 if (smp_ltk_encrypt(conn, sec_level))
02bc7455 914 goto done;
d26a2345 915
51a8efd7 916 if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
d26a2345
VCG		 917 return 0;
918
8aab4757 919 smp = smp_chan_create(conn);
2b64d153
BG		 920 if (!smp)
921 return 1;
922
923 authreq = seclevel_to_authreq(sec_level);
d26a2345 924
2e233644
JH		 925 /* hcon->auth_type is set by pair_device in mgmt.c. If the MITM
926 * flag is set we should also set it for the SMP request.
927 */
928 if ((hcon->auth_type & 0x01))
929 authreq |= SMP_AUTH_MITM;
930
d26a2345
VCG		 931 if (hcon->link_mode & HCI_LM_MASTER) {
932 struct smp_cmd_pairing cp;
f01ead31 933
2b64d153 934 build_pairing_cmd(conn, &cp, NULL, authreq);
1c1def09
VCG		 935 smp->preq[0] = SMP_CMD_PAIRING_REQ;
936 memcpy(&smp->preq[1], &cp, sizeof(cp));
f01ead31 937
eb492e01
AB		 938 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
939 } else {
940 struct smp_cmd_security_req cp;
2b64d153 941 cp.auth_req = authreq;
eb492e01
AB		 942 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
943 }
944
02bc7455 945done:
edca792c
JH		 946 set_bit(SMP_FLAG_INITIATOR, &smp->smp_flags);
947
f1cb9af5 948 hcon->pending_sec_level = sec_level;
f1cb9af5 949
eb492e01
AB		 950 return 0;
951}
952
7034b911
VCG		 953static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
954{
16b90839 955 struct smp_cmd_encrypt_info *rp = (void *) skb->data;
1c1def09 956 struct smp_chan *smp = conn->smp_chan;
16b90839 957
c46b98be
JH		 958 BT_DBG("conn %p", conn);
959
960 if (skb->len < sizeof(*rp))
961 return SMP_UNSPECIFIED;
962
6131ddc8
JH		 963 /* Ignore this PDU if it wasn't requested */
964 if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
965 return 0;
966
16b90839
VCG		 967 skb_pull(skb, sizeof(*rp));
968
1c1def09 969 memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
16b90839 970
7034b911
VCG		 971 return 0;
972}
973
974static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
975{
16b90839 976 struct smp_cmd_master_ident *rp = (void *) skb->data;
1c1def09 977 struct smp_chan *smp = conn->smp_chan;
c9839a11
VCG		 978 struct hci_dev *hdev = conn->hcon->hdev;
979 struct hci_conn *hcon = conn->hcon;
23d0e128 980 struct smp_ltk *ltk;
c9839a11 981 u8 authenticated;
16b90839 982
c46b98be
JH		 983 BT_DBG("conn %p", conn);
984
985 if (skb->len < sizeof(*rp))
986 return SMP_UNSPECIFIED;
987
6131ddc8
JH		 988 /* Ignore this PDU if it wasn't requested */
989 if (!(smp->remote_key_dist & SMP_DIST_ENC_KEY))
990 return 0;
991
9747a9f3
JH		 992 /* Mark the information as received */
993 smp->remote_key_dist &= ~SMP_DIST_ENC_KEY;
994
16b90839 995 skb_pull(skb, sizeof(*rp));
7034b911 996
c9839a11 997 hci_dev_lock(hdev);
ce39fb4e 998 authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
35d70271 999 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, HCI_SMP_LTK,
23d0e128
JH		 1000 authenticated, smp->tk, smp->enc_key_size,
1001 rp->ediv, rp->rand);
1002 smp->ltk = ltk;
fd349c02 1003 if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
4bd6d38e 1004 smp_distribute_keys(conn);
c9839a11 1005 hci_dev_unlock(hdev);
7034b911
VCG		 1006
1007 return 0;
1008}
1009
fd349c02
JH		 1010static int smp_cmd_ident_info(struct l2cap_conn *conn, struct sk_buff *skb)
1011{
1012 struct smp_cmd_ident_info *info = (void *) skb->data;
1013 struct smp_chan *smp = conn->smp_chan;
1014
1015 BT_DBG("");
1016
1017 if (skb->len < sizeof(*info))
1018 return SMP_UNSPECIFIED;
1019
6131ddc8
JH		 1020 /* Ignore this PDU if it wasn't requested */
1021 if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
1022 return 0;
1023
fd349c02
JH		 1024 skb_pull(skb, sizeof(*info));
1025
1026 memcpy(smp->irk, info->irk, 16);
1027
1028 return 0;
1029}
1030
1031static int smp_cmd_ident_addr_info(struct l2cap_conn *conn,
1032 struct sk_buff *skb)
1033{
1034 struct smp_cmd_ident_addr_info *info = (void *) skb->data;
1035 struct smp_chan *smp = conn->smp_chan;
1036 struct hci_conn *hcon = conn->hcon;
1037 bdaddr_t rpa;
1038
1039 BT_DBG("");
1040
1041 if (skb->len < sizeof(*info))
1042 return SMP_UNSPECIFIED;
1043
6131ddc8
JH		 1044 /* Ignore this PDU if it wasn't requested */
1045 if (!(smp->remote_key_dist & SMP_DIST_ID_KEY))
1046 return 0;
1047
9747a9f3
JH		 1048 /* Mark the information as received */
1049 smp->remote_key_dist &= ~SMP_DIST_ID_KEY;
1050
fd349c02
JH		 1051 skb_pull(skb, sizeof(*info));
1052
a9a58f86
JH		 1053 /* Strictly speaking the Core Specification (4.1) allows sending
1054 * an empty address which would force us to rely on just the IRK
1055 * as "identity information". However, since such
1056 * implementations are not known of and in order to not over
1057 * complicate our implementation, simply pretend that we never
1058 * received an IRK for such a device.
1059 */
1060 if (!bacmp(&info->bdaddr, BDADDR_ANY)) {
1061 BT_ERR("Ignoring IRK with no identity address");
4bd6d38e 1062 smp_distribute_keys(conn);
a9a58f86
JH		 1063 return 0;
1064 }
1065
fd349c02
JH		 1066 bacpy(&smp->id_addr, &info->bdaddr);
1067 smp->id_addr_type = info->addr_type;
1068
1069 if (hci_bdaddr_is_rpa(&hcon->dst, hcon->dst_type))
1070 bacpy(&rpa, &hcon->dst);
1071 else
1072 bacpy(&rpa, BDADDR_ANY);
1073
23d0e128
JH		 1074 smp->remote_irk = hci_add_irk(conn->hcon->hdev, &smp->id_addr,
1075 smp->id_addr_type, smp->irk, &rpa);
fd349c02 1076
4bd6d38e 1077 smp_distribute_keys(conn);
fd349c02
JH		 1078
1079 return 0;
1080}
1081
7ee4ea36
MH		 1082static int smp_cmd_sign_info(struct l2cap_conn *conn, struct sk_buff *skb)
1083{
1084 struct smp_cmd_sign_info *rp = (void *) skb->data;
1085 struct smp_chan *smp = conn->smp_chan;
1086 struct hci_dev *hdev = conn->hcon->hdev;
1087 struct smp_csrk *csrk;
1088
1089 BT_DBG("conn %p", conn);
1090
1091 if (skb->len < sizeof(*rp))
1092 return SMP_UNSPECIFIED;
1093
1094 /* Ignore this PDU if it wasn't requested */
1095 if (!(smp->remote_key_dist & SMP_DIST_SIGN))
1096 return 0;
1097
1098 /* Mark the information as received */
1099 smp->remote_key_dist &= ~SMP_DIST_SIGN;
1100
1101 skb_pull(skb, sizeof(*rp));
1102
1103 hci_dev_lock(hdev);
1104 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1105 if (csrk) {
1106 csrk->master = 0x01;
1107 memcpy(csrk->val, rp->csrk, sizeof(csrk->val));
1108 }
1109 smp->csrk = csrk;
1110 if (!(smp->remote_key_dist & SMP_DIST_SIGN))
1111 smp_distribute_keys(conn);
1112 hci_dev_unlock(hdev);
1113
1114 return 0;
1115}
1116
eb492e01
AB		 1117int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
1118{
7b9899db 1119 struct hci_conn *hcon = conn->hcon;
92381f5c 1120 __u8 code, reason;
eb492e01
AB		 1121 int err = 0;
1122
7b9899db
MH		 1123 if (hcon->type != LE_LINK) {
1124 kfree_skb(skb);
3432711f 1125 return 0;
7b9899db
MH		 1126 }
1127
92381f5c
MH		 1128 if (skb->len < 1) {
1129 kfree_skb(skb);
1130 return -EILSEQ;
1131 }
1132
06ae3314 1133 if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) {
2e65c9d2
AG		 1134 err = -ENOTSUPP;
1135 reason = SMP_PAIRING_NOTSUPP;
1136 goto done;
1137 }
1138
92381f5c 1139 code = skb->data[0];
eb492e01
AB		 1140 skb_pull(skb, sizeof(code));
1141
8cf9fa12
JH		 1142 /*
1143 * The SMP context must be initialized for all other PDUs except
1144 * pairing and security requests. If we get any other PDU when
1145 * not initialized simply disconnect (done if this function
1146 * returns an error).
1147 */
1148 if (code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ &&
1149 !conn->smp_chan) {
1150 BT_ERR("Unexpected SMP command 0x%02x. Disconnecting.", code);
1151 kfree_skb(skb);
1152 return -ENOTSUPP;
1153 }
1154
eb492e01
AB		 1155 switch (code) {
1156 case SMP_CMD_PAIRING_REQ:
da85e5e5 1157 reason = smp_cmd_pairing_req(conn, skb);
eb492e01
AB		 1158 break;
1159
1160 case SMP_CMD_PAIRING_FAIL:
84794e11 1161 smp_failure(conn, 0);
da85e5e5
VCG		 1162 reason = 0;
1163 err = -EPERM;
eb492e01
AB		 1164 break;
1165
1166 case SMP_CMD_PAIRING_RSP:
da85e5e5 1167 reason = smp_cmd_pairing_rsp(conn, skb);
88ba43b6
AB		 1168 break;
1169
1170 case SMP_CMD_SECURITY_REQ:
da85e5e5 1171 reason = smp_cmd_security_req(conn, skb);
88ba43b6
AB		 1172 break;
1173
eb492e01 1174 case SMP_CMD_PAIRING_CONFIRM:
da85e5e5 1175 reason = smp_cmd_pairing_confirm(conn, skb);
88ba43b6
AB		 1176 break;
1177
eb492e01 1178 case SMP_CMD_PAIRING_RANDOM:
da85e5e5 1179 reason = smp_cmd_pairing_random(conn, skb);
88ba43b6
AB		 1180 break;
1181
eb492e01 1182 case SMP_CMD_ENCRYPT_INFO:
7034b911
VCG		 1183 reason = smp_cmd_encrypt_info(conn, skb);
1184 break;
1185
eb492e01 1186 case SMP_CMD_MASTER_IDENT:
7034b911
VCG		 1187 reason = smp_cmd_master_ident(conn, skb);
1188 break;
1189
eb492e01 1190 case SMP_CMD_IDENT_INFO:
fd349c02
JH		 1191 reason = smp_cmd_ident_info(conn, skb);
1192 break;
1193
eb492e01 1194 case SMP_CMD_IDENT_ADDR_INFO:
fd349c02
JH		 1195 reason = smp_cmd_ident_addr_info(conn, skb);
1196 break;
1197
eb492e01 1198 case SMP_CMD_SIGN_INFO:
7ee4ea36 1199 reason = smp_cmd_sign_info(conn, skb);
7034b911
VCG		 1200 break;
1201
eb492e01
AB		 1202 default:
1203 BT_DBG("Unknown command code 0x%2.2x", code);
1204
1205 reason = SMP_CMD_NOTSUPP;
eb492e01 1206 err = -EOPNOTSUPP;
3a0259bb 1207 goto done;
eb492e01
AB		 1208 }
1209
3a0259bb
VCG		 1210done:
1211 if (reason)
84794e11 1212 smp_failure(conn, reason);
3a0259bb 1213
eb492e01
AB		 1214 kfree_skb(skb);
1215 return err;
1216}
7034b911 1217
35d70271
JH		 1218static void smp_notify_keys(struct l2cap_conn *conn)
1219{
1220 struct smp_chan *smp = conn->smp_chan;
1221 struct hci_conn *hcon = conn->hcon;
1222 struct hci_dev *hdev = hcon->hdev;
53ac6ab6
MH		 1223 struct smp_cmd_pairing *req = (void *) &smp->preq[1];
1224 struct smp_cmd_pairing *rsp = (void *) &smp->prsp[1];
1225 bool persistent;
35d70271 1226
61b1a7fb 1227 if (smp->remote_irk) {
95fbac8a 1228 mgmt_new_irk(hdev, smp->remote_irk);
61b1a7fb
JH		 1229 /* Now that user space can be considered to know the
1230 * identity address track the connection based on it
1231 * from now on.
1232 */
1233 bacpy(&hcon->dst, &smp->remote_irk->bdaddr);
1234 hcon->dst_type = smp->remote_irk->addr_type;
1235 l2cap_conn_update_id_addr(hcon);
1236 }
95fbac8a 1237
53ac6ab6
MH		 1238 /* The LTKs and CSRKs should be persistent only if both sides
1239 * had the bonding bit set in their authentication requests.
1240 */
1241 persistent = !!((req->auth_req & rsp->auth_req) & SMP_AUTH_BONDING);
1242
7ee4ea36
MH		 1243 if (smp->csrk) {
1244 smp->csrk->bdaddr_type = hcon->dst_type;
1245 bacpy(&smp->csrk->bdaddr, &hcon->dst);
53ac6ab6 1246 mgmt_new_csrk(hdev, smp->csrk, persistent);
7ee4ea36
MH		 1247 }
1248
1249 if (smp->slave_csrk) {
1250 smp->slave_csrk->bdaddr_type = hcon->dst_type;
1251 bacpy(&smp->slave_csrk->bdaddr, &hcon->dst);
53ac6ab6 1252 mgmt_new_csrk(hdev, smp->slave_csrk, persistent);
7ee4ea36
MH		 1253 }
1254
35d70271
JH		 1255 if (smp->ltk) {
1256 smp->ltk->bdaddr_type = hcon->dst_type;
1257 bacpy(&smp->ltk->bdaddr, &hcon->dst);
53ac6ab6 1258 mgmt_new_ltk(hdev, smp->ltk, persistent);
35d70271
JH		 1259 }
1260
1261 if (smp->slave_ltk) {
1262 smp->slave_ltk->bdaddr_type = hcon->dst_type;
1263 bacpy(&smp->slave_ltk->bdaddr, &hcon->dst);
53ac6ab6 1264 mgmt_new_ltk(hdev, smp->slave_ltk, persistent);
35d70271
JH		 1265 }
1266}
1267
4bd6d38e 1268int smp_distribute_keys(struct l2cap_conn *conn)
7034b911
VCG		 1269{
1270 struct smp_cmd_pairing *req, *rsp;
1c1def09 1271 struct smp_chan *smp = conn->smp_chan;
524237cb
JH		 1272 struct hci_conn *hcon = conn->hcon;
1273 struct hci_dev *hdev = hcon->hdev;
38ccdc93 1274 bool ltk_encrypt;
7034b911
VCG		 1275 __u8 *keydist;
1276
4bd6d38e 1277 BT_DBG("conn %p", conn);
7034b911 1278
524237cb 1279 if (!test_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
d26a2345
VCG		 1280 return 0;
1281
1c1def09 1282 rsp = (void *) &smp->prsp[1];
7034b911
VCG		 1283
1284 /* The responder sends its keys first */
efabba37 1285 if (hcon->out && (smp->remote_key_dist & 0x07))
7034b911
VCG		 1286 return 0;
1287
1c1def09 1288 req = (void *) &smp->preq[1];
7034b911 1289
524237cb 1290 if (hcon->out) {
7034b911
VCG		 1291 keydist = &rsp->init_key_dist;
1292 *keydist &= req->init_key_dist;
1293 } else {
1294 keydist = &rsp->resp_key_dist;
1295 *keydist &= req->resp_key_dist;
1296 }
1297
7034b911
VCG		 1298 BT_DBG("keydist 0x%x", *keydist);
1299
1300 if (*keydist & SMP_DIST_ENC_KEY) {
1301 struct smp_cmd_encrypt_info enc;
1302 struct smp_cmd_master_ident ident;
23d0e128 1303 struct smp_ltk *ltk;
c9839a11 1304 u8 authenticated;
7034b911 1305 __le16 ediv;
fe39c7b2 1306 __le64 rand;
7034b911
VCG		 1307
1308 get_random_bytes(enc.ltk, sizeof(enc.ltk));
1309 get_random_bytes(&ediv, sizeof(ediv));
fe39c7b2 1310 get_random_bytes(&rand, sizeof(rand));
7034b911
VCG		 1311
1312 smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);
1313
c9839a11 1314 authenticated = hcon->sec_level == BT_SECURITY_HIGH;
524237cb 1315 ltk = hci_add_ltk(hdev, &hcon->dst, hcon->dst_type,
35d70271 1316 HCI_SMP_LTK_SLAVE, authenticated, enc.ltk,
fe39c7b2 1317 smp->enc_key_size, ediv, rand);
23d0e128 1318 smp->slave_ltk = ltk;
16b90839 1319
58115373 1320 ident.ediv = ediv;
fe39c7b2 1321 ident.rand = rand;
7034b911
VCG		 1322
1323 smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);
1324
1325 *keydist &= ~SMP_DIST_ENC_KEY;
1326 }
1327
1328 if (*keydist & SMP_DIST_ID_KEY) {
1329 struct smp_cmd_ident_addr_info addrinfo;
1330 struct smp_cmd_ident_info idinfo;
1331
863efaf2 1332 memcpy(idinfo.irk, hdev->irk, sizeof(idinfo.irk));
7034b911
VCG		 1333
1334 smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
1335
82d4b359
JH		 1336 /* The hci_conn contains the local identity address
1337 * after the connection has been established.
1338 *
1339 * This is true even when the connection has been
1340 * established using a resolvable random address.
1341 */
524237cb 1342 bacpy(&addrinfo.bdaddr, &hcon->src);
82d4b359 1343 addrinfo.addr_type = hcon->src_type;
7034b911
VCG		 1344
1345 smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
f1560463 1346 &addrinfo);
7034b911
VCG		 1347
1348 *keydist &= ~SMP_DIST_ID_KEY;
1349 }
1350
1351 if (*keydist & SMP_DIST_SIGN) {
1352 struct smp_cmd_sign_info sign;
7ee4ea36 1353 struct smp_csrk *csrk;
7034b911 1354
7ee4ea36 1355 /* Generate a new random key */
7034b911
VCG		 1356 get_random_bytes(sign.csrk, sizeof(sign.csrk));
1357
7ee4ea36
MH		 1358 csrk = kzalloc(sizeof(*csrk), GFP_KERNEL);
1359 if (csrk) {
1360 csrk->master = 0x00;
1361 memcpy(csrk->val, sign.csrk, sizeof(csrk->val));
1362 }
1363 smp->slave_csrk = csrk;
1364
7034b911
VCG		 1365 smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
1366
1367 *keydist &= ~SMP_DIST_SIGN;
1368 }
1369
efabba37
JH		 1370 /* If there are still keys to be received wait for them */
1371 if ((smp->remote_key_dist & 0x07))
1372 return 0;
1373
38ccdc93
JH		 1374 /* Check if we should try to re-encrypt the link with the LTK.
1375 * SMP_FLAG_LTK_ENCRYPT flag is used to track whether we've
1376 * already tried this (in which case we shouldn't try again).
1377 *
1378 * The request will trigger an encryption key refresh event
1379 * which will cause a call to auth_cfm and eventually lead to
1380 * l2cap_core.c calling this smp_distribute_keys function again
1381 * and thereby completing the process.
1382 */
1383 if (smp->ltk)
1384 ltk_encrypt = !test_and_set_bit(SMP_FLAG_LTK_ENCRYPT,
1385 &smp->smp_flags);
1386 else
1387 ltk_encrypt = false;
efabba37 1388
38ccdc93
JH		 1389 /* Re-encrypt the link with LTK if possible */
1390 if (ltk_encrypt && hcon->out) {
e3098be4
JH		 1391 queue_delayed_work(hdev->req_workqueue, &smp->reencrypt,
1392 SMP_REENCRYPT_TIMEOUT);
38ccdc93
JH		 1393 } else {
1394 clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags);
1395 cancel_delayed_work_sync(&conn->security_timer);
1396 set_bit(SMP_FLAG_COMPLETE, &smp->smp_flags);
1397 smp_notify_keys(conn);
1398 smp_chan_destroy(conn);
1399 }
d26a2345 1400
7034b911
VCG		 1401 return 0;
1402}
Linux kernel - Deliverables
This page took 0.386794 seconds and 5 git commands to generate.