Root/net/bluetooth/smp.c

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
23#include <linux/crypto.h>
24#include <linux/scatterlist.h>
25#include <crypto/b128ops.h>
26
27#include <net/bluetooth/bluetooth.h>
28#include <net/bluetooth/hci_core.h>
29#include <net/bluetooth/l2cap.h>
30#include <net/bluetooth/mgmt.h>
31
32#include "smp.h"
33
34#define SMP_TIMEOUT msecs_to_jiffies(30000)
35
36#define AUTH_REQ_MASK 0x07
37
38static inline void swap128(u8 src[16], u8 dst[16])
39{
40    int i;
41    for (i = 0; i < 16; i++)
42        dst[15 - i] = src[i];
43}
44
45static inline void swap56(u8 src[7], u8 dst[7])
46{
47    int i;
48    for (i = 0; i < 7; i++)
49        dst[6 - i] = src[i];
50}
51
52static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r)
53{
54    struct blkcipher_desc desc;
55    struct scatterlist sg;
56    int err, iv_len;
57    unsigned char iv[128];
58
59    if (tfm == NULL) {
60        BT_ERR("tfm %p", tfm);
61        return -EINVAL;
62    }
63
64    desc.tfm = tfm;
65    desc.flags = 0;
66
67    err = crypto_blkcipher_setkey(tfm, k, 16);
68    if (err) {
69        BT_ERR("cipher setkey failed: %d", err);
70        return err;
71    }
72
73    sg_init_one(&sg, r, 16);
74
75    iv_len = crypto_blkcipher_ivsize(tfm);
76    if (iv_len) {
77        memset(&iv, 0xff, iv_len);
78        crypto_blkcipher_set_iv(tfm, iv, iv_len);
79    }
80
81    err = crypto_blkcipher_encrypt(&desc, &sg, &sg, 16);
82    if (err)
83        BT_ERR("Encrypt data error %d", err);
84
85    return err;
86}
87
88static int smp_c1(struct crypto_blkcipher *tfm, u8 k[16], u8 r[16],
89          u8 preq[7], u8 pres[7], u8 _iat, bdaddr_t *ia,
90          u8 _rat, bdaddr_t *ra, u8 res[16])
91{
92    u8 p1[16], p2[16];
93    int err;
94
95    memset(p1, 0, 16);
96
97    /* p1 = pres || preq || _rat || _iat */
98    swap56(pres, p1);
99    swap56(preq, p1 + 7);
100    p1[14] = _rat;
101    p1[15] = _iat;
102
103    memset(p2, 0, 16);
104
105    /* p2 = padding || ia || ra */
106    baswap((bdaddr_t *) (p2 + 4), ia);
107    baswap((bdaddr_t *) (p2 + 10), ra);
108
109    /* res = r XOR p1 */
110    u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);
111
112    /* res = e(k, res) */
113    err = smp_e(tfm, k, res);
114    if (err) {
115        BT_ERR("Encrypt data error");
116        return err;
117    }
118
119    /* res = res XOR p2 */
120    u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);
121
122    /* res = e(k, res) */
123    err = smp_e(tfm, k, res);
124    if (err)
125        BT_ERR("Encrypt data error");
126
127    return err;
128}
129
130static int smp_s1(struct crypto_blkcipher *tfm, u8 k[16], u8 r1[16],
131          u8 r2[16], u8 _r[16])
132{
133    int err;
134
135    /* Just least significant octets from r1 and r2 are considered */
136    memcpy(_r, r1 + 8, 8);
137    memcpy(_r + 8, r2 + 8, 8);
138
139    err = smp_e(tfm, k, _r);
140    if (err)
141        BT_ERR("Encrypt data error");
142
143    return err;
144}
145
146static int smp_rand(u8 *buf)
147{
148    get_random_bytes(buf, 16);
149
150    return 0;
151}
152
153static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code,
154                     u16 dlen, void *data)
155{
156    struct sk_buff *skb;
157    struct l2cap_hdr *lh;
158    int len;
159
160    len = L2CAP_HDR_SIZE + sizeof(code) + dlen;
161
162    if (len > conn->mtu)
163        return NULL;
164
165    skb = bt_skb_alloc(len, GFP_ATOMIC);
166    if (!skb)
167        return NULL;
168
169    lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
170    lh->len = cpu_to_le16(sizeof(code) + dlen);
171    lh->cid = __constant_cpu_to_le16(L2CAP_CID_SMP);
172
173    memcpy(skb_put(skb, sizeof(code)), &code, sizeof(code));
174
175    memcpy(skb_put(skb, dlen), data, dlen);
176
177    return skb;
178}
179
180static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
181{
182    struct sk_buff *skb = smp_build_cmd(conn, code, len, data);
183
184    BT_DBG("code 0x%2.2x", code);
185
186    if (!skb)
187        return;
188
189    skb->priority = HCI_PRIO_MAX;
190    hci_send_acl(conn->hchan, skb, 0);
191
192    cancel_delayed_work_sync(&conn->security_timer);
193    schedule_delayed_work(&conn->security_timer, SMP_TIMEOUT);
194}
195
196static __u8 authreq_to_seclevel(__u8 authreq)
197{
198    if (authreq & SMP_AUTH_MITM)
199        return BT_SECURITY_HIGH;
200    else
201        return BT_SECURITY_MEDIUM;
202}
203
204static __u8 seclevel_to_authreq(__u8 sec_level)
205{
206    switch (sec_level) {
207    case BT_SECURITY_HIGH:
208        return SMP_AUTH_MITM | SMP_AUTH_BONDING;
209    case BT_SECURITY_MEDIUM:
210        return SMP_AUTH_BONDING;
211    default:
212        return SMP_AUTH_NONE;
213    }
214}
215
216static void build_pairing_cmd(struct l2cap_conn *conn,
217                  struct smp_cmd_pairing *req,
218                  struct smp_cmd_pairing *rsp, __u8 authreq)
219{
220    u8 dist_keys = 0;
221
222    if (test_bit(HCI_PAIRABLE, &conn->hcon->hdev->dev_flags)) {
223        dist_keys = SMP_DIST_ENC_KEY;
224        authreq |= SMP_AUTH_BONDING;
225    } else {
226        authreq &= ~SMP_AUTH_BONDING;
227    }
228
229    if (rsp == NULL) {
230        req->io_capability = conn->hcon->io_capability;
231        req->oob_flag = SMP_OOB_NOT_PRESENT;
232        req->max_key_size = SMP_MAX_ENC_KEY_SIZE;
233        req->init_key_dist = 0;
234        req->resp_key_dist = dist_keys;
235        req->auth_req = (authreq & AUTH_REQ_MASK);
236        return;
237    }
238
239    rsp->io_capability = conn->hcon->io_capability;
240    rsp->oob_flag = SMP_OOB_NOT_PRESENT;
241    rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
242    rsp->init_key_dist = 0;
243    rsp->resp_key_dist = req->resp_key_dist & dist_keys;
244    rsp->auth_req = (authreq & AUTH_REQ_MASK);
245}
246
247static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
248{
249    struct smp_chan *smp = conn->smp_chan;
250
251    if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) ||
252        (max_key_size < SMP_MIN_ENC_KEY_SIZE))
253        return SMP_ENC_KEY_SIZE;
254
255    smp->enc_key_size = max_key_size;
256
257    return 0;
258}
259
260static void smp_failure(struct l2cap_conn *conn, u8 reason, u8 send)
261{
262    struct hci_conn *hcon = conn->hcon;
263
264    if (send)
265        smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason),
266                 &reason);
267
268    clear_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags);
269    mgmt_auth_failed(hcon->hdev, &hcon->dst, hcon->type, hcon->dst_type,
270             HCI_ERROR_AUTH_FAILURE);
271
272    cancel_delayed_work_sync(&conn->security_timer);
273
274    if (test_and_clear_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
275        smp_chan_destroy(conn);
276}
277
278#define JUST_WORKS 0x00
279#define JUST_CFM 0x01
280#define REQ_PASSKEY 0x02
281#define CFM_PASSKEY 0x03
282#define REQ_OOB 0x04
283#define OVERLAP 0xFF
284
285static const u8 gen_method[5][5] = {
286    { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
287    { JUST_WORKS, JUST_CFM, REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
288    { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
289    { JUST_WORKS, JUST_CFM, JUST_WORKS, JUST_WORKS, JUST_CFM },
290    { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP },
291};
292
293static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth,
294                        u8 local_io, u8 remote_io)
295{
296    struct hci_conn *hcon = conn->hcon;
297    struct smp_chan *smp = conn->smp_chan;
298    u8 method;
299    u32 passkey = 0;
300    int ret = 0;
301
302    /* Initialize key for JUST WORKS */
303    memset(smp->tk, 0, sizeof(smp->tk));
304    clear_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
305
306    BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io);
307
308    /* If neither side wants MITM, use JUST WORKS */
309    /* If either side has unknown io_caps, use JUST WORKS */
310    /* Otherwise, look up method from the table */
311    if (!(auth & SMP_AUTH_MITM) ||
312        local_io > SMP_IO_KEYBOARD_DISPLAY ||
313        remote_io > SMP_IO_KEYBOARD_DISPLAY)
314        method = JUST_WORKS;
315    else
316        method = gen_method[remote_io][local_io];
317
318    /* If not bonding, don't ask user to confirm a Zero TK */
319    if (!(auth & SMP_AUTH_BONDING) && method == JUST_CFM)
320        method = JUST_WORKS;
321
322    /* If Just Works, Continue with Zero TK */
323    if (method == JUST_WORKS) {
324        set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
325        return 0;
326    }
327
328    /* Not Just Works/Confirm results in MITM Authentication */
329    if (method != JUST_CFM)
330        set_bit(SMP_FLAG_MITM_AUTH, &smp->smp_flags);
331
332    /* If both devices have Keyoard-Display I/O, the master
333     * Confirms and the slave Enters the passkey.
334     */
335    if (method == OVERLAP) {
336        if (hcon->link_mode & HCI_LM_MASTER)
337            method = CFM_PASSKEY;
338        else
339            method = REQ_PASSKEY;
340    }
341
342    /* Generate random passkey. Not valid until confirmed. */
343    if (method == CFM_PASSKEY) {
344        u8 key[16];
345
346        memset(key, 0, sizeof(key));
347        get_random_bytes(&passkey, sizeof(passkey));
348        passkey %= 1000000;
349        put_unaligned_le32(passkey, key);
350        swap128(key, smp->tk);
351        BT_DBG("PassKey: %d", passkey);
352    }
353
354    hci_dev_lock(hcon->hdev);
355
356    if (method == REQ_PASSKEY)
357        ret = mgmt_user_passkey_request(hcon->hdev, &hcon->dst,
358                        hcon->type, hcon->dst_type);
359    else
360        ret = mgmt_user_confirm_request(hcon->hdev, &hcon->dst,
361                        hcon->type, hcon->dst_type,
362                        cpu_to_le32(passkey), 0);
363
364    hci_dev_unlock(hcon->hdev);
365
366    return ret;
367}
368
369static void confirm_work(struct work_struct *work)
370{
371    struct smp_chan *smp = container_of(work, struct smp_chan, confirm);
372    struct l2cap_conn *conn = smp->conn;
373    struct crypto_blkcipher *tfm;
374    struct smp_cmd_pairing_confirm cp;
375    int ret;
376    u8 res[16], reason;
377
378    BT_DBG("conn %p", conn);
379
380    tfm = crypto_alloc_blkcipher("ecb(aes)", 0, CRYPTO_ALG_ASYNC);
381    if (IS_ERR(tfm)) {
382        reason = SMP_UNSPECIFIED;
383        goto error;
384    }
385
386    smp->tfm = tfm;
387
388    if (conn->hcon->out)
389        ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp,
390                 conn->hcon->src_type, &conn->hcon->src,
391                 conn->hcon->dst_type, &conn->hcon->dst, res);
392    else
393        ret = smp_c1(tfm, smp->tk, smp->prnd, smp->preq, smp->prsp,
394                 conn->hcon->dst_type, &conn->hcon->dst,
395                 conn->hcon->src_type, &conn->hcon->src, res);
396    if (ret) {
397        reason = SMP_UNSPECIFIED;
398        goto error;
399    }
400
401    clear_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
402
403    swap128(res, cp.confirm_val);
404    smp_send_cmd(smp->conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
405
406    return;
407
408error:
409    smp_failure(conn, reason, 1);
410}
411
412static void random_work(struct work_struct *work)
413{
414    struct smp_chan *smp = container_of(work, struct smp_chan, random);
415    struct l2cap_conn *conn = smp->conn;
416    struct hci_conn *hcon = conn->hcon;
417    struct crypto_blkcipher *tfm = smp->tfm;
418    u8 reason, confirm[16], res[16], key[16];
419    int ret;
420
421    if (IS_ERR_OR_NULL(tfm)) {
422        reason = SMP_UNSPECIFIED;
423        goto error;
424    }
425
426    BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
427
428    if (hcon->out)
429        ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp,
430                 hcon->src_type, &hcon->src,
431                 hcon->dst_type, &hcon->dst, res);
432    else
433        ret = smp_c1(tfm, smp->tk, smp->rrnd, smp->preq, smp->prsp,
434                 hcon->dst_type, &hcon->dst,
435                 hcon->src_type, &hcon->src, res);
436    if (ret) {
437        reason = SMP_UNSPECIFIED;
438        goto error;
439    }
440
441    swap128(res, confirm);
442
443    if (memcmp(smp->pcnf, confirm, sizeof(smp->pcnf)) != 0) {
444        BT_ERR("Pairing failed (confirmation values mismatch)");
445        reason = SMP_CONFIRM_FAILED;
446        goto error;
447    }
448
449    if (hcon->out) {
450        u8 stk[16], rand[8];
451        __le16 ediv;
452
453        memset(rand, 0, sizeof(rand));
454        ediv = 0;
455
456        smp_s1(tfm, smp->tk, smp->rrnd, smp->prnd, key);
457        swap128(key, stk);
458
459        memset(stk + smp->enc_key_size, 0,
460               SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
461
462        if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags)) {
463            reason = SMP_UNSPECIFIED;
464            goto error;
465        }
466
467        hci_le_start_enc(hcon, ediv, rand, stk);
468        hcon->enc_key_size = smp->enc_key_size;
469    } else {
470        u8 stk[16], r[16], rand[8];
471        __le16 ediv;
472
473        memset(rand, 0, sizeof(rand));
474        ediv = 0;
475
476        swap128(smp->prnd, r);
477        smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(r), r);
478
479        smp_s1(tfm, smp->tk, smp->prnd, smp->rrnd, key);
480        swap128(key, stk);
481
482        memset(stk + smp->enc_key_size, 0,
483               SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
484
485        hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
486                HCI_SMP_STK_SLAVE, 0, 0, stk, smp->enc_key_size,
487                ediv, rand);
488    }
489
490    return;
491
492error:
493    smp_failure(conn, reason, 1);
494}
495
496static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
497{
498    struct smp_chan *smp;
499
500    smp = kzalloc(sizeof(*smp), GFP_ATOMIC);
501    if (!smp)
502        return NULL;
503
504    INIT_WORK(&smp->confirm, confirm_work);
505    INIT_WORK(&smp->random, random_work);
506
507    smp->conn = conn;
508    conn->smp_chan = smp;
509    conn->hcon->smp_conn = conn;
510
511    hci_conn_hold(conn->hcon);
512
513    return smp;
514}
515
516void smp_chan_destroy(struct l2cap_conn *conn)
517{
518    struct smp_chan *smp = conn->smp_chan;
519
520    BUG_ON(!smp);
521
522    if (smp->tfm)
523        crypto_free_blkcipher(smp->tfm);
524
525    kfree(smp);
526    conn->smp_chan = NULL;
527    conn->hcon->smp_conn = NULL;
528    hci_conn_drop(conn->hcon);
529}
530
531int smp_user_confirm_reply(struct hci_conn *hcon, u16 mgmt_op, __le32 passkey)
532{
533    struct l2cap_conn *conn = hcon->smp_conn;
534    struct smp_chan *smp;
535    u32 value;
536    u8 key[16];
537
538    BT_DBG("");
539
540    if (!conn)
541        return -ENOTCONN;
542
543    smp = conn->smp_chan;
544
545    switch (mgmt_op) {
546    case MGMT_OP_USER_PASSKEY_REPLY:
547        value = le32_to_cpu(passkey);
548        memset(key, 0, sizeof(key));
549        BT_DBG("PassKey: %d", value);
550        put_unaligned_le32(value, key);
551        swap128(key, smp->tk);
552        /* Fall Through */
553    case MGMT_OP_USER_CONFIRM_REPLY:
554        set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
555        break;
556    case MGMT_OP_USER_PASSKEY_NEG_REPLY:
557    case MGMT_OP_USER_CONFIRM_NEG_REPLY:
558        smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED, 1);
559        return 0;
560    default:
561        smp_failure(conn, SMP_PASSKEY_ENTRY_FAILED, 1);
562        return -EOPNOTSUPP;
563    }
564
565    /* If it is our turn to send Pairing Confirm, do so now */
566    if (test_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags))
567        queue_work(hcon->hdev->workqueue, &smp->confirm);
568
569    return 0;
570}
571
572static u8 smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
573{
574    struct smp_cmd_pairing rsp, *req = (void *) skb->data;
575    struct smp_chan *smp;
576    u8 key_size;
577    u8 auth = SMP_AUTH_NONE;
578    int ret;
579
580    BT_DBG("conn %p", conn);
581
582    if (conn->hcon->link_mode & HCI_LM_MASTER)
583        return SMP_CMD_NOTSUPP;
584
585    if (!test_and_set_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags))
586        smp = smp_chan_create(conn);
587    else
588        smp = conn->smp_chan;
589
590    if (!smp)
591        return SMP_UNSPECIFIED;
592
593    smp->preq[0] = SMP_CMD_PAIRING_REQ;
594    memcpy(&smp->preq[1], req, sizeof(*req));
595    skb_pull(skb, sizeof(*req));
596
597    /* We didn't start the pairing, so match remote */
598    if (req->auth_req & SMP_AUTH_BONDING)
599        auth = req->auth_req;
600
601    conn->hcon->pending_sec_level = authreq_to_seclevel(auth);
602
603    build_pairing_cmd(conn, req, &rsp, auth);
604
605    key_size = min(req->max_key_size, rsp.max_key_size);
606    if (check_enc_key_size(conn, key_size))
607        return SMP_ENC_KEY_SIZE;
608
609    ret = smp_rand(smp->prnd);
610    if (ret)
611        return SMP_UNSPECIFIED;
612
613    smp->prsp[0] = SMP_CMD_PAIRING_RSP;
614    memcpy(&smp->prsp[1], &rsp, sizeof(rsp));
615
616    smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(rsp), &rsp);
617
618    /* Request setup of TK */
619    ret = tk_request(conn, 0, auth, rsp.io_capability, req->io_capability);
620    if (ret)
621        return SMP_UNSPECIFIED;
622
623    return 0;
624}
625
626static u8 smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
627{
628    struct smp_cmd_pairing *req, *rsp = (void *) skb->data;
629    struct smp_chan *smp = conn->smp_chan;
630    struct hci_dev *hdev = conn->hcon->hdev;
631    u8 key_size, auth = SMP_AUTH_NONE;
632    int ret;
633
634    BT_DBG("conn %p", conn);
635
636    if (!(conn->hcon->link_mode & HCI_LM_MASTER))
637        return SMP_CMD_NOTSUPP;
638
639    skb_pull(skb, sizeof(*rsp));
640
641    req = (void *) &smp->preq[1];
642
643    key_size = min(req->max_key_size, rsp->max_key_size);
644    if (check_enc_key_size(conn, key_size))
645        return SMP_ENC_KEY_SIZE;
646
647    ret = smp_rand(smp->prnd);
648    if (ret)
649        return SMP_UNSPECIFIED;
650
651    smp->prsp[0] = SMP_CMD_PAIRING_RSP;
652    memcpy(&smp->prsp[1], rsp, sizeof(*rsp));
653
654    if ((req->auth_req & SMP_AUTH_BONDING) &&
655        (rsp->auth_req & SMP_AUTH_BONDING))
656        auth = SMP_AUTH_BONDING;
657
658    auth |= (req->auth_req | rsp->auth_req) & SMP_AUTH_MITM;
659
660    ret = tk_request(conn, 0, auth, req->io_capability, rsp->io_capability);
661    if (ret)
662        return SMP_UNSPECIFIED;
663
664    set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
665
666    /* Can't compose response until we have been confirmed */
667    if (!test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags))
668        return 0;
669
670    queue_work(hdev->workqueue, &smp->confirm);
671
672    return 0;
673}
674
675static u8 smp_cmd_pairing_confirm(struct l2cap_conn *conn, struct sk_buff *skb)
676{
677    struct smp_chan *smp = conn->smp_chan;
678    struct hci_dev *hdev = conn->hcon->hdev;
679
680    BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
681
682    memcpy(smp->pcnf, skb->data, sizeof(smp->pcnf));
683    skb_pull(skb, sizeof(smp->pcnf));
684
685    if (conn->hcon->out) {
686        u8 random[16];
687
688        swap128(smp->prnd, random);
689        smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(random),
690                 random);
691    } else if (test_bit(SMP_FLAG_TK_VALID, &smp->smp_flags)) {
692        queue_work(hdev->workqueue, &smp->confirm);
693    } else {
694        set_bit(SMP_FLAG_CFM_PENDING, &smp->smp_flags);
695    }
696
697    return 0;
698}
699
700static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
701{
702    struct smp_chan *smp = conn->smp_chan;
703    struct hci_dev *hdev = conn->hcon->hdev;
704
705    BT_DBG("conn %p", conn);
706
707    swap128(skb->data, smp->rrnd);
708    skb_pull(skb, sizeof(smp->rrnd));
709
710    queue_work(hdev->workqueue, &smp->random);
711
712    return 0;
713}
714
715static u8 smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
716{
717    struct smp_ltk *key;
718    struct hci_conn *hcon = conn->hcon;
719
720    key = hci_find_ltk_by_addr(hcon->hdev, &hcon->dst, hcon->dst_type);
721    if (!key)
722        return 0;
723
724    if (sec_level > BT_SECURITY_MEDIUM && !key->authenticated)
725        return 0;
726
727    if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
728        return 1;
729
730    hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
731    hcon->enc_key_size = key->enc_size;
732
733    return 1;
734}
735
736static u8 smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
737{
738    struct smp_cmd_security_req *rp = (void *) skb->data;
739    struct smp_cmd_pairing cp;
740    struct hci_conn *hcon = conn->hcon;
741    struct smp_chan *smp;
742
743    BT_DBG("conn %p", conn);
744
745    if (!(conn->hcon->link_mode & HCI_LM_MASTER))
746        return SMP_CMD_NOTSUPP;
747
748    hcon->pending_sec_level = authreq_to_seclevel(rp->auth_req);
749
750    if (smp_ltk_encrypt(conn, hcon->pending_sec_level))
751        return 0;
752
753    if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
754        return 0;
755
756    smp = smp_chan_create(conn);
757
758    skb_pull(skb, sizeof(*rp));
759
760    memset(&cp, 0, sizeof(cp));
761    build_pairing_cmd(conn, &cp, NULL, rp->auth_req);
762
763    smp->preq[0] = SMP_CMD_PAIRING_REQ;
764    memcpy(&smp->preq[1], &cp, sizeof(cp));
765
766    smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
767
768    return 0;
769}
770
771int smp_conn_security(struct hci_conn *hcon, __u8 sec_level)
772{
773    struct l2cap_conn *conn = hcon->l2cap_data;
774    struct smp_chan *smp = conn->smp_chan;
775    __u8 authreq;
776
777    BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
778
779    if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags))
780        return 1;
781
782    if (sec_level == BT_SECURITY_LOW)
783        return 1;
784
785    if (hcon->sec_level >= sec_level)
786        return 1;
787
788    if (hcon->link_mode & HCI_LM_MASTER)
789        if (smp_ltk_encrypt(conn, sec_level))
790            goto done;
791
792    if (test_and_set_bit(HCI_CONN_LE_SMP_PEND, &hcon->flags))
793        return 0;
794
795    smp = smp_chan_create(conn);
796    if (!smp)
797        return 1;
798
799    authreq = seclevel_to_authreq(sec_level);
800
801    if (hcon->link_mode & HCI_LM_MASTER) {
802        struct smp_cmd_pairing cp;
803
804        build_pairing_cmd(conn, &cp, NULL, authreq);
805        smp->preq[0] = SMP_CMD_PAIRING_REQ;
806        memcpy(&smp->preq[1], &cp, sizeof(cp));
807
808        smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
809    } else {
810        struct smp_cmd_security_req cp;
811        cp.auth_req = authreq;
812        smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
813    }
814
815done:
816    hcon->pending_sec_level = sec_level;
817
818    return 0;
819}
820
821static int smp_cmd_encrypt_info(struct l2cap_conn *conn, struct sk_buff *skb)
822{
823    struct smp_cmd_encrypt_info *rp = (void *) skb->data;
824    struct smp_chan *smp = conn->smp_chan;
825
826    skb_pull(skb, sizeof(*rp));
827
828    memcpy(smp->tk, rp->ltk, sizeof(smp->tk));
829
830    return 0;
831}
832
833static int smp_cmd_master_ident(struct l2cap_conn *conn, struct sk_buff *skb)
834{
835    struct smp_cmd_master_ident *rp = (void *) skb->data;
836    struct smp_chan *smp = conn->smp_chan;
837    struct hci_dev *hdev = conn->hcon->hdev;
838    struct hci_conn *hcon = conn->hcon;
839    u8 authenticated;
840
841    skb_pull(skb, sizeof(*rp));
842
843    hci_dev_lock(hdev);
844    authenticated = (hcon->sec_level == BT_SECURITY_HIGH);
845    hci_add_ltk(hdev, &hcon->dst, hcon->dst_type, HCI_SMP_LTK, 1,
846            authenticated, smp->tk, smp->enc_key_size,
847            rp->ediv, rp->rand);
848    smp_distribute_keys(conn, 1);
849    hci_dev_unlock(hdev);
850
851    return 0;
852}
853
854int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
855{
856    struct hci_conn *hcon = conn->hcon;
857    __u8 code, reason;
858    int err = 0;
859
860    if (hcon->type != LE_LINK) {
861        kfree_skb(skb);
862        return 0;
863    }
864
865    if (skb->len < 1) {
866        kfree_skb(skb);
867        return -EILSEQ;
868    }
869
870    if (!test_bit(HCI_LE_ENABLED, &hcon->hdev->dev_flags)) {
871        err = -ENOTSUPP;
872        reason = SMP_PAIRING_NOTSUPP;
873        goto done;
874    }
875
876    code = skb->data[0];
877    skb_pull(skb, sizeof(code));
878
879    /*
880     * The SMP context must be initialized for all other PDUs except
881     * pairing and security requests. If we get any other PDU when
882     * not initialized simply disconnect (done if this function
883     * returns an error).
884     */
885    if (code != SMP_CMD_PAIRING_REQ && code != SMP_CMD_SECURITY_REQ &&
886        !conn->smp_chan) {
887        BT_ERR("Unexpected SMP command 0x%02x. Disconnecting.", code);
888        kfree_skb(skb);
889        return -ENOTSUPP;
890    }
891
892    switch (code) {
893    case SMP_CMD_PAIRING_REQ:
894        reason = smp_cmd_pairing_req(conn, skb);
895        break;
896
897    case SMP_CMD_PAIRING_FAIL:
898        smp_failure(conn, skb->data[0], 0);
899        reason = 0;
900        err = -EPERM;
901        break;
902
903    case SMP_CMD_PAIRING_RSP:
904        reason = smp_cmd_pairing_rsp(conn, skb);
905        break;
906
907    case SMP_CMD_SECURITY_REQ:
908        reason = smp_cmd_security_req(conn, skb);
909        break;
910
911    case SMP_CMD_PAIRING_CONFIRM:
912        reason = smp_cmd_pairing_confirm(conn, skb);
913        break;
914
915    case SMP_CMD_PAIRING_RANDOM:
916        reason = smp_cmd_pairing_random(conn, skb);
917        break;
918
919    case SMP_CMD_ENCRYPT_INFO:
920        reason = smp_cmd_encrypt_info(conn, skb);
921        break;
922
923    case SMP_CMD_MASTER_IDENT:
924        reason = smp_cmd_master_ident(conn, skb);
925        break;
926
927    case SMP_CMD_IDENT_INFO:
928    case SMP_CMD_IDENT_ADDR_INFO:
929    case SMP_CMD_SIGN_INFO:
930        /* Just ignored */
931        reason = 0;
932        break;
933
934    default:
935        BT_DBG("Unknown command code 0x%2.2x", code);
936
937        reason = SMP_CMD_NOTSUPP;
938        err = -EOPNOTSUPP;
939        goto done;
940    }
941
942done:
943    if (reason)
944        smp_failure(conn, reason, 1);
945
946    kfree_skb(skb);
947    return err;
948}
949
950int smp_distribute_keys(struct l2cap_conn *conn, __u8 force)
951{
952    struct smp_cmd_pairing *req, *rsp;
953    struct smp_chan *smp = conn->smp_chan;
954    __u8 *keydist;
955
956    BT_DBG("conn %p force %d", conn, force);
957
958    if (!test_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags))
959        return 0;
960
961    rsp = (void *) &smp->prsp[1];
962
963    /* The responder sends its keys first */
964    if (!force && conn->hcon->out && (rsp->resp_key_dist & 0x07))
965        return 0;
966
967    req = (void *) &smp->preq[1];
968
969    if (conn->hcon->out) {
970        keydist = &rsp->init_key_dist;
971        *keydist &= req->init_key_dist;
972    } else {
973        keydist = &rsp->resp_key_dist;
974        *keydist &= req->resp_key_dist;
975    }
976
977
978    BT_DBG("keydist 0x%x", *keydist);
979
980    if (*keydist & SMP_DIST_ENC_KEY) {
981        struct smp_cmd_encrypt_info enc;
982        struct smp_cmd_master_ident ident;
983        struct hci_conn *hcon = conn->hcon;
984        u8 authenticated;
985        __le16 ediv;
986
987        get_random_bytes(enc.ltk, sizeof(enc.ltk));
988        get_random_bytes(&ediv, sizeof(ediv));
989        get_random_bytes(ident.rand, sizeof(ident.rand));
990
991        smp_send_cmd(conn, SMP_CMD_ENCRYPT_INFO, sizeof(enc), &enc);
992
993        authenticated = hcon->sec_level == BT_SECURITY_HIGH;
994        hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
995                HCI_SMP_LTK_SLAVE, 1, authenticated,
996                enc.ltk, smp->enc_key_size, ediv, ident.rand);
997
998        ident.ediv = ediv;
999
1000        smp_send_cmd(conn, SMP_CMD_MASTER_IDENT, sizeof(ident), &ident);
1001
1002        *keydist &= ~SMP_DIST_ENC_KEY;
1003    }
1004
1005    if (*keydist & SMP_DIST_ID_KEY) {
1006        struct smp_cmd_ident_addr_info addrinfo;
1007        struct smp_cmd_ident_info idinfo;
1008
1009        /* Send a dummy key */
1010        get_random_bytes(idinfo.irk, sizeof(idinfo.irk));
1011
1012        smp_send_cmd(conn, SMP_CMD_IDENT_INFO, sizeof(idinfo), &idinfo);
1013
1014        /* Just public address */
1015        memset(&addrinfo, 0, sizeof(addrinfo));
1016        bacpy(&addrinfo.bdaddr, &conn->hcon->src);
1017
1018        smp_send_cmd(conn, SMP_CMD_IDENT_ADDR_INFO, sizeof(addrinfo),
1019                 &addrinfo);
1020
1021        *keydist &= ~SMP_DIST_ID_KEY;
1022    }
1023
1024    if (*keydist & SMP_DIST_SIGN) {
1025        struct smp_cmd_sign_info sign;
1026
1027        /* Send a dummy key */
1028        get_random_bytes(sign.csrk, sizeof(sign.csrk));
1029
1030        smp_send_cmd(conn, SMP_CMD_SIGN_INFO, sizeof(sign), &sign);
1031
1032        *keydist &= ~SMP_DIST_SIGN;
1033    }
1034
1035    if (conn->hcon->out || force) {
1036        clear_bit(HCI_CONN_LE_SMP_PEND, &conn->hcon->flags);
1037        cancel_delayed_work_sync(&conn->security_timer);
1038        smp_chan_destroy(conn);
1039    }
1040
1041    return 0;
1042}
1043

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive