crypto: chacha - register only "-lib" drivers

For the "chacha20", "xchacha20", and "xchacha12" skcipher algorithms,
instead of registering "*-generic" drivers as well as conditionally
registering "*-$(ARCH)" drivers, instead just register "*-lib" drivers.
These just use the regular library functions, so they just do the right
thing and are fully accelerated when supported by the CPU.

This eliminates the need for the ChaCha library to support
chacha_crypt_generic() and hchacha_block_generic() as part of its
external interface.  A later commit will make chacha_crypt_generic() a
static function.

Since this commit removes several "*-generic" driver names which
crypto/testmgr.c expects to exist, update testmgr.c accordingly.

Reviewed-by: Ard Biesheuvel <ardb@kernel.org>
Link: https://lore.kernel.org/r/20250827151131.27733-3-ebiggers@kernel.org
Signed-off-by: Eric Biggers <ebiggers@kernel.org>

diff --git a/crypto/Kconfig b/crypto/Kconfig
index e8ccf5f51b85534b9cccec8b80b989f563cdd8ef..09e8fb6ee0813f6f97d75db6a2c86a41d67e4a9e 100644 (file)
--- a/crypto/Kconfig
+++ b/crypto/Kconfig
@@ -648,7 +648,6 @@ config CRYPTO_ARC4
 config CRYPTO_CHACHA20
        tristate "ChaCha"
        select CRYPTO_LIB_CHACHA
-       select CRYPTO_LIB_CHACHA_GENERIC
        select CRYPTO_SKCIPHER
        help
          The ChaCha20, XChaCha20, and XChaCha12 stream cipher algorithms

diff --git a/crypto/chacha.c b/crypto/chacha.c
index c3a11f4e2d13dc46d7f223077921e7668b5caf07..ec16d5a33f3cd6748b2aa28e4ec80710b52c453e 100644 (file)
--- a/crypto/chacha.c
+++ b/crypto/chacha.c
@@ -47,7 +47,7 @@ static int chacha12_setkey(struct crypto_skcipher *tfm,
 
 static int chacha_stream_xor(struct skcipher_request *req,
                             const struct chacha_ctx *ctx,
-                            const u8 iv[CHACHA_IV_SIZE], bool arch)
+                            const u8 iv[CHACHA_IV_SIZE])
 {
        struct skcipher_walk walk;
        struct chacha_state state;
@@ -63,36 +63,23 @@ static int chacha_stream_xor(struct skcipher_request *req,
                if (nbytes < walk.total)
                        nbytes = round_down(nbytes, CHACHA_BLOCK_SIZE);
 
-               if (arch)
-                       chacha_crypt(&state, walk.dst.virt.addr,
-                                    walk.src.virt.addr, nbytes, ctx->nrounds);
-               else
-                       chacha_crypt_generic(&state, walk.dst.virt.addr,
-                                            walk.src.virt.addr, nbytes,
-                                            ctx->nrounds);
+               chacha_crypt(&state, walk.dst.virt.addr, walk.src.virt.addr,
+                            nbytes, ctx->nrounds);
                err = skcipher_walk_done(&walk, walk.nbytes - nbytes);
        }
 
        return err;
 }
 
-static int crypto_chacha_crypt_generic(struct skcipher_request *req)
+static int crypto_chacha_crypt(struct skcipher_request *req)
 {
        struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
        const struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
 
-       return chacha_stream_xor(req, ctx, req->iv, false);
+       return chacha_stream_xor(req, ctx, req->iv);
 }
 
