Commit d63007eb authored by Ard Biesheuvel's avatar Ard Biesheuvel Committed by Herbert Xu
Browse files

crypto: ablkcipher - remove deprecated and unused ablkcipher support 



Now that all users of the deprecated ablkcipher interface have been
moved to the skcipher interface, ablkcipher is no longer used and
can be removed.

Reviewed-by: default avatarEric Biggers <ebiggers@kernel.org>
Signed-off-by: default avatarArd Biesheuvel <ardb@kernel.org>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 809abaef

Documentation/crypto/api-skcipher.rst

+1 −19
Original line number Diff line number Diff line
@@ -5,7 +5,7 @@ Block Cipher Algorithm Definitions 
   :doc: Block Cipher Algorithm Definitions



.. kernel-doc:: include/linux/crypto.h

   :functions: crypto_alg ablkcipher_alg cipher_alg compress_alg

   :functions: crypto_alg cipher_alg compress_alg



Symmetric Key Cipher API

------------------------
@@ -33,21 +33,3 @@ Single Block Cipher API 


.. kernel-doc:: include/linux/crypto.h

   :functions: crypto_alloc_cipher crypto_free_cipher crypto_has_cipher crypto_cipher_blocksize crypto_cipher_setkey crypto_cipher_encrypt_one crypto_cipher_decrypt_one
 


Asynchronous Block Cipher API - Deprecated

------------------------------------------



.. kernel-doc:: include/linux/crypto.h

   :doc: Asynchronous Block Cipher API



.. kernel-doc:: include/linux/crypto.h

   :functions: crypto_free_ablkcipher crypto_ablkcipher_ivsize crypto_ablkcipher_blocksize crypto_ablkcipher_setkey crypto_ablkcipher_reqtfm crypto_ablkcipher_encrypt crypto_ablkcipher_decrypt



Asynchronous Cipher Request Handle - Deprecated

-----------------------------------------------



.. kernel-doc:: include/linux/crypto.h

   :doc: Asynchronous Cipher Request Handle



.. kernel-doc:: include/linux/crypto.h

   :functions: crypto_ablkcipher_reqsize ablkcipher_request_set_tfm ablkcipher_request_alloc ablkcipher_request_free ablkcipher_request_set_callback ablkcipher_request_set_crypt

Documentation/crypto/architecture.rst

+0 −2
Original line number Diff line number Diff line
@@ -201,8 +201,6 @@ the aforementioned cipher types: 
-  CRYPTO_ALG_TYPE_AEAD Authenticated Encryption with Associated Data

   (MAC)



-  CRYPTO_ALG_TYPE_ABLKCIPHER Asynchronous multi-block cipher



-  CRYPTO_ALG_TYPE_KPP Key-agreement Protocol Primitive (KPP) such as

   an ECDH or DH implementation

Documentation/crypto/crypto_engine.rst

+0 −4
Original line number Diff line number Diff line
@@ -63,8 +63,6 @@ request by using: 
When your driver receives a crypto_request, you must to transfer it to

the crypto engine via one of:



* crypto_transfer_ablkcipher_request_to_engine()



* crypto_transfer_aead_request_to_engine()



* crypto_transfer_akcipher_request_to_engine()
@@ -75,8 +73,6 @@ the crypto engine via one of: 


At the end of the request process, a call to one of the following functions is needed:



* crypto_finalize_ablkcipher_request()



* crypto_finalize_aead_request()



* crypto_finalize_akcipher_request()

crypto/Makefile

+1 −3
Original line number Diff line number Diff line
@@ -16,9 +16,7 @@ obj-$(CONFIG_CRYPTO_ALGAPI2) += crypto_algapi.o 
obj-$(CONFIG_CRYPTO_AEAD2) += aead.o

obj-$(CONFIG_CRYPTO_AEAD2) += geniv.o



crypto_skcipher-y := ablkcipher.o

crypto_skcipher-y += skcipher.o

obj-$(CONFIG_CRYPTO_SKCIPHER2) += crypto_skcipher.o

obj-$(CONFIG_CRYPTO_SKCIPHER2) += skcipher.o

obj-$(CONFIG_CRYPTO_SEQIV) += seqiv.o

obj-$(CONFIG_CRYPTO_ECHAINIV) += echainiv.o

crypto/ablkcipher.c

deleted100644 → 0
+0 −407
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * Asynchronous block chaining cipher operations.

 *

 * This is the asynchronous version of blkcipher.c indicating completion

 * via a callback.

 *

 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>

 */



