crypto: x86/serpent-sse2 - convert to skcipher interface

Convert the SSE2 implementation of Serpent from the (deprecated)
ablkcipher and blkcipher interfaces over to the skcipher interface.
Note that this includes replacing the use of ablk_helper with
crypto_simd.

Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

diff --git a/arch/x86/crypto/serpent_sse2_glue.c b/arch/x86/crypto/serpent_sse2_glue.c
index 9e2734384ce584b15cb09fbe52b1de1211fa4522..3dafe137596a9fc6f3acf602e68652e5869973ae 100644 (file)
--- a/arch/x86/crypto/serpent_sse2_glue.c
+++ b/arch/x86/crypto/serpent_sse2_glue.c
@@ -30,19 +30,22 @@
  */
 
 #include <linux/module.h>
-#include <linux/hardirq.h>
 #include <linux/types.h>
 #include <linux/crypto.h>
 #include <linux/err.h>
-#include <crypto/ablk_helper.h>
 #include <crypto/algapi.h>
-#include <crypto/serpent.h>
-#include <crypto/cryptd.h>
 #include <crypto/b128ops.h>
-#include <crypto/ctr.h>
+#include <crypto/internal/simd.h>
+#include <crypto/serpent.h>
 #include <asm/crypto/serpent-sse2.h>
 #include <asm/crypto/glue_helper.h>
 
+static int serpent_setkey_skcipher(struct crypto_skcipher *tfm,
+                                  const u8 *key, unsigned int keylen)
+{
+       return __serpent_setkey(crypto_skcipher_ctx(tfm), key, keylen);
+}
+
 static void serpent_decrypt_cbc_xway(void *ctx, u128 *dst, const u128 *src)
 {
        u128 ivs[SERPENT_PARALLEL_BLOCKS - 1];
@@ -137,166 +140,79 @@ static const struct common_glue_ctx serpent_dec_cbc = {
        } }
 };
 
-static int ecb_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int ecb_encrypt(struct skcipher_request *req)
 {
-       return glue_ecb_crypt_128bit(&serpent_enc, desc, dst, src, nbytes);
+       return glue_ecb_req_128bit(&serpent_enc, req);
 }
 
-static int ecb_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int ecb_decrypt(struct skcipher_request *req)
 {
-       return glue_ecb_crypt_128bit(&serpent_dec, desc, dst, src, nbytes);
+       return glue_ecb_req_128bit(&serpent_dec, req);
 }
 
-static int cbc_encrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int cbc_encrypt(struct skcipher_request *req)
 {
-       return glue_cbc_encrypt_128bit(GLUE_FUNC_CAST(__serpent_encrypt), desc,
-                                    dst, src, nbytes);
+       return glue_cbc_encrypt_req_128bit(GLUE_FUNC_CAST(__serpent_encrypt),
+                                          req);
 }
 
-static int cbc_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                      struct scatterlist *src, unsigned int nbytes)
+static int cbc_decrypt(struct skcipher_request *req)
 {
-       return glue_cbc_decrypt_128bit(&serpent_dec_cbc, desc, dst, src,
-                                      nbytes);
+       return glue_cbc_decrypt_req_128bit(&serpent_dec_cbc, req);
 }
 
-static int ctr_crypt(struct blkcipher_desc *desc, struct scatterlist *dst,
-                    struct scatterlist *src, unsigned int nbytes)
+static int ctr_crypt(struct skcipher_request *req)
 {
-       return glue_ctr_crypt_128bit(&serpent_ctr, desc, dst, src, nbytes);
+       return glue_ctr_req_128bit(&serpent_ctr, req);
 }
 
