lib/crypto: aescfb: Use new AES library API

Switch from the old AES library functions (which use struct
crypto_aes_ctx) to the new ones (which use struct aes_enckey).  This
eliminates the unnecessary computation and caching of the decryption
round keys.  The new AES en/decryption functions are also much faster
and use AES instructions when supported by the CPU.

Note that in addition to the change in the key preparation function and
the key struct type itself, the change in the type of the key struct
results in aes_encrypt() (which is temporarily a type-generic macro)
calling the new encryption function rather than the old one.

Acked-by: Ard Biesheuvel <ardb@kernel.org>
Link: https://lore.kernel.org/r/20260112192035.10427-33-ebiggers@kernel.org
Signed-off-by: Eric Biggers <ebiggers@kernel.org>

diff --git a/drivers/char/tpm/tpm2-sessions.c b/drivers/char/tpm/tpm2-sessions.c
index 4149379665c49d2642f5a895d95b4d3eed86e7e1..09df6353ef04d77f1a39c16f5c00877b5151610b 100644 (file)
--- a/drivers/char/tpm/tpm2-sessions.c
+++ b/drivers/char/tpm/tpm2-sessions.c
@@ -126,7 +126,7 @@ struct tpm2_auth {
        u8 session_key[SHA256_DIGEST_SIZE];
        u8 passphrase[SHA256_DIGEST_SIZE];
        int passphrase_len;
-       struct crypto_aes_ctx aes_ctx;
+       struct aes_enckey aes_key;
        /* saved session attributes: */
        u8 attrs;
        __be32 ordinal;
@@ -677,8 +677,8 @@ int tpm_buf_fill_hmac_session(struct tpm_chip *chip, struct tpm_buf *buf)
                          auth->scratch);
 
                len = tpm_buf_read_u16(buf, &offset_p);
