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