Bluetooth: SMP: Use AES-CMAC library API

Now that AES-CMAC has a library API, convert net/bluetooth/smp.c to use
it instead of the "cmac(aes)" crypto_shash.  Since the library API
doesn't require dynamic memory allocation, we no longer need to pass a
crypto_shash object down the call stack and can simply allocate the
aes_cmac_key on the stack in smp_aes_cmac() (renamed from aes_cmac()).

The result is simpler and faster code that no longer relies on the
error-prone loading of algorithms by name.

Note that the maximum stack usage actually decreases slightly, despite
the expanded AES key being moved to the stack.  This is because the old
code called crypto_shash_tfm_digest(), which allocates 384 bytes on the
stack for a maximally-sized hash descriptor for any algorithm.  The new
code instead declares a 288-byte aes_cmac_key, then calls aes_cmac()
which declares a 32-byte aes_cmac_ctx.  Since 288 + 32 < 384, the
maximum stack usage decreases.  I.e. the entire expanded AES key easily
fits in the space that the generic crypto API was wasting before.

I didn't add zeroization of the aes_cmac_key, since smp_aes_cmac()
already copies the raw key to the stack without zeroizing it.

Reviewed-by: Ard Biesheuvel <ardb@kernel.org>
Signed-off-by: Eric Biggers <ebiggers@kernel.org>
Signed-off-by: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

diff --git a/net/bluetooth/Kconfig b/net/bluetooth/Kconfig
index 5a8bf91067103716478e2c68f8142f65e911b2bb..d250e94e90eba5fef84f30b7aed192c04ea364ed 100644 (file)
--- a/net/bluetooth/Kconfig
+++ b/net/bluetooth/Kconfig
@@ -10,8 +10,7 @@ menuconfig BT
        select CRC16
        select CRYPTO
        select CRYPTO_LIB_AES
-       imply CRYPTO_AES
-       select CRYPTO_CMAC
+       select CRYPTO_LIB_AES_CBC_MACS
        select CRYPTO_ECDH
        help
          Bluetooth is low-cost, low-power, short-range wireless technology.

diff --git a/net/bluetooth/smp.c b/net/bluetooth/smp.c
index 98f1da4f5f559bdfd53aeb87f9a636c88fb19ca0..1739c1989dbd5f22b0ef069bfdefab395b013aa4 100644 (file)
--- a/net/bluetooth/smp.c
+++ b/net/bluetooth/smp.c
@@ -22,8 +22,8 @@
 
 #include <linux/debugfs.h>
 #include <linux/scatterlist.h>
+#include <crypto/aes-cbc-macs.h>
 #include <crypto/aes.h>
-#include <crypto/hash.h>
 #include <crypto/kpp.h>
 #include <crypto/utils.h>
 
@@ -63,7 +63,7 @@
                                 0x3f : 0x07)
 #define KEY_DIST_MASK          0x07
 