-static int crypto_chacha_crypt_arch(struct skcipher_request *req)
-{
-       struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
-       const struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
-
-       return chacha_stream_xor(req, ctx, req->iv, true);
-}
-
-static int crypto_xchacha_crypt(struct skcipher_request *req, bool arch)
+static int crypto_xchacha_crypt(struct skcipher_request *req)
 {
        struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
        const struct chacha_ctx *ctx = crypto_skcipher_ctx(tfm);
@@ -102,10 +89,7 @@ static int crypto_xchacha_crypt(struct skcipher_request *req, bool arch)
 
        /* Compute the subkey given the original key and first 128 nonce bits */
        chacha_init(&state, ctx->key, req->iv);
-       if (arch)
-               hchacha_block(&state, subctx.key, ctx->nrounds);
-       else
-               hchacha_block_generic(&state, subctx.key, ctx->nrounds);
+       hchacha_block(&state, subctx.key, ctx->nrounds);
        subctx.nrounds = ctx->nrounds;
 
        /* Build the real IV */
@@ -113,71 +97,13 @@ static int crypto_xchacha_crypt(struct skcipher_request *req, bool arch)
        memcpy(&real_iv[8], req->iv + 16, 8); /* remaining 64 nonce bits */
 
        /* Generate the stream and XOR it with the data */
-       return chacha_stream_xor(req, &subctx, real_iv, arch);
-}
-
-static int crypto_xchacha_crypt_generic(struct skcipher_request *req)
-{
-       return crypto_xchacha_crypt(req, false);
-}
-
-static int crypto_xchacha_crypt_arch(struct skcipher_request *req)
-{
-       return crypto_xchacha_crypt(req, true);
+       return chacha_stream_xor(req, &subctx, real_iv);
 }
 
 static struct skcipher_alg algs[] = {
        {
                .base.cra_name          = "chacha20",
-               .base.cra_driver_name   = "chacha20-generic",
-               .base.cra_priority      = 100,
-               .base.cra_blocksize     = 1,
-               .base.cra_ctxsize       = sizeof(struct chacha_ctx),
-               .base.cra_module        = THIS_MODULE,
-
-               .min_keysize            = CHACHA_KEY_SIZE,
-               .max_keysize            = CHACHA_KEY_SIZE,
-               .ivsize                 = CHACHA_IV_SIZE,
-               .chunksize              = CHACHA_BLOCK_SIZE,
-               .setkey                 = chacha20_setkey,
-               .encrypt                = crypto_chacha_crypt_generic,
-               .decrypt                = crypto_chacha_crypt_generic,
-       },
-       {
-               .base.cra_name          = "xchacha20",
-               .base.cra_driver_name   = "xchacha20-generic",
-               .base.cra_priority      = 100,
-               .base.cra_blocksize     = 1,
-               .base.cra_ctxsize       = sizeof(struct chacha_ctx),
-               .base.cra_module        = THIS_MODULE,
-
-               .min_keysize            = CHACHA_KEY_SIZE,
-               .max_keysize            = CHACHA_KEY_SIZE,
-               .ivsize                 = XCHACHA_IV_SIZE,
-               .chunksize              = CHACHA_BLOCK_SIZE,
-               .setkey                 = chacha20_setkey,
-               .encrypt                = crypto_xchacha_crypt_generic,
-               .decrypt                = crypto_xchacha_crypt_generic,
-       },
-       {
-               .base.cra_name          = "xchacha12",
-               .base.cra_driver_name   = "xchacha12-generic",
-               .base.cra_priority      = 100,
-               .base.cra_blocksize     = 1,
-               .base.cra_ctxsize       = sizeof(struct chacha_ctx),
-               .base.cra_module        = THIS_MODULE,
-
-               .min_keysize            = CHACHA_KEY_SIZE,
-               .max_keysize            = CHACHA_KEY_SIZE,
-               .ivsize                 = XCHACHA_IV_SIZE,
-               .chunksize              = CHACHA_BLOCK_SIZE,
-               .setkey                 = chacha12_setkey,
-               .encrypt                = crypto_xchacha_crypt_generic,
-               .decrypt                = crypto_xchacha_crypt_generic,
-       },
-       {
-               .base.cra_name          = "chacha20",
-               .base.cra_driver_name   = "chacha20-" __stringify(ARCH),
+               .base.cra_driver_name   = "chacha20-lib",
                .base.cra_priority      = 300,
                .base.cra_blocksize     = 1,
                .base.cra_ctxsize       = sizeof(struct chacha_ctx),
@@ -188,12 +114,12 @@ static struct skcipher_alg algs[] = {
                .ivsize                 = CHACHA_IV_SIZE,
                .chunksize              = CHACHA_BLOCK_SIZE,
                .setkey                 = chacha20_setkey,
-               .encrypt                = crypto_chacha_crypt_arch,
-               .decrypt                = crypto_chacha_crypt_arch,
+               .encrypt                = crypto_chacha_crypt,
+               .decrypt                = crypto_chacha_crypt,
        },
        {
                .base.cra_name          = "xchacha20",
-               .base.cra_driver_name   = "xchacha20-" __stringify(ARCH),
+               .base.cra_driver_name   = "xchacha20-lib",
                .base.cra_priority      = 300,
                .base.cra_blocksize     = 1,
                .base.cra_ctxsize       = sizeof(struct chacha_ctx),
@@ -204,12 +130,12 @@ static struct skcipher_alg algs[] = {
                .ivsize                 = XCHACHA_IV_SIZE,
                .chunksize              = CHACHA_BLOCK_SIZE,
                .setkey                 = chacha20_setkey,
-               .encrypt                = crypto_xchacha_crypt_arch,
-               .decrypt                = crypto_xchacha_crypt_arch,
+               .encrypt                = crypto_xchacha_crypt,
+               .decrypt                = crypto_xchacha_crypt,
        },
        {
                .base.cra_name          = "xchacha12",
-               .base.cra_driver_name   = "xchacha12-" __stringify(ARCH),
+               .base.cra_driver_name   = "xchacha12-lib",
                .base.cra_priority      = 300,
                .base.cra_blocksize     = 1,
                .base.cra_ctxsize       = sizeof(struct chacha_ctx),
@@ -220,27 +146,19 @@ static struct skcipher_alg algs[] = {
                .ivsize                 = XCHACHA_IV_SIZE,
                .chunksize              = CHACHA_BLOCK_SIZE,
                .setkey                 = chacha12_setkey,
-               .encrypt                = crypto_xchacha_crypt_arch,
-               .decrypt                = crypto_xchacha_crypt_arch,
+               .encrypt                = crypto_xchacha_crypt,
+               .decrypt                = crypto_xchacha_crypt,
        }
 };
 
-static unsigned int num_algs;
-
 static int __init crypto_chacha_mod_init(void)
 {
-       /* register the arch flavours only if they differ from generic */
-       num_algs = ARRAY_SIZE(algs);
-       BUILD_BUG_ON(ARRAY_SIZE(algs) % 2 != 0);
-       if (!chacha_is_arch_optimized())
-               num_algs /= 2;
-
-       return crypto_register_skciphers(algs, num_algs);
+       return crypto_register_skciphers(algs, ARRAY_SIZE(algs));
 }
 
 static void __exit crypto_chacha_mod_fini(void)
 {
-       crypto_unregister_skciphers(algs, num_algs);
+       crypto_unregister_skciphers(algs, ARRAY_SIZE(algs));
 }
 
 module_init(crypto_chacha_mod_init);
@@ -250,11 +168,8 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Martin Willi <martin@strongswan.org>");
 MODULE_DESCRIPTION("Crypto API wrappers for the ChaCha20, XChaCha20, and XChaCha12 stream ciphers");
 MODULE_ALIAS_CRYPTO("chacha20");
-MODULE_ALIAS_CRYPTO("chacha20-generic");
-MODULE_ALIAS_CRYPTO("chacha20-"  __stringify(ARCH));
+MODULE_ALIAS_CRYPTO("chacha20-lib");
 MODULE_ALIAS_CRYPTO("xchacha20");
-MODULE_ALIAS_CRYPTO("xchacha20-generic");
-MODULE_ALIAS_CRYPTO("xchacha20-"  __stringify(ARCH));
+MODULE_ALIAS_CRYPTO("xchacha20-lib");
 MODULE_ALIAS_CRYPTO("xchacha12");
-MODULE_ALIAS_CRYPTO("xchacha12-generic");
-MODULE_ALIAS_CRYPTO("xchacha12-"  __stringify(ARCH));
+MODULE_ALIAS_CRYPTO("xchacha12-lib");

diff --git a/crypto/testmgr.c b/crypto/testmgr.c
index beab926ba102e50085a9d59b248d64a34f12ef5c..781445f5f56a61122aec76578c8a349303352b3b 100644 (file)
--- a/crypto/testmgr.c
+++ b/crypto/testmgr.c
@@ -4152,14 +4152,14 @@ static int alg_test_null(const struct alg_test_desc *desc,
 static const struct alg_test_desc alg_test_descs[] = {
        {
                .alg = "adiantum(xchacha12,aes)",
-               .generic_driver = "adiantum(xchacha12-generic,aes-generic,nhpoly1305-generic)",
+               .generic_driver = "adiantum(xchacha12-lib,aes-generic,nhpoly1305-generic)",
                .test = alg_test_skcipher,
                .suite = {
                        .cipher = __VECS(adiantum_xchacha12_aes_tv_template)
                },
        }, {
                .alg = "adiantum(xchacha20,aes)",
-               .generic_driver = "adiantum(xchacha20-generic,aes-generic,nhpoly1305-generic)",
+               .generic_driver = "adiantum(xchacha20-lib,aes-generic,nhpoly1305-generic)",
                .test = alg_test_skcipher,
                .suite = {
                        .cipher = __VECS(adiantum_xchacha20_aes_tv_template)
@@ -4485,6 +4485,7 @@ static const struct alg_test_desc alg_test_descs[] = {
                }
        }, {
                .alg = "chacha20",
+               .generic_driver = "chacha20-lib",
                .test = alg_test_skcipher,
                .suite = {
                        .cipher = __VECS(chacha20_tv_template)
@@ -5420,12 +5421,14 @@ static const struct alg_test_desc alg_test_descs[] = {
                }
        }, {
                .alg = "rfc7539(chacha20,poly1305)",
+               .generic_driver = "rfc7539(chacha20-lib,poly1305-generic)",
                .test = alg_test_aead,
                .suite = {
                        .aead = __VECS(rfc7539_tv_template)
                }
        }, {
                .alg = "rfc7539esp(chacha20,poly1305)",
+               .generic_driver = "rfc7539esp(chacha20-lib,poly1305-generic)",
                .test = alg_test_aead,
                .suite = {
                        .aead = {
@@ -5591,12 +5594,14 @@ static const struct alg_test_desc alg_test_descs[] = {
                }
        }, {
                .alg = "xchacha12",
+               .generic_driver = "xchacha12-lib",
                .test = alg_test_skcipher,
                .suite = {
                        .cipher = __VECS(xchacha12_tv_template)
                },
        }, {
                .alg = "xchacha20",
+               .generic_driver = "xchacha20-lib",
                .test = alg_test_skcipher,
                .suite = {
                        .cipher = __VECS(xchacha20_tv_template)