Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next

Pull networking updates from David Miller:

 1) Add TX fast path in mac80211, from Johannes Berg.

 2) Add TSO/GRO support to ibmveth, from Thomas Falcon

 3) Move away from cached routes in ipv6, just like ipv4, from Martin
    KaFai Lau.

 4) Lots of new rhashtable tests, from Thomas Graf.

 5) Run ingress qdisc lockless, from Alexei Starovoitov.

 6) Allow servers to fetch TCP packet headers for SYN packets of new
    connections, for fingerprinting.  From Eric Dumazet.

 7) Add mode parameter to pktgen, for testing receive.  From Alexei
    Starovoitov.

 8) Cache access optimizations via simplifications of build_skb(), from
    Alexander Duyck.

 9) Move page frag allocator under mm/, also from Alexander.

10) Add xmit_more support to hv_netvsc, from KY Srinivasan.

11) Add a counter guard in case we try to perform endless reclassify
    loops in the packet scheduler.

12) Extern flow dissector to be programmable and use it in new "Flower"
    classifier.  From Jiri Pirko.

13) AF_PACKET fanout rollover fixes, performance improvements, and new
    statistics.  From Willem de Bruijn.

14) Add netdev driver for GENEVE tunnels, from John W Linville.

15) Add ingress netfilter hooks and filtering, from Pablo Neira Ayuso.

16) Fix handling of epoll edge triggers in TCP, from Eric Dumazet.

17) Add an ECN retry fallback for the initial TCP handshake, from Daniel
    Borkmann.

18) Add tail call support to BPF, from Alexei Starovoitov.

19) Add several pktgen helper scripts, from Jesper Dangaard Brouer.

20) Add zerocopy support to AF_UNIX, from Hannes Frederic Sowa.

21) Favor even port numbers for allocation to connect() requests, and
    odd port numbers for bind(0), in an effort to help avoid
    ip_local_port_range exhaustion.  From Eric Dumazet.

22) Add Cavium ThunderX driver, from Sunil Goutham.

23) Allow bpf programs to access skb_iif and dev->ifindex SKB metadata,
    from Alexei Starovoitov.

24) Add support for T6 chips in cxgb4vf driver, from Hariprasad Shenai.

25) Double TCP Small Queues default to 256K to accomodate situations
    like the XEN driver and wireless aggregation.  From Wei Liu.

26) Add more entropy inputs to flow dissector, from Tom Herbert.

27) Add CDG congestion control algorithm to TCP, from Kenneth Klette
    Jonassen.

28) Convert ipset over to RCU locking, from Jozsef Kadlecsik.

29) Track and act upon link status of ipv4 route nexthops, from Andy
    Gospodarek.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (1670 commits)
  bridge: vlan: flush the dynamically learned entries on port vlan delete
  bridge: multicast: add a comment to br_port_state_selection about blocking state
  net: inet_diag: export IPV6_V6ONLY sockopt
  stmmac: troubleshoot unexpected bits in des0 & des1
  net: ipv4 sysctl option to ignore routes when nexthop link is down
  net: track link-status of ipv4 nexthops
  net: switchdev: ignore unsupported bridge flags
  net: Cavium: Fix MAC address setting in shutdown state
  drivers: net: xgene: fix for ACPI support without ACPI
  ip: report the original address of ICMP messages
  net/mlx5e: Prefetch skb data on RX
  net/mlx5e: Pop cq outside mlx5e_get_cqe
  net/mlx5e: Remove mlx5e_cq.sqrq back-pointer
  net/mlx5e: Remove extra spaces
  net/mlx5e: Avoid TX CQE generation if more xmit packets expected
  net/mlx5e: Avoid redundant dev_kfree_skb() upon NOP completion
  net/mlx5e: Remove re-assignment of wq type in mlx5e_enable_rq()
  net/mlx5e: Use skb_shinfo(skb)->gso_segs rather than counting them
  net/mlx5e: Static mapping of netdev priv resources to/from netdev TX queues
  net/mlx4_en: Use HW counters for rx/tx bytes/packets in PF device
  ...

1 files changed, 135 insertions, 23 deletions

diff --git a/net/bluetooth/smp.c b/net/bluetooth/smp.c
index 1ab3dc9c8f99..3d0f7d2a0616 100644
--- a/net/bluetooth/smp.c
+++ b/net/bluetooth/smp.c
@@ -33,6 +33,9 @@
 #include "ecc.h"
 #include "smp.h"
 