-static struct crypto_alg serpent_algs[] = { {
-       .cra_name               = "__ecb-serpent-sse2",
-       .cra_driver_name        = "__driver-ecb-serpent-sse2",
-       .cra_priority           = 0,
-       .cra_flags              = CRYPTO_ALG_TYPE_BLKCIPHER |
-                                 CRYPTO_ALG_INTERNAL,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct serpent_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_blkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_u = {
-               .blkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .setkey         = serpent_setkey,
-                       .encrypt        = ecb_encrypt,
-                       .decrypt        = ecb_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "__cbc-serpent-sse2",
-       .cra_driver_name        = "__driver-cbc-serpent-sse2",
-       .cra_priority           = 0,
-       .cra_flags              = CRYPTO_ALG_TYPE_BLKCIPHER |
-                                 CRYPTO_ALG_INTERNAL,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct serpent_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_blkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_u = {
-               .blkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .setkey         = serpent_setkey,
-                       .encrypt        = cbc_encrypt,
-                       .decrypt        = cbc_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "__ctr-serpent-sse2",
-       .cra_driver_name        = "__driver-ctr-serpent-sse2",
-       .cra_priority           = 0,
-       .cra_flags              = CRYPTO_ALG_TYPE_BLKCIPHER |
-                                 CRYPTO_ALG_INTERNAL,
-       .cra_blocksize          = 1,
-       .cra_ctxsize            = sizeof(struct serpent_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_blkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_u = {
-               .blkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = serpent_setkey,
-                       .encrypt        = ctr_crypt,
-                       .decrypt        = ctr_crypt,
-               },
-       },
-}, {
-       .cra_name               = "ecb(serpent)",
-       .cra_driver_name        = "ecb-serpent-sse2",
-       .cra_priority           = 400,
-       .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct async_helper_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_ablkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_init               = ablk_init,
-       .cra_exit               = ablk_exit,
-       .cra_u = {
-               .ablkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .setkey         = ablk_set_key,
-                       .encrypt        = ablk_encrypt,
-                       .decrypt        = ablk_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "cbc(serpent)",
-       .cra_driver_name        = "cbc-serpent-sse2",
-       .cra_priority           = 400,
-       .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
-       .cra_blocksize          = SERPENT_BLOCK_SIZE,
-       .cra_ctxsize            = sizeof(struct async_helper_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_ablkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_init               = ablk_init,
-       .cra_exit               = ablk_exit,
-       .cra_u = {
-               .ablkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = ablk_set_key,
-                       .encrypt        = __ablk_encrypt,
-                       .decrypt        = ablk_decrypt,
-               },
-       },
-}, {
-       .cra_name               = "ctr(serpent)",
-       .cra_driver_name        = "ctr-serpent-sse2",
-       .cra_priority           = 400,
-       .cra_flags              = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
-       .cra_blocksize          = 1,
-       .cra_ctxsize            = sizeof(struct async_helper_ctx),
-       .cra_alignmask          = 0,
-       .cra_type               = &crypto_ablkcipher_type,
-       .cra_module             = THIS_MODULE,
-       .cra_init               = ablk_init,
-       .cra_exit               = ablk_exit,
-       .cra_u = {
-               .ablkcipher = {
-                       .min_keysize    = SERPENT_MIN_KEY_SIZE,
-                       .max_keysize    = SERPENT_MAX_KEY_SIZE,
-                       .ivsize         = SERPENT_BLOCK_SIZE,
-                       .setkey         = ablk_set_key,
-                       .encrypt        = ablk_encrypt,
-                       .decrypt        = ablk_encrypt,
-                       .geniv          = "chainiv",
-               },
+static struct skcipher_alg serpent_algs[] = {
+       {
+               .base.cra_name          = "__ecb(serpent)",
+               .base.cra_driver_name   = "__ecb-serpent-sse2",
+               .base.cra_priority      = 400,
+               .base.cra_flags         = CRYPTO_ALG_INTERNAL,
+               .base.cra_blocksize     = SERPENT_BLOCK_SIZE,
+               .base.cra_ctxsize       = sizeof(struct serpent_ctx),
+               .base.cra_module        = THIS_MODULE,
+               .min_keysize            = SERPENT_MIN_KEY_SIZE,
+               .max_keysize            = SERPENT_MAX_KEY_SIZE,
+               .setkey                 = serpent_setkey_skcipher,
+               .encrypt                = ecb_encrypt,
+               .decrypt                = ecb_decrypt,
+       }, {
+               .base.cra_name          = "__cbc(serpent)",
+               .base.cra_driver_name   = "__cbc-serpent-sse2",
+               .base.cra_priority      = 400,
+               .base.cra_flags         = CRYPTO_ALG_INTERNAL,
+               .base.cra_blocksize     = SERPENT_BLOCK_SIZE,
+               .base.cra_ctxsize       = sizeof(struct serpent_ctx),
+               .base.cra_module        = THIS_MODULE,
+               .min_keysize            = SERPENT_MIN_KEY_SIZE,
+               .max_keysize            = SERPENT_MAX_KEY_SIZE,
+               .ivsize                 = SERPENT_BLOCK_SIZE,
+               .setkey                 = serpent_setkey_skcipher,
+               .encrypt                = cbc_encrypt,
+               .decrypt                = cbc_decrypt,
+       }, {
+               .base.cra_name          = "__ctr(serpent)",
+               .base.cra_driver_name   = "__ctr-serpent-sse2",
+               .base.cra_priority      = 400,
+               .base.cra_flags         = CRYPTO_ALG_INTERNAL,
+               .base.cra_blocksize     = 1,
+               .base.cra_ctxsize       = sizeof(struct serpent_ctx),
+               .base.cra_module        = THIS_MODULE,
+               .min_keysize            = SERPENT_MIN_KEY_SIZE,
+               .max_keysize            = SERPENT_MAX_KEY_SIZE,
+               .ivsize                 = SERPENT_BLOCK_SIZE,
+               .chunksize              = SERPENT_BLOCK_SIZE,
+               .setkey                 = serpent_setkey_skcipher,
+               .encrypt                = ctr_crypt,
+               .decrypt                = ctr_crypt,
        },
-} };
+};
+
+static struct simd_skcipher_alg *serpent_simd_algs[ARRAY_SIZE(serpent_algs)];
 
 static int __init serpent_sse2_init(void)
 {
@@ -305,12 +221,15 @@ static int __init serpent_sse2_init(void)
                return -ENODEV;
        }
 
-       return crypto_register_algs(serpent_algs, ARRAY_SIZE(serpent_algs));
+       return simd_register_skciphers_compat(serpent_algs,
+                                             ARRAY_SIZE(serpent_algs),
+                                             serpent_simd_algs);
 }
 
 static void __exit serpent_sse2_exit(void)
 {
-       crypto_unregister_algs(serpent_algs, ARRAY_SIZE(serpent_algs));
+       simd_unregister_skciphers(serpent_algs, ARRAY_SIZE(serpent_algs),
+                                 serpent_simd_algs);
 }
 
 module_init(serpent_sse2_init);

diff --git a/crypto/Kconfig b/crypto/Kconfig
index 4b2026e07bacf81d154854fb57846d70babff515..f6d3eec494ee4c3e83d680ca55c3025b8e093a99 100644 (file)
--- a/crypto/Kconfig
+++ b/crypto/Kconfig
@@ -1422,11 +1422,10 @@ config CRYPTO_SERPENT
 config CRYPTO_SERPENT_SSE2_X86_64
        tristate "Serpent cipher algorithm (x86_64/SSE2)"
        depends on X86 && 64BIT
-       select CRYPTO_ALGAPI
-       select CRYPTO_CRYPTD
-       select CRYPTO_ABLK_HELPER
+       select CRYPTO_BLKCIPHER
        select CRYPTO_GLUE_HELPER_X86
        select CRYPTO_SERPENT
+       select CRYPTO_SIMD
        help
          Serpent cipher algorithm, by Anderson, Biham & Knudsen.
 
@@ -1442,11 +1441,10 @@ config CRYPTO_SERPENT_SSE2_X86_64
 config CRYPTO_SERPENT_SSE2_586
        tristate "Serpent cipher algorithm (i586/SSE2)"
        depends on X86 && !64BIT
-       select CRYPTO_ALGAPI
-       select CRYPTO_CRYPTD
-       select CRYPTO_ABLK_HELPER
+       select CRYPTO_BLKCIPHER
        select CRYPTO_GLUE_HELPER_X86
        select CRYPTO_SERPENT
+       select CRYPTO_SIMD
        help
          Serpent cipher algorithm, by Anderson, Biham & Knudsen.