Re: [PATCH v2 24/27] crypto: talitos - switch to skcipher API

[Christophe Leroy <christophe.leroy@c-s.fr>]

Le 24/10/2019 à 15:23, Ard Biesheuvel a écrit :
> Commit 7a7ffe65c8c5 ("crypto: skcipher - Add top-level skcipher interface")
> dated 20 august 2015 introduced the new skcipher API which is supposed to
> replace both blkcipher and ablkcipher. While all consumers of the API have
> been converted long ago, some producers of the ablkcipher remain, forcing
> us to keep the ablkcipher support routines alive, along with the matching
> code to expose [a]blkciphers via the skcipher API.
> 
> So switch this driver to the skcipher API, allowing us to finally drop the
> blkcipher code in the near future.
> 
> Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>

With this series, I get the following Oops at boot:

[    3.715154] BUG: Kernel NULL pointer dereference at 0x00000084
[    3.720721] Faulting instruction address: 0xc0348c9c
[    3.725641] Oops: Kernel access of bad area, sig: 11 [#1]
[    3.730981] BE PAGE_SIZE=16K PREEMPT CMPC885
[    3.735223] CPU: 0 PID: 69 Comm: cryptomgr_test Tainted: G        W 
       5.4.0-rc4-s3k-dev-00852-ga6dfc2456b41 #2442
[    3.745858] NIP:  c0348c9c LR: c021dd88 CTR: c0348c30
[    3.750864] REGS: c6303be0 TRAP: 0300   Tainted: G        W 
(5.4.0-rc4-s3k-dev-00852-ga6dfc2456b41)
[    3.760559] MSR:  00009032 <EE,ME,IR,DR,RI>  CR: 24002202  XER: 00000000
[    3.767192] DAR: 00000084 DSISR: c0000000
[    3.767192] GPR00: c021dd88 c6303c98 c61c1e00 c6348800 c7fc1a40 
00000830 00000028 c7fc1a82
[    3.767192] GPR08: 00000001 00000000 c7f90000 00000004 84002202 
00000000 c003b9b8 c62452e0
[    3.767192] GPR16: c6339a00 c6348830 c06a7ee8 000000dc c6303d30 
c6339930 c6348a00 c6303db0
[    3.767192] GPR24: 00000010 00000400 c6348c00 c05b13c8 c05d6924 
c6303cc0 00000000 c6348800
[    3.804591] NIP [c0348c9c] ahash_init+0x6c/0x128
[    3.809161] LR [c021dd88] do_ahash_op.isra.33+0x24/0x70
[    3.814256] Call Trace:
[    3.816717] [c6303ca8] [c021dd88] do_ahash_op.isra.33+0x24/0x70
[    3.822573] [c6303cb8] [c021ebc8] test_ahash_vec_cfg+0x238/0x5a8
[    3.828514] [c6303da8] [c02215c8] __alg_test_hash.isra.38+0x16c/0x334
[    3.834879] [c6303e08] [c022180c] alg_test_hash+0x7c/0x164
[    3.840299] [c6303e28] [c0222168] alg_test+0xc0/0x384
[    3.845288] [c6303ef8] [c021ce40] cryptomgr_test+0x48/0x50
[    3.850705] [c6303f08] [c003ba98] kthread+0xe0/0x10c
[    3.855619] [c6303f38] [c000e1cc] ret_from_kernel_thread+0x14/0x1c
[    3.861675] Instruction dump:
[    3.864613] 5484ba74 814afff0 7c7f1b78 314affdf 7cc63110 54c60034 
38c60048 3d40c080
[    3.872271] 814a8208 90c30078 7c8a2214 54a504be <815e0084> 0f090000 
2f8a0000 409e0058

Christophe


> ---
>   drivers/crypto/talitos.c | 306 +++++++++-----------
>   1 file changed, 142 insertions(+), 164 deletions(-)
> 
> diff --git a/drivers/crypto/talitos.c b/drivers/crypto/talitos.c
> index bcd533671ccc..c29f8c02ea05 100644
> --- a/drivers/crypto/talitos.c
> +++ b/drivers/crypto/talitos.c
> @@ -35,7 +35,7 @@
>   #include <crypto/md5.h>
>   #include <crypto/internal/aead.h>
>   #include <crypto/authenc.h>
> -#include <crypto/skcipher.h>
> +#include <crypto/internal/skcipher.h>
>   #include <crypto/hash.h>
>   #include <crypto/internal/hash.h>
>   #include <crypto/scatterwalk.h>
> @@ -1490,10 +1490,10 @@ static int aead_decrypt(struct aead_request *req)
>   	return ipsec_esp(edesc, req, false, ipsec_esp_decrypt_swauth_done);
>   }
>   
> -static int ablkcipher_setkey(struct crypto_ablkcipher *cipher,
> +static int skcipher_setkey(struct crypto_skcipher *cipher,
>   			     const u8 *key, unsigned int keylen)
>   {
> -	struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
> +	struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher);
>   	struct device *dev = ctx->dev;
>   
>   	if (ctx->keylen)
> @@ -1507,39 +1507,39 @@ static int ablkcipher_setkey(struct crypto_ablkcipher *cipher,
>   	return 0;
>   }
>   
> -static int ablkcipher_des_setkey(struct crypto_ablkcipher *cipher,
> +static int skcipher_des_setkey(struct crypto_skcipher *cipher,
>   				 const u8 *key, unsigned int keylen)
>   {
> -	return verify_ablkcipher_des_key(cipher, key) ?:
> -	       ablkcipher_setkey(cipher, key, keylen);
> +	return verify_skcipher_des_key(cipher, key) ?:
> +	       skcipher_setkey(cipher, key, keylen);
>   }
>   
> -static int ablkcipher_des3_setkey(struct crypto_ablkcipher *cipher,
> +static int skcipher_des3_setkey(struct crypto_skcipher *cipher,
>   				  const u8 *key, unsigned int keylen)
>   {
> -	return verify_ablkcipher_des3_key(cipher, key) ?:
> -	       ablkcipher_setkey(cipher, key, keylen);
> +	return verify_skcipher_des3_key(cipher, key) ?:
> +	       skcipher_setkey(cipher, key, keylen);
>   }
>   
> -static int ablkcipher_aes_setkey(struct crypto_ablkcipher *cipher,
> +static int skcipher_aes_setkey(struct crypto_skcipher *cipher,
>   				  const u8 *key, unsigned int keylen)
>   {
>   	if (keylen == AES_KEYSIZE_128 || keylen == AES_KEYSIZE_192 ||
>   	    keylen == AES_KEYSIZE_256)
> -		return ablkcipher_setkey(cipher, key, keylen);
> +		return skcipher_setkey(cipher, key, keylen);
>   
> -	crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
> +	crypto_skcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
>   
>   	return -EINVAL;
>   }
>   
>   static void common_nonsnoop_unmap(struct device *dev,
>   				  struct talitos_edesc *edesc,
> -				  struct ablkcipher_request *areq)
> +				  struct skcipher_request *areq)
>   {
>   	unmap_single_talitos_ptr(dev, &edesc->desc.ptr[5], DMA_FROM_DEVICE);
>   
> -	talitos_sg_unmap(dev, edesc, areq->src, areq->dst, areq->nbytes, 0);
> +	talitos_sg_unmap(dev, edesc, areq->src, areq->dst, areq->cryptlen, 0);
>   	unmap_single_talitos_ptr(dev, &edesc->desc.ptr[1], DMA_TO_DEVICE);
>   
>   	if (edesc->dma_len)
> @@ -1547,20 +1547,20 @@ static void common_nonsnoop_unmap(struct device *dev,
>   				 DMA_BIDIRECTIONAL);
>   }
>   
> -static void ablkcipher_done(struct device *dev,
> +static void skcipher_done(struct device *dev,
>   			    struct talitos_desc *desc, void *context,
>   			    int err)
>   {
> -	struct ablkcipher_request *areq = context;
> -	struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq);
> -	struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
> -	unsigned int ivsize = crypto_ablkcipher_ivsize(cipher);
> +	struct skcipher_request *areq = context;
> +	struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq);
> +	struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher);
> +	unsigned int ivsize = crypto_skcipher_ivsize(cipher);
>   	struct talitos_edesc *edesc;
>   
>   	edesc = container_of(desc, struct talitos_edesc, desc);
>   
>   	common_nonsnoop_unmap(dev, edesc, areq);
> -	memcpy(areq->info, ctx->iv, ivsize);
> +	memcpy(areq->iv, ctx->iv, ivsize);
>   
>   	kfree(edesc);
>   
> @@ -1568,17 +1568,17 @@ static void ablkcipher_done(struct device *dev,
>   }
>   
>   static int common_nonsnoop(struct talitos_edesc *edesc,
> -			   struct ablkcipher_request *areq,
> +			   struct skcipher_request *areq,
>   			   void (*callback) (struct device *dev,
>   					     struct talitos_desc *desc,
>   					     void *context, int error))
>   {
> -	struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq);
> -	struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
> +	struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq);
> +	struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher);
>   	struct device *dev = ctx->dev;
>   	struct talitos_desc *desc = &edesc->desc;
> -	unsigned int cryptlen = areq->nbytes;
> -	unsigned int ivsize = crypto_ablkcipher_ivsize(cipher);
> +	unsigned int cryptlen = areq->cryptlen;
> +	unsigned int ivsize = crypto_skcipher_ivsize(cipher);
>   	int sg_count, ret;
>   	bool sync_needed = false;
>   	struct talitos_private *priv = dev_get_drvdata(dev);
> @@ -1638,65 +1638,65 @@ static int common_nonsnoop(struct talitos_edesc *edesc,
>   	return ret;
>   }
>   
> -static struct talitos_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request *
> +static struct talitos_edesc *skcipher_edesc_alloc(struct skcipher_request *
>   						    areq, bool encrypt)
>   {
> -	struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq);
> -	struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
> -	unsigned int ivsize = crypto_ablkcipher_ivsize(cipher);
> +	struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq);
> +	struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher);
> +	unsigned int ivsize = crypto_skcipher_ivsize(cipher);
>   
>   	return talitos_edesc_alloc(ctx->dev, areq->src, areq->dst,
> -				   areq->info, 0, areq->nbytes, 0, ivsize, 0,
> +				   areq->iv, 0, areq->cryptlen, 0, ivsize, 0,
>   				   areq->base.flags, encrypt);
>   }
>   
> -static int ablkcipher_encrypt(struct ablkcipher_request *areq)
> +static int skcipher_encrypt(struct skcipher_request *areq)
>   {
> -	struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq);
> -	struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
> +	struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq);
> +	struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher);
>   	struct talitos_edesc *edesc;
>   	unsigned int blocksize =
> -			crypto_tfm_alg_blocksize(crypto_ablkcipher_tfm(cipher));
> +			crypto_tfm_alg_blocksize(crypto_skcipher_tfm(cipher));
>   
> -	if (!areq->nbytes)
> +	if (!areq->cryptlen)
>   		return 0;
>   
> -	if (areq->nbytes % blocksize)
> +	if (areq->cryptlen % blocksize)
>   		return -EINVAL;
>   
>   	/* allocate extended descriptor */
> -	edesc = ablkcipher_edesc_alloc(areq, true);
> +	edesc = skcipher_edesc_alloc(areq, true);
>   	if (IS_ERR(edesc))
>   		return PTR_ERR(edesc);
>   
>   	/* set encrypt */
>   	edesc->desc.hdr = ctx->desc_hdr_template | DESC_HDR_MODE0_ENCRYPT;
>   
> -	return common_nonsnoop(edesc, areq, ablkcipher_done);
> +	return common_nonsnoop(edesc, areq, skcipher_done);
>   }
>   
> -static int ablkcipher_decrypt(struct ablkcipher_request *areq)
> +static int skcipher_decrypt(struct skcipher_request *areq)
>   {
> -	struct crypto_ablkcipher *cipher = crypto_ablkcipher_reqtfm(areq);
> -	struct talitos_ctx *ctx = crypto_ablkcipher_ctx(cipher);
> +	struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(areq);
> +	struct talitos_ctx *ctx = crypto_skcipher_ctx(cipher);
>   	struct talitos_edesc *edesc;
>   	unsigned int blocksize =
> -			crypto_tfm_alg_blocksize(crypto_ablkcipher_tfm(cipher));
> +			crypto_tfm_alg_blocksize(crypto_skcipher_tfm(cipher));
>   
> -	if (!areq->nbytes)
> +	if (!areq->cryptlen)
>   		return 0;
>   
> -	if (areq->nbytes % blocksize)
> +	if (areq->cryptlen % blocksize)
>   		return -EINVAL;
>   
>   	/* allocate extended descriptor */
> -	edesc = ablkcipher_edesc_alloc(areq, false);
> +	edesc = skcipher_edesc_alloc(areq, false);
>   	if (IS_ERR(edesc))
>   		return PTR_ERR(edesc);
>   
>   	edesc->desc.hdr = ctx->desc_hdr_template | DESC_HDR_DIR_INBOUND;
>   
> -	return common_nonsnoop(edesc, areq, ablkcipher_done);
> +	return common_nonsnoop(edesc, areq, skcipher_done);
>   }
>   
>   static void common_nonsnoop_hash_unmap(struct device *dev,
> @@ -2257,7 +2257,7 @@ struct talitos_alg_template {
>   	u32 type;
>   	u32 priority;
>   	union {
> -		struct crypto_alg crypto;
> +		struct skcipher_alg skcipher;
>   		struct ahash_alg hash;
>   		struct aead_alg aead;
>   	} alg;
> @@ -2702,123 +2702,102 @@ static struct talitos_alg_template driver_algs[] = {
>   				     DESC_HDR_MODE1_MDEU_PAD |
>   				     DESC_HDR_MODE1_MDEU_MD5_HMAC,
>   	},
> -	/* ABLKCIPHER algorithms. */
> -	{	.type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> -		.alg.crypto = {
> -			.cra_name = "ecb(aes)",
> -			.cra_driver_name = "ecb-aes-talitos",
> -			.cra_blocksize = AES_BLOCK_SIZE,
> -			.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
> -				     CRYPTO_ALG_ASYNC,
> -			.cra_ablkcipher = {
> -				.min_keysize = AES_MIN_KEY_SIZE,
> -				.max_keysize = AES_MAX_KEY_SIZE,
> -				.setkey = ablkcipher_aes_setkey,
> -			}
> +	/* SKCIPHER algorithms. */
> +	{	.type = CRYPTO_ALG_TYPE_SKCIPHER,
> +		.alg.skcipher = {
> +			.base.cra_name = "ecb(aes)",
> +			.base.cra_driver_name = "ecb-aes-talitos",
> +			.base.cra_blocksize = AES_BLOCK_SIZE,
> +			.base.cra_flags = CRYPTO_ALG_ASYNC,
> +			.min_keysize = AES_MIN_KEY_SIZE,
> +			.max_keysize = AES_MAX_KEY_SIZE,
> +			.setkey = skcipher_aes_setkey,
>   		},
>   		.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU |
>   				     DESC_HDR_SEL0_AESU,
>   	},
> -	{	.type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> -		.alg.crypto = {
> -			.cra_name = "cbc(aes)",
> -			.cra_driver_name = "cbc-aes-talitos",
> -			.cra_blocksize = AES_BLOCK_SIZE,
> -			.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
> -                                     CRYPTO_ALG_ASYNC,
> -			.cra_ablkcipher = {
> -				.min_keysize = AES_MIN_KEY_SIZE,
> -				.max_keysize = AES_MAX_KEY_SIZE,
> -				.ivsize = AES_BLOCK_SIZE,
> -				.setkey = ablkcipher_aes_setkey,
> -			}
> +	{	.type = CRYPTO_ALG_TYPE_SKCIPHER,
> +		.alg.skcipher = {
> +			.base.cra_name = "cbc(aes)",
> +			.base.cra_driver_name = "cbc-aes-talitos",
> +			.base.cra_blocksize = AES_BLOCK_SIZE,
> +			.base.cra_flags = CRYPTO_ALG_ASYNC,
> +			.min_keysize = AES_MIN_KEY_SIZE,
> +			.max_keysize = AES_MAX_KEY_SIZE,
> +			.ivsize = AES_BLOCK_SIZE,
> +			.setkey = skcipher_aes_setkey,
>   		},
>   		.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU |
>   				     DESC_HDR_SEL0_AESU |
>   				     DESC_HDR_MODE0_AESU_CBC,
>   	},
> -	{	.type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> -		.alg.crypto = {
> -			.cra_name = "ctr(aes)",
> -			.cra_driver_name = "ctr-aes-talitos",
> -			.cra_blocksize = 1,
> -			.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
> -				     CRYPTO_ALG_ASYNC,
> -			.cra_ablkcipher = {
> -				.min_keysize = AES_MIN_KEY_SIZE,
> -				.max_keysize = AES_MAX_KEY_SIZE,
> -				.ivsize = AES_BLOCK_SIZE,
> -				.setkey = ablkcipher_aes_setkey,
> -			}
> +	{	.type = CRYPTO_ALG_TYPE_SKCIPHER,
> +		.alg.skcipher = {
> +			.base.cra_name = "ctr(aes)",
> +			.base.cra_driver_name = "ctr-aes-talitos",
> +			.base.cra_blocksize = 1,
> +			.base.cra_flags = CRYPTO_ALG_ASYNC,
> +			.min_keysize = AES_MIN_KEY_SIZE,
> +			.max_keysize = AES_MAX_KEY_SIZE,
> +			.ivsize = AES_BLOCK_SIZE,
> +			.setkey = skcipher_aes_setkey,
>   		},
>   		.desc_hdr_template = DESC_HDR_TYPE_AESU_CTR_NONSNOOP |
>   				     DESC_HDR_SEL0_AESU |
>   				     DESC_HDR_MODE0_AESU_CTR,
>   	},
> -	{	.type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> -		.alg.crypto = {
> -			.cra_name = "ecb(des)",
> -			.cra_driver_name = "ecb-des-talitos",
> -			.cra_blocksize = DES_BLOCK_SIZE,
> -			.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
> -				     CRYPTO_ALG_ASYNC,
> -			.cra_ablkcipher = {
> -				.min_keysize = DES_KEY_SIZE,
> -				.max_keysize = DES_KEY_SIZE,
> -				.setkey = ablkcipher_des_setkey,
> -			}
> +	{	.type = CRYPTO_ALG_TYPE_SKCIPHER,
> +		.alg.skcipher = {
> +			.base.cra_name = "ecb(des)",
> +			.base.cra_driver_name = "ecb-des-talitos",
> +			.base.cra_blocksize = DES_BLOCK_SIZE,
> +			.base.cra_flags = CRYPTO_ALG_ASYNC,
> +			.min_keysize = DES_KEY_SIZE,
> +			.max_keysize = DES_KEY_SIZE,
> +			.setkey = skcipher_des_setkey,
>   		},
>   		.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU |
>   				     DESC_HDR_SEL0_DEU,
>   	},
> -	{	.type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> -		.alg.crypto = {
> -			.cra_name = "cbc(des)",
> -			.cra_driver_name = "cbc-des-talitos",
> -			.cra_blocksize = DES_BLOCK_SIZE,
> -			.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
> -				     CRYPTO_ALG_ASYNC,
> -			.cra_ablkcipher = {
> -				.min_keysize = DES_KEY_SIZE,
> -				.max_keysize = DES_KEY_SIZE,
> -				.ivsize = DES_BLOCK_SIZE,
> -				.setkey = ablkcipher_des_setkey,
> -			}
> +	{	.type = CRYPTO_ALG_TYPE_SKCIPHER,
> +		.alg.skcipher = {
> +			.base.cra_name = "cbc(des)",
> +			.base.cra_driver_name = "cbc-des-talitos",
> +			.base.cra_blocksize = DES_BLOCK_SIZE,
> +			.base.cra_flags = CRYPTO_ALG_ASYNC,
> +			.min_keysize = DES_KEY_SIZE,
> +			.max_keysize = DES_KEY_SIZE,
> +			.ivsize = DES_BLOCK_SIZE,
> +			.setkey = skcipher_des_setkey,
>   		},
>   		.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU |
>   				     DESC_HDR_SEL0_DEU |
>   				     DESC_HDR_MODE0_DEU_CBC,
>   	},
> -	{	.type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> -		.alg.crypto = {
> -			.cra_name = "ecb(des3_ede)",
> -			.cra_driver_name = "ecb-3des-talitos",
> -			.cra_blocksize = DES3_EDE_BLOCK_SIZE,
> -			.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
> -				     CRYPTO_ALG_ASYNC,
> -			.cra_ablkcipher = {
> -				.min_keysize = DES3_EDE_KEY_SIZE,
> -				.max_keysize = DES3_EDE_KEY_SIZE,
> -				.setkey = ablkcipher_des3_setkey,
> -			}
> +	{	.type = CRYPTO_ALG_TYPE_SKCIPHER,
> +		.alg.skcipher = {
> +			.base.cra_name = "ecb(des3_ede)",
> +			.base.cra_driver_name = "ecb-3des-talitos",
> +			.base.cra_blocksize = DES3_EDE_BLOCK_SIZE,
> +			.base.cra_flags = CRYPTO_ALG_ASYNC,
> +			.min_keysize = DES3_EDE_KEY_SIZE,
> +			.max_keysize = DES3_EDE_KEY_SIZE,
> +			.setkey = skcipher_des3_setkey,
>   		},
>   		.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU |
>   				     DESC_HDR_SEL0_DEU |
>   				     DESC_HDR_MODE0_DEU_3DES,
>   	},
> -	{	.type = CRYPTO_ALG_TYPE_ABLKCIPHER,
> -		.alg.crypto = {
> -			.cra_name = "cbc(des3_ede)",
> -			.cra_driver_name = "cbc-3des-talitos",
> -			.cra_blocksize = DES3_EDE_BLOCK_SIZE,
> -			.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER |
> -                                     CRYPTO_ALG_ASYNC,
> -			.cra_ablkcipher = {
> -				.min_keysize = DES3_EDE_KEY_SIZE,
> -				.max_keysize = DES3_EDE_KEY_SIZE,
> -				.ivsize = DES3_EDE_BLOCK_SIZE,
> -				.setkey = ablkcipher_des3_setkey,
> -			}
> +	{	.type = CRYPTO_ALG_TYPE_SKCIPHER,
> +		.alg.skcipher = {
> +			.base.cra_name = "cbc(des3_ede)",
> +			.base.cra_driver_name = "cbc-3des-talitos",
> +			.base.cra_blocksize = DES3_EDE_BLOCK_SIZE,
> +			.base.cra_flags = CRYPTO_ALG_ASYNC,
> +			.min_keysize = DES3_EDE_KEY_SIZE,
> +			.max_keysize = DES3_EDE_KEY_SIZE,
> +			.ivsize = DES3_EDE_BLOCK_SIZE,
> +			.setkey = skcipher_des3_setkey,
>   		},
>   		.desc_hdr_template = DESC_HDR_TYPE_COMMON_NONSNOOP_NO_AFEU |
>   			             DESC_HDR_SEL0_DEU |
> @@ -3036,40 +3015,39 @@ static int talitos_init_common(struct talitos_ctx *ctx,
>   	return 0;
>   }
>   
> -static int talitos_cra_init(struct crypto_tfm *tfm)
> +static int talitos_cra_init_aead(struct crypto_aead *tfm)
>   {
> -	struct crypto_alg *alg = tfm->__crt_alg;
> +	struct aead_alg *alg = crypto_aead_alg(tfm);
>   	struct talitos_crypto_alg *talitos_alg;
> -	struct talitos_ctx *ctx = crypto_tfm_ctx(tfm);
> +	struct talitos_ctx *ctx = crypto_aead_ctx(tfm);
>   
> -	if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_AHASH)
> -		talitos_alg = container_of(__crypto_ahash_alg(alg),
> -					   struct talitos_crypto_alg,
> -					   algt.alg.hash);
> -	else
> -		talitos_alg = container_of(alg, struct talitos_crypto_alg,
> -					   algt.alg.crypto);
> +	talitos_alg = container_of(alg, struct talitos_crypto_alg,
> +				   algt.alg.aead);
>   
>   	return talitos_init_common(ctx, talitos_alg);
>   }
>   
> -static int talitos_cra_init_aead(struct crypto_aead *tfm)
> +static int talitos_cra_init_skcipher(struct crypto_skcipher *tfm)
>   {
> -	struct aead_alg *alg = crypto_aead_alg(tfm);
> +	struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
>   	struct talitos_crypto_alg *talitos_alg;
> -	struct talitos_ctx *ctx = crypto_aead_ctx(tfm);
> +	struct talitos_ctx *ctx = crypto_skcipher_ctx(tfm);
>   
>   	talitos_alg = container_of(alg, struct talitos_crypto_alg,
> -				   algt.alg.aead);
> +				   algt.alg.skcipher);
>   
>   	return talitos_init_common(ctx, talitos_alg);
>   }
>   
>   static int talitos_cra_init_ahash(struct crypto_tfm *tfm)
>   {
> +	struct crypto_alg *alg = tfm->__crt_alg;
> +	struct talitos_crypto_alg *talitos_alg;
>   	struct talitos_ctx *ctx = crypto_tfm_ctx(tfm);
>   
> -	talitos_cra_init(tfm);
> +	talitos_alg = container_of(__crypto_ahash_alg(alg),
> +				   struct talitos_crypto_alg,
> +				   algt.alg.hash);
>   
>   	ctx->keylen = 0;
>   	crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
> @@ -3116,7 +3094,8 @@ static int talitos_remove(struct platform_device *ofdev)
>   
>   	list_for_each_entry_safe(t_alg, n, &priv->alg_list, entry) {
>   		switch (t_alg->algt.type) {
> -		case CRYPTO_ALG_TYPE_ABLKCIPHER:
> +		case CRYPTO_ALG_TYPE_SKCIPHER:
> +			crypto_unregister_skcipher(&t_alg->algt.alg.skcipher);
>   			break;
>   		case CRYPTO_ALG_TYPE_AEAD:
>   			crypto_unregister_aead(&t_alg->algt.alg.aead);
> @@ -3160,15 +3139,14 @@ static struct talitos_crypto_alg *talitos_alg_alloc(struct device *dev,
>   	t_alg->algt = *template;
>   
>   	switch (t_alg->algt.type) {
> -	case CRYPTO_ALG_TYPE_ABLKCIPHER:
> -		alg = &t_alg->algt.alg.crypto;
> -		alg->cra_init = talitos_cra_init;
> +	case CRYPTO_ALG_TYPE_SKCIPHER:
> +		alg = &t_alg->algt.alg.skcipher.base;
>   		alg->cra_exit = talitos_cra_exit;
> -		alg->cra_type = &crypto_ablkcipher_type;
> -		alg->cra_ablkcipher.setkey = alg->cra_ablkcipher.setkey ?:
> -					     ablkcipher_setkey;
> -		alg->cra_ablkcipher.encrypt = ablkcipher_encrypt;
> -		alg->cra_ablkcipher.decrypt = ablkcipher_decrypt;
> +		t_alg->algt.alg.skcipher.init = talitos_cra_init_skcipher;
> +		t_alg->algt.alg.skcipher.setkey =
> +			t_alg->algt.alg.skcipher.setkey ?: skcipher_setkey;
> +		t_alg->algt.alg.skcipher.encrypt = skcipher_encrypt;
> +		t_alg->algt.alg.skcipher.decrypt = skcipher_decrypt;
>   		break;
>   	case CRYPTO_ALG_TYPE_AEAD:
>   		alg = &t_alg->algt.alg.aead.base;
> @@ -3465,10 +3443,10 @@ static int talitos_probe(struct platform_device *ofdev)
>   			}
>   
>   			switch (t_alg->algt.type) {
> -			case CRYPTO_ALG_TYPE_ABLKCIPHER:
> -				err = crypto_register_alg(
> -						&t_alg->algt.alg.crypto);
> -				alg = &t_alg->algt.alg.crypto;
> +			case CRYPTO_ALG_TYPE_SKCIPHER:
> +				err = crypto_register_skcipher(
> +						&t_alg->algt.alg.skcipher);
> +				alg = &t_alg->algt.alg.skcipher.base;
>   				break;
>   
>   			case CRYPTO_ALG_TYPE_AEAD:
>