#include <crypto/internal/skcipher.h>

#include <linux/err.h>

#include <linux/kernel.h>

#include <linux/slab.h>

#include <linux/seq_file.h>

#include <linux/cryptouser.h>

#include <linux/compiler.h>

#include <net/netlink.h>



#include <crypto/scatterwalk.h>



#include "internal.h"



struct ablkcipher_buffer {

	struct list_head	entry;

	struct scatter_walk	dst;

	unsigned int		len;

	void			*data;

};



enum {

	ABLKCIPHER_WALK_SLOW = 1 << 0,

};



static inline void ablkcipher_buffer_write(struct ablkcipher_buffer *p)

{

	scatterwalk_copychunks(p->data, &p->dst, p->len, 1);

}



void __ablkcipher_walk_complete(struct ablkcipher_walk *walk)

{

	struct ablkcipher_buffer *p, *tmp;



	list_for_each_entry_safe(p, tmp, &walk->buffers, entry) {

		ablkcipher_buffer_write(p);

		list_del(&p->entry);

		kfree(p);

	}

}

EXPORT_SYMBOL_GPL(__ablkcipher_walk_complete);



static inline void ablkcipher_queue_write(struct ablkcipher_walk *walk,

					  struct ablkcipher_buffer *p)

{

	p->dst = walk->out;

	list_add_tail(&p->entry, &walk->buffers);

}



/* Get a spot of the specified length that does not straddle a page.

 * The caller needs to ensure that there is enough space for this operation.

 */

static inline u8 *ablkcipher_get_spot(u8 *start, unsigned int len)

{

	u8 *end_page = (u8 *)(((unsigned long)(start + len - 1)) & PAGE_MASK);



	return max(start, end_page);

}



static inline void ablkcipher_done_slow(struct ablkcipher_walk *walk,

					unsigned int n)

{

	for (;;) {

		unsigned int len_this_page = scatterwalk_pagelen(&walk->out);



		if (len_this_page > n)

			len_this_page = n;

		scatterwalk_advance(&walk->out, n);

		if (n == len_this_page)

			break;

		n -= len_this_page;

		scatterwalk_start(&walk->out, sg_next(walk->out.sg));

	}

}



static inline void ablkcipher_done_fast(struct ablkcipher_walk *walk,

					unsigned int n)

{

	scatterwalk_advance(&walk->in, n);

	scatterwalk_advance(&walk->out, n);

}



static int ablkcipher_walk_next(struct ablkcipher_request *req,

				struct ablkcipher_walk *walk);



int ablkcipher_walk_done(struct ablkcipher_request *req,

			 struct ablkcipher_walk *walk, int err)

{

	struct crypto_tfm *tfm = req->base.tfm;

	unsigned int n; /* bytes processed */

	bool more;



	if (unlikely(err < 0))

		goto finish;



	n = walk->nbytes - err;

	walk->total -= n;

	more = (walk->total != 0);



	if (likely(!(walk->flags & ABLKCIPHER_WALK_SLOW))) {

		ablkcipher_done_fast(walk, n);

	} else {

		if (WARN_ON(err)) {

			/* unexpected case; didn't process all bytes */

			err = -EINVAL;

			goto finish;

		}

		ablkcipher_done_slow(walk, n);

	}



	scatterwalk_done(&walk->in, 0, more);

	scatterwalk_done(&walk->out, 1, more);



	if (more) {

		crypto_yield(req->base.flags);

		return ablkcipher_walk_next(req, walk);

	}

	err = 0;

finish:

	walk->nbytes = 0;

	if (walk->iv != req->info)

		memcpy(req->info, walk->iv, tfm->crt_ablkcipher.ivsize);

	kfree(walk->iv_buffer);

	return err;

}

EXPORT_SYMBOL_GPL(ablkcipher_walk_done);



static inline int ablkcipher_next_slow(struct ablkcipher_request *req,

				       struct ablkcipher_walk *walk,

				       unsigned int bsize,

				       unsigned int alignmask,

				       void **src_p, void **dst_p)

