Commit c79b411e authored by Eric Biggers's avatar Eric Biggers Committed by Herbert Xu
Browse files

crypto: skcipher - remove remnants of internal IV generators 



Remove dead code related to internal IV generators, which are no longer
used since they've been replaced with the "seqiv" and "echainiv"
templates.  The removed code includes:

- The "givcipher" (GIVCIPHER) algorithm type.  No algorithms are
  registered with this type anymore, so it's unneeded.

- The "const char *geniv" member of aead_alg, ablkcipher_alg, and
  blkcipher_alg.  A few algorithms still set this, but it isn't used
  anymore except to show via /proc/crypto and CRYPTO_MSG_GETALG.
  Just hardcode "<default>" or "<none>" in those cases.

- The 'skcipher_givcrypt_request' structure, which is never used.

Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent dec5d0db

Documentation/crypto/api.rst

+0 −9
Original line number Diff line number Diff line 
Programming Interface

=====================



Please note that the kernel crypto API contains the AEAD givcrypt API

(crypto_aead_giv\* and aead_givcrypt\* function calls in

include/crypto/aead.h). This API is obsolete and will be removed in the

future. To obtain the functionality of an AEAD cipher with internal IV

generation, use the IV generator as a regular cipher. For example,

rfc4106(gcm(aes)) is the AEAD cipher with external IV generation and

seqniv(rfc4106(gcm(aes))) implies that the kernel crypto API generates

the IV. Different IV generators are available.



.. class:: toc-title



	   Table of contents

Documentation/crypto/architecture.rst

+5 −26
Original line number Diff line number Diff line
@@ -157,10 +157,6 @@ applicable to a cipher, it is not displayed: 


   -  rng for random number generator



   -  givcipher for cipher with associated IV generator (see the geniv

      entry below for the specification of the IV generator type used by

      the cipher implementation)



   -  kpp for a Key-agreement Protocol Primitive (KPP) cipher such as

      an ECDH or DH implementation
@@ -174,16 +170,7 @@ applicable to a cipher, it is not displayed: 


-  digestsize: output size of the message digest



-  geniv: IV generation type:



   -  eseqiv for encrypted sequence number based IV generation



   -  seqiv for sequence number based IV generation



   -  chainiv for chain iv generation



   -  <builtin> is a marker that the cipher implements IV generation and

      handling as it is specific to the given cipher

-  geniv: IV generator (obsolete)



Key Sizes

---------
@@ -218,10 +205,6 @@ the aforementioned cipher types: 


-  CRYPTO_ALG_TYPE_ABLKCIPHER Asynchronous multi-block cipher



-  CRYPTO_ALG_TYPE_GIVCIPHER Asynchronous multi-block cipher packed

   together with an IV generator (see geniv field in the /proc/crypto

   listing for the known IV generators)



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

   an ECDH or DH implementation
@@ -338,18 +321,14 @@ uses the API applicable to the cipher type specified for the block. 


The following call sequence is applicable when the IPSEC layer triggers

an encryption operation with the esp_output function. During

configuration, the administrator set up the use of rfc4106(gcm(aes)) as

the cipher for ESP. The following call sequence is now depicted in the

ASCII art above:

configuration, the administrator set up the use of seqiv(rfc4106(gcm(aes)))

as the cipher for ESP. The following call sequence is now depicted in

the ASCII art above:



1. esp_output() invokes crypto_aead_encrypt() to trigger an

   encryption operation of the AEAD cipher with IV generator.



   In case of GCM, the SEQIV implementation is registered as GIVCIPHER

   in crypto_rfc4106_alloc().



   The SEQIV performs its operation to generate an IV where the core

   function is seqiv_geniv().

   The SEQIV generates the IV.



2. Now, SEQIV uses the AEAD API function calls to invoke the associated

   AEAD cipher. In our case, during the instantiation of SEQIV, the

crypto/ablkcipher.c

+2 −74
Original line number Diff line number Diff line
@@ -368,8 +368,7 @@ static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg) 
	memset(&rblkcipher, 0, sizeof(rblkcipher));



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

	strscpy(rblkcipher.geniv, alg->cra_ablkcipher.geniv ?: "<default>",

		sizeof(rblkcipher.geniv));

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



	rblkcipher.blocksize = alg->cra_blocksize;

	rblkcipher.min_keysize = alg->cra_ablkcipher.min_keysize;
