Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit efcf8023 authored by Herbert Xu's avatar Herbert Xu
Browse files

[CRYPTO] drivers: Remove obsolete block cipher operations 



This patch removes obsolete block operations of the simple cipher type
from drivers.  These were preserved so that existing users can make a
smooth transition.  Now that the transition is complete, they are no
longer needed.

Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent f12cc209

arch/s390/crypto/aes_s390.c

+0 −112
Original line number Diff line number Diff line
@@ -113,114 +113,6 @@ static void aes_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) 
	}

}



static unsigned int aes_encrypt_ecb(const struct cipher_desc *desc, u8 *out,

				    const u8 *in, unsigned int nbytes)

{

	struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(AES_BLOCK_SIZE - 1);



	switch (sctx->key_len) {

	case 16:

		ret = crypt_s390_km(KM_AES_128_ENCRYPT, &sctx->key, out, in, nbytes);

		BUG_ON((ret < 0) || (ret != nbytes));

		break;

	case 24:

		ret = crypt_s390_km(KM_AES_192_ENCRYPT, &sctx->key, out, in, nbytes);

		BUG_ON((ret < 0) || (ret != nbytes));

		break;

	case 32:

		ret = crypt_s390_km(KM_AES_256_ENCRYPT, &sctx->key, out, in, nbytes);

		BUG_ON((ret < 0) || (ret != nbytes));

		break;

	}

	return nbytes;

}



static unsigned int aes_decrypt_ecb(const struct cipher_desc *desc, u8 *out,

				    const u8 *in, unsigned int nbytes)

{

	struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(AES_BLOCK_SIZE - 1);



	switch (sctx->key_len) {

	case 16:

		ret = crypt_s390_km(KM_AES_128_DECRYPT, &sctx->key, out, in, nbytes);

		BUG_ON((ret < 0) || (ret != nbytes));

		break;

	case 24:

		ret = crypt_s390_km(KM_AES_192_DECRYPT, &sctx->key, out, in, nbytes);

		BUG_ON((ret < 0) || (ret != nbytes));

		break;

	case 32:

		ret = crypt_s390_km(KM_AES_256_DECRYPT, &sctx->key, out, in, nbytes);

		BUG_ON((ret < 0) || (ret != nbytes));

		break;

	}

	return nbytes;

}



static unsigned int aes_encrypt_cbc(const struct cipher_desc *desc, u8 *out,

				    const u8 *in, unsigned int nbytes)

{

	struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(AES_BLOCK_SIZE - 1);



	memcpy(&sctx->iv, desc->info, AES_BLOCK_SIZE);

	switch (sctx->key_len) {

	case 16:

		ret = crypt_s390_kmc(KMC_AES_128_ENCRYPT, &sctx->iv, out, in, nbytes);

		BUG_ON((ret < 0) || (ret != nbytes));

		break;

	case 24:

		ret = crypt_s390_kmc(KMC_AES_192_ENCRYPT, &sctx->iv, out, in, nbytes);

		BUG_ON((ret < 0) || (ret != nbytes));

		break;

	case 32:

		ret = crypt_s390_kmc(KMC_AES_256_ENCRYPT, &sctx->iv, out, in, nbytes);

		BUG_ON((ret < 0) || (ret != nbytes));

		break;

	}

	memcpy(desc->info, &sctx->iv, AES_BLOCK_SIZE);



	return nbytes;

}



static unsigned int aes_decrypt_cbc(const struct cipher_desc *desc, u8 *out,

				    const u8 *in, unsigned int nbytes)

{

	struct s390_aes_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(AES_BLOCK_SIZE - 1);



	memcpy(&sctx->iv, desc->info, AES_BLOCK_SIZE);

	switch (sctx->key_len) {

	case 16:

		ret = crypt_s390_kmc(KMC_AES_128_DECRYPT, &sctx->iv, out, in, nbytes);

		BUG_ON((ret < 0) || (ret != nbytes));

		break;

	case 24:

		ret = crypt_s390_kmc(KMC_AES_192_DECRYPT, &sctx->iv, out, in, nbytes);

		BUG_ON((ret < 0) || (ret != nbytes));

		break;

	case 32:

		ret = crypt_s390_kmc(KMC_AES_256_DECRYPT, &sctx->iv, out, in, nbytes);

		BUG_ON((ret < 0) || (ret != nbytes));

		break;

	}

	return nbytes;

}