{

	unsigned aligned_bsize = ALIGN(bsize, alignmask + 1);

	struct ablkcipher_buffer *p;

	void *src, *dst, *base;

	unsigned int n;



	n = ALIGN(sizeof(struct ablkcipher_buffer), alignmask + 1);

	n += (aligned_bsize * 3 - (alignmask + 1) +

	      (alignmask & ~(crypto_tfm_ctx_alignment() - 1)));



	p = kmalloc(n, GFP_ATOMIC);

	if (!p)

		return ablkcipher_walk_done(req, walk, -ENOMEM);



	base = p + 1;



	dst = (u8 *)ALIGN((unsigned long)base, alignmask + 1);

	src = dst = ablkcipher_get_spot(dst, bsize);



	p->len = bsize;

	p->data = dst;



	scatterwalk_copychunks(src, &walk->in, bsize, 0);



	ablkcipher_queue_write(walk, p);



	walk->nbytes = bsize;

	walk->flags |= ABLKCIPHER_WALK_SLOW;



	*src_p = src;

	*dst_p = dst;



	return 0;

}



static inline int ablkcipher_copy_iv(struct ablkcipher_walk *walk,

				     struct crypto_tfm *tfm,

				     unsigned int alignmask)

{

	unsigned bs = walk->blocksize;

	unsigned int ivsize = tfm->crt_ablkcipher.ivsize;

	unsigned aligned_bs = ALIGN(bs, alignmask + 1);

	unsigned int size = aligned_bs * 2 + ivsize + max(aligned_bs, ivsize) -

			    (alignmask + 1);

	u8 *iv;



	size += alignmask & ~(crypto_tfm_ctx_alignment() - 1);

	walk->iv_buffer = kmalloc(size, GFP_ATOMIC);

	if (!walk->iv_buffer)

		return -ENOMEM;



	iv = (u8 *)ALIGN((unsigned long)walk->iv_buffer, alignmask + 1);

	iv = ablkcipher_get_spot(iv, bs) + aligned_bs;

	iv = ablkcipher_get_spot(iv, bs) + aligned_bs;

	iv = ablkcipher_get_spot(iv, ivsize);



	walk->iv = memcpy(iv, walk->iv, ivsize);

	return 0;

}



static inline int ablkcipher_next_fast(struct ablkcipher_request *req,

				       struct ablkcipher_walk *walk)

{

	walk->src.page = scatterwalk_page(&walk->in);

	walk->src.offset = offset_in_page(walk->in.offset);

	walk->dst.page = scatterwalk_page(&walk->out);

	walk->dst.offset = offset_in_page(walk->out.offset);



	return 0;

}



static int ablkcipher_walk_next(struct ablkcipher_request *req,

				struct ablkcipher_walk *walk)

{

	struct crypto_tfm *tfm = req->base.tfm;

	unsigned int alignmask, bsize, n;

	void *src, *dst;

	int err;



	alignmask = crypto_tfm_alg_alignmask(tfm);

	n = walk->total;

	if (unlikely(n < crypto_tfm_alg_blocksize(tfm))) {

		req->base.flags |= CRYPTO_TFM_RES_BAD_BLOCK_LEN;

		return ablkcipher_walk_done(req, walk, -EINVAL);

	}



	walk->flags &= ~ABLKCIPHER_WALK_SLOW;

	src = dst = NULL;



	bsize = min(walk->blocksize, n);

	n = scatterwalk_clamp(&walk->in, n);

	n = scatterwalk_clamp(&walk->out, n);



	if (n < bsize ||

	    !scatterwalk_aligned(&walk->in, alignmask) ||

	    !scatterwalk_aligned(&walk->out, alignmask)) {

		err = ablkcipher_next_slow(req, walk, bsize, alignmask,

					   &src, &dst);

		goto set_phys_lowmem;

	}



	walk->nbytes = n;



	return ablkcipher_next_fast(req, walk);



set_phys_lowmem:

	if (err >= 0) {

		walk->src.page = virt_to_page(src);

		walk->dst.page = virt_to_page(dst);

		walk->src.offset = ((unsigned long)src & (PAGE_SIZE - 1));

		walk->dst.offset = ((unsigned long)dst & (PAGE_SIZE - 1));

	}



	return err;

}



static int ablkcipher_walk_first(struct ablkcipher_request *req,

				 struct ablkcipher_walk *walk)

{

	struct crypto_tfm *tfm = req->base.tfm;

	unsigned int alignmask;



	alignmask = crypto_tfm_alg_alignmask(tfm);

	if (WARN_ON_ONCE(in_irq()))

		return -EDEADLK;



	walk->iv = req->info;

	walk->nbytes = walk->total;

	if (unlikely(!walk->total))

		return 0;



	walk->iv_buffer = NULL;

	if (unlikely(((unsigned long)walk->iv & alignmask))) {

		int err = ablkcipher_copy_iv(walk, tfm, alignmask);



		if (err)

			return err;

	}



