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