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 <net/bluetooth/bluetooth.h>
  24 #include <net/bluetooth/hci_core.h>
  25 #include <net/bluetooth/l2cap.h>
  26 #include <net/bluetooth/smp.h>
  27 #include <linux/crypto.h>
  28 #include <crypto/b128ops.h>
  29
  30 static inline void swap128(u8 src[16], u8 dst[16])
  31 {
  32         int i;
  33         for (i = 0; i < 16; i++)
  34                 dst[15 - i] = src[i];
  35 }
  36
  37 static inline void swap56(u8 src[7], u8 dst[7])
  38 {
  39         int i;
  40         for (i = 0; i < 7; i++)
  41                 dst[6 - i] = src[i];
  42 }
  43
  44 static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r)
  45 {
  46         struct blkcipher_desc desc;
  47         struct scatterlist sg;
  48         int err, iv_len;
  49         unsigned char iv[128];
  50
  51         if (tfm == NULL) {
  52                 BT_ERR("tfm %p", tfm);
  53                 return -EINVAL;
  54         }
  55
  56         desc.tfm = tfm;
  57         desc.flags = 0;
  58
  59         err = crypto_blkcipher_setkey(tfm, k, 16);
  60         if (err) {
  61                 BT_ERR("cipher setkey failed: %d", err);
  62                 return err;
  63         }
  64
  65         sg_init_one(&sg, r, 16);
  66
  67         iv_len = crypto_blkcipher_ivsize(tfm);
  68         if (iv_len) {
  69                 memset(&iv, 0xff, iv_len);
  70                 crypto_blkcipher_set_iv(tfm, iv, iv_len);
  71         }
  72
  73         err = crypto_blkcipher_encrypt(&desc, &sg, &sg, 16);
  74         if (err)
  75                 BT_ERR("Encrypt data error %d", err);
  76
  77         return err;
  78 }
  79
  80 static int smp_c1(struct crypto_blkcipher *tfm, u8 k[16], u8 r[16],
  81                 u8 preq[7], u8 pres[7], u8 _iat, bdaddr_t *ia,
  82                 u8 _rat, bdaddr_t *ra, u8 res[16])
  83 {
  84         u8 p1[16], p2[16];
  85         int err;
  86
  87         memset(p1, 0, 16);
  88
  89         /* p1 = pres || preq || _rat || _iat */
  90         swap56(pres, p1);
  91         swap56(preq, p1 + 7);
  92         p1[14] = _rat;
  93         p1[15] = _iat;
  94
  95         memset(p2, 0, 16);
  96
  97         /* p2 = padding || ia || ra */
  98         baswap((bdaddr_t *) (p2 + 4), ia);
  99         baswap((bdaddr_t *) (p2 + 10), ra);
 100
 101         /* res = r XOR p1 */
 102         u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);
 103
 104         /* res = e(k, res) */
 105         err = smp_e(tfm, k, res);
 106         if (err) {
 107                 BT_ERR("Encrypt data error");
 108                 return err;
 109         }
 110
 111         /* res = res XOR p2 */
 112         u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);
 113
 114         /* res = e(k, res) */
 115         err = smp_e(tfm, k, res);
 116         if (err)
 117                 BT_ERR("Encrypt data error");
 118
 119         return err;
 120 }
 121
 122 static int smp_s1(struct crypto_blkcipher *tfm, u8 k[16],
 123                         u8 r1[16], u8 r2[16], u8 _r[16])
 124 {
 125         int err;
 126
 127         /* Just least significant octets from r1 and r2 are considered */
 128         memcpy(_r, r1 + 8, 8);
 129         memcpy(_r + 8, r2 + 8, 8);
 130
 131         err = smp_e(tfm, k, _r);
 132         if (err)
 133                 BT_ERR("Encrypt data error");
 134
 135         return err;
 136 }
 137
 138 static int smp_rand(u8 *buf)
 139 {
 140         get_random_bytes(buf, 16);
 141
 142         return 0;
 143 }
 144
 145 static struct sk_buff *smp_build_cmd(struct l2cap_conn *conn, u8 code,
 146                                                 u16 dlen, void *data)
 147 {
 148         struct sk_buff *skb;
 149         struct l2cap_hdr *lh;
 150         int len;
 151
 152         len = L2CAP_HDR_SIZE + sizeof(code) + dlen;
 153
 154         if (len > conn->mtu)
 155                 return NULL;
 156
 157         skb = bt_skb_alloc(len, GFP_ATOMIC);
 158         if (!skb)
 159                 return NULL;
 160
 161         lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
 162         lh->len = cpu_to_le16(sizeof(code) + dlen);
 163         lh->cid = cpu_to_le16(L2CAP_CID_SMP);
 164
 165         memcpy(skb_put(skb, sizeof(code)), &code, sizeof(code));
 166
 167         memcpy(skb_put(skb, dlen), data, dlen);
 168
 169         return skb;
 170 }
 171
 172 static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
 173 {
 174         struct sk_buff *skb = smp_build_cmd(conn, code, len, data);
 175
 176         BT_DBG("code 0x%2.2x", code);
 177
 178         if (!skb)
 179                 return;
 180
 181         hci_send_acl(conn->hcon, skb, 0);
 182 }
 183
 184 static void smp_cmd_pairing_req(struct l2cap_conn *conn, struct sk_buff *skb)
 185 {
 186         struct smp_cmd_pairing *rp = (void *) skb->data;
 187
 188         BT_DBG("conn %p", conn);
 189
 190         skb_pull(skb, sizeof(*rp));
 191
 192         rp->io_capability = 0x00;
 193         rp->oob_flag = 0x00;
 194         rp->max_key_size = 16;
 195         rp->init_key_dist = 0x00;
 196         rp->resp_key_dist = 0x00;
 197         rp->auth_req &= (SMP_AUTH_BONDING | SMP_AUTH_MITM);
 198
 199         smp_send_cmd(conn, SMP_CMD_PAIRING_RSP, sizeof(*rp), rp);
 200 }
 201
 202 static void smp_cmd_pairing_rsp(struct l2cap_conn *conn, struct sk_buff *skb)
 203 {
 204         struct smp_cmd_pairing_confirm cp;
 205
 206         BT_DBG("conn %p", conn);
 207
 208         memset(&cp, 0, sizeof(cp));
 209
 210         smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(cp), &cp);
 211 }
 212
 213 static void smp_cmd_pairing_confirm(struct l2cap_conn *conn,
 214                                                         struct sk_buff *skb)
 215 {
 216         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
 217
 218         if (conn->hcon->out) {
 219                 struct smp_cmd_pairing_random random;
 220
 221                 memset(&random, 0, sizeof(random));
 222
 223                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(random),
 224                                                                 &random);
 225         } else {
 226                 struct smp_cmd_pairing_confirm confirm;
 227
 228                 memset(&confirm, 0, sizeof(confirm));
 229
 230                 smp_send_cmd(conn, SMP_CMD_PAIRING_CONFIRM, sizeof(confirm),
 231                                                                 &confirm);
 232         }
 233 }
 234
 235 static void smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
 236 {
 237         struct smp_cmd_pairing_random cp;
 238
 239         BT_DBG("conn %p %s", conn, conn->hcon->out ? "master" : "slave");
 240
 241         skb_pull(skb, sizeof(cp));
 242
 243         if (conn->hcon->out) {
 244                 /* FIXME: start encryption */
 245         } else {
 246                 memset(&cp, 0, sizeof(cp));
 247
 248                 smp_send_cmd(conn, SMP_CMD_PAIRING_RANDOM, sizeof(cp), &cp);
 249         }
 250 }
 251
 252 static void smp_cmd_security_req(struct l2cap_conn *conn, struct sk_buff *skb)
 253 {
 254         struct smp_cmd_security_req *rp = (void *) skb->data;
 255         struct smp_cmd_pairing cp;
 256
 257         BT_DBG("conn %p", conn);
 258
 259         skb_pull(skb, sizeof(*rp));
 260         memset(&cp, 0, sizeof(cp));
 261
 262         cp.io_capability = 0x00;
 263         cp.oob_flag = 0x00;
 264         cp.max_key_size = 16;
 265         cp.init_key_dist = 0x00;
 266         cp.resp_key_dist = 0x00;
 267         cp.auth_req = rp->auth_req & (SMP_AUTH_BONDING | SMP_AUTH_MITM);
 268
 269         smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
 270 }
 271
 272 int smp_conn_security(struct l2cap_conn *conn, __u8 sec_level)
 273 {
 274         struct hci_conn *hcon = conn->hcon;
 275         __u8 authreq;
 276
 277         BT_DBG("conn %p hcon %p level 0x%2.2x", conn, hcon, sec_level);
 278
 279         if (IS_ERR(hcon->hdev->tfm))
 280                 return 1;
 281
 282         switch (sec_level) {
 283         case BT_SECURITY_MEDIUM:
 284                 /* Encrypted, no MITM protection */
 285                 authreq = HCI_AT_NO_BONDING_MITM;
 286                 break;
 287
 288         case BT_SECURITY_HIGH:
 289                 /* Bonding, MITM protection */
 290                 authreq = HCI_AT_GENERAL_BONDING_MITM;
 291                 break;
 292
 293         case BT_SECURITY_LOW:
 294         default:
 295                 return 1;
 296         }
 297
 298         if (hcon->link_mode & HCI_LM_MASTER) {
 299                 struct smp_cmd_pairing cp;
 300                 cp.io_capability = 0x00;
 301                 cp.oob_flag = 0x00;
 302                 cp.max_key_size = 16;
 303                 cp.init_key_dist = 0x00;
 304                 cp.resp_key_dist = 0x00;
 305                 cp.auth_req = authreq;
 306                 smp_send_cmd(conn, SMP_CMD_PAIRING_REQ, sizeof(cp), &cp);
 307         } else {
 308                 struct smp_cmd_security_req cp;
 309                 cp.auth_req = authreq;
 310                 smp_send_cmd(conn, SMP_CMD_SECURITY_REQ, sizeof(cp), &cp);
 311         }
 312
 313         return 0;
 314 }
 315
 316 int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
 317 {
 318         __u8 code = skb->data[0];
 319         __u8 reason;
 320         int err = 0;
 321
 322         if (IS_ERR(conn->hcon->hdev->tfm)) {
 323                 err = PTR_ERR(conn->hcon->hdev->tfm);
 324                 reason = SMP_PAIRING_NOTSUPP;
 325                 goto done;
 326         }
 327
 328         skb_pull(skb, sizeof(code));
 329
 330         switch (code) {
 331         case SMP_CMD_PAIRING_REQ:
 332                 smp_cmd_pairing_req(conn, skb);
 333                 break;
 334
 335         case SMP_CMD_PAIRING_FAIL:
 336                 break;
 337
 338         case SMP_CMD_PAIRING_RSP:
 339                 smp_cmd_pairing_rsp(conn, skb);
 340                 break;
 341
 342         case SMP_CMD_SECURITY_REQ:
 343                 smp_cmd_security_req(conn, skb);
 344                 break;
 345
 346         case SMP_CMD_PAIRING_CONFIRM:
 347                 smp_cmd_pairing_confirm(conn, skb);
 348                 break;
 349
 350         case SMP_CMD_PAIRING_RANDOM:
 351                 smp_cmd_pairing_random(conn, skb);
 352                 break;
 353
 354         case SMP_CMD_ENCRYPT_INFO:
 355         case SMP_CMD_MASTER_IDENT:
 356         case SMP_CMD_IDENT_INFO:
 357         case SMP_CMD_IDENT_ADDR_INFO:
 358         case SMP_CMD_SIGN_INFO:
 359         default:
 360                 BT_DBG("Unknown command code 0x%2.2x", code);
 361
 362                 reason = SMP_CMD_NOTSUPP;
 363                 err = -EOPNOTSUPP;
 364                 goto done;
 365         }
 366
 367 done:
 368         if (reason)
 369                 smp_send_cmd(conn, SMP_CMD_PAIRING_FAIL, sizeof(reason),
 370                                                                 &reason);
 371
 372         kfree_skb(skb);
 373         return err;
 374 }