	scatterwalk_start(&walk->in, walk->in.sg);

	scatterwalk_start(&walk->out, walk->out.sg);



	return ablkcipher_walk_next(req, walk);

}



int ablkcipher_walk_phys(struct ablkcipher_request *req,

			 struct ablkcipher_walk *walk)

{

	walk->blocksize = crypto_tfm_alg_blocksize(req->base.tfm);

	return ablkcipher_walk_first(req, walk);

}

EXPORT_SYMBOL_GPL(ablkcipher_walk_phys);



static int setkey_unaligned(struct crypto_ablkcipher *tfm, const u8 *key,

			    unsigned int keylen)

{

	struct ablkcipher_alg *cipher = crypto_ablkcipher_alg(tfm);

	unsigned long alignmask = crypto_ablkcipher_alignmask(tfm);

	int ret;

	u8 *buffer, *alignbuffer;

	unsigned long absize;



	absize = keylen + alignmask;

	buffer = kmalloc(absize, GFP_ATOMIC);

	if (!buffer)

		return -ENOMEM;



	alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);

	memcpy(alignbuffer, key, keylen);

	ret = cipher->setkey(tfm, alignbuffer, keylen);

	memset(alignbuffer, 0, keylen);

	kfree(buffer);

	return ret;

}



static int setkey(struct crypto_ablkcipher *tfm, const u8 *key,

		  unsigned int keylen)

{

	struct ablkcipher_alg *cipher = crypto_ablkcipher_alg(tfm);

	unsigned long alignmask = crypto_ablkcipher_alignmask(tfm);



	if (keylen < cipher->min_keysize || keylen > cipher->max_keysize) {

		crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);

		return -EINVAL;

	}



	if ((unsigned long)key & alignmask)

		return setkey_unaligned(tfm, key, keylen);



	return cipher->setkey(tfm, key, keylen);

}



static unsigned int crypto_ablkcipher_ctxsize(struct crypto_alg *alg, u32 type,

					      u32 mask)

{

	return alg->cra_ctxsize;

}



static int crypto_init_ablkcipher_ops(struct crypto_tfm *tfm, u32 type,

				      u32 mask)

{

	struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;

	struct ablkcipher_tfm *crt = &tfm->crt_ablkcipher;



	if (alg->ivsize > PAGE_SIZE / 8)

		return -EINVAL;



	crt->setkey = setkey;

	crt->encrypt = alg->encrypt;

	crt->decrypt = alg->decrypt;

	crt->base = __crypto_ablkcipher_cast(tfm);

	crt->ivsize = alg->ivsize;



	return 0;

}



#ifdef CONFIG_NET

static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg)

{

	struct crypto_report_blkcipher rblkcipher;



	memset(&rblkcipher, 0, sizeof(rblkcipher));



	strscpy(rblkcipher.type, "ablkcipher", sizeof(rblkcipher.type));

	strscpy(rblkcipher.geniv, "<default>", sizeof(rblkcipher.geniv));



	rblkcipher.blocksize = alg->cra_blocksize;

	rblkcipher.min_keysize = alg->cra_ablkcipher.min_keysize;

	rblkcipher.max_keysize = alg->cra_ablkcipher.max_keysize;

	rblkcipher.ivsize = alg->cra_ablkcipher.ivsize;



	return nla_put(skb, CRYPTOCFGA_REPORT_BLKCIPHER,

		       sizeof(rblkcipher), &rblkcipher);

}

#else

static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg)

{

	return -ENOSYS;

}

#endif



static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg)

	__maybe_unused;

static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg)

{

	struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher;



	seq_printf(m, "type         : ablkcipher\n");

	seq_printf(m, "async        : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ?

					     "yes" : "no");

	seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);

	seq_printf(m, "min keysize  : %u\n", ablkcipher->min_keysize);

	seq_printf(m, "max keysize  : %u\n", ablkcipher->max_keysize);

	seq_printf(m, "ivsize       : %u\n", ablkcipher->ivsize);

	seq_printf(m, "geniv        : <default>\n");

}



const struct crypto_type crypto_ablkcipher_type = {

	.ctxsize = crypto_ablkcipher_ctxsize,

	.init = crypto_init_ablkcipher_ops,

#ifdef CONFIG_PROC_FS

	.show = crypto_ablkcipher_show,

#endif

	.report = crypto_ablkcipher_report,

};

EXPORT_SYMBOL_GPL(crypto_ablkcipher_type);