-/* Maximum message length that can be passed to aes_cmac */
+/* Maximum message length that can be passed to smp_aes_cmac */
 #define CMAC_MSG_MAX   80
 
 enum {
@@ -89,7 +89,6 @@ struct smp_dev {
        u8                      local_rand[16];
        bool                    debug_key;
 
-       struct crypto_shash     *tfm_cmac;
        struct crypto_kpp       *tfm_ecdh;
 };
 
@@ -127,7 +126,6 @@ struct smp_chan {
        u8                      dhkey[32];
        u8                      mackey[16];
 
-       struct crypto_shash     *tfm_cmac;
        struct crypto_kpp       *tfm_ecdh;
 };
 
@@ -166,20 +164,15 @@ static inline void swap_buf(const u8 *src, u8 *dst, size_t len)
  * AES-CMAC, f4, f5, f6, g2 and h6.
  */
 
-static int aes_cmac(struct crypto_shash *tfm, const u8 k[16], const u8 *m,
-                   size_t len, u8 mac[16])
+static int smp_aes_cmac(const u8 k[16], const u8 *m, size_t len, u8 mac[16])
 {
        uint8_t tmp[16], mac_msb[16], msg_msb[CMAC_MSG_MAX];
+       struct aes_cmac_key key;
        int err;
 
        if (len > CMAC_MSG_MAX)
                return -EFBIG;
 
-       if (!tfm) {
-               BT_ERR("tfm %p", tfm);
-               return -EINVAL;
-       }
-
        /* Swap key and message from LSB to MSB */
        swap_buf(k, tmp, 16);
        swap_buf(m, msg_msb, len);
@@ -187,17 +180,10 @@ static int aes_cmac(struct crypto_shash *tfm, const u8 k[16], const u8 *m,
        SMP_DBG("msg (len %zu) %*phN", len, (int) len, m);
        SMP_DBG("key %16phN", k);
 
-       err = crypto_shash_setkey(tfm, tmp, 16);
-       if (err) {
-               BT_ERR("cipher setkey failed: %d", err);
+       err = aes_cmac_preparekey(&key, tmp, 16);
+       if (WARN_ON_ONCE(err)) /* Should never happen, as 16 is valid keylen */
                return err;
-       }
-
-       err = crypto_shash_tfm_digest(tfm, msg_msb, len, mac_msb);
-       if (err) {
-               BT_ERR("Hash computation error %d", err);
-               return err;
-       }
+       aes_cmac(&key, msg_msb, len, mac_msb);
 
        swap_buf(mac_msb, mac, 16);
 
@@ -206,8 +192,8 @@ static int aes_cmac(struct crypto_shash *tfm, const u8 k[16], const u8 *m,
        return 0;
 }
 
-static int smp_f4(struct crypto_shash *tfm_cmac, const u8 u[32],
-                 const u8 v[32], const u8 x[16], u8 z, u8 res[16])
+static int smp_f4(const u8 u[32], const u8 v[32], const u8 x[16], u8 z,
+                 u8 res[16])
 {
        u8 m[65];
        int err;
@@ -220,7 +206,7 @@ static int smp_f4(struct crypto_shash *tfm_cmac, const u8 u[32],
        memcpy(m + 1, v, 32);
        memcpy(m + 33, u, 32);
 
-       err = aes_cmac(tfm_cmac, x, m, sizeof(m), res);
+       err = smp_aes_cmac(x, m, sizeof(m), res);
        if (err)
                return err;
 
@@ -229,9 +215,8 @@ static int smp_f4(struct crypto_shash *tfm_cmac, const u8 u[32],
        return err;
 }
 
-static int smp_f5(struct crypto_shash *tfm_cmac, const u8 w[32],
-                 const u8 n1[16], const u8 n2[16], const u8 a1[7],
-                 const u8 a2[7], u8 mackey[16], u8 ltk[16])
+static int smp_f5(const u8 w[32], const u8 n1[16], const u8 n2[16],
+                 const u8 a1[7], const u8 a2[7], u8 mackey[16], u8 ltk[16])
 {
        /* The btle, salt and length "magic" values are as defined in
         * the SMP section of the Bluetooth core specification. In ASCII
@@ -250,7 +235,7 @@ static int smp_f5(struct crypto_shash *tfm_cmac, const u8 w[32],
        SMP_DBG("n1 %16phN n2 %16phN", n1, n2);
        SMP_DBG("a1 %7phN a2 %7phN", a1, a2);
 
-       err = aes_cmac(tfm_cmac, salt, w, 32, t);
+       err = smp_aes_cmac(salt, w, 32, t);
        if (err)
                return err;
 
@@ -265,7 +250,7 @@ static int smp_f5(struct crypto_shash *tfm_cmac, const u8 w[32],
 
        m[52] = 0; /* Counter */
 
-       err = aes_cmac(tfm_cmac, t, m, sizeof(m), mackey);
+       err = smp_aes_cmac(t, m, sizeof(m), mackey);
        if (err)
                return err;
 
@@ -273,7 +258,7 @@ static int smp_f5(struct crypto_shash *tfm_cmac, const u8 w[32],
 
        m[52] = 1; /* Counter */
 
-       err = aes_cmac(tfm_cmac, t, m, sizeof(m), ltk);
+       err = smp_aes_cmac(t, m, sizeof(m), ltk);
        if (err)
                return err;
 
@@ -282,10 +267,9 @@ static int smp_f5(struct crypto_shash *tfm_cmac, const u8 w[32],
        return 0;
 }
 
-static int smp_f6(struct crypto_shash *tfm_cmac, const u8 w[16],
-                 const u8 n1[16], const u8 n2[16], const u8 r[16],
-                 const u8 io_cap[3], const u8 a1[7], const u8 a2[7],
-                 u8 res[16])
+static int smp_f6(const u8 w[16], const u8 n1[16], const u8 n2[16],
+                 const u8 r[16], const u8 io_cap[3], const u8 a1[7],
+                 const u8 a2[7], u8 res[16])
 {
        u8 m[65];
        int err;
@@ -301,7 +285,7 @@ static int smp_f6(struct crypto_shash *tfm_cmac, const u8 w[16],
        memcpy(m + 33, n2, 16);
        memcpy(m + 49, n1, 16);
 
-       err = aes_cmac(tfm_cmac, w, m, sizeof(m), res);
+       err = smp_aes_cmac(w, m, sizeof(m), res);
        if (err)
                return err;
 
@@ -310,8 +294,8 @@ static int smp_f6(struct crypto_shash *tfm_cmac, const u8 w[16],
        return err;
 }
 
-static int smp_g2(struct crypto_shash *tfm_cmac, const u8 u[32], const u8 v[32],
-                 const u8 x[16], const u8 y[16], u32 *val)
+static int smp_g2(const u8 u[32], const u8 v[32], const u8 x[16],
+                 const u8 y[16], u32 *val)
 {
        u8 m[80], tmp[16];
        int err;
@@ -324,7 +308,7 @@ static int smp_g2(struct crypto_shash *tfm_cmac, const u8 u[32], const u8 v[32],
        memcpy(m + 16, v, 32);
        memcpy(m + 48, u, 32);
 
-       err = aes_cmac(tfm_cmac, x, m, sizeof(m), tmp);
+       err = smp_aes_cmac(x, m, sizeof(m), tmp);
        if (err)
                return err;
 
@@ -336,14 +320,13 @@ static int smp_g2(struct crypto_shash *tfm_cmac, const u8 u[32], const u8 v[32],
        return 0;
 }
 
-static int smp_h6(struct crypto_shash *tfm_cmac, const u8 w[16],
-                 const u8 key_id[4], u8 res[16])
+static int smp_h6(const u8 w[16], const u8 key_id[4], u8 res[16])
 {
        int err;
 
        SMP_DBG("w %16phN key_id %4phN", w, key_id);
 
-       err = aes_cmac(tfm_cmac, w, key_id, 4, res);
+       err = smp_aes_cmac(w, key_id, 4, res);
        if (err)
                return err;
 
@@ -352,14 +335,13 @@ static int smp_h6(struct crypto_shash *tfm_cmac, const u8 w[16],
        return err;
 }
 
-static int smp_h7(struct crypto_shash *tfm_cmac, const u8 w[16],
-                 const u8 salt[16], u8 res[16])
+static int smp_h7(const u8 w[16], const u8 salt[16], u8 res[16])
 {
        int err;
 
        SMP_DBG("w %16phN salt %16phN", w, salt);
 
-       err = aes_cmac(tfm_cmac, salt, w, 16, res);
+       err = smp_aes_cmac(salt, w, 16, res);
        if (err)
                return err;
 
@@ -574,8 +556,7 @@ int smp_generate_oob(struct hci_dev *hdev, u8 hash[16], u8 rand[16])
 
        get_random_bytes(smp->local_rand, 16);
 
-       err = smp_f4(smp->tfm_cmac, smp->local_pk, smp->local_pk,
-                    smp->local_rand, 0, hash);
+       err = smp_f4(smp->local_pk, smp->local_pk, smp->local_rand, 0, hash);
        if (err < 0)
                return err;
 
@@ -757,7 +738,6 @@ static void smp_chan_destroy(struct l2cap_conn *conn)
        kfree_sensitive(smp->responder_csrk);
        kfree_sensitive(smp->link_key);
 
-       crypto_free_shash(smp->tfm_cmac);
        crypto_free_kpp(smp->tfm_ecdh);
 
        /* Ensure that we don't leave any debug key around if debug key
@@ -1160,7 +1140,7 @@ static void sc_generate_link_key(struct smp_chan *smp)
                /* SALT = 0x000000000000000000000000746D7031 */
                const u8 salt[16] = { 0x31, 0x70, 0x6d, 0x74 };
 
-               if (smp_h7(smp->tfm_cmac, smp->tk, salt, smp->link_key)) {
+               if (smp_h7(smp->tk, salt, smp->link_key)) {
                        kfree_sensitive(smp->link_key);
                        smp->link_key = NULL;
                        return;
@@ -1169,14 +1149,14 @@ static void sc_generate_link_key(struct smp_chan *smp)
                /* From core spec. Spells out in ASCII as 'tmp1'. */
                const u8 tmp1[4] = { 0x31, 0x70, 0x6d, 0x74 };
 
-               if (smp_h6(smp->tfm_cmac, smp->tk, tmp1, smp->link_key)) {
+               if (smp_h6(smp->tk, tmp1, smp->link_key)) {
                        kfree_sensitive(smp->link_key);
                        smp->link_key = NULL;
                        return;
                }
        }
 
-       if (smp_h6(smp->tfm_cmac, smp->link_key, lebr, smp->link_key)) {
+       if (smp_h6(smp->link_key, lebr, smp->link_key)) {
                kfree_sensitive(smp->link_key);
                smp->link_key = NULL;
                return;
@@ -1218,17 +1198,17 @@ static void sc_generate_ltk(struct smp_chan *smp)
                /* SALT = 0x000000000000000000000000746D7032 */
                const u8 salt[16] = { 0x32, 0x70, 0x6d, 0x74 };
 
-               if (smp_h7(smp->tfm_cmac, key->val, salt, smp->tk))
+               if (smp_h7(key->val, salt, smp->tk))
                        return;
        } else {
                /* From core spec. Spells out in ASCII as 'tmp2'. */
                const u8 tmp2[4] = { 0x32, 0x70, 0x6d, 0x74 };
 
-               if (smp_h6(smp->tfm_cmac, key->val, tmp2, smp->tk))
+               if (smp_h6(key->val, tmp2, smp->tk))
                        return;
        }
 
-       if (smp_h6(smp->tfm_cmac, smp->tk, brle, smp->tk))
+       if (smp_h6(smp->tk, brle, smp->tk))
                return;
 
        sc_add_ltk(smp);
@@ -1389,16 +1369,10 @@ static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
        if (!smp)
                return NULL;
 
-       smp->tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, 0);
-       if (IS_ERR(smp->tfm_cmac)) {
-               bt_dev_err(hcon->hdev, "Unable to create CMAC crypto context");
-               goto zfree_smp;
-       }
-
        smp->tfm_ecdh = crypto_alloc_kpp("ecdh-nist-p256", 0, 0);
        if (IS_ERR(smp->tfm_ecdh)) {
                bt_dev_err(hcon->hdev, "Unable to create ECDH crypto context");
-               goto free_shash;
+               goto zfree_smp;
        }
 
        smp->conn = conn;
@@ -1412,8 +1386,6 @@ static struct smp_chan *smp_chan_create(struct l2cap_conn *conn)
 
        return smp;
 
-free_shash:
-       crypto_free_shash(smp->tfm_cmac);
 zfree_smp:
        kfree_sensitive(smp);
        return NULL;
@@ -1437,7 +1409,7 @@ static int sc_mackey_and_ltk(struct smp_chan *smp, u8 mackey[16], u8 ltk[16])
        a[6] = hcon->init_addr_type;
        b[6] = hcon->resp_addr_type;
 
-       return smp_f5(smp->tfm_cmac, smp->dhkey, na, nb, a, b, mackey, ltk);
+       return smp_f5(smp->dhkey, na, nb, a, b, mackey, ltk);
 }
 
 static void sc_dhkey_check(struct smp_chan *smp)
@@ -1470,8 +1442,8 @@ static void sc_dhkey_check(struct smp_chan *smp)
        if (smp->method == REQ_OOB)
                memcpy(r, smp->rr, 16);
 
-       smp_f6(smp->tfm_cmac, smp->mackey, smp->prnd, smp->rrnd, r, io_cap,
-              local_addr, remote_addr, check.e);
+       smp_f6(smp->mackey, smp->prnd, smp->rrnd, r, io_cap, local_addr,
+              remote_addr, check.e);
 
        smp_send_cmd(smp->conn, SMP_CMD_DHKEY_CHECK, sizeof(check), &check);
 }
@@ -1488,7 +1460,7 @@ static u8 sc_passkey_send_confirm(struct smp_chan *smp)
 
        get_random_bytes(smp->prnd, sizeof(smp->prnd));
 
-       if (smp_f4(smp->tfm_cmac, smp->local_pk, smp->remote_pk, smp->prnd, r,
+       if (smp_f4(smp->local_pk, smp->remote_pk, smp->prnd, r,
                   cfm.confirm_val))
                return SMP_UNSPECIFIED;
 
@@ -1513,8 +1485,7 @@ static u8 sc_passkey_round(struct smp_chan *smp, u8 smp_op)
                r = ((hcon->passkey_notify >> smp->passkey_round) & 0x01);
                r |= 0x80;
 
-               if (smp_f4(smp->tfm_cmac, smp->remote_pk, smp->local_pk,
-                          smp->rrnd, r, cfm))
+               if (smp_f4(smp->remote_pk, smp->local_pk, smp->rrnd, r, cfm))
                        return SMP_UNSPECIFIED;
 
                if (crypto_memneq(smp->pcnf, cfm, 16))
@@ -2178,8 +2149,7 @@ static u8 smp_cmd_pairing_random(struct l2cap_conn *conn, struct sk_buff *skb)
        if (test_bit(SMP_FLAG_INITIATOR, &smp->flags)) {
                u8 cfm[16];
 
-               err = smp_f4(smp->tfm_cmac, smp->remote_pk, smp->local_pk,
-                            smp->rrnd, 0, cfm);
+               err = smp_f4(smp->remote_pk, smp->local_pk, smp->rrnd, 0, cfm);
                if (err)
                        return SMP_UNSPECIFIED;
 
@@ -2205,7 +2175,7 @@ mackey_and_ltk:
                return 0;
        }
 
-       err = smp_g2(smp->tfm_cmac, pkax, pkbx, na, nb, &passkey);
+       err = smp_g2(pkax, pkbx, na, nb, &passkey);
        if (err)
                return SMP_UNSPECIFIED;
 
@@ -2750,8 +2720,8 @@ static int smp_cmd_public_key(struct l2cap_conn *conn, struct sk_buff *skb)
        memcpy(smp->remote_pk, key, 64);
 
        if (test_bit(SMP_FLAG_REMOTE_OOB, &smp->flags)) {
-               err = smp_f4(smp->tfm_cmac, smp->remote_pk, smp->remote_pk,
-                            smp->rr, 0, cfm.confirm_val);
+               err = smp_f4(smp->remote_pk, smp->remote_pk, smp->rr, 0,
+                            cfm.confirm_val);
                if (err)
                        return SMP_UNSPECIFIED;
 
@@ -2851,8 +2821,8 @@ static int smp_cmd_public_key(struct l2cap_conn *conn, struct sk_buff *skb)
        if (test_bit(SMP_FLAG_INITIATOR, &smp->flags))
                return 0;
 
-       err = smp_f4(smp->tfm_cmac, smp->local_pk, smp->remote_pk, smp->prnd,
-                    0, cfm.confirm_val);
+       err = smp_f4(smp->local_pk, smp->remote_pk, smp->prnd, 0,
+                    cfm.confirm_val);
        if (err)
                return SMP_UNSPECIFIED;
 
@@ -2899,8 +2869,8 @@ static int smp_cmd_dhkey_check(struct l2cap_conn *conn, struct sk_buff *skb)
        else if (smp->method == REQ_OOB)
                memcpy(r, smp->lr, 16);
 
-       err = smp_f6(smp->tfm_cmac, smp->mackey, smp->rrnd, smp->prnd, r,
-                    io_cap, remote_addr, local_addr, e);
+       err = smp_f6(smp->mackey, smp->rrnd, smp->prnd, r, io_cap, remote_addr,
+                    local_addr, e);
        if (err)
                return SMP_UNSPECIFIED;
 
@@ -3286,7 +3256,6 @@ static struct l2cap_chan *smp_add_cid(struct hci_dev *hdev, u16 cid)
 {
        struct l2cap_chan *chan;
        struct smp_dev *smp;
-       struct crypto_shash *tfm_cmac;
        struct crypto_kpp *tfm_ecdh;
 
        if (cid == L2CAP_CID_SMP_BREDR) {
@@ -3298,30 +3267,20 @@ static struct l2cap_chan *smp_add_cid(struct hci_dev *hdev, u16 cid)
        if (!smp)
                return ERR_PTR(-ENOMEM);
 
-       tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, 0);
-       if (IS_ERR(tfm_cmac)) {
-               bt_dev_err(hdev, "Unable to create CMAC crypto context");
-               kfree_sensitive(smp);
-               return ERR_CAST(tfm_cmac);
-       }
-
        tfm_ecdh = crypto_alloc_kpp("ecdh-nist-p256", 0, 0);
        if (IS_ERR(tfm_ecdh)) {
                bt_dev_err(hdev, "Unable to create ECDH crypto context");
-               crypto_free_shash(tfm_cmac);
                kfree_sensitive(smp);
                return ERR_CAST(tfm_ecdh);
        }
 
        smp->local_oob = false;
-       smp->tfm_cmac = tfm_cmac;
        smp->tfm_ecdh = tfm_ecdh;
 
 create_chan:
        chan = l2cap_chan_create();
        if (!chan) {
                if (smp) {
-                       crypto_free_shash(smp->tfm_cmac);
                        crypto_free_kpp(smp->tfm_ecdh);
                        kfree_sensitive(smp);
                }
@@ -3368,7 +3327,6 @@ static void smp_del_chan(struct l2cap_chan *chan)
        smp = chan->data;
        if (smp) {
                chan->data = NULL;
-               crypto_free_shash(smp->tfm_cmac);
                crypto_free_kpp(smp->tfm_ecdh);
                kfree_sensitive(smp);
        }
@@ -3565,7 +3523,7 @@ static int __init test_s1(void)
        return 0;
 }
 
-static int __init test_f4(struct crypto_shash *tfm_cmac)
+static int __init test_f4(void)
 {
        const u8 u[32] = {
                        0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
@@ -3587,7 +3545,7 @@ static int __init test_f4(struct crypto_shash *tfm_cmac)
        u8 res[16];
        int err;
 
-       err = smp_f4(tfm_cmac, u, v, x, z, res);
+       err = smp_f4(u, v, x, z, res);
        if (err)
                return err;
 
@@ -3597,7 +3555,7 @@ static int __init test_f4(struct crypto_shash *tfm_cmac)
        return 0;
 }
 
-static int __init test_f5(struct crypto_shash *tfm_cmac)
+static int __init test_f5(void)
 {
        const u8 w[32] = {
                        0x98, 0xa6, 0xbf, 0x73, 0xf3, 0x34, 0x8d, 0x86,
@@ -3621,7 +3579,7 @@ static int __init test_f5(struct crypto_shash *tfm_cmac)
        u8 mackey[16], ltk[16];
        int err;
 
-       err = smp_f5(tfm_cmac, w, n1, n2, a1, a2, mackey, ltk);
+       err = smp_f5(w, n1, n2, a1, a2, mackey, ltk);
        if (err)
                return err;
 
@@ -3634,7 +3592,7 @@ static int __init test_f5(struct crypto_shash *tfm_cmac)
        return 0;
 }
 
-static int __init test_f6(struct crypto_shash *tfm_cmac)
+static int __init test_f6(void)
 {
        const u8 w[16] = {
                        0x20, 0x6e, 0x63, 0xce, 0x20, 0x6a, 0x3f, 0xfd,
@@ -3657,7 +3615,7 @@ static int __init test_f6(struct crypto_shash *tfm_cmac)
        u8 res[16];
        int err;
 
-       err = smp_f6(tfm_cmac, w, n1, n2, r, io_cap, a1, a2, res);
+       err = smp_f6(w, n1, n2, r, io_cap, a1, a2, res);
        if (err)
                return err;
 
@@ -3667,7 +3625,7 @@ static int __init test_f6(struct crypto_shash *tfm_cmac)
        return 0;
 }
 
-static int __init test_g2(struct crypto_shash *tfm_cmac)
+static int __init test_g2(void)
 {
        const u8 u[32] = {
                        0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
@@ -3689,7 +3647,7 @@ static int __init test_g2(struct crypto_shash *tfm_cmac)
        u32 val;
        int err;
 
-       err = smp_g2(tfm_cmac, u, v, x, y, &val);
+       err = smp_g2(u, v, x, y, &val);
        if (err)
                return err;
 
@@ -3699,7 +3657,7 @@ static int __init test_g2(struct crypto_shash *tfm_cmac)
        return 0;
 }
 
-static int __init test_h6(struct crypto_shash *tfm_cmac)
+static int __init test_h6(void)
 {
        const u8 w[16] = {
                        0x9b, 0x7d, 0x39, 0x0a, 0xa6, 0x10, 0x10, 0x34,
@@ -3711,7 +3669,7 @@ static int __init test_h6(struct crypto_shash *tfm_cmac)
        u8 res[16];
        int err;
 
-       err = smp_h6(tfm_cmac, w, key_id, res);
+       err = smp_h6(w, key_id, res);
        if (err)
                return err;
 
@@ -3736,8 +3694,7 @@ static const struct file_operations test_smp_fops = {
        .llseek         = default_llseek,
 };
 
-static int __init run_selftests(struct crypto_shash *tfm_cmac,
-                               struct crypto_kpp *tfm_ecdh)
+static int __init run_selftests(struct crypto_kpp *tfm_ecdh)
 {
        ktime_t calltime, delta, rettime;
        unsigned long long duration;
@@ -3769,31 +3726,31 @@ static int __init run_selftests(struct crypto_shash *tfm_cmac,
                goto done;
        }
 
-       err = test_f4(tfm_cmac);
+       err = test_f4();
        if (err) {
                BT_ERR("smp_f4 test failed");
                goto done;
        }
 
-       err = test_f5(tfm_cmac);
+       err = test_f5();
        if (err) {
                BT_ERR("smp_f5 test failed");
                goto done;
        }
 
-       err = test_f6(tfm_cmac);
+       err = test_f6();
        if (err) {
                BT_ERR("smp_f6 test failed");
                goto done;
        }
 
-       err = test_g2(tfm_cmac);
+       err = test_g2();
        if (err) {
                BT_ERR("smp_g2 test failed");
                goto done;
        }
 
-       err = test_h6(tfm_cmac);
+       err = test_h6();
        if (err) {
                BT_ERR("smp_h6 test failed");
                goto done;
@@ -3820,26 +3777,17 @@ done:
 
 int __init bt_selftest_smp(void)
 {
-       struct crypto_shash *tfm_cmac;
        struct crypto_kpp *tfm_ecdh;
        int err;
 
-       tfm_cmac = crypto_alloc_shash("cmac(aes)", 0, 0);
-       if (IS_ERR(tfm_cmac)) {
-               BT_ERR("Unable to create CMAC crypto context");
-               return PTR_ERR(tfm_cmac);
-       }
-
        tfm_ecdh = crypto_alloc_kpp("ecdh-nist-p256", 0, 0);
        if (IS_ERR(tfm_ecdh)) {
                BT_ERR("Unable to create ECDH crypto context");
-               crypto_free_shash(tfm_cmac);
                return PTR_ERR(tfm_ecdh);
        }
 
-       err = run_selftests(tfm_cmac, tfm_ecdh);
+       err = run_selftests(tfm_ecdh);
 
-       crypto_free_shash(tfm_cmac);
        crypto_free_kpp(tfm_ecdh);
 
        return err;