static struct crypto_alg aes_alg = {

	.cra_name		=	"aes",
@@ -238,10 +130,6 @@ static struct crypto_alg aes_alg = { 
			.cia_setkey		=	aes_set_key,

			.cia_encrypt		=	aes_encrypt,

			.cia_decrypt		=	aes_decrypt,

			.cia_encrypt_ecb	=	aes_encrypt_ecb,

			.cia_decrypt_ecb	=	aes_decrypt_ecb,

			.cia_encrypt_cbc	=	aes_encrypt_cbc,

			.cia_decrypt_cbc	=	aes_decrypt_cbc,

		}

	}

};

arch/s390/crypto/des_s390.c

+0 −203
Original line number Diff line number Diff line
@@ -73,67 +73,6 @@ static void des_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) 
	crypt_s390_km(KM_DEA_DECRYPT, dctx->key, out, in, DES_BLOCK_SIZE);

}



static unsigned int des_encrypt_ecb(const struct cipher_desc *desc, u8 *out,

				    const u8 *in, unsigned int nbytes)

{

	struct crypt_s390_des_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(DES_BLOCK_SIZE - 1);

	ret = crypt_s390_km(KM_DEA_ENCRYPT, sctx->key, out, in, nbytes);

	BUG_ON((ret < 0) || (ret != nbytes));



	return nbytes;

}



static unsigned int des_decrypt_ecb(const struct cipher_desc *desc, u8 *out,

				    const u8 *in, unsigned int nbytes)

{

	struct crypt_s390_des_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(DES_BLOCK_SIZE - 1);

	ret = crypt_s390_km(KM_DEA_DECRYPT, sctx->key, out, in, nbytes);

	BUG_ON((ret < 0) || (ret != nbytes));



	return nbytes;

}



static unsigned int des_encrypt_cbc(const struct cipher_desc *desc, u8 *out,

				    const u8 *in, unsigned int nbytes)

{

	struct crypt_s390_des_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(DES_BLOCK_SIZE - 1);



	memcpy(sctx->iv, desc->info, DES_BLOCK_SIZE);

	ret = crypt_s390_kmc(KMC_DEA_ENCRYPT, &sctx->iv, out, in, nbytes);

	BUG_ON((ret < 0) || (ret != nbytes));



	memcpy(desc->info, sctx->iv, DES_BLOCK_SIZE);

	return nbytes;

}



static unsigned int des_decrypt_cbc(const struct cipher_desc *desc, u8 *out,

				    const u8 *in, unsigned int nbytes)

{

	struct crypt_s390_des_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(DES_BLOCK_SIZE - 1);



	memcpy(&sctx->iv, desc->info, DES_BLOCK_SIZE);

	ret = crypt_s390_kmc(KMC_DEA_DECRYPT, &sctx->iv, out, in, nbytes);

	BUG_ON((ret < 0) || (ret != nbytes));



	return nbytes;

}



static struct crypto_alg des_alg = {

	.cra_name		=	"des",

	.cra_driver_name	=	"des-s390",
@@ -150,10 +89,6 @@ static struct crypto_alg des_alg = { 
			.cia_setkey		=	des_setkey,

			.cia_encrypt		=	des_encrypt,

			.cia_decrypt		=	des_decrypt,

			.cia_encrypt_ecb	=	des_encrypt_ecb,

			.cia_decrypt_ecb	=	des_decrypt_ecb,

			.cia_encrypt_cbc	=	des_encrypt_cbc,

			.cia_decrypt_cbc	=	des_decrypt_cbc,

		}

	}

};
@@ -344,71 +279,6 @@ static void des3_128_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 
		      DES3_128_BLOCK_SIZE);

}



static unsigned int des3_128_encrypt_ecb(const struct cipher_desc *desc,

					 u8 *out, const u8 *in,

					 unsigned int nbytes)

{

	struct crypt_s390_des3_128_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(DES3_128_BLOCK_SIZE - 1);

	ret = crypt_s390_km(KM_TDEA_128_ENCRYPT, sctx->key, out, in, nbytes);

	BUG_ON((ret < 0) || (ret != nbytes));



	return nbytes;

}