-               aes_expandkey(&auth->aes_ctx, auth->scratch, AES_KEY_BYTES);
-               aescfb_encrypt(&auth->aes_ctx, &buf->data[offset_p],
+               aes_prepareenckey(&auth->aes_key, auth->scratch, AES_KEY_BYTES);
+               aescfb_encrypt(&auth->aes_key, &buf->data[offset_p],
                               &buf->data[offset_p], len,
                               auth->scratch + AES_KEY_BYTES);
                /* reset p to beginning of parameters for HMAC */
@@ -858,8 +858,8 @@ int tpm_buf_check_hmac_response(struct tpm_chip *chip, struct tpm_buf *buf,
                          auth->scratch);
 
                len = tpm_buf_read_u16(buf, &offset_p);
-               aes_expandkey(&auth->aes_ctx, auth->scratch, AES_KEY_BYTES);
-               aescfb_decrypt(&auth->aes_ctx, &buf->data[offset_p],
+               aes_prepareenckey(&auth->aes_key, auth->scratch, AES_KEY_BYTES);
+               aescfb_decrypt(&auth->aes_key, &buf->data[offset_p],
                               &buf->data[offset_p], len,
                               auth->scratch + AES_KEY_BYTES);
        }

diff --git a/include/crypto/aes.h b/include/crypto/aes.h
index 4a56aed59973b84a3d386130206948ce8488e8e8..4cb3c27d1bf587d11fe4e49630391a99c3dbe49f 100644 (file)
--- a/include/crypto/aes.h
+++ b/include/crypto/aes.h
@@ -343,9 +343,9 @@ extern const u8 crypto_aes_inv_sbox[];
 extern const u32 aes_enc_tab[256];
 extern const u32 aes_dec_tab[256];
 
-void aescfb_encrypt(const struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src,
+void aescfb_encrypt(const struct aes_enckey *key, u8 *dst, const u8 *src,
                    int len, const u8 iv[AES_BLOCK_SIZE]);
-void aescfb_decrypt(const struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src,
+void aescfb_decrypt(const struct aes_enckey *key, u8 *dst, const u8 *src,
                    int len, const u8 iv[AES_BLOCK_SIZE]);
 
 #endif

diff --git a/lib/crypto/aescfb.c b/lib/crypto/aescfb.c
index 0f294c8cbf3c25124691cd5386bbc530553f4efe..147e5211728f805486f1a1e707f05848282981ef 100644 (file)
--- a/lib/crypto/aescfb.c
+++ b/lib/crypto/aescfb.c
@@ -11,7 +11,7 @@
 #include <linux/module.h>
 #include <asm/irqflags.h>
 
-static void aescfb_encrypt_block(const struct crypto_aes_ctx *ctx, void *dst,
+static void aescfb_encrypt_block(const struct aes_enckey *key, void *dst,
                                 const void *src)
 {
        unsigned long flags;
@@ -25,27 +25,27 @@ static void aescfb_encrypt_block(const struct crypto_aes_ctx *ctx, void *dst,
         * interrupts disabled.
         */
        local_irq_save(flags);
-       aes_encrypt(ctx, dst, src);
+       aes_encrypt(key, dst, src);
        local_irq_restore(flags);
 }
 
 /**
  * aescfb_encrypt - Perform AES-CFB encryption on a block of data
  *
- * @ctx:       The AES-CFB key schedule
+ * @key:       The AES-CFB key schedule
  * @dst:       Pointer to the ciphertext output buffer
  * @src:       Pointer the plaintext (may equal @dst for encryption in place)
  * @len:       The size in bytes of the plaintext and ciphertext.
  * @iv:                The initialization vector (IV) to use for this block of data
  */
-void aescfb_encrypt(const struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src,
+void aescfb_encrypt(const struct aes_enckey *key, u8 *dst, const u8 *src,
                    int len, const u8 iv[AES_BLOCK_SIZE])
 {
        u8 ks[AES_BLOCK_SIZE];
        const u8 *v = iv;
 
        while (len > 0) {
-               aescfb_encrypt_block(ctx, ks, v);
+               aescfb_encrypt_block(key, ks, v);
                crypto_xor_cpy(dst, src, ks, min(len, AES_BLOCK_SIZE));
                v = dst;
 
@@ -61,18 +61,18 @@ EXPORT_SYMBOL(aescfb_encrypt);
 /**
  * aescfb_decrypt - Perform AES-CFB decryption on a block of data
  *
- * @ctx:       The AES-CFB key schedule
+ * @key:       The AES-CFB key schedule
  * @dst:       Pointer to the plaintext output buffer
  * @src:       Pointer the ciphertext (may equal @dst for decryption in place)
  * @len:       The size in bytes of the plaintext and ciphertext.
  * @iv:                The initialization vector (IV) to use for this block of data
  */
-void aescfb_decrypt(const struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src,
+void aescfb_decrypt(const struct aes_enckey *key, u8 *dst, const u8 *src,
                    int len, const u8 iv[AES_BLOCK_SIZE])
 {
        u8 ks[2][AES_BLOCK_SIZE];
 
-       aescfb_encrypt_block(ctx, ks[0], iv);
+       aescfb_encrypt_block(key, ks[0], iv);
 
        for (int i = 0; len > 0; i ^= 1) {
                if (len > AES_BLOCK_SIZE)
@@ -81,7 +81,7 @@ void aescfb_decrypt(const struct crypto_aes_ctx *ctx, u8 *dst, const u8 *src,
                         * performing the XOR, as that may update in place and
                         * overwrite the ciphertext.
                         */
-                       aescfb_encrypt_block(ctx, ks[!i], src);
+                       aescfb_encrypt_block(key, ks[!i], src);
 
                crypto_xor_cpy(dst, src, ks[i], min(len, AES_BLOCK_SIZE));
 
@@ -214,15 +214,15 @@ static struct {
 static int __init libaescfb_init(void)
 {
        for (int i = 0; i < ARRAY_SIZE(aescfb_tv); i++) {
-               struct crypto_aes_ctx ctx;
+               struct aes_enckey key;
                u8 buf[64];
 
-               if (aes_expandkey(&ctx, aescfb_tv[i].key, aescfb_tv[i].klen)) {
-                       pr_err("aes_expandkey() failed on vector %d\n", i);
+               if (aes_prepareenckey(&key, aescfb_tv[i].key, aescfb_tv[i].klen)) {
+                       pr_err("aes_prepareenckey() failed on vector %d\n", i);
                        return -ENODEV;
                }
 
-               aescfb_encrypt(&ctx, buf, aescfb_tv[i].ptext, aescfb_tv[i].len,
+               aescfb_encrypt(&key, buf, aescfb_tv[i].ptext, aescfb_tv[i].len,
                               aescfb_tv[i].iv);
                if (memcmp(buf, aescfb_tv[i].ctext, aescfb_tv[i].len)) {
                        pr_err("aescfb_encrypt() #1 failed on vector %d\n", i);
@@ -230,14 +230,14 @@ static int __init libaescfb_init(void)
                }
 
                /* decrypt in place */
-               aescfb_decrypt(&ctx, buf, buf, aescfb_tv[i].len, aescfb_tv[i].iv);
+               aescfb_decrypt(&key, buf, buf, aescfb_tv[i].len, aescfb_tv[i].iv);
                if (memcmp(buf, aescfb_tv[i].ptext, aescfb_tv[i].len)) {
                        pr_err("aescfb_decrypt() failed on vector %d\n", i);
                        return -ENODEV;
                }
 
                /* encrypt in place */
-               aescfb_encrypt(&ctx, buf, buf, aescfb_tv[i].len, aescfb_tv[i].iv);
+               aescfb_encrypt(&key, buf, buf, aescfb_tv[i].len, aescfb_tv[i].iv);
                if (memcmp(buf, aescfb_tv[i].ctext, aescfb_tv[i].len)) {
                        pr_err("aescfb_encrypt() #2 failed on vector %d\n", i);