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