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