static unsigned int des3_128_decrypt_ecb(const struct cipher_desc *desc,

					 u8 *out, const u8 *in,

					 unsigned int nbytes)

{

	struct crypt_s390_des3_128_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(DES3_128_BLOCK_SIZE - 1);

	ret = crypt_s390_km(KM_TDEA_128_DECRYPT, sctx->key, out, in, nbytes);

	BUG_ON((ret < 0) || (ret != nbytes));



	return nbytes;

}



static unsigned int des3_128_encrypt_cbc(const struct cipher_desc *desc,

					 u8 *out, const u8 *in,

					 unsigned int nbytes)

{

	struct crypt_s390_des3_128_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(DES3_128_BLOCK_SIZE - 1);



	memcpy(sctx->iv, desc->info, DES3_128_BLOCK_SIZE);

	ret = crypt_s390_kmc(KMC_TDEA_128_ENCRYPT, &sctx->iv, out, in, nbytes);

	BUG_ON((ret < 0) || (ret != nbytes));



	memcpy(desc->info, sctx->iv, DES3_128_BLOCK_SIZE);

	return nbytes;

}



static unsigned int des3_128_decrypt_cbc(const struct cipher_desc *desc,

					 u8 *out, const u8 *in,

					 unsigned int nbytes)

{

	struct crypt_s390_des3_128_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(DES3_128_BLOCK_SIZE - 1);



	memcpy(&sctx->iv, desc->info, DES3_128_BLOCK_SIZE);

	ret = crypt_s390_kmc(KMC_TDEA_128_DECRYPT, &sctx->iv, out, in, nbytes);

	BUG_ON((ret < 0) || (ret != nbytes));



	return nbytes;

}



static struct crypto_alg des3_128_alg = {

	.cra_name		=	"des3_ede128",

	.cra_driver_name	=	"des3_ede128-s390",
@@ -425,10 +295,6 @@ static struct crypto_alg des3_128_alg = { 
			.cia_setkey		=	des3_128_setkey,

			.cia_encrypt		=	des3_128_encrypt,

			.cia_decrypt		=	des3_128_decrypt,

			.cia_encrypt_ecb	=	des3_128_encrypt_ecb,

			.cia_decrypt_ecb	=	des3_128_decrypt_ecb,

			.cia_encrypt_cbc	=	des3_128_encrypt_cbc,

			.cia_decrypt_cbc	=	des3_128_decrypt_cbc,

		}

	}

};
@@ -575,71 +441,6 @@ static void des3_192_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src) 
		      DES3_192_BLOCK_SIZE);

}



static unsigned int des3_192_encrypt_ecb(const struct cipher_desc *desc,

					 u8 *out, const u8 *in,

					 unsigned int nbytes)

{

	struct crypt_s390_des3_192_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(DES3_192_BLOCK_SIZE - 1);

	ret = crypt_s390_km(KM_TDEA_192_ENCRYPT, sctx->key, out, in, nbytes);

	BUG_ON((ret < 0) || (ret != nbytes));



	return nbytes;

}



static unsigned int des3_192_decrypt_ecb(const struct cipher_desc *desc,

					 u8 *out, const u8 *in,

					 unsigned int nbytes)

{

	struct crypt_s390_des3_192_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(DES3_192_BLOCK_SIZE - 1);

	ret = crypt_s390_km(KM_TDEA_192_DECRYPT, sctx->key, out, in, nbytes);

	BUG_ON((ret < 0) || (ret != nbytes));



	return nbytes;

}



static unsigned int des3_192_encrypt_cbc(const struct cipher_desc *desc,

					 u8 *out, const u8 *in,

					 unsigned int nbytes)

{

	struct crypt_s390_des3_192_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(DES3_192_BLOCK_SIZE - 1);



	memcpy(sctx->iv, desc->info, DES3_192_BLOCK_SIZE);

	ret = crypt_s390_kmc(KMC_TDEA_192_ENCRYPT, &sctx->iv, out, in, nbytes);

	BUG_ON((ret < 0) || (ret != nbytes));



	memcpy(desc->info, sctx->iv, DES3_192_BLOCK_SIZE);

	return nbytes;

}



static unsigned int des3_192_decrypt_cbc(const struct cipher_desc *desc,

					 u8 *out, const u8 *in,

					 unsigned int nbytes)