@@ -399,7 +398,7 @@ static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg) 
	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        : %s\n", ablkcipher->geniv ?: "<default>");

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

}



const struct crypto_type crypto_ablkcipher_type = {
@@ -411,74 +410,3 @@ const struct crypto_type crypto_ablkcipher_type = { 
	.report = crypto_ablkcipher_report,

};

EXPORT_SYMBOL_GPL(crypto_ablkcipher_type);
 


static int crypto_init_givcipher_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 = tfm->__crt_alg->cra_flags & CRYPTO_ALG_GENIV ?

		      alg->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_givcipher_report(struct sk_buff *skb, struct crypto_alg *alg)

{

	struct crypto_report_blkcipher rblkcipher;



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



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

	strscpy(rblkcipher.geniv, alg->cra_ablkcipher.geniv ?: "<built-in>",

		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_givcipher_report(struct sk_buff *skb, struct crypto_alg *alg)

{

	return -ENOSYS;

}

#endif



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

	__maybe_unused;

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

{

	struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher;



	seq_printf(m, "type         : givcipher\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        : %s\n", ablkcipher->geniv ?: "<built-in>");

}



const struct crypto_type crypto_givcipher_type = {

	.ctxsize = crypto_ablkcipher_ctxsize,

	.init = crypto_init_givcipher_ops,

#ifdef CONFIG_PROC_FS

	.show = crypto_givcipher_show,

#endif

	.report = crypto_givcipher_report,

};

EXPORT_SYMBOL_GPL(crypto_givcipher_type);

crypto/blkcipher.c

+2 −4
Original line number Diff line number Diff line
@@ -510,8 +510,7 @@ static int crypto_blkcipher_report(struct sk_buff *skb, struct crypto_alg *alg) 
	memset(&rblkcipher, 0, sizeof(rblkcipher));



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

	strscpy(rblkcipher.geniv, alg->cra_blkcipher.geniv ?: "<default>",

		sizeof(rblkcipher.geniv));

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



	rblkcipher.blocksize = alg->cra_blocksize;

	rblkcipher.min_keysize = alg->cra_blkcipher.min_keysize;
@@ -537,8 +536,7 @@ static void crypto_blkcipher_show(struct seq_file *m, struct crypto_alg *alg) 
	seq_printf(m, "min keysize  : %u\n", alg->cra_blkcipher.min_keysize);

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

	seq_printf(m, "ivsize       : %u\n", alg->cra_blkcipher.ivsize);

	seq_printf(m, "geniv        : %s\n", alg->cra_blkcipher.geniv ?:

					     "<default>");

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

}



const struct crypto_type crypto_blkcipher_type = {

crypto/cryptd.c

+1 −3
Original line number Diff line number Diff line
@@ -422,8 +422,6 @@ static int cryptd_create_blkcipher(struct crypto_template *tmpl, 
	inst->alg.cra_ablkcipher.min_keysize = alg->cra_blkcipher.min_keysize;

	inst->alg.cra_ablkcipher.max_keysize = alg->cra_blkcipher.max_keysize;



	inst->alg.cra_ablkcipher.geniv = alg->cra_blkcipher.geniv;



	inst->alg.cra_ctxsize = sizeof(struct cryptd_blkcipher_ctx);



	inst->alg.cra_init = cryptd_blkcipher_init_tfm;
@@ -1174,7 +1172,7 @@ struct cryptd_ablkcipher *cryptd_alloc_ablkcipher(const char *alg_name, 
		return ERR_PTR(-EINVAL);

	type = crypto_skcipher_type(type);

	mask &= ~CRYPTO_ALG_TYPE_MASK;

	mask |= (CRYPTO_ALG_GENIV | CRYPTO_ALG_TYPE_BLKCIPHER_MASK);

	mask |= CRYPTO_ALG_TYPE_BLKCIPHER_MASK;

	tfm = crypto_alloc_base(cryptd_alg_name, type, mask);

	if (IS_ERR(tfm))

		return ERR_CAST(tfm);

CRA Git | Maintained and supported by SUSTech CRA and CCSE