+#define SMP_DEV(hdev) \
+        ((struct smp_dev *)((struct l2cap_chan *)((hdev)->smp_data))->data)
+
 /* Low-level debug macros to be used for stuff that we don't want
  * accidentially in dmesg, i.e. the values of the various crypto keys
  * and the inputs & outputs of crypto functions.
@@ -81,6 +84,9 @@ struct smp_dev {
         u8                      local_rand[16];
         bool                    debug_key;
 
+        u8                      min_key_size;
+        u8                      max_key_size;
+
         struct crypto_blkcipher *tfm_aes;
         struct crypto_hash      *tfm_cmac;
 };
@@ -371,6 +377,8 @@ static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r)
         uint8_t tmp[16], data[16];
         int err;
 
+        SMP_DBG("k %16phN r %16phN", k, r);
+
         if (!tfm) {
                 BT_ERR("tfm %p", tfm);
                 return -EINVAL;
@@ -400,6 +408,8 @@ static int smp_e(struct crypto_blkcipher *tfm, const u8 *k, u8 *r)
         /* Most significant octet of encryptedData corresponds to data[0] */
         swap_buf(data, r, 16);
 
+        SMP_DBG("r %16phN", r);
+
         return err;
 }
 
@@ -410,6 +420,10 @@ static int smp_c1(struct crypto_blkcipher *tfm_aes, const u8 k[16],
         u8 p1[16], p2[16];
         int err;
 
+        SMP_DBG("k %16phN r %16phN", k, r);
+        SMP_DBG("iat %u ia %6phN rat %u ra %6phN", _iat, ia, _rat, ra);
+        SMP_DBG("preq %7phN pres %7phN", preq, pres);
+
         memset(p1, 0, 16);
 
         /* p1 = pres || preq || _rat || _iat */
@@ -418,10 +432,7 @@ static int smp_c1(struct crypto_blkcipher *tfm_aes, const u8 k[16],
         memcpy(p1 + 2, preq, 7);
         memcpy(p1 + 9, pres, 7);
 
-        /* p2 = padding || ia || ra */
-        memcpy(p2, ra, 6);
-        memcpy(p2 + 6, ia, 6);
-        memset(p2 + 12, 0, 4);
+        SMP_DBG("p1 %16phN", p1);
 
         /* res = r XOR p1 */
         u128_xor((u128 *) res, (u128 *) r, (u128 *) p1);
@@ -433,6 +444,13 @@ static int smp_c1(struct crypto_blkcipher *tfm_aes, const u8 k[16],
                 return err;
         }
 
+        /* p2 = padding || ia || ra */
+        memcpy(p2, ra, 6);
+        memcpy(p2 + 6, ia, 6);
+        memset(p2 + 12, 0, 4);
+
+        SMP_DBG("p2 %16phN", p2);
+
         /* res = res XOR p2 */
         u128_xor((u128 *) res, (u128 *) res, (u128 *) p2);
 
@@ -696,7 +714,7 @@ static void build_pairing_cmd(struct l2cap_conn *conn,
         if (rsp == NULL) {
                 req->io_capability = conn->hcon->io_capability;
                 req->oob_flag = oob_flag;
-                req->max_key_size = SMP_MAX_ENC_KEY_SIZE;
+                req->max_key_size = SMP_DEV(hdev)->max_key_size;
                 req->init_key_dist = local_dist;
                 req->resp_key_dist = remote_dist;
                 req->auth_req = (authreq & AUTH_REQ_MASK(hdev));
@@ -707,7 +725,7 @@ static void build_pairing_cmd(struct l2cap_conn *conn,
 
         rsp->io_capability = conn->hcon->io_capability;
         rsp->oob_flag = oob_flag;
-        rsp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
+        rsp->max_key_size = SMP_DEV(hdev)->max_key_size;
         rsp->init_key_dist = req->init_key_dist & remote_dist;
         rsp->resp_key_dist = req->resp_key_dist & local_dist;
         rsp->auth_req = (authreq & AUTH_REQ_MASK(hdev));
@@ -718,10 +736,11 @@ static void build_pairing_cmd(struct l2cap_conn *conn,
 static u8 check_enc_key_size(struct l2cap_conn *conn, __u8 max_key_size)
 {
         struct l2cap_chan *chan = conn->smp;
+        struct hci_dev *hdev = conn->hcon->hdev;
         struct smp_chan *smp = chan->data;
 
-        if ((max_key_size > SMP_MAX_ENC_KEY_SIZE) ||
-            (max_key_size < SMP_MIN_ENC_KEY_SIZE))
+        if (max_key_size > SMP_DEV(hdev)->max_key_size ||
+            max_key_size < SMP_MIN_ENC_KEY_SIZE)
                 return SMP_ENC_KEY_SIZE;
 
         smp->enc_key_size = max_key_size;
@@ -985,13 +1004,10 @@ static u8 smp_random(struct smp_chan *smp)
 
                 smp_s1(smp->tfm_aes, smp->tk, smp->rrnd, smp->prnd, stk);
 
-                memset(stk + smp->enc_key_size, 0,
-                       SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
-
                 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
                         return SMP_UNSPECIFIED;
 
-                hci_le_start_enc(hcon, ediv, rand, stk);
+                hci_le_start_enc(hcon, ediv, rand, stk, smp->enc_key_size);
                 hcon->enc_key_size = smp->enc_key_size;
                 set_bit(HCI_CONN_STK_ENCRYPT, &hcon->flags);
         } else {
@@ -1004,9 +1020,6 @@ static u8 smp_random(struct smp_chan *smp)
 
                 smp_s1(smp->tfm_aes, smp->tk, smp->prnd, smp->rrnd, stk);
 
-                memset(stk + smp->enc_key_size, 0,
-                       SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
-
                 if (hcon->pending_sec_level == BT_SECURITY_HIGH)
                         auth = 1;
                 else
@@ -1144,9 +1157,6 @@ static void sc_add_ltk(struct smp_chan *smp)
         else
                 auth = 0;
 
-        memset(smp->tk + smp->enc_key_size, 0,
-               SMP_MAX_ENC_KEY_SIZE - smp->enc_key_size);
-
         smp->ltk = hci_add_ltk(hcon->hdev, &hcon->dst, hcon->dst_type,
                                key_type, auth, smp->tk, smp->enc_key_size,
                                0, 0);
@@ -1268,7 +1278,14 @@ static void smp_distribute_keys(struct smp_chan *smp)
                 __le16 ediv;
                 __le64 rand;
 
-                get_random_bytes(enc.ltk, sizeof(enc.ltk));
+                /* Make sure we generate only the significant amount of
+                 * bytes based on the encryption key size, and set the rest
+                 * of the value to zeroes.
+                 */
+                get_random_bytes(enc.ltk, smp->enc_key_size);
+                memset(enc.ltk + smp->enc_key_size, 0,
+                       sizeof(enc.ltk) - smp->enc_key_size);
+
                 get_random_bytes(&ediv, sizeof(ediv));
                 get_random_bytes(&rand, sizeof(rand));
 
@@ -1688,7 +1705,7 @@ static void build_bredr_pairing_cmd(struct smp_chan *smp,
 
                 req->init_key_dist   = local_dist;
                 req->resp_key_dist   = remote_dist;
-                req->max_key_size    = SMP_MAX_ENC_KEY_SIZE;
+                req->max_key_size    = conn->hcon->enc_key_size;
 
                 smp->remote_key_dist = remote_dist;
 
@@ -1697,7 +1714,7 @@ static void build_bredr_pairing_cmd(struct smp_chan *smp,
 
         memset(rsp, 0, sizeof(*rsp));
 
-        rsp->max_key_size    = SMP_MAX_ENC_KEY_SIZE;
+        rsp->max_key_size    = conn->hcon->enc_key_size;
         rsp->init_key_dist   = req->init_key_dist & remote_dist;
         rsp->resp_key_dist   = req->resp_key_dist & local_dist;
 
@@ -2190,7 +2207,7 @@ static bool smp_ltk_encrypt(struct l2cap_conn *conn, u8 sec_level)
         if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &hcon->flags))
                 return true;
 
-        hci_le_start_enc(hcon, key->ediv, key->rand, key->val);
+        hci_le_start_enc(hcon, key->ediv, key->rand, key->val, key->enc_size);
         hcon->enc_key_size = key->enc_size;
 
         /* We never store STKs for master role, so clear this flag */
@@ -2738,7 +2755,7 @@ static int smp_cmd_dhkey_check(struct l2cap_conn *conn, struct sk_buff *skb)
         sc_add_ltk(smp);
 
         if (hcon->out) {
-                hci_le_start_enc(hcon, 0, 0, smp->tk);
+                hci_le_start_enc(hcon, 0, 0, smp->tk, smp->enc_key_size);
                 hcon->enc_key_size = smp->enc_key_size;
         }
 
@@ -3120,6 +3137,8 @@ static struct l2cap_chan *smp_add_cid(struct hci_dev *hdev, u16 cid)
 
         smp->tfm_aes = tfm_aes;
         smp->tfm_cmac = tfm_cmac;
+        smp->min_key_size = SMP_MIN_ENC_KEY_SIZE;
+        smp->max_key_size = SMP_MAX_ENC_KEY_SIZE;
 
 create_chan:
         chan = l2cap_chan_create();
@@ -3242,6 +3261,94 @@ static const struct file_operations force_bredr_smp_fops = {
         .llseek         = default_llseek,
 };
 
+static ssize_t le_min_key_size_read(struct file *file,
+                                     char __user *user_buf,
+                                     size_t count, loff_t *ppos)
+{
+        struct hci_dev *hdev = file->private_data;
+        char buf[4];
+
+        snprintf(buf, sizeof(buf), "%2u\n", SMP_DEV(hdev)->min_key_size);
+
+        return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
+}
+
+static ssize_t le_min_key_size_write(struct file *file,
+                                      const char __user *user_buf,
+                                      size_t count, loff_t *ppos)
+{
+        struct hci_dev *hdev = file->private_data;
+        char buf[32];
+        size_t buf_size = min(count, (sizeof(buf) - 1));
+        u8 key_size;
+
+        if (copy_from_user(buf, user_buf, buf_size))
+                return -EFAULT;
+
+        buf[buf_size] = '\0';
+
+        sscanf(buf, "%hhu", &key_size);
+
+        if (key_size > SMP_DEV(hdev)->max_key_size ||
+            key_size < SMP_MIN_ENC_KEY_SIZE)
+                return -EINVAL;
+
+        SMP_DEV(hdev)->min_key_size = key_size;
+
+        return count;
+}
+
+static const struct file_operations le_min_key_size_fops = {
+        .open           = simple_open,
+        .read           = le_min_key_size_read,
+        .write          = le_min_key_size_write,
+        .llseek         = default_llseek,
+};
+
+static ssize_t le_max_key_size_read(struct file *file,
+                                     char __user *user_buf,
+                                     size_t count, loff_t *ppos)
+{
+        struct hci_dev *hdev = file->private_data;
+        char buf[4];
+
+        snprintf(buf, sizeof(buf), "%2u\n", SMP_DEV(hdev)->max_key_size);
+
+        return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
+}
+
+static ssize_t le_max_key_size_write(struct file *file,
+                                      const char __user *user_buf,
+                                      size_t count, loff_t *ppos)
+{
+        struct hci_dev *hdev = file->private_data;
+        char buf[32];
+        size_t buf_size = min(count, (sizeof(buf) - 1));
+        u8 key_size;
+
+        if (copy_from_user(buf, user_buf, buf_size))
+                return -EFAULT;
+
+        buf[buf_size] = '\0';
+
+        sscanf(buf, "%hhu", &key_size);
+
+        if (key_size > SMP_MAX_ENC_KEY_SIZE ||
+            key_size < SMP_DEV(hdev)->min_key_size)
+                return -EINVAL;
+
+        SMP_DEV(hdev)->max_key_size = key_size;
+
+        return count;
+}
+
+static const struct file_operations le_max_key_size_fops = {
+        .open           = simple_open,
+        .read           = le_max_key_size_read,
+        .write          = le_max_key_size_write,
+        .llseek         = default_llseek,
+};
+
 int smp_register(struct hci_dev *hdev)
 {
         struct l2cap_chan *chan;
@@ -3266,6 +3373,11 @@ int smp_register(struct hci_dev *hdev)
 
         hdev->smp_data = chan;
 
+        debugfs_create_file("le_min_key_size", 0644, hdev->debugfs, hdev,
+                            &le_min_key_size_fops);
+        debugfs_create_file("le_max_key_size", 0644, hdev->debugfs, hdev,
+                            &le_max_key_size_fops);
+
         /* If the controller does not support BR/EDR Secure Connections
          * feature, then the BR/EDR SMP channel shall not be present.
          *