{

	struct crypt_s390_des3_192_ctx *sctx = crypto_tfm_ctx(desc->tfm);

	int ret;



	/* only use complete blocks */

	nbytes &= ~(DES3_192_BLOCK_SIZE - 1);



	memcpy(&sctx->iv, desc->info, DES3_192_BLOCK_SIZE);

	ret = crypt_s390_kmc(KMC_TDEA_192_DECRYPT, &sctx->iv, out, in, nbytes);

	BUG_ON((ret < 0) || (ret != nbytes));



	return nbytes;

}



static struct crypto_alg des3_192_alg = {

	.cra_name		=	"des3_ede",

	.cra_driver_name	=	"des3_ede-s390",
@@ -656,10 +457,6 @@ static struct crypto_alg des3_192_alg = { 
			.cia_setkey		=	des3_192_setkey,

			.cia_encrypt		=	des3_192_encrypt,

			.cia_decrypt		=	des3_192_decrypt,

			.cia_encrypt_ecb	=	des3_192_encrypt_ecb,

			.cia_decrypt_ecb	=	des3_192_decrypt_ecb,

			.cia_encrypt_cbc	=	des3_192_encrypt_cbc,

			.cia_decrypt_cbc	=	des3_192_decrypt_cbc,

		}

	}

};

drivers/crypto/padlock-aes.c

+0 −44
Original line number Diff line number Diff line
@@ -452,46 +452,6 @@ static void aes_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in) 
	padlock_xcrypt_ecb(in, out, ctx->D, &ctx->cword.decrypt, 1);

}



static unsigned int aes_encrypt_ecb(const struct cipher_desc *desc, u8 *out,

				    const u8 *in, unsigned int nbytes)

{

	struct aes_ctx *ctx = aes_ctx(desc->tfm);

	padlock_xcrypt_ecb(in, out, ctx->E, &ctx->cword.encrypt,

			   nbytes / AES_BLOCK_SIZE);

	return nbytes & ~(AES_BLOCK_SIZE - 1);

}



static unsigned int aes_decrypt_ecb(const struct cipher_desc *desc, u8 *out,

				    const u8 *in, unsigned int nbytes)

{

	struct aes_ctx *ctx = aes_ctx(desc->tfm);

	padlock_xcrypt_ecb(in, out, ctx->D, &ctx->cword.decrypt,

			   nbytes / AES_BLOCK_SIZE);

	return nbytes & ~(AES_BLOCK_SIZE - 1);

}



static unsigned int aes_encrypt_cbc(const struct cipher_desc *desc, u8 *out,

				    const u8 *in, unsigned int nbytes)

{

	struct aes_ctx *ctx = aes_ctx(desc->tfm);

	u8 *iv;



	iv = padlock_xcrypt_cbc(in, out, ctx->E, desc->info,

				&ctx->cword.encrypt, nbytes / AES_BLOCK_SIZE);

	memcpy(desc->info, iv, AES_BLOCK_SIZE);



	return nbytes & ~(AES_BLOCK_SIZE - 1);

}



static unsigned int aes_decrypt_cbc(const struct cipher_desc *desc, u8 *out,

				    const u8 *in, unsigned int nbytes)

{

	struct aes_ctx *ctx = aes_ctx(desc->tfm);

	padlock_xcrypt_cbc(in, out, ctx->D, desc->info, &ctx->cword.decrypt,

			   nbytes / AES_BLOCK_SIZE);

	return nbytes & ~(AES_BLOCK_SIZE - 1);

}



static struct crypto_alg aes_alg = {

	.cra_name		=	"aes",

	.cra_driver_name	=	"aes-padlock",
@@ -509,10 +469,6 @@ static struct crypto_alg aes_alg = { 
			.cia_setkey	   	= 	aes_set_key,

			.cia_encrypt	 	=	aes_encrypt,

			.cia_decrypt	  	=	aes_decrypt,

			.cia_encrypt_ecb 	=	aes_encrypt_ecb,

			.cia_decrypt_ecb  	=	aes_decrypt_ecb,

			.cia_encrypt_cbc 	=	aes_encrypt_cbc,

			.cia_decrypt_cbc  	=	aes_decrypt_cbc,

		}

	}

};