Bluetooth: Add MITM mechanism to LE-SMP

To achive Man-In-The-Middle (MITM) level security with Low Energy,
we have to enable User Passkey Comparison.  This commit modifies the
hard-coded JUST-WORKS pairing mechanism to support query via the MGMT
interface of Passkey comparison and User Confirmation.

Signed-off-by: Brian Gix <bgix@codeaurora.org>
Acked-by: Marcel Holtmann<marcel@holtmann.org>
Signed-off-by: Gustavo F. Padovan <padovan@profusion.mobi>

3 files changed, 211 insertions, 22 deletions

diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index 5ce73dbaf604..4ff08d61eea5 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -310,6 +310,7 @@ struct hci_conn {
         struct hci_dev  *hdev;
         void            *l2cap_data;
         void            *sco_data;
+        void            *smp_conn;
 
         struct hci_conn *link;
 
diff --git a/include/net/bluetooth/smp.h b/include/net/bluetooth/smp.h
index 15b97d549441..aeaf5fa2b9f1 100644
--- a/include/net/bluetooth/smp.h
+++ b/include/net/bluetooth/smp.h
@@ -115,6 +115,10 @@ struct smp_cmd_security_req {
 #define SMP_MIN_ENC_KEY_SIZE            7
 #define SMP_MAX_ENC_KEY_SIZE            16
 
+#define SMP_FLAG_TK_VALID       1
+#define SMP_FLAG_CFM_PENDING    2
+#define SMP_FLAG_MITM_AUTH      3
+
 struct smp_chan {
         struct l2cap_conn *conn;
         u8              preq[7]; /* SMP Pairing Request */
@@ -124,6 +128,7 @@ struct smp_chan {
         u8              pcnf[16]; /* SMP Pairing Confirm */
         u8              tk[16]; /* SMP Temporary Key */
         u8              smp_key_size;
+        unsigned long   smp_flags;
         struct crypto_blkcipher *tfm;
         struct work_struct confirm;
         struct work_struct random;
@@ -134,6 +139,7 @@ struct smp_chan {
 int smp_conn_security(struct l2cap_conn *conn, __u8 sec_level);
 int smp_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb);
 int smp_distribute_keys(struct l2cap_conn *conn, __u8 force);
+int smp_user_confirm_reply(struct hci_conn *conn, u16 mgmt_op, __le32 passkey);
 
 void smp_chan_destroy(struct l2cap_conn *conn);
 
diff --git a/net/bluetooth/smp.c b/net/bluetooth/smp.c
index 0ee2905a6179..9fea4bfd0eb5 100644
--- a/net/bluetooth/smp.c
+++ b/net/bluetooth/smp.c
@@ -23,6 +23,7 @@
 #include <net/bluetooth/bluetooth.h>
 #include <net/bluetooth/hci_core.h>
 #include <net/bluetooth/l2cap.h>
+#include <net/bluetooth/mgmt.h>
 #include <net/bluetooth/smp.h>
 #include <linux/crypto.h>
 #include <linux/scatterlist.h>
@@ -189,24 +190,45 @@ static void smp_send_cmd(struct l2cap_conn *conn, u8 code, u16 len, void *data)
                                         msecs_to_jiffies(SMP_TIMEOUT));
 }
 
+static __u8 authreq_to_seclevel(__u8 authreq)
+{
+        if (authreq & SMP_AUTH_MITM)
+                return BT_SECURITY_HIGH;
+        else
+                return BT_SECURITY_MEDIUM;
+}
+
+static __u8 seclevel_to_authreq(__u8 sec_level)
+{
+        switch (sec_level) {
+        case BT_SECURITY_HIGH:
+                return SMP_AUTH_MITM | SMP_AUTH_BONDING;
+        case BT_SECURITY_MEDIUM:
+                return SMP_AUTH_BONDING;
+        default:
+                return SMP_AUTH_NONE;
+        }
+}
+
 static void build_pairing_cmd(struct l2cap_conn *conn,
                                 struct smp_cmd_pairing *req,
                                 struct smp_cmd_pairing *rsp,
                                 __u8 authreq)
 {
-        u8 dist_keys;
+        u8 dist_keys = 0;
 
-        dist_keys = 0;
         if (test_bit(HCI_PAIRABLE, &conn->hcon->hdev->flags)) {
                 dist_keys = SMP_DIST_ENC_KEY;
                 authreq |= SMP_AUTH_BONDING;
+        } else {
+                authreq &= ~SMP_AUTH_BONDING;
         }
 
         if (rsp == NULL) {
                 req->io_capability = conn->hcon->io_capability;
                 req->oob_flag = SMP_OOB_NOT_PRESENT;
                 req->max_key_size = SMP_MAX_ENC_KEY_SIZE;
-                req->init_key_dist = dist_keys;
+                req->init_key_dist = 0;
                 req->resp_key_dist = dist_keys;
                 req->auth_req = authreq;
                 return;
@@ -215,7 +237,7 @@ static void build_pairing_cmd(struct l2cap_conn *conn,
         rsp->io_capability = conn->hcon->io_capability;
         rsp->oob_flag = SMP_OOB_NOT_PRESENT;
         rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
-        rsp->init_key_dist = req->init_key_dist & dist_keys;
+        rsp->init_key_dist = 0;
         rsp->resp_key_dist = req->resp_key_dist & dist_keys;
         rsp->auth_req = authreq;
 }
@@ -245,6 +267,95 @@ static void smp_failure(struct l2cap_conn *conn, u8 reason, u8 send)
         smp_chan_destroy(conn);
 }
 
+#define JUST_WORKS      0x00
+#define JUST_CFM        0x01
+#define REQ_PASSKEY     0x02
+#define CFM_PASSKEY     0x03
+#define REQ_OOB         0x04
+#define OVERLAP         0xFF
+
+static const u8 gen_method[5][5] = {
+        { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
+        { JUST_WORKS,  JUST_CFM,    REQ_PASSKEY, JUST_WORKS, REQ_PASSKEY },
+        { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, CFM_PASSKEY },
+        { JUST_WORKS,  JUST_CFM,    JUST_WORKS,  JUST_WORKS, JUST_CFM    },
+        { CFM_PASSKEY, CFM_PASSKEY, REQ_PASSKEY, JUST_WORKS, OVERLAP     },
+};
+
+static int tk_request(struct l2cap_conn *conn, u8 remote_oob, u8 auth,
+                                                u8 local_io, u8 remote_io)
+{
+        struct hci_conn *hcon = conn->hcon;
+        struct smp_chan *smp = conn->smp_chan;
+        u8 method;
+        u32 passkey = 0;
+        int ret = 0;
+
+        /* Initialize key for JUST WORKS */
+        memset(smp->tk, 0, sizeof(smp->tk));
+        clear_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
+
+        BT_DBG("tk_request: auth:%d lcl:%d rem:%d", auth, local_io, remote_io);
+
+        /* If neither side wants MITM, use JUST WORKS */
+        /* If either side has unknown io_caps, use JUST WORKS */
+        /* Otherwise, look up method from the table */
+        if (!(auth & SMP_AUTH_MITM) ||
+                        local_io > SMP_IO_KEYBOARD_DISPLAY ||
+                        remote_io > SMP_IO_KEYBOARD_DISPLAY)
+                method = JUST_WORKS;
+        else
+                method = gen_method[local_io][remote_io];
+
+        /* If not bonding, don't ask user to confirm a Zero TK */
+        if (!(auth & SMP_AUTH_BONDING) && method == JUST_CFM)
+                method = JUST_WORKS;
+
+        /* If Just Works, Continue with Zero TK */
+        if (method == JUST_WORKS) {
+                set_bit(SMP_FLAG_TK_VALID, &smp->smp_flags);
+                return 0;
+        }
+
+        /* Not Just Works/Confirm results in MITM Authentication */
+        if (method != JUST_CFM)
+                set_bit(SMP_FLAG_MITM_AUTH, &smp->smp_flags);
+
+        /* If both devices have Keyoard-Display I/O, the master
+         * Confirms and the slave Enters the passkey.