crypto: arc4 - remove cipher implementation

There are no remaining users of the cipher implementation, and there
are no meaningful ways in which the arc4 cipher can be combined with
templates other than ECB (and the way we do provide that combination
is highly dubious to begin with).

So let's drop the arc4 cipher altogether, and only keep the ecb(arc4)
skcipher, which is used in various places in the kernel.

Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/crypto/arc4.c b/crypto/arc4.c
index d303b7ff1fed8dad1edb3c584d39aa915f3ab948..dbb1f8b65396e5afec33516c155017f1149b20f7 100644 (file)
--- a/crypto/arc4.c
+++ b/crypto/arc4.c
@@ -18,26 +18,15 @@
 #include <linux/init.h>
 #include <linux/module.h>
 
-static int arc4_set_key(struct crypto_tfm *tfm, const u8 *in_key,
-                       unsigned int key_len)
+static int crypto_arc4_setkey(struct crypto_skcipher *tfm, const u8 *in_key,
+                             unsigned int key_len)
 {
-       struct arc4_ctx *ctx = crypto_tfm_ctx(tfm);
+       struct arc4_ctx *ctx = crypto_skcipher_ctx(tfm);
 
        return arc4_setkey(ctx, in_key, key_len);
 }
 
-static int arc4_set_key_skcipher(struct crypto_skcipher *tfm, const u8 *in_key,
-                                unsigned int key_len)
-{
-       return arc4_set_key(&tfm->base, in_key, key_len);
-}
-
-static void arc4_crypt_one(struct crypto_tfm *tfm, u8 *out, const u8 *in)
-{
-       arc4_crypt(crypto_tfm_ctx(tfm), out, in, 1);
-}
-
-static int ecb_arc4_crypt(struct skcipher_request *req)
+static int crypto_arc4_crypt(struct skcipher_request *req)
 {
        struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
        struct arc4_ctx *ctx = crypto_skcipher_ctx(tfm);
@@ -55,25 +44,11 @@ static int ecb_arc4_crypt(struct skcipher_request *req)
        return err;
 }
 
-static struct crypto_alg arc4_cipher = {
-       .cra_name               =       "arc4",
-       .cra_driver_name        =       "arc4-generic",
-       .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
-       .cra_blocksize          =       ARC4_BLOCK_SIZE,
-       .cra_ctxsize            =       sizeof(struct arc4_ctx),
-       .cra_module             =       THIS_MODULE,
-       .cra_u                  =       {
-               .cipher = {
-                       .cia_min_keysize        =       ARC4_MIN_KEY_SIZE,
-                       .cia_max_keysize        =       ARC4_MAX_KEY_SIZE,
-                       .cia_setkey             =       arc4_set_key,
-                       .cia_encrypt            =       arc4_crypt_one,
-                       .cia_decrypt            =       arc4_crypt_one,
-               },
-       },
-};
-
-static struct skcipher_alg arc4_skcipher = {
+static struct skcipher_alg arc4_alg = {
+       /*
+        * For legacy reasons, this is named "ecb(arc4)", not "arc4".
+        * Nevertheless it's actually a stream cipher, not a block cipher.
+        */
        .base.cra_name          =       "ecb(arc4)",
        .base.cra_driver_name   =       "ecb(arc4)-generic",
        .base.cra_priority      =       100,
@@ -82,29 +57,19 @@ static struct skcipher_alg arc4_skcipher = {
        .base.cra_module        =       THIS_MODULE,
        .min_keysize            =       ARC4_MIN_KEY_SIZE,
        .max_keysize            =       ARC4_MAX_KEY_SIZE,
-       .setkey                 =       arc4_set_key_skcipher,
-       .encrypt                =       ecb_arc4_crypt,
-       .decrypt                =       ecb_arc4_crypt,
+       .setkey                 =       crypto_arc4_setkey,
+       .encrypt                =       crypto_arc4_crypt,
+       .decrypt                =       crypto_arc4_crypt,
 };
 
 static int __init arc4_init(void)
 {
-       int err;
-
-       err = crypto_register_alg(&arc4_cipher);
-       if (err)
-               return err;
-
-       err = crypto_register_skcipher(&arc4_skcipher);
-       if (err)
-               crypto_unregister_alg(&arc4_cipher);
-       return err;
+       return crypto_register_skcipher(&arc4_alg);
 }
 
 static void __exit arc4_exit(void)
 {
-       crypto_unregister_alg(&arc4_cipher);
-       crypto_unregister_skcipher(&arc4_skcipher);
+       crypto_unregister_skcipher(&arc4_alg);
 }
 
 subsys_initcall(arc4_init);
@@ -113,4 +78,4 @@ module_exit(arc4_exit);
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("ARC4 Cipher Algorithm");
 MODULE_AUTHOR("Jon Oberheide <jon@oberheide.org>");
-MODULE_ALIAS_CRYPTO("arc4");
+MODULE_ALIAS_CRYPTO("ecb(arc4)");

diff --git a/crypto/testmgr.c b/crypto/testmgr.c
index f7fdd7fe89a9efbccc489f29a84146ad0ac4b683..5d163dd2ffaca9ebed6a89f4d272bd0f702c49ca 100644 (file)
--- a/crypto/testmgr.c
+++ b/crypto/testmgr.c
@@ -4404,6 +4404,7 @@ static const struct alg_test_desc alg_test_descs[] = {
                }
        }, {
                .alg = "ecb(arc4)",
+               .generic_driver = "ecb(arc4)-generic",
                .test = alg_test_skcipher,
                .suite = {
                        .cipher = __VECS(arc4_tv_template)