Skip to contentSkip to conversation

crypto: nx - convert to skcipher API

PATCH In review Eric Biggers 3 participants 14 messages Oct 13, 2019 – Oct 18, 2019

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

cover crypto: nx - convert to skcipher API

This series converts the PowerPC Nest (NX) implementations of AES modes from the deprecated "blkcipher" API to the "skcipher" API. This is needed in order for the blkcipher API to be removed.

This patchset is compile-tested only, as I don't have this hardware. If anyone has this hardware, please test this patchset with CONFIG_CRYPTO_MANAGER_EXTRA_TESTS=y.

Eric Biggers (4):
crypto: nx - don't abuse blkcipher_desc to pass iv around
crypto: nx - convert AES-ECB to skcipher API
crypto: nx - convert AES-CBC to skcipher API
crypto: nx - convert AES-CTR to skcipher API

 drivers/crypto/nx/nx-aes-cbc.c | 81 ++++++++++++++-----------------
 drivers/crypto/nx/nx-aes-ccm.c | 40 ++++++----------
 drivers/crypto/nx/nx-aes-ctr.c | 87 +++++++++++++++-------------------
 drivers/crypto/nx/nx-aes-ecb.c | 76 +++++++++++++----------------
 drivers/crypto/nx/nx-aes-gcm.c | 24 ++++------
 drivers/crypto/nx/nx.c         | 64 ++++++++++++++-----------
 drivers/crypto/nx/nx.h         | 19 ++++----
 7 files changed, 176 insertions(+), 215 deletions(-)
Signature · 1 line
2.23.0
#1 lore raw

PATCH 1/4 crypto: nx - don't abuse blkcipher_desc to pass iv around

From: Eric Biggers <[email protected]>

The NX crypto driver is using 'struct blkcipher_desc' to pass the IV around, even for AEADs (for which it creates the struct on the stack). This is not appropriate since this structure is part of the "blkcipher" API, which is deprecated and will be removed.

Just pass around the IV directly instead.

---
 drivers/crypto/nx/nx-aes-cbc.c |  5 +++--
 drivers/crypto/nx/nx-aes-ccm.c | 40 ++++++++++++----------------------
 drivers/crypto/nx/nx-aes-ctr.c |  5 +++--
 drivers/crypto/nx/nx-aes-ecb.c |  4 ++--
 drivers/crypto/nx/nx-aes-gcm.c | 24 +++++++++-----------
 drivers/crypto/nx/nx.c         | 16 +++++++-------
 drivers/crypto/nx/nx.h         |  6 ++---
 7 files changed, 43 insertions(+), 57 deletions(-)
drivers/crypto/nx/nx-aes-cbc.c +3 -2
index e631f9979127..482a203a9260 100644
@@ -72,8 +72,9 @@ static int cbc_aes_nx_crypt(struct blkcipher_desc *desc,
 	do {
 		to_process = nbytes - processed;
 
-		rc = nx_build_sg_lists(nx_ctx, desc, dst, src, &to_process,
-				       processed, csbcpb->cpb.aes_cbc.iv);
+		rc = nx_build_sg_lists(nx_ctx, desc->info, dst, src,
+				       &to_process, processed,
+				       csbcpb->cpb.aes_cbc.iv);
 		if (rc)
 			goto out;
 
drivers/crypto/nx/nx-aes-ccm.c +14 -26
index 5be8f01c5da8..84fed736ed2e 100644
@@ -327,7 +327,7 @@ static int generate_pat(u8                   *iv,
 }
 
 static int ccm_nx_decrypt(struct aead_request   *req,
-			  struct blkcipher_desc *desc,
+			  u8                    *iv,
 			  unsigned int assoclen)
 {
 	struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(req->base.tfm);
@@ -348,7 +348,7 @@ static int ccm_nx_decrypt(struct aead_request   *req,
 				 req->src, nbytes + req->assoclen, authsize,
 				 SCATTERWALK_FROM_SG);
 
-	rc = generate_pat(desc->info, req, nx_ctx, authsize, nbytes, assoclen,
+	rc = generate_pat(iv, req, nx_ctx, authsize, nbytes, assoclen,
 			  csbcpb->cpb.aes_ccm.in_pat_or_b0);
 	if (rc)
 		goto out;
@@ -367,7 +367,7 @@ static int ccm_nx_decrypt(struct aead_request   *req,
 
 		NX_CPB_FDM(nx_ctx->csbcpb) &= ~NX_FDM_ENDE_ENCRYPT;
 
-		rc = nx_build_sg_lists(nx_ctx, desc, req->dst, req->src,
+		rc = nx_build_sg_lists(nx_ctx, iv, req->dst, req->src,
 				       &to_process, processed + req->assoclen,
 				       csbcpb->cpb.aes_ccm.iv_or_ctr);
 		if (rc)
@@ -381,7 +381,7 @@ static int ccm_nx_decrypt(struct aead_request   *req,
 		/* for partial completion, copy following for next
 		 * entry into loop...
 		 */
-		memcpy(desc->info, csbcpb->cpb.aes_ccm.out_ctr, AES_BLOCK_SIZE);
+		memcpy(iv, csbcpb->cpb.aes_ccm.out_ctr, AES_BLOCK_SIZE);
 		memcpy(csbcpb->cpb.aes_ccm.in_pat_or_b0,
 			csbcpb->cpb.aes_ccm.out_pat_or_mac, AES_BLOCK_SIZE);
 		memcpy(csbcpb->cpb.aes_ccm.in_s0,
@@ -405,7 +405,7 @@ static int ccm_nx_decrypt(struct aead_request   *req,
 }
 
 static int ccm_nx_encrypt(struct aead_request   *req,
-			  struct blkcipher_desc *desc,
+			  u8                    *iv,
 			  unsigned int assoclen)
 {
 	struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(req->base.tfm);
@@ -418,7 +418,7 @@ static int ccm_nx_encrypt(struct aead_request   *req,
 
 	spin_lock_irqsave(&nx_ctx->lock, irq_flags);
 
-	rc = generate_pat(desc->info, req, nx_ctx, authsize, nbytes, assoclen,
+	rc = generate_pat(iv, req, nx_ctx, authsize, nbytes, assoclen,
 			  csbcpb->cpb.aes_ccm.in_pat_or_b0);
 	if (rc)
 		goto out;
@@ -436,7 +436,7 @@ static int ccm_nx_encrypt(struct aead_request   *req,
 
 		NX_CPB_FDM(csbcpb) |= NX_FDM_ENDE_ENCRYPT;
 
-		rc = nx_build_sg_lists(nx_ctx, desc, req->dst, req->src,
+		rc = nx_build_sg_lists(nx_ctx, iv, req->dst, req->src,
 				       &to_process, processed + req->assoclen,
 				       csbcpb->cpb.aes_ccm.iv_or_ctr);
 		if (rc)
@@ -450,7 +450,7 @@ static int ccm_nx_encrypt(struct aead_request   *req,
 		/* for partial completion, copy following for next
 		 * entry into loop...
 		 */
-		memcpy(desc->info, csbcpb->cpb.aes_ccm.out_ctr, AES_BLOCK_SIZE);
+		memcpy(iv, csbcpb->cpb.aes_ccm.out_ctr, AES_BLOCK_SIZE);
 		memcpy(csbcpb->cpb.aes_ccm.in_pat_or_b0,
 			csbcpb->cpb.aes_ccm.out_pat_or_mac, AES_BLOCK_SIZE);
 		memcpy(csbcpb->cpb.aes_ccm.in_s0,
@@ -481,60 +481,48 @@ static int ccm4309_aes_nx_encrypt(struct aead_request *req)
 {
 	struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(req->base.tfm);
 	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
-	struct blkcipher_desc desc;
 	u8 *iv = rctx->iv;
 
 	iv[0] = 3;
 	memcpy(iv + 1, nx_ctx->priv.ccm.nonce, 3);
 	memcpy(iv + 4, req->iv, 8);
 
-	desc.info = iv;
-
-	return ccm_nx_encrypt(req, &desc, req->assoclen - 8);
+	return ccm_nx_encrypt(req, iv, req->assoclen - 8);
 }
 
 static int ccm_aes_nx_encrypt(struct aead_request *req)
 {
-	struct blkcipher_desc desc;
 	int rc;
 
-	desc.info = req->iv;
-
-	rc = crypto_ccm_check_iv(desc.info);
+	rc = crypto_ccm_check_iv(req->iv);
 	if (rc)
 		return rc;
 
-	return ccm_nx_encrypt(req, &desc, req->assoclen);
+	return ccm_nx_encrypt(req, req->iv, req->assoclen);
 }
 
 static int ccm4309_aes_nx_decrypt(struct aead_request *req)
 {
 	struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(req->base.tfm);
 	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
-	struct blkcipher_desc desc;
 	u8 *iv = rctx->iv;
 
 	iv[0] = 3;
 	memcpy(iv + 1, nx_ctx->priv.ccm.nonce, 3);
 	memcpy(iv + 4, req->iv, 8);
 
-	desc.info = iv;
-
-	return ccm_nx_decrypt(req, &desc, req->assoclen - 8);
+	return ccm_nx_decrypt(req, iv, req->assoclen - 8);
 }
 
 static int ccm_aes_nx_decrypt(struct aead_request *req)
 {
-	struct blkcipher_desc desc;
 	int rc;
 
-	desc.info = req->iv;
-
-	rc = crypto_ccm_check_iv(desc.info);
+	rc = crypto_ccm_check_iv(req->iv);
 	if (rc)
 		return rc;
 
-	return ccm_nx_decrypt(req, &desc, req->assoclen);
+	return ccm_nx_decrypt(req, req->iv, req->assoclen);
 }
 
 /* tell the block cipher walk routines that this is a stream cipher by
drivers/crypto/nx/nx-aes-ctr.c +3 -2
index 191e226a11a1..05e558cefe94 100644
@@ -85,8 +85,9 @@ static int ctr_aes_nx_crypt(struct blkcipher_desc *desc,
 	do {
 		to_process = nbytes - processed;
 
-		rc = nx_build_sg_lists(nx_ctx, desc, dst, src, &to_process,
-				       processed, csbcpb->cpb.aes_ctr.iv);
+		rc = nx_build_sg_lists(nx_ctx, desc->info, dst, src,
+				       &to_process, processed,
+				       csbcpb->cpb.aes_ctr.iv);
 		if (rc)
 			goto out;
 
drivers/crypto/nx/nx-aes-ecb.c +2 -2
index c67570470c9d..87183890d1ab 100644
@@ -72,8 +72,8 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
 	do {
 		to_process = nbytes - processed;
 
-		rc = nx_build_sg_lists(nx_ctx, desc, dst, src, &to_process,
-				processed, NULL);
+		rc = nx_build_sg_lists(nx_ctx, NULL, dst, src, &to_process,
+				       processed, NULL);
 		if (rc)
 			goto out;
 
drivers/crypto/nx/nx-aes-gcm.c +10 -14
index 7d3d67871270..898220e159d3 100644
@@ -166,8 +166,7 @@ static int nx_gca(struct nx_crypto_ctx  *nx_ctx,
 	return rc;
 }
 
-static int gmac(struct aead_request *req, struct blkcipher_desc *desc,
-		unsigned int assoclen)
+static int gmac(struct aead_request *req, const u8 *iv, unsigned int assoclen)
 {
 	int rc;
 	struct nx_crypto_ctx *nx_ctx =
@@ -190,7 +189,7 @@ static int gmac(struct aead_request *req, struct blkcipher_desc *desc,
 			   nx_ctx->ap->databytelen/NX_PAGE_SIZE);
 
 	/* Copy IV */
-	memcpy(csbcpb->cpb.aes_gcm.iv_or_cnt, desc->info, AES_BLOCK_SIZE);
+	memcpy(csbcpb->cpb.aes_gcm.iv_or_cnt, iv, AES_BLOCK_SIZE);
 
 	do {
 		/*
@@ -240,8 +239,7 @@ static int gmac(struct aead_request *req, struct blkcipher_desc *desc,
 	return rc;
 }
 
-static int gcm_empty(struct aead_request *req, struct blkcipher_desc *desc,
-		     int enc)
+static int gcm_empty(struct aead_request *req, const u8 *iv, int enc)
 {
 	int rc;
 	struct nx_crypto_ctx *nx_ctx =
@@ -268,7 +266,7 @@ static int gcm_empty(struct aead_request *req, struct blkcipher_desc *desc,
 	len = AES_BLOCK_SIZE;
 
 	/* Encrypt the counter/IV */
-	in_sg = nx_build_sg_list(nx_ctx->in_sg, (u8 *) desc->info,
+	in_sg = nx_build_sg_list(nx_ctx->in_sg, (u8 *) iv,
 				 &len, nx_ctx->ap->sglen);
 
 	if (len != AES_BLOCK_SIZE)
@@ -285,7 +283,7 @@ static int gcm_empty(struct aead_request *req, struct blkcipher_desc *desc,
 	nx_ctx->op.outlen = (nx_ctx->out_sg - out_sg) * sizeof(struct nx_sg);
 
 	rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
-			   desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
+			   req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
 	if (rc)
 		goto out;
 	atomic_inc(&(nx_ctx->stats->aes_ops));
@@ -313,7 +311,6 @@ static int gcm_aes_nx_crypt(struct aead_request *req, int enc,
 		crypto_aead_ctx(crypto_aead_reqtfm(req));
 	struct nx_gcm_rctx *rctx = aead_request_ctx(req);
 	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
-	struct blkcipher_desc desc;
 	unsigned int nbytes = req->cryptlen;
 	unsigned int processed = 0, to_process;
 	unsigned long irq_flags;
@@ -321,15 +318,14 @@ static int gcm_aes_nx_crypt(struct aead_request *req, int enc,
 
 	spin_lock_irqsave(&nx_ctx->lock, irq_flags);
 
-	desc.info = rctx->iv;
 	/* initialize the counter */
-	*(u32 *)(desc.info + NX_GCM_CTR_OFFSET) = 1;
+	*(u32 *)&rctx->iv[NX_GCM_CTR_OFFSET] = 1;
 
 	if (nbytes == 0) {
 		if (assoclen == 0)
-			rc = gcm_empty(req, &desc, enc);
+			rc = gcm_empty(req, rctx->iv, enc);
 		else
-			rc = gmac(req, &desc, assoclen);
+			rc = gmac(req, rctx->iv, assoclen);
 		if (rc)
 			goto out;
 		else
@@ -358,7 +354,7 @@ static int gcm_aes_nx_crypt(struct aead_request *req, int enc,
 		to_process = nbytes - processed;
 
 		csbcpb->cpb.aes_gcm.bit_length_data = nbytes * 8;
-		rc = nx_build_sg_lists(nx_ctx, &desc, req->dst,
+		rc = nx_build_sg_lists(nx_ctx, rctx->iv, req->dst,
 				       req->src, &to_process,
 				       processed + req->assoclen,
 				       csbcpb->cpb.aes_gcm.iv_or_cnt);
@@ -377,7 +373,7 @@ static int gcm_aes_nx_crypt(struct aead_request *req, int enc,
 		if (rc)
 			goto out;
 
-		memcpy(desc.info, csbcpb->cpb.aes_gcm.out_cnt, AES_BLOCK_SIZE);
+		memcpy(rctx->iv, csbcpb->cpb.aes_gcm.out_cnt, AES_BLOCK_SIZE);
 		memcpy(csbcpb->cpb.aes_gcm.in_pat_or_aad,
 			csbcpb->cpb.aes_gcm.out_pat_or_mac, AES_BLOCK_SIZE);
 		memcpy(csbcpb->cpb.aes_gcm.in_s0,
drivers/crypto/nx/nx.c +8 -8
index 28817880c76d..1202a00715ac 100644
@@ -243,25 +243,25 @@ static long int trim_sg_list(struct nx_sg *sg,
  *                     scatterlists based on them.
  *
  * @nx_ctx: NX crypto context for the lists we're building
- * @desc: the block cipher descriptor for the operation
+ * @iv: iv data, if the algorithm requires it
  * @dst: destination scatterlist
  * @src: source scatterlist
  * @nbytes: length of data described in the scatterlists
  * @offset: number of bytes to fast-forward past at the beginning of
  *          scatterlists.
- * @iv: destination for the iv data, if the algorithm requires it
+ * @oiv: destination for the iv data, if the algorithm requires it
  *
- * This is common code shared by all the AES algorithms. It uses the block
- * cipher walk routines to traverse input and output scatterlists, building
+ * This is common code shared by all the AES algorithms. It uses the crypto
+ * scatterlist walk routines to traverse input and output scatterlists, building
  * corresponding NX scatterlists
  */
 int nx_build_sg_lists(struct nx_crypto_ctx  *nx_ctx,
-		      struct blkcipher_desc *desc,
+		      const u8              *iv,
 		      struct scatterlist    *dst,
 		      struct scatterlist    *src,
 		      unsigned int          *nbytes,
 		      unsigned int           offset,
-		      u8                    *iv)
+		      u8                    *oiv)
 {
 	unsigned int delta = 0;
 	unsigned int total = *nbytes;
@@ -274,8 +274,8 @@ int nx_build_sg_lists(struct nx_crypto_ctx  *nx_ctx,
 	max_sg_len = min_t(u64, max_sg_len,
 			nx_ctx->ap->databytelen/NX_PAGE_SIZE);
 
-	if (iv)
-		memcpy(iv, desc->info, AES_BLOCK_SIZE);
+	if (oiv)
+		memcpy(oiv, iv, AES_BLOCK_SIZE);
 
 	*nbytes = min_t(u64, *nbytes, nx_ctx->ap->databytelen);
 
drivers/crypto/nx/nx.h +3 -3
index 7ecca168f8c4..768ebae9731e 100644
@@ -155,9 +155,9 @@ void nx_ctx_init(struct nx_crypto_ctx *nx_ctx, unsigned int function);
 int nx_hcall_sync(struct nx_crypto_ctx *ctx, struct vio_pfo_op *op,
 		  u32 may_sleep);
 struct nx_sg *nx_build_sg_list(struct nx_sg *, u8 *, unsigned int *, u32);
-int nx_build_sg_lists(struct nx_crypto_ctx *, struct blkcipher_desc *,
-		      struct scatterlist *, struct scatterlist *, unsigned int *,
-		      unsigned int, u8 *);
+int nx_build_sg_lists(struct nx_crypto_ctx *nx_ctx, const u8 *iv,
+		      struct scatterlist *dst, struct scatterlist *src,
+		      unsigned int *nbytes, unsigned int offset, u8 *oiv);
 struct nx_sg *nx_walk_and_build(struct nx_sg *, unsigned int,
 				struct scatterlist *, unsigned int,
 				unsigned int *);
Signature · 1 line
2.23.0
#3 lore raw

PATCH 2/4 crypto: nx - convert AES-ECB to skcipher API

In reply to Eric Biggers

From: Eric Biggers <[email protected]>

Convert the PowerPC Nest (NX) implementation of AES-ECB from the deprecated "blkcipher" API to the "skcipher" API. This is needed in order for the blkcipher API to be removed.

---
 drivers/crypto/nx/nx-aes-ecb.c | 76 ++++++++++++++--------------------
 drivers/crypto/nx/nx.c         | 28 ++++++++++---
 drivers/crypto/nx/nx.h         |  5 ++-
 3 files changed, 58 insertions(+), 51 deletions(-)
drivers/crypto/nx/nx-aes-ecb.c +32 -44
index 87183890d1ab..77e338dc33f1 100644
@@ -18,11 +18,11 @@
 #include "nx.h"
 
 
-static int ecb_aes_nx_set_key(struct crypto_tfm *tfm,
-			      const u8          *in_key,
-			      unsigned int       key_len)
+static int ecb_aes_nx_set_key(struct crypto_skcipher *tfm,
+			      const u8               *in_key,
+			      unsigned int            key_len)
 {
-	struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(tfm);
+	struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
 	struct nx_csbcpb *csbcpb = (struct nx_csbcpb *)nx_ctx->csbcpb;
 
 	nx_ctx_init(nx_ctx, HCOP_FC_AES);
@@ -50,13 +50,11 @@ static int ecb_aes_nx_set_key(struct crypto_tfm *tfm,
 	return 0;
 }
 
-static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
-			    struct scatterlist    *dst,
-			    struct scatterlist    *src,
-			    unsigned int           nbytes,
-			    int                    enc)
+static int ecb_aes_nx_crypt(struct skcipher_request *req,
+			    int                      enc)
 {
-	struct nx_crypto_ctx *nx_ctx = crypto_blkcipher_ctx(desc->tfm);
+	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+	struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
 	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
 	unsigned long irq_flags;
 	unsigned int processed = 0, to_process;
@@ -70,10 +68,10 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
 		NX_CPB_FDM(csbcpb) &= ~NX_FDM_ENDE_ENCRYPT;
 
 	do {
-		to_process = nbytes - processed;
+		to_process = req->cryptlen - processed;
 
-		rc = nx_build_sg_lists(nx_ctx, NULL, dst, src, &to_process,
-				       processed, NULL);
+		rc = nx_build_sg_lists(nx_ctx, NULL, req->dst, req->src,
+				       &to_process, processed, NULL);
 		if (rc)
 			goto out;
 
@@ -83,7 +81,7 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
 		}
 
 		rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
-				   desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
+				   req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
 		if (rc)
 			goto out;
 
@@ -92,46 +90,36 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
 			     &(nx_ctx->stats->aes_bytes));
 
 		processed += to_process;
-	} while (processed < nbytes);
+	} while (processed < req->cryptlen);
 
 out:
 	spin_unlock_irqrestore(&nx_ctx->lock, irq_flags);
 	return rc;
 }
 
-static int ecb_aes_nx_encrypt(struct blkcipher_desc *desc,
-			      struct scatterlist    *dst,
-			      struct scatterlist    *src,
-			      unsigned int           nbytes)
+static int ecb_aes_nx_encrypt(struct skcipher_request *req)
 {
-	return ecb_aes_nx_crypt(desc, dst, src, nbytes, 1);
+	return ecb_aes_nx_crypt(req, 1);
 }
 
-static int ecb_aes_nx_decrypt(struct blkcipher_desc *desc,
-			      struct scatterlist    *dst,
-			      struct scatterlist    *src,
-			      unsigned int           nbytes)
+static int ecb_aes_nx_decrypt(struct skcipher_request *req)
 {
-	return ecb_aes_nx_crypt(desc, dst, src, nbytes, 0);
+	return ecb_aes_nx_crypt(req, 0);
 }
 
-struct crypto_alg nx_ecb_aes_alg = {
-	.cra_name        = "ecb(aes)",
-	.cra_driver_name = "ecb-aes-nx",
-	.cra_priority    = 300,
-	.cra_flags       = CRYPTO_ALG_TYPE_BLKCIPHER,
-	.cra_blocksize   = AES_BLOCK_SIZE,
-	.cra_alignmask   = 0xf,
-	.cra_ctxsize     = sizeof(struct nx_crypto_ctx),
-	.cra_type        = &crypto_blkcipher_type,
-	.cra_module      = THIS_MODULE,
-	.cra_init        = nx_crypto_ctx_aes_ecb_init,
-	.cra_exit        = nx_crypto_ctx_exit,
-	.cra_blkcipher = {
-		.min_keysize = AES_MIN_KEY_SIZE,
-		.max_keysize = AES_MAX_KEY_SIZE,
-		.setkey      = ecb_aes_nx_set_key,
-		.encrypt     = ecb_aes_nx_encrypt,
-		.decrypt     = ecb_aes_nx_decrypt,
-	}
+struct skcipher_alg nx_ecb_aes_alg = {
+	.base.cra_name		= "ecb(aes)",
+	.base.cra_driver_name	= "ecb-aes-nx",
+	.base.cra_priority	= 300,
+	.base.cra_blocksize	= AES_BLOCK_SIZE,
+	.base.cra_alignmask	= 0xf,
+	.base.cra_ctxsize	= sizeof(struct nx_crypto_ctx),
+	.base.cra_module	= THIS_MODULE,
+	.init			= nx_crypto_ctx_aes_ecb_init,
+	.exit			= nx_crypto_ctx_skcipher_exit,
+	.min_keysize		= AES_MIN_KEY_SIZE,
+	.max_keysize		= AES_MAX_KEY_SIZE,
+	.setkey			= ecb_aes_nx_set_key,
+	.encrypt		= ecb_aes_nx_encrypt,
+	.decrypt		= ecb_aes_nx_decrypt,
 };
drivers/crypto/nx/nx.c +23 -5
index 1202a00715ac..4b97081e7486 100644
@@ -517,6 +517,12 @@ static int nx_register_alg(struct crypto_alg *alg, u32 fc, u32 mode)
 	       crypto_register_alg(alg) : 0;
 }
 
+static int nx_register_skcipher(struct skcipher_alg *alg, u32 fc, u32 mode)
+{
+	return nx_check_props(&nx_driver.viodev->dev, fc, mode) ?
+	       crypto_register_skcipher(alg) : 0;
+}
+
 static int nx_register_aead(struct aead_alg *alg, u32 fc, u32 mode)
 {
 	return nx_check_props(&nx_driver.viodev->dev, fc, mode) ?
@@ -537,6 +543,12 @@ static void nx_unregister_alg(struct crypto_alg *alg, u32 fc, u32 mode)
 		crypto_unregister_alg(alg);
 }
 
+static void nx_unregister_skcipher(struct skcipher_alg *alg, u32 fc, u32 mode)
+{
+	if (nx_check_props(NULL, fc, mode))
+		crypto_unregister_skcipher(alg);
+}
+
 static void nx_unregister_aead(struct aead_alg *alg, u32 fc, u32 mode)
 {
 	if (nx_check_props(NULL, fc, mode))
@@ -573,7 +585,7 @@ static int nx_register_algs(void)
 
 	nx_driver.of.status = NX_OKAY;
 
-	rc = nx_register_alg(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
+	rc = nx_register_skcipher(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
 	if (rc)
 		goto out;
 
@@ -637,7 +649,7 @@ static int nx_register_algs(void)
 out_unreg_cbc:
 	nx_unregister_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
 out_unreg_ecb:
-	nx_unregister_alg(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
+	nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
 out:
 	return rc;
 }
@@ -716,9 +728,9 @@ int nx_crypto_ctx_aes_cbc_init(struct crypto_tfm *tfm)
 				  NX_MODE_AES_CBC);
 }
 
-int nx_crypto_ctx_aes_ecb_init(struct crypto_tfm *tfm)
+int nx_crypto_ctx_aes_ecb_init(struct crypto_skcipher *tfm)
 {
-	return nx_crypto_ctx_init(crypto_tfm_ctx(tfm), NX_FC_AES,
+	return nx_crypto_ctx_init(crypto_skcipher_ctx(tfm), NX_FC_AES,
 				  NX_MODE_AES_ECB);
 }
 
@@ -752,6 +764,11 @@ void nx_crypto_ctx_exit(struct crypto_tfm *tfm)
 	nx_ctx->out_sg = NULL;
 }
 
+void nx_crypto_ctx_skcipher_exit(struct crypto_skcipher *tfm)
+{
+	nx_crypto_ctx_exit(crypto_skcipher_ctx(tfm));
+}
+
 void nx_crypto_ctx_aead_exit(struct crypto_aead *tfm)
 {
 	struct nx_crypto_ctx *nx_ctx = crypto_aead_ctx(tfm);
@@ -801,7 +818,8 @@ static int nx_remove(struct vio_dev *viodev)
 		nx_unregister_alg(&nx_ctr3686_aes_alg,
 				  NX_FC_AES, NX_MODE_AES_CTR);
 		nx_unregister_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
-		nx_unregister_alg(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
+		nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES,
+				       NX_MODE_AES_ECB);
 	}
 
 	return 0;
drivers/crypto/nx/nx.h +3 -2
index 768ebae9731e..1a839ef21c4f 100644
@@ -147,9 +147,10 @@ int nx_crypto_ctx_aes_gcm_init(struct crypto_aead *tfm);
 int nx_crypto_ctx_aes_xcbc_init(struct crypto_tfm *tfm);
 int nx_crypto_ctx_aes_ctr_init(struct crypto_tfm *tfm);
 int nx_crypto_ctx_aes_cbc_init(struct crypto_tfm *tfm);
-int nx_crypto_ctx_aes_ecb_init(struct crypto_tfm *tfm);
+int nx_crypto_ctx_aes_ecb_init(struct crypto_skcipher *tfm);
 int nx_crypto_ctx_sha_init(struct crypto_tfm *tfm);
 void nx_crypto_ctx_exit(struct crypto_tfm *tfm);
+void nx_crypto_ctx_skcipher_exit(struct crypto_skcipher *tfm);
 void nx_crypto_ctx_aead_exit(struct crypto_aead *tfm);
 void nx_ctx_init(struct nx_crypto_ctx *nx_ctx, unsigned int function);
 int nx_hcall_sync(struct nx_crypto_ctx *ctx, struct vio_pfo_op *op,
@@ -176,7 +177,7 @@ void nx_debugfs_fini(struct nx_crypto_driver *);
 #define NX_PAGE_NUM(x)		((u64)(x) & 0xfffffffffffff000ULL)
 
 extern struct crypto_alg nx_cbc_aes_alg;
-extern struct crypto_alg nx_ecb_aes_alg;
+extern struct skcipher_alg nx_ecb_aes_alg;
 extern struct aead_alg nx_gcm_aes_alg;
 extern struct aead_alg nx_gcm4106_aes_alg;
 extern struct crypto_alg nx_ctr3686_aes_alg;
Signature · 1 line
2.23.0
#5 lore raw

PATCH 3/4 crypto: nx - convert AES-CBC to skcipher API

In reply to Eric Biggers

From: Eric Biggers <[email protected]>

Convert the PowerPC Nest (NX) implementation of AES-CBC from the deprecated "blkcipher" API to the "skcipher" API. This is needed in order for the blkcipher API to be removed.

---
 drivers/crypto/nx/nx-aes-cbc.c | 78 ++++++++++++++--------------------
 drivers/crypto/nx/nx.c         | 11 ++---
 drivers/crypto/nx/nx.h         |  4 +-
 3 files changed, 41 insertions(+), 52 deletions(-)
drivers/crypto/nx/nx-aes-cbc.c +33 -45
index 482a203a9260..92e921eceed7 100644
@@ -18,11 +18,11 @@
 #include "nx.h"
 
 
-static int cbc_aes_nx_set_key(struct crypto_tfm *tfm,
-			      const u8          *in_key,
-			      unsigned int       key_len)
+static int cbc_aes_nx_set_key(struct crypto_skcipher *tfm,
+			      const u8               *in_key,
+			      unsigned int            key_len)
 {
-	struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(tfm);
+	struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
 	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
 
 	nx_ctx_init(nx_ctx, HCOP_FC_AES);
@@ -50,13 +50,11 @@ static int cbc_aes_nx_set_key(struct crypto_tfm *tfm,
 	return 0;
 }
 
-static int cbc_aes_nx_crypt(struct blkcipher_desc *desc,
-			    struct scatterlist    *dst,
-			    struct scatterlist    *src,
-			    unsigned int           nbytes,
-			    int                    enc)
+static int cbc_aes_nx_crypt(struct skcipher_request *req,
+			    int                      enc)
 {
-	struct nx_crypto_ctx *nx_ctx = crypto_blkcipher_ctx(desc->tfm);
+	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+	struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
 	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
 	unsigned long irq_flags;
 	unsigned int processed = 0, to_process;
@@ -70,9 +68,9 @@ static int cbc_aes_nx_crypt(struct blkcipher_desc *desc,
 		NX_CPB_FDM(csbcpb) &= ~NX_FDM_ENDE_ENCRYPT;
 
 	do {
-		to_process = nbytes - processed;
+		to_process = req->cryptlen - processed;
 
-		rc = nx_build_sg_lists(nx_ctx, desc->info, dst, src,
+		rc = nx_build_sg_lists(nx_ctx, req->iv, req->dst, req->src,
 				       &to_process, processed,
 				       csbcpb->cpb.aes_cbc.iv);
 		if (rc)
@@ -84,56 +82,46 @@ static int cbc_aes_nx_crypt(struct blkcipher_desc *desc,
 		}
 
 		rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
-				   desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
+				   req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
 		if (rc)
 			goto out;
 
-		memcpy(desc->info, csbcpb->cpb.aes_cbc.cv, AES_BLOCK_SIZE);
+		memcpy(req->iv, csbcpb->cpb.aes_cbc.cv, AES_BLOCK_SIZE);
 		atomic_inc(&(nx_ctx->stats->aes_ops));
 		atomic64_add(csbcpb->csb.processed_byte_count,
 			     &(nx_ctx->stats->aes_bytes));
 
 		processed += to_process;
-	} while (processed < nbytes);
+	} while (processed < req->cryptlen);
 out:
 	spin_unlock_irqrestore(&nx_ctx->lock, irq_flags);
 	return rc;
 }
 
-static int cbc_aes_nx_encrypt(struct blkcipher_desc *desc,
-			      struct scatterlist    *dst,
-			      struct scatterlist    *src,
-			      unsigned int           nbytes)
+static int cbc_aes_nx_encrypt(struct skcipher_request *req)
 {
-	return cbc_aes_nx_crypt(desc, dst, src, nbytes, 1);
+	return cbc_aes_nx_crypt(req, 1);
 }
 
-static int cbc_aes_nx_decrypt(struct blkcipher_desc *desc,
-			      struct scatterlist    *dst,
-			      struct scatterlist    *src,
-			      unsigned int           nbytes)
+static int cbc_aes_nx_decrypt(struct skcipher_request *req)
 {
-	return cbc_aes_nx_crypt(desc, dst, src, nbytes, 0);
+	return cbc_aes_nx_crypt(req, 0);
 }
 
-struct crypto_alg nx_cbc_aes_alg = {
-	.cra_name        = "cbc(aes)",
-	.cra_driver_name = "cbc-aes-nx",
-	.cra_priority    = 300,
-	.cra_flags       = CRYPTO_ALG_TYPE_BLKCIPHER,
-	.cra_blocksize   = AES_BLOCK_SIZE,
-	.cra_ctxsize     = sizeof(struct nx_crypto_ctx),
-	.cra_type        = &crypto_blkcipher_type,
-	.cra_alignmask   = 0xf,
-	.cra_module      = THIS_MODULE,
-	.cra_init        = nx_crypto_ctx_aes_cbc_init,
-	.cra_exit        = nx_crypto_ctx_exit,
-	.cra_blkcipher = {
-		.min_keysize = AES_MIN_KEY_SIZE,
-		.max_keysize = AES_MAX_KEY_SIZE,
-		.ivsize      = AES_BLOCK_SIZE,
-		.setkey      = cbc_aes_nx_set_key,
-		.encrypt     = cbc_aes_nx_encrypt,
-		.decrypt     = cbc_aes_nx_decrypt,
-	}
+struct skcipher_alg nx_cbc_aes_alg = {
+	.base.cra_name		= "cbc(aes)",
+	.base.cra_driver_name	= "cbc-aes-nx",
+	.base.cra_priority	= 300,
+	.base.cra_blocksize	= AES_BLOCK_SIZE,
+	.base.cra_ctxsize	= sizeof(struct nx_crypto_ctx),
+	.base.cra_alignmask	= 0xf,
+	.base.cra_module	= THIS_MODULE,
+	.init			= nx_crypto_ctx_aes_cbc_init,
+	.exit			= nx_crypto_ctx_skcipher_exit,
+	.min_keysize		= AES_MIN_KEY_SIZE,
+	.max_keysize		= AES_MAX_KEY_SIZE,
+	.ivsize			= AES_BLOCK_SIZE,
+	.setkey			= cbc_aes_nx_set_key,
+	.encrypt		= cbc_aes_nx_encrypt,
+	.decrypt		= cbc_aes_nx_decrypt,
 };
drivers/crypto/nx/nx.c +6 -5
index 4b97081e7486..8e5367776ca0 100644
@@ -589,7 +589,7 @@ static int nx_register_algs(void)
 	if (rc)
 		goto out;
 
-	rc = nx_register_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
+	rc = nx_register_skcipher(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
 	if (rc)
 		goto out_unreg_ecb;
 
@@ -647,7 +647,7 @@ static int nx_register_algs(void)
 out_unreg_ctr3686:
 	nx_unregister_alg(&nx_ctr3686_aes_alg, NX_FC_AES, NX_MODE_AES_CTR);
 out_unreg_cbc:
-	nx_unregister_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
+	nx_unregister_skcipher(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
 out_unreg_ecb:
 	nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
 out:
@@ -722,9 +722,9 @@ int nx_crypto_ctx_aes_ctr_init(struct crypto_tfm *tfm)
 				  NX_MODE_AES_CTR);
 }
 
-int nx_crypto_ctx_aes_cbc_init(struct crypto_tfm *tfm)
+int nx_crypto_ctx_aes_cbc_init(struct crypto_skcipher *tfm)
 {
-	return nx_crypto_ctx_init(crypto_tfm_ctx(tfm), NX_FC_AES,
+	return nx_crypto_ctx_init(crypto_skcipher_ctx(tfm), NX_FC_AES,
 				  NX_MODE_AES_CBC);
 }
 
@@ -817,7 +817,8 @@ static int nx_remove(struct vio_dev *viodev)
 				   NX_FC_AES, NX_MODE_AES_GCM);
 		nx_unregister_alg(&nx_ctr3686_aes_alg,
 				  NX_FC_AES, NX_MODE_AES_CTR);
-		nx_unregister_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
+		nx_unregister_skcipher(&nx_cbc_aes_alg, NX_FC_AES,
+				       NX_MODE_AES_CBC);
 		nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES,
 				       NX_MODE_AES_ECB);
 	}
drivers/crypto/nx/nx.h +2 -2
index 1a839ef21c4f..2e1a3e5e65cb 100644
@@ -146,7 +146,7 @@ int nx_crypto_ctx_aes_ccm_init(struct crypto_aead *tfm);
 int nx_crypto_ctx_aes_gcm_init(struct crypto_aead *tfm);
 int nx_crypto_ctx_aes_xcbc_init(struct crypto_tfm *tfm);
 int nx_crypto_ctx_aes_ctr_init(struct crypto_tfm *tfm);
-int nx_crypto_ctx_aes_cbc_init(struct crypto_tfm *tfm);
+int nx_crypto_ctx_aes_cbc_init(struct crypto_skcipher *tfm);
 int nx_crypto_ctx_aes_ecb_init(struct crypto_skcipher *tfm);
 int nx_crypto_ctx_sha_init(struct crypto_tfm *tfm);
 void nx_crypto_ctx_exit(struct crypto_tfm *tfm);
@@ -176,7 +176,7 @@ void nx_debugfs_fini(struct nx_crypto_driver *);
 
 #define NX_PAGE_NUM(x)		((u64)(x) & 0xfffffffffffff000ULL)
 
-extern struct crypto_alg nx_cbc_aes_alg;
+extern struct skcipher_alg nx_cbc_aes_alg;
 extern struct skcipher_alg nx_ecb_aes_alg;
 extern struct aead_alg nx_gcm_aes_alg;
 extern struct aead_alg nx_gcm4106_aes_alg;
Signature · 1 line
2.23.0
#7 lore raw

PATCH 4/4 crypto: nx - convert AES-CTR to skcipher API

In reply to Eric Biggers

From: Eric Biggers <[email protected]>

Convert the PowerPC Nest (NX) implementation of AES-CTR from the deprecated "blkcipher" API to the "skcipher" API. This is needed in order for the blkcipher API to be removed.

---
 drivers/crypto/nx/nx-aes-ctr.c | 84 +++++++++++++++-------------------
 drivers/crypto/nx/nx.c         | 25 +++-------
 drivers/crypto/nx/nx.h         |  4 +-
 3 files changed, 46 insertions(+), 67 deletions(-)
drivers/crypto/nx/nx-aes-ctr.c +37 -47
index 05e558cefe94..6d5ce1a66f1e 100644
@@ -19,11 +19,11 @@
 #include "nx.h"
 
 
-static int ctr_aes_nx_set_key(struct crypto_tfm *tfm,
-			      const u8          *in_key,
-			      unsigned int       key_len)
+static int ctr_aes_nx_set_key(struct crypto_skcipher *tfm,
+			      const u8               *in_key,
+			      unsigned int            key_len)
 {
-	struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(tfm);
+	struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
 	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
 
 	nx_ctx_init(nx_ctx, HCOP_FC_AES);
@@ -51,11 +51,11 @@ static int ctr_aes_nx_set_key(struct crypto_tfm *tfm,
 	return 0;
 }
 
-static int ctr3686_aes_nx_set_key(struct crypto_tfm *tfm,
-				  const u8          *in_key,
-				  unsigned int       key_len)
+static int ctr3686_aes_nx_set_key(struct crypto_skcipher *tfm,
+				  const u8               *in_key,
+				  unsigned int            key_len)
 {
-	struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(tfm);
+	struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
 
 	if (key_len < CTR_RFC3686_NONCE_SIZE)
 		return -EINVAL;
@@ -69,12 +69,10 @@ static int ctr3686_aes_nx_set_key(struct crypto_tfm *tfm,
 	return ctr_aes_nx_set_key(tfm, in_key, key_len);
 }
 
-static int ctr_aes_nx_crypt(struct blkcipher_desc *desc,
-			    struct scatterlist    *dst,
-			    struct scatterlist    *src,
-			    unsigned int           nbytes)
+static int ctr_aes_nx_crypt(struct skcipher_request *req, u8 *iv)
 {
-	struct nx_crypto_ctx *nx_ctx = crypto_blkcipher_ctx(desc->tfm);
+	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+	struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
 	struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
 	unsigned long irq_flags;
 	unsigned int processed = 0, to_process;
@@ -83,9 +81,9 @@ static int ctr_aes_nx_crypt(struct blkcipher_desc *desc,
 	spin_lock_irqsave(&nx_ctx->lock, irq_flags);
 
 	do {
-		to_process = nbytes - processed;
+		to_process = req->cryptlen - processed;
 
-		rc = nx_build_sg_lists(nx_ctx, desc->info, dst, src,
+		rc = nx_build_sg_lists(nx_ctx, iv, req->dst, req->src,
 				       &to_process, processed,
 				       csbcpb->cpb.aes_ctr.iv);
 		if (rc)
@@ -97,59 +95,51 @@ static int ctr_aes_nx_crypt(struct blkcipher_desc *desc,
 		}
 
 		rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
-				   desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
+				   req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
 		if (rc)
 			goto out;
 
-		memcpy(desc->info, csbcpb->cpb.aes_cbc.cv, AES_BLOCK_SIZE);
+		memcpy(iv, csbcpb->cpb.aes_cbc.cv, AES_BLOCK_SIZE);
 
 		atomic_inc(&(nx_ctx->stats->aes_ops));
 		atomic64_add(csbcpb->csb.processed_byte_count,
 			     &(nx_ctx->stats->aes_bytes));
 
 		processed += to_process;
-	} while (processed < nbytes);
+	} while (processed < req->cryptlen);
 out:
 	spin_unlock_irqrestore(&nx_ctx->lock, irq_flags);
 	return rc;
 }
 
-static int ctr3686_aes_nx_crypt(struct blkcipher_desc *desc,
-				struct scatterlist    *dst,
-				struct scatterlist    *src,
-				unsigned int           nbytes)
+static int ctr3686_aes_nx_crypt(struct skcipher_request *req)
 {
-	struct nx_crypto_ctx *nx_ctx = crypto_blkcipher_ctx(desc->tfm);
+	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+	struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
 	u8 iv[16];
 
 	memcpy(iv, nx_ctx->priv.ctr.nonce, CTR_RFC3686_IV_SIZE);
-	memcpy(iv + CTR_RFC3686_NONCE_SIZE,
-	       desc->info, CTR_RFC3686_IV_SIZE);
+	memcpy(iv + CTR_RFC3686_NONCE_SIZE, req->iv, CTR_RFC3686_IV_SIZE);
 	iv[12] = iv[13] = iv[14] = 0;
 	iv[15] = 1;
 
-	desc->info = iv;
-
-	return ctr_aes_nx_crypt(desc, dst, src, nbytes);
+	return ctr_aes_nx_crypt(req, iv);
 }
 
-struct crypto_alg nx_ctr3686_aes_alg = {
-	.cra_name        = "rfc3686(ctr(aes))",
-	.cra_driver_name = "rfc3686-ctr-aes-nx",
-	.cra_priority    = 300,
-	.cra_flags       = CRYPTO_ALG_TYPE_BLKCIPHER,
-	.cra_blocksize   = 1,
-	.cra_ctxsize     = sizeof(struct nx_crypto_ctx),
-	.cra_type        = &crypto_blkcipher_type,
-	.cra_module      = THIS_MODULE,
-	.cra_init        = nx_crypto_ctx_aes_ctr_init,
-	.cra_exit        = nx_crypto_ctx_exit,
-	.cra_blkcipher = {
-		.min_keysize = AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
-		.max_keysize = AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
-		.ivsize      = CTR_RFC3686_IV_SIZE,
-		.setkey      = ctr3686_aes_nx_set_key,
-		.encrypt     = ctr3686_aes_nx_crypt,
-		.decrypt     = ctr3686_aes_nx_crypt,
-	}
+struct skcipher_alg nx_ctr3686_aes_alg = {
+	.base.cra_name		= "rfc3686(ctr(aes))",
+	.base.cra_driver_name	= "rfc3686-ctr-aes-nx",
+	.base.cra_priority	= 300,
+	.base.cra_blocksize	= 1,
+	.base.cra_ctxsize	= sizeof(struct nx_crypto_ctx),
+	.base.cra_module	= THIS_MODULE,
+	.init			= nx_crypto_ctx_aes_ctr_init,
+	.exit			= nx_crypto_ctx_skcipher_exit,
+	.min_keysize		= AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
+	.max_keysize		= AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
+	.ivsize			= CTR_RFC3686_IV_SIZE,
+	.setkey			= ctr3686_aes_nx_set_key,
+	.encrypt		= ctr3686_aes_nx_crypt,
+	.decrypt		= ctr3686_aes_nx_crypt,
+	.chunksize		= AES_BLOCK_SIZE,
 };
drivers/crypto/nx/nx.c +7 -18
index 8e5367776ca0..f03c238f5a31 100644
@@ -511,12 +511,6 @@ static bool nx_check_props(struct device *dev, u32 fc, u32 mode)
 	return true;
 }
 
-static int nx_register_alg(struct crypto_alg *alg, u32 fc, u32 mode)
-{
-	return nx_check_props(&nx_driver.viodev->dev, fc, mode) ?
-	       crypto_register_alg(alg) : 0;
-}
-
 static int nx_register_skcipher(struct skcipher_alg *alg, u32 fc, u32 mode)
 {
 	return nx_check_props(&nx_driver.viodev->dev, fc, mode) ?
@@ -537,12 +531,6 @@ static int nx_register_shash(struct shash_alg *alg, u32 fc, u32 mode, int slot)
 	       crypto_register_shash(alg) : 0;
 }
 
-static void nx_unregister_alg(struct crypto_alg *alg, u32 fc, u32 mode)
-{
-	if (nx_check_props(NULL, fc, mode))
-		crypto_unregister_alg(alg);
-}
-
 static void nx_unregister_skcipher(struct skcipher_alg *alg, u32 fc, u32 mode)
 {
 	if (nx_check_props(NULL, fc, mode))
@@ -593,7 +581,8 @@ static int nx_register_algs(void)
 	if (rc)
 		goto out_unreg_ecb;
 
-	rc = nx_register_alg(&nx_ctr3686_aes_alg, NX_FC_AES, NX_MODE_AES_CTR);
+	rc = nx_register_skcipher(&nx_ctr3686_aes_alg, NX_FC_AES,
+				  NX_MODE_AES_CTR);
 	if (rc)
 		goto out_unreg_cbc;
 
@@ -645,7 +634,7 @@ static int nx_register_algs(void)
 out_unreg_gcm:
 	nx_unregister_aead(&nx_gcm_aes_alg, NX_FC_AES, NX_MODE_AES_GCM);
 out_unreg_ctr3686:
-	nx_unregister_alg(&nx_ctr3686_aes_alg, NX_FC_AES, NX_MODE_AES_CTR);
+	nx_unregister_skcipher(&nx_ctr3686_aes_alg, NX_FC_AES, NX_MODE_AES_CTR);
 out_unreg_cbc:
 	nx_unregister_skcipher(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
 out_unreg_ecb:
@@ -716,9 +705,9 @@ int nx_crypto_ctx_aes_gcm_init(struct crypto_aead *tfm)
 				  NX_MODE_AES_GCM);
 }
 
-int nx_crypto_ctx_aes_ctr_init(struct crypto_tfm *tfm)
+int nx_crypto_ctx_aes_ctr_init(struct crypto_skcipher *tfm)
 {
-	return nx_crypto_ctx_init(crypto_tfm_ctx(tfm), NX_FC_AES,
+	return nx_crypto_ctx_init(crypto_skcipher_ctx(tfm), NX_FC_AES,
 				  NX_MODE_AES_CTR);
 }
 
@@ -815,8 +804,8 @@ static int nx_remove(struct vio_dev *viodev)
 				   NX_FC_AES, NX_MODE_AES_GCM);
 		nx_unregister_aead(&nx_gcm_aes_alg,
 				   NX_FC_AES, NX_MODE_AES_GCM);
-		nx_unregister_alg(&nx_ctr3686_aes_alg,
-				  NX_FC_AES, NX_MODE_AES_CTR);
+		nx_unregister_skcipher(&nx_ctr3686_aes_alg,
+				       NX_FC_AES, NX_MODE_AES_CTR);
 		nx_unregister_skcipher(&nx_cbc_aes_alg, NX_FC_AES,
 				       NX_MODE_AES_CBC);
 		nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES,
drivers/crypto/nx/nx.h +2 -2
index 2e1a3e5e65cb..91c54289124a 100644
@@ -145,7 +145,7 @@ struct crypto_aead;
 int nx_crypto_ctx_aes_ccm_init(struct crypto_aead *tfm);
 int nx_crypto_ctx_aes_gcm_init(struct crypto_aead *tfm);
 int nx_crypto_ctx_aes_xcbc_init(struct crypto_tfm *tfm);
-int nx_crypto_ctx_aes_ctr_init(struct crypto_tfm *tfm);
+int nx_crypto_ctx_aes_ctr_init(struct crypto_skcipher *tfm);
 int nx_crypto_ctx_aes_cbc_init(struct crypto_skcipher *tfm);
 int nx_crypto_ctx_aes_ecb_init(struct crypto_skcipher *tfm);
 int nx_crypto_ctx_sha_init(struct crypto_tfm *tfm);
@@ -180,7 +180,7 @@ extern struct skcipher_alg nx_cbc_aes_alg;
 extern struct skcipher_alg nx_ecb_aes_alg;
 extern struct aead_alg nx_gcm_aes_alg;
 extern struct aead_alg nx_gcm4106_aes_alg;
-extern struct crypto_alg nx_ctr3686_aes_alg;
+extern struct skcipher_alg nx_ctr3686_aes_alg;
 extern struct aead_alg nx_ccm_aes_alg;
 extern struct aead_alg nx_ccm4309_aes_alg;
 extern struct shash_alg nx_shash_aes_xcbc_alg;
Signature · 1 line
2.23.0
#9 lore raw
In reply to Eric Biggers
Quoted 15 lines · Eric Biggers

This series converts the PowerPC Nest (NX) implementations of AES modes from the deprecated "blkcipher" API to the "skcipher" API. This is needed in order for the blkcipher API to be removed.

This patchset is compile-tested only, as I don't have this hardware. If anyone has this hardware, please test this patchset with CONFIG_CRYPTO_MANAGER_EXTRA_TESTS=y.

Eric Biggers (4):
crypto: nx - don't abuse blkcipher_desc to pass iv around
crypto: nx - convert AES-ECB to skcipher API
crypto: nx - convert AES-CBC to skcipher API
crypto: nx - convert AES-CTR to skcipher API

Quoted 9 lines
 drivers/crypto/nx/nx-aes-cbc.c | 81 ++++++++++++++-----------------
 drivers/crypto/nx/nx-aes-ccm.c | 40 ++++++----------
 drivers/crypto/nx/nx-aes-ctr.c | 87 +++++++++++++++-------------------
 drivers/crypto/nx/nx-aes-ecb.c | 76 +++++++++++++----------------
 drivers/crypto/nx/nx-aes-gcm.c | 24 ++++------
 drivers/crypto/nx/nx.c         | 64 ++++++++++++++-----------
 drivers/crypto/nx/nx.h         | 19 ++++----
 7 files changed, 176 insertions(+), 215 deletions(-)

Hi Eric,

Thanks for taking this on. I'll look in more detail at these patches during the week. In the meantime, I may have a stab at converting ccp, virtio-crypto and omap aes/des myself, since i have the hardware to test those.

Thanks,
Ard.

#10 lore raw
Quoted 27 lines · Ard Biesheuvel
Quoted 15 lines · Eric Biggers

This series converts the PowerPC Nest (NX) implementations of AES modes from the deprecated "blkcipher" API to the "skcipher" API. This is needed in order for the blkcipher API to be removed.

This patchset is compile-tested only, as I don't have this hardware. If anyone has this hardware, please test this patchset with CONFIG_CRYPTO_MANAGER_EXTRA_TESTS=y.

Eric Biggers (4):
crypto: nx - don't abuse blkcipher_desc to pass iv around
crypto: nx - convert AES-ECB to skcipher API
crypto: nx - convert AES-CBC to skcipher API
crypto: nx - convert AES-CTR to skcipher API

Quoted 9 lines
 drivers/crypto/nx/nx-aes-cbc.c | 81 ++++++++++++++-----------------
 drivers/crypto/nx/nx-aes-ccm.c | 40 ++++++----------
 drivers/crypto/nx/nx-aes-ctr.c | 87 +++++++++++++++-------------------
 drivers/crypto/nx/nx-aes-ecb.c | 76 +++++++++++++----------------
 drivers/crypto/nx/nx-aes-gcm.c | 24 ++++------
 drivers/crypto/nx/nx.c         | 64 ++++++++++++++-----------
 drivers/crypto/nx/nx.h         | 19 ++++----
 7 files changed, 176 insertions(+), 215 deletions(-)
Quoted 7 lines

Hi Eric,

Thanks for taking this on. I'll look in more detail at these patches during the week. In the meantime, I may have a stab at converting ccp, virtio-crypto and omap aes/des myself, since i have the hardware to test those.

OK, I got a bit carried away, and converted a bunch of platforms in drivers/crypto (build tested only, except for the virtio driver)

crypto: qce - switch to skcipher API
crypto: rockchip - switch to skcipher API
crypto: stm32 - switch to skcipher API
crypto: sahara - switch to skcipher API
crypto: picoxcell - switch to skcipher API
crypto: mediatek - switch to skcipher API
crypto: mxs - switch to skcipher API
crypto: ixp4xx - switch to skcipher API
crypto: hifn - switch to skcipher API
crypto: chelsio - switch to skcipher API
crypto: cavium/cpt - switch to skcipher API
crypto: nitrox - remove cra_type reference to ablkcipher
crypto: bcm-spu - switch to skcipher API
crypto: atmel-tdes - switch to skcipher API
crypto: atmel-aes - switch to skcipher API
crypto: s5p - switch to skcipher API
crypto: ux500 - switch to skcipher API
crypto: omap - switch to skcipher API
crypto: virtio - switch to skcipher API
crypto: virtio - deal with unsupported input sizes
crypto: virtio - implement missing support for output IVs
crypto: ccp - switch from ablkcipher to skcipher

https://git.kernel.org/pub/scm/linux/kernel/git/ardb/linux.git/log/?h=ablkcipher-removal

I pushed the branch to kernelci, so hopefully we'll get some automated results, but I think only a small subset of these are boot tested atm.

#11 lore raw
Quoted 62 lines · Ard Biesheuvel
Quoted 27 lines · Ard Biesheuvel
Quoted 15 lines · Eric Biggers

This series converts the PowerPC Nest (NX) implementations of AES modes from the deprecated "blkcipher" API to the "skcipher" API. This is needed in order for the blkcipher API to be removed.

This patchset is compile-tested only, as I don't have this hardware. If anyone has this hardware, please test this patchset with CONFIG_CRYPTO_MANAGER_EXTRA_TESTS=y.

Eric Biggers (4):
crypto: nx - don't abuse blkcipher_desc to pass iv around
crypto: nx - convert AES-ECB to skcipher API
crypto: nx - convert AES-CBC to skcipher API
crypto: nx - convert AES-CTR to skcipher API

Quoted 9 lines
 drivers/crypto/nx/nx-aes-cbc.c | 81 ++++++++++++++-----------------
 drivers/crypto/nx/nx-aes-ccm.c | 40 ++++++----------
 drivers/crypto/nx/nx-aes-ctr.c | 87 +++++++++++++++-------------------
 drivers/crypto/nx/nx-aes-ecb.c | 76 +++++++++++++----------------
 drivers/crypto/nx/nx-aes-gcm.c | 24 ++++------
 drivers/crypto/nx/nx.c         | 64 ++++++++++++++-----------
 drivers/crypto/nx/nx.h         | 19 ++++----
 7 files changed, 176 insertions(+), 215 deletions(-)
Quoted 7 lines

Hi Eric,

Thanks for taking this on. I'll look in more detail at these patches during the week. In the meantime, I may have a stab at converting ccp, virtio-crypto and omap aes/des myself, since i have the hardware to test those.

OK, I got a bit carried away, and converted a bunch of platforms in drivers/crypto (build tested only, except for the virtio driver)

crypto: qce - switch to skcipher API
crypto: rockchip - switch to skcipher API
crypto: stm32 - switch to skcipher API
crypto: sahara - switch to skcipher API
crypto: picoxcell - switch to skcipher API
crypto: mediatek - switch to skcipher API
crypto: mxs - switch to skcipher API
crypto: ixp4xx - switch to skcipher API
crypto: hifn - switch to skcipher API
crypto: chelsio - switch to skcipher API
crypto: cavium/cpt - switch to skcipher API
crypto: nitrox - remove cra_type reference to ablkcipher
crypto: bcm-spu - switch to skcipher API
crypto: atmel-tdes - switch to skcipher API
crypto: atmel-aes - switch to skcipher API
crypto: s5p - switch to skcipher API
crypto: ux500 - switch to skcipher API
crypto: omap - switch to skcipher API
crypto: virtio - switch to skcipher API
crypto: virtio - deal with unsupported input sizes
crypto: virtio - implement missing support for output IVs
crypto: ccp - switch from ablkcipher to skcipher

Quoted 4 lines

https://git.kernel.org/pub/scm/linux/kernel/git/ardb/linux.git/log/?h=ablkcipher-removal

I pushed the branch to kernelci, so hopefully we'll get some automated results, but I think only a small subset of these are boot tested atm.

Awesome, thanks for doing this! I was just planning to do "blkcipher" for now, but your patches will take care of almost all of "ablkcipher" too.

A few things I noticed from quickly skimming through your patches:

"ecb-des3-omap", "cbc-des3-omap", "atmel-ecb-tdes", "atmel-cbc-tdes", and "atmel-ofb-tdes" had their min and/or max key size incorrectly changed to 8 (DES_BLOCK_SIZE or DES3_EDE_BLOCK_SIZE) rather than left as 24 (DES3_EDE_KEY_SIZE or 3*DES_KEY_SIZE).

cra_blocksize for "atmel-cfb64-aes" was changed from CFB64_BLOCK_SIZE to AES_BLOCKSIZE. Intentional?

cra_blocksize for "stm32-ctr-aes" and for "cfb-aes-mtk" was changed from 1 to AES_BLOCK_SIZE. Intentional?

CRYPTO_ALG_NEED_FALLBACK was added to "cbc-des-picoxcell" and "ecb-des-picoxcell". Intentional?

In drivers/crypto/ixp4xx_crypto.c, .walksize was set on "rfc3686(ctr(aes))" rather than .chunksize. Intentional?

In drivers/crypto/qce/, CRYPTO_ALG_TYPE_ABLKCIPHER should be replaced with CRYPTO_ALG_TYPE_SKCIPHER.

In drivers/crypto/stm32/, could rename crypto_algs[] to skcipher_algs[].

Thanks!

- Eric

#12 lore raw
Quoted 64 lines · Eric Biggers
Quoted 62 lines · Ard Biesheuvel
Quoted 27 lines · Ard Biesheuvel
Quoted 15 lines · Eric Biggers

This series converts the PowerPC Nest (NX) implementations of AES modes from the deprecated "blkcipher" API to the "skcipher" API. This is needed in order for the blkcipher API to be removed.

This patchset is compile-tested only, as I don't have this hardware. If anyone has this hardware, please test this patchset with CONFIG_CRYPTO_MANAGER_EXTRA_TESTS=y.

Eric Biggers (4):
crypto: nx - don't abuse blkcipher_desc to pass iv around
crypto: nx - convert AES-ECB to skcipher API
crypto: nx - convert AES-CBC to skcipher API
crypto: nx - convert AES-CTR to skcipher API

Quoted 9 lines
 drivers/crypto/nx/nx-aes-cbc.c | 81 ++++++++++++++-----------------
 drivers/crypto/nx/nx-aes-ccm.c | 40 ++++++----------
 drivers/crypto/nx/nx-aes-ctr.c | 87 +++++++++++++++-------------------
 drivers/crypto/nx/nx-aes-ecb.c | 76 +++++++++++++----------------
 drivers/crypto/nx/nx-aes-gcm.c | 24 ++++------
 drivers/crypto/nx/nx.c         | 64 ++++++++++++++-----------
 drivers/crypto/nx/nx.h         | 19 ++++----
 7 files changed, 176 insertions(+), 215 deletions(-)
Quoted 7 lines

Hi Eric,

Thanks for taking this on. I'll look in more detail at these patches during the week. In the meantime, I may have a stab at converting ccp, virtio-crypto and omap aes/des myself, since i have the hardware to test those.

OK, I got a bit carried away, and converted a bunch of platforms in drivers/crypto (build tested only, except for the virtio driver)

crypto: qce - switch to skcipher API
crypto: rockchip - switch to skcipher API
crypto: stm32 - switch to skcipher API
crypto: sahara - switch to skcipher API
crypto: picoxcell - switch to skcipher API
crypto: mediatek - switch to skcipher API
crypto: mxs - switch to skcipher API
crypto: ixp4xx - switch to skcipher API
crypto: hifn - switch to skcipher API
crypto: chelsio - switch to skcipher API
crypto: cavium/cpt - switch to skcipher API
crypto: nitrox - remove cra_type reference to ablkcipher
crypto: bcm-spu - switch to skcipher API
crypto: atmel-tdes - switch to skcipher API
crypto: atmel-aes - switch to skcipher API
crypto: s5p - switch to skcipher API
crypto: ux500 - switch to skcipher API
crypto: omap - switch to skcipher API
crypto: virtio - switch to skcipher API
crypto: virtio - deal with unsupported input sizes
crypto: virtio - implement missing support for output IVs
crypto: ccp - switch from ablkcipher to skcipher

Quoted 8 lines
Quoted 4 lines

https://git.kernel.org/pub/scm/linux/kernel/git/ardb/linux.git/log/?h=ablkcipher-removal

I pushed the branch to kernelci, so hopefully we'll get some automated results, but I think only a small subset of these are boot tested atm.

Awesome, thanks for doing this! I was just planning to do "blkcipher" for now, but your patches will take care of almost all of "ablkcipher" too.

Yeah. I thought it was about time we take care of this, and ablkcipher is much more straightforward anyway.

Quoted 2 lines

A few things I noticed from quickly skimming through your patches:

Thanks. These are all mistakes on my part - I went through these at high speed with lots of mechanical search-replace.

Quoted 25 lines

"ecb-des3-omap", "cbc-des3-omap", "atmel-ecb-tdes", "atmel-cbc-tdes", and "atmel-ofb-tdes" had their min and/or max key size incorrectly changed to 8 (DES_BLOCK_SIZE or DES3_EDE_BLOCK_SIZE) rather than left as 24 (DES3_EDE_KEY_SIZE or 3*DES_KEY_SIZE).

cra_blocksize for "atmel-cfb64-aes" was changed from CFB64_BLOCK_SIZE to AES_BLOCKSIZE. Intentional?

cra_blocksize for "stm32-ctr-aes" and for "cfb-aes-mtk" was changed from 1 to AES_BLOCK_SIZE. Intentional?

CRYPTO_ALG_NEED_FALLBACK was added to "cbc-des-picoxcell" and "ecb-des-picoxcell". Intentional?

In drivers/crypto/ixp4xx_crypto.c, .walksize was set on "rfc3686(ctr(aes))" rather than .chunksize. Intentional?

In drivers/crypto/qce/, CRYPTO_ALG_TYPE_ABLKCIPHER should be replaced with CRYPTO_ALG_TYPE_SKCIPHER.

In drivers/crypto/stm32/, could rename crypto_algs[] to skcipher_algs[].

Thanks!

- Eric

Reviewed-by on v1 1/4
#2 lore raw

Re: [PATCH 1/4] crypto: nx - don't abuse blkcipher_desc to pass iv around

In reply to Eric Biggers
Quoted 11 lines · Eric Biggers

From: Eric Biggers <[email protected]>

The NX crypto driver is using 'struct blkcipher_desc' to pass the IV around, even for AEADs (for which it creates the struct on the stack). This is not appropriate since this structure is part of the "blkcipher" API, which is deprecated and will be removed.

Just pass around the IV directly instead.

Quoted 363 lines
---
 drivers/crypto/nx/nx-aes-cbc.c |  5 +++--
 drivers/crypto/nx/nx-aes-ccm.c | 40 ++++++++++++----------------------
 drivers/crypto/nx/nx-aes-ctr.c |  5 +++--
 drivers/crypto/nx/nx-aes-ecb.c |  4 ++--
 drivers/crypto/nx/nx-aes-gcm.c | 24 +++++++++-----------
 drivers/crypto/nx/nx.c         | 16 +++++++-------
 drivers/crypto/nx/nx.h         |  6 ++---
 7 files changed, 43 insertions(+), 57 deletions(-)
drivers/crypto/nx/nx-aes-cbc.c +3 -2
index e631f9979127..482a203a9260 100644
@@ -72,8 +72,9 @@ static int cbc_aes_nx_crypt(struct blkcipher_desc *desc,
        do {
                to_process = nbytes - processed;
 
-               rc = nx_build_sg_lists(nx_ctx, desc, dst, src, &to_process,
-                                      processed, csbcpb->cpb.aes_cbc.iv);
+               rc = nx_build_sg_lists(nx_ctx, desc->info, dst, src,
+                                      &to_process, processed,
+                                      csbcpb->cpb.aes_cbc.iv);
                if (rc)
                        goto out;
 
drivers/crypto/nx/nx-aes-ccm.c +14 -26
index 5be8f01c5da8..84fed736ed2e 100644
@@ -327,7 +327,7 @@ static int generate_pat(u8                   *iv,
 }
 
 static int ccm_nx_decrypt(struct aead_request   *req,
-                         struct blkcipher_desc *desc,
+                         u8                    *iv,
                          unsigned int assoclen)
 {
        struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(req->base.tfm);
@@ -348,7 +348,7 @@ static int ccm_nx_decrypt(struct aead_request   *req,
                                 req->src, nbytes + req->assoclen, authsize,
                                 SCATTERWALK_FROM_SG);
 
-       rc = generate_pat(desc->info, req, nx_ctx, authsize, nbytes, assoclen,
+       rc = generate_pat(iv, req, nx_ctx, authsize, nbytes, assoclen,
                          csbcpb->cpb.aes_ccm.in_pat_or_b0);
        if (rc)
                goto out;
@@ -367,7 +367,7 @@ static int ccm_nx_decrypt(struct aead_request   *req,
 
                NX_CPB_FDM(nx_ctx->csbcpb) &= ~NX_FDM_ENDE_ENCRYPT;
 
-               rc = nx_build_sg_lists(nx_ctx, desc, req->dst, req->src,
+               rc = nx_build_sg_lists(nx_ctx, iv, req->dst, req->src,
                                       &to_process, processed + req->assoclen,
                                       csbcpb->cpb.aes_ccm.iv_or_ctr);
                if (rc)
@@ -381,7 +381,7 @@ static int ccm_nx_decrypt(struct aead_request   *req,
                /* for partial completion, copy following for next
                 * entry into loop...
                 */
-               memcpy(desc->info, csbcpb->cpb.aes_ccm.out_ctr, AES_BLOCK_SIZE);
+               memcpy(iv, csbcpb->cpb.aes_ccm.out_ctr, AES_BLOCK_SIZE);
                memcpy(csbcpb->cpb.aes_ccm.in_pat_or_b0,
                        csbcpb->cpb.aes_ccm.out_pat_or_mac, AES_BLOCK_SIZE);
                memcpy(csbcpb->cpb.aes_ccm.in_s0,
@@ -405,7 +405,7 @@ static int ccm_nx_decrypt(struct aead_request   *req,
 }
 
 static int ccm_nx_encrypt(struct aead_request   *req,
-                         struct blkcipher_desc *desc,
+                         u8                    *iv,
                          unsigned int assoclen)
 {
        struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(req->base.tfm);
@@ -418,7 +418,7 @@ static int ccm_nx_encrypt(struct aead_request   *req,
 
        spin_lock_irqsave(&nx_ctx->lock, irq_flags);
 
-       rc = generate_pat(desc->info, req, nx_ctx, authsize, nbytes, assoclen,
+       rc = generate_pat(iv, req, nx_ctx, authsize, nbytes, assoclen,
                          csbcpb->cpb.aes_ccm.in_pat_or_b0);
        if (rc)
                goto out;
@@ -436,7 +436,7 @@ static int ccm_nx_encrypt(struct aead_request   *req,
 
                NX_CPB_FDM(csbcpb) |= NX_FDM_ENDE_ENCRYPT;
 
-               rc = nx_build_sg_lists(nx_ctx, desc, req->dst, req->src,
+               rc = nx_build_sg_lists(nx_ctx, iv, req->dst, req->src,
                                       &to_process, processed + req->assoclen,
                                       csbcpb->cpb.aes_ccm.iv_or_ctr);
                if (rc)
@@ -450,7 +450,7 @@ static int ccm_nx_encrypt(struct aead_request   *req,
                /* for partial completion, copy following for next
                 * entry into loop...
                 */
-               memcpy(desc->info, csbcpb->cpb.aes_ccm.out_ctr, AES_BLOCK_SIZE);
+               memcpy(iv, csbcpb->cpb.aes_ccm.out_ctr, AES_BLOCK_SIZE);
                memcpy(csbcpb->cpb.aes_ccm.in_pat_or_b0,
                        csbcpb->cpb.aes_ccm.out_pat_or_mac, AES_BLOCK_SIZE);
                memcpy(csbcpb->cpb.aes_ccm.in_s0,
@@ -481,60 +481,48 @@ static int ccm4309_aes_nx_encrypt(struct aead_request *req)
 {
        struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(req->base.tfm);
        struct nx_gcm_rctx *rctx = aead_request_ctx(req);
-       struct blkcipher_desc desc;
        u8 *iv = rctx->iv;
 
        iv[0] = 3;
        memcpy(iv + 1, nx_ctx->priv.ccm.nonce, 3);
        memcpy(iv + 4, req->iv, 8);
 
-       desc.info = iv;
-
-       return ccm_nx_encrypt(req, &desc, req->assoclen - 8);
+       return ccm_nx_encrypt(req, iv, req->assoclen - 8);
 }
 
 static int ccm_aes_nx_encrypt(struct aead_request *req)
 {
-       struct blkcipher_desc desc;
        int rc;
 
-       desc.info = req->iv;
-
-       rc = crypto_ccm_check_iv(desc.info);
+       rc = crypto_ccm_check_iv(req->iv);
        if (rc)
                return rc;
 
-       return ccm_nx_encrypt(req, &desc, req->assoclen);
+       return ccm_nx_encrypt(req, req->iv, req->assoclen);
 }
 
 static int ccm4309_aes_nx_decrypt(struct aead_request *req)
 {
        struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(req->base.tfm);
        struct nx_gcm_rctx *rctx = aead_request_ctx(req);
-       struct blkcipher_desc desc;
        u8 *iv = rctx->iv;
 
        iv[0] = 3;
        memcpy(iv + 1, nx_ctx->priv.ccm.nonce, 3);
        memcpy(iv + 4, req->iv, 8);
 
-       desc.info = iv;
-
-       return ccm_nx_decrypt(req, &desc, req->assoclen - 8);
+       return ccm_nx_decrypt(req, iv, req->assoclen - 8);
 }
 
 static int ccm_aes_nx_decrypt(struct aead_request *req)
 {
-       struct blkcipher_desc desc;
        int rc;
 
-       desc.info = req->iv;
-
-       rc = crypto_ccm_check_iv(desc.info);
+       rc = crypto_ccm_check_iv(req->iv);
        if (rc)
                return rc;
 
-       return ccm_nx_decrypt(req, &desc, req->assoclen);
+       return ccm_nx_decrypt(req, req->iv, req->assoclen);
 }
 
 /* tell the block cipher walk routines that this is a stream cipher by
drivers/crypto/nx/nx-aes-ctr.c +3 -2
index 191e226a11a1..05e558cefe94 100644
@@ -85,8 +85,9 @@ static int ctr_aes_nx_crypt(struct blkcipher_desc *desc,
        do {
                to_process = nbytes - processed;
 
-               rc = nx_build_sg_lists(nx_ctx, desc, dst, src, &to_process,
-                                      processed, csbcpb->cpb.aes_ctr.iv);
+               rc = nx_build_sg_lists(nx_ctx, desc->info, dst, src,
+                                      &to_process, processed,
+                                      csbcpb->cpb.aes_ctr.iv);
                if (rc)
                        goto out;
 
drivers/crypto/nx/nx-aes-ecb.c +2 -2
index c67570470c9d..87183890d1ab 100644
@@ -72,8 +72,8 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
        do {
                to_process = nbytes - processed;
 
-               rc = nx_build_sg_lists(nx_ctx, desc, dst, src, &to_process,
-                               processed, NULL);
+               rc = nx_build_sg_lists(nx_ctx, NULL, dst, src, &to_process,
+                                      processed, NULL);
                if (rc)
                        goto out;
 
drivers/crypto/nx/nx-aes-gcm.c +10 -14
index 7d3d67871270..898220e159d3 100644
@@ -166,8 +166,7 @@ static int nx_gca(struct nx_crypto_ctx  *nx_ctx,
        return rc;
 }
 
-static int gmac(struct aead_request *req, struct blkcipher_desc *desc,
-               unsigned int assoclen)
+static int gmac(struct aead_request *req, const u8 *iv, unsigned int assoclen)
 {
        int rc;
        struct nx_crypto_ctx *nx_ctx =
@@ -190,7 +189,7 @@ static int gmac(struct aead_request *req, struct blkcipher_desc *desc,
                           nx_ctx->ap->databytelen/NX_PAGE_SIZE);
 
        /* Copy IV */
-       memcpy(csbcpb->cpb.aes_gcm.iv_or_cnt, desc->info, AES_BLOCK_SIZE);
+       memcpy(csbcpb->cpb.aes_gcm.iv_or_cnt, iv, AES_BLOCK_SIZE);
 
        do {
                /*
@@ -240,8 +239,7 @@ static int gmac(struct aead_request *req, struct blkcipher_desc *desc,
        return rc;
 }
 
-static int gcm_empty(struct aead_request *req, struct blkcipher_desc *desc,
-                    int enc)
+static int gcm_empty(struct aead_request *req, const u8 *iv, int enc)
 {
        int rc;
        struct nx_crypto_ctx *nx_ctx =
@@ -268,7 +266,7 @@ static int gcm_empty(struct aead_request *req, struct blkcipher_desc *desc,
        len = AES_BLOCK_SIZE;
 
        /* Encrypt the counter/IV */
-       in_sg = nx_build_sg_list(nx_ctx->in_sg, (u8 *) desc->info,
+       in_sg = nx_build_sg_list(nx_ctx->in_sg, (u8 *) iv,
                                 &len, nx_ctx->ap->sglen);
 
        if (len != AES_BLOCK_SIZE)
@@ -285,7 +283,7 @@ static int gcm_empty(struct aead_request *req, struct blkcipher_desc *desc,
        nx_ctx->op.outlen = (nx_ctx->out_sg - out_sg) * sizeof(struct nx_sg);
 
        rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
-                          desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
+                          req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
        if (rc)
                goto out;
        atomic_inc(&(nx_ctx->stats->aes_ops));
@@ -313,7 +311,6 @@ static int gcm_aes_nx_crypt(struct aead_request *req, int enc,
                crypto_aead_ctx(crypto_aead_reqtfm(req));
        struct nx_gcm_rctx *rctx = aead_request_ctx(req);
        struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
-       struct blkcipher_desc desc;
        unsigned int nbytes = req->cryptlen;
        unsigned int processed = 0, to_process;
        unsigned long irq_flags;
@@ -321,15 +318,14 @@ static int gcm_aes_nx_crypt(struct aead_request *req, int enc,
 
        spin_lock_irqsave(&nx_ctx->lock, irq_flags);
 
-       desc.info = rctx->iv;
        /* initialize the counter */
-       *(u32 *)(desc.info + NX_GCM_CTR_OFFSET) = 1;
+       *(u32 *)&rctx->iv[NX_GCM_CTR_OFFSET] = 1;
 
        if (nbytes == 0) {
                if (assoclen == 0)
-                       rc = gcm_empty(req, &desc, enc);
+                       rc = gcm_empty(req, rctx->iv, enc);
                else
-                       rc = gmac(req, &desc, assoclen);
+                       rc = gmac(req, rctx->iv, assoclen);
                if (rc)
                        goto out;
                else
@@ -358,7 +354,7 @@ static int gcm_aes_nx_crypt(struct aead_request *req, int enc,
                to_process = nbytes - processed;
 
                csbcpb->cpb.aes_gcm.bit_length_data = nbytes * 8;
-               rc = nx_build_sg_lists(nx_ctx, &desc, req->dst,
+               rc = nx_build_sg_lists(nx_ctx, rctx->iv, req->dst,
                                       req->src, &to_process,
                                       processed + req->assoclen,
                                       csbcpb->cpb.aes_gcm.iv_or_cnt);
@@ -377,7 +373,7 @@ static int gcm_aes_nx_crypt(struct aead_request *req, int enc,
                if (rc)
                        goto out;
 
-               memcpy(desc.info, csbcpb->cpb.aes_gcm.out_cnt, AES_BLOCK_SIZE);
+               memcpy(rctx->iv, csbcpb->cpb.aes_gcm.out_cnt, AES_BLOCK_SIZE);
                memcpy(csbcpb->cpb.aes_gcm.in_pat_or_aad,
                        csbcpb->cpb.aes_gcm.out_pat_or_mac, AES_BLOCK_SIZE);
                memcpy(csbcpb->cpb.aes_gcm.in_s0,
drivers/crypto/nx/nx.c +8 -8
index 28817880c76d..1202a00715ac 100644
@@ -243,25 +243,25 @@ static long int trim_sg_list(struct nx_sg *sg,
  *                     scatterlists based on them.
  *
  * @nx_ctx: NX crypto context for the lists we're building
- * @desc: the block cipher descriptor for the operation
+ * @iv: iv data, if the algorithm requires it
  * @dst: destination scatterlist
  * @src: source scatterlist
  * @nbytes: length of data described in the scatterlists
  * @offset: number of bytes to fast-forward past at the beginning of
  *          scatterlists.
- * @iv: destination for the iv data, if the algorithm requires it
+ * @oiv: destination for the iv data, if the algorithm requires it
  *
- * This is common code shared by all the AES algorithms. It uses the block
- * cipher walk routines to traverse input and output scatterlists, building
+ * This is common code shared by all the AES algorithms. It uses the crypto
+ * scatterlist walk routines to traverse input and output scatterlists, building
  * corresponding NX scatterlists
  */
 int nx_build_sg_lists(struct nx_crypto_ctx  *nx_ctx,
-                     struct blkcipher_desc *desc,
+                     const u8              *iv,
                      struct scatterlist    *dst,
                      struct scatterlist    *src,
                      unsigned int          *nbytes,
                      unsigned int           offset,
-                     u8                    *iv)
+                     u8                    *oiv)
 {
        unsigned int delta = 0;
        unsigned int total = *nbytes;
@@ -274,8 +274,8 @@ int nx_build_sg_lists(struct nx_crypto_ctx  *nx_ctx,
        max_sg_len = min_t(u64, max_sg_len,
                        nx_ctx->ap->databytelen/NX_PAGE_SIZE);
 
-       if (iv)
-               memcpy(iv, desc->info, AES_BLOCK_SIZE);
+       if (oiv)
+               memcpy(oiv, iv, AES_BLOCK_SIZE);
 
        *nbytes = min_t(u64, *nbytes, nx_ctx->ap->databytelen);
 
drivers/crypto/nx/nx.h +3 -4
index 7ecca168f8c4..768ebae9731e 100644
@@ -155,9 +155,9 @@ void nx_ctx_init(struct nx_crypto_ctx *nx_ctx, unsigned int function);
 int nx_hcall_sync(struct nx_crypto_ctx *ctx, struct vio_pfo_op *op,
                  u32 may_sleep);
 struct nx_sg *nx_build_sg_list(struct nx_sg *, u8 *, unsigned int *, u32);
-int nx_build_sg_lists(struct nx_crypto_ctx *, struct blkcipher_desc *,
-                     struct scatterlist *, struct scatterlist *, unsigned int *,
-                     unsigned int, u8 *);
+int nx_build_sg_lists(struct nx_crypto_ctx *nx_ctx, const u8 *iv,
+                     struct scatterlist *dst, struct scatterlist *src,
+                     unsigned int *nbytes, unsigned int offset, u8 *oiv);
 struct nx_sg *nx_walk_and_build(struct nx_sg *, unsigned int,
                                struct scatterlist *, unsigned int,
                                unsigned int *);
--

2.23.0

Reviewed-by on v1 2/4
#4 lore raw

Re: [PATCH 2/4] crypto: nx - convert AES-ECB to skcipher API

In reply to Eric Biggers
Quoted 8 lines · Eric Biggers

From: Eric Biggers <[email protected]>

Convert the PowerPC Nest (NX) implementation of AES-ECB from the deprecated "blkcipher" API to the "skcipher" API. This is needed in order for the blkcipher API to be removed.

Quoted 244 lines
---
 drivers/crypto/nx/nx-aes-ecb.c | 76 ++++++++++++++--------------------
 drivers/crypto/nx/nx.c         | 28 ++++++++++---
 drivers/crypto/nx/nx.h         |  5 ++-
 3 files changed, 58 insertions(+), 51 deletions(-)
drivers/crypto/nx/nx-aes-ecb.c +32 -44
index 87183890d1ab..77e338dc33f1 100644
@@ -18,11 +18,11 @@
 #include "nx.h"
 
 
-static int ecb_aes_nx_set_key(struct crypto_tfm *tfm,
-                             const u8          *in_key,
-                             unsigned int       key_len)
+static int ecb_aes_nx_set_key(struct crypto_skcipher *tfm,
+                             const u8               *in_key,
+                             unsigned int            key_len)
 {
-       struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(tfm);
+       struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
        struct nx_csbcpb *csbcpb = (struct nx_csbcpb *)nx_ctx->csbcpb;
 
        nx_ctx_init(nx_ctx, HCOP_FC_AES);
@@ -50,13 +50,11 @@ static int ecb_aes_nx_set_key(struct crypto_tfm *tfm,
        return 0;
 }
 
-static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
-                           struct scatterlist    *dst,
-                           struct scatterlist    *src,
-                           unsigned int           nbytes,
-                           int                    enc)
+static int ecb_aes_nx_crypt(struct skcipher_request *req,
+                           int                      enc)
 {
-       struct nx_crypto_ctx *nx_ctx = crypto_blkcipher_ctx(desc->tfm);
+       struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+       struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
        struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
        unsigned long irq_flags;
        unsigned int processed = 0, to_process;
@@ -70,10 +68,10 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
                NX_CPB_FDM(csbcpb) &= ~NX_FDM_ENDE_ENCRYPT;
 
        do {
-               to_process = nbytes - processed;
+               to_process = req->cryptlen - processed;
 
-               rc = nx_build_sg_lists(nx_ctx, NULL, dst, src, &to_process,
-                                      processed, NULL);
+               rc = nx_build_sg_lists(nx_ctx, NULL, req->dst, req->src,
+                                      &to_process, processed, NULL);
                if (rc)
                        goto out;
 
@@ -83,7 +81,7 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
                }
 
                rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
-                                  desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
+                                  req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
                if (rc)
                        goto out;
 
@@ -92,46 +90,36 @@ static int ecb_aes_nx_crypt(struct blkcipher_desc *desc,
                             &(nx_ctx->stats->aes_bytes));
 
                processed += to_process;
-       } while (processed < nbytes);
+       } while (processed < req->cryptlen);
 
 out:
        spin_unlock_irqrestore(&nx_ctx->lock, irq_flags);
        return rc;
 }
 
-static int ecb_aes_nx_encrypt(struct blkcipher_desc *desc,
-                             struct scatterlist    *dst,
-                             struct scatterlist    *src,
-                             unsigned int           nbytes)
+static int ecb_aes_nx_encrypt(struct skcipher_request *req)
 {
-       return ecb_aes_nx_crypt(desc, dst, src, nbytes, 1);
+       return ecb_aes_nx_crypt(req, 1);
 }
 
-static int ecb_aes_nx_decrypt(struct blkcipher_desc *desc,
-                             struct scatterlist    *dst,
-                             struct scatterlist    *src,
-                             unsigned int           nbytes)
+static int ecb_aes_nx_decrypt(struct skcipher_request *req)
 {
-       return ecb_aes_nx_crypt(desc, dst, src, nbytes, 0);
+       return ecb_aes_nx_crypt(req, 0);
 }
 
-struct crypto_alg nx_ecb_aes_alg = {
-       .cra_name        = "ecb(aes)",
-       .cra_driver_name = "ecb-aes-nx",
-       .cra_priority    = 300,
-       .cra_flags       = CRYPTO_ALG_TYPE_BLKCIPHER,
-       .cra_blocksize   = AES_BLOCK_SIZE,
-       .cra_alignmask   = 0xf,
-       .cra_ctxsize     = sizeof(struct nx_crypto_ctx),
-       .cra_type        = &crypto_blkcipher_type,
-       .cra_module      = THIS_MODULE,
-       .cra_init        = nx_crypto_ctx_aes_ecb_init,
-       .cra_exit        = nx_crypto_ctx_exit,
-       .cra_blkcipher = {
-               .min_keysize = AES_MIN_KEY_SIZE,
-               .max_keysize = AES_MAX_KEY_SIZE,
-               .setkey      = ecb_aes_nx_set_key,
-               .encrypt     = ecb_aes_nx_encrypt,
-               .decrypt     = ecb_aes_nx_decrypt,
-       }
+struct skcipher_alg nx_ecb_aes_alg = {
+       .base.cra_name          = "ecb(aes)",
+       .base.cra_driver_name   = "ecb-aes-nx",
+       .base.cra_priority      = 300,
+       .base.cra_blocksize     = AES_BLOCK_SIZE,
+       .base.cra_alignmask     = 0xf,
+       .base.cra_ctxsize       = sizeof(struct nx_crypto_ctx),
+       .base.cra_module        = THIS_MODULE,
+       .init                   = nx_crypto_ctx_aes_ecb_init,
+       .exit                   = nx_crypto_ctx_skcipher_exit,
+       .min_keysize            = AES_MIN_KEY_SIZE,
+       .max_keysize            = AES_MAX_KEY_SIZE,
+       .setkey                 = ecb_aes_nx_set_key,
+       .encrypt                = ecb_aes_nx_encrypt,
+       .decrypt                = ecb_aes_nx_decrypt,
 };
drivers/crypto/nx/nx.c +23 -5
index 1202a00715ac..4b97081e7486 100644
@@ -517,6 +517,12 @@ static int nx_register_alg(struct crypto_alg *alg, u32 fc, u32 mode)
               crypto_register_alg(alg) : 0;
 }
 
+static int nx_register_skcipher(struct skcipher_alg *alg, u32 fc, u32 mode)
+{
+       return nx_check_props(&nx_driver.viodev->dev, fc, mode) ?
+              crypto_register_skcipher(alg) : 0;
+}
+
 static int nx_register_aead(struct aead_alg *alg, u32 fc, u32 mode)
 {
        return nx_check_props(&nx_driver.viodev->dev, fc, mode) ?
@@ -537,6 +543,12 @@ static void nx_unregister_alg(struct crypto_alg *alg, u32 fc, u32 mode)
                crypto_unregister_alg(alg);
 }
 
+static void nx_unregister_skcipher(struct skcipher_alg *alg, u32 fc, u32 mode)
+{
+       if (nx_check_props(NULL, fc, mode))
+               crypto_unregister_skcipher(alg);
+}
+
 static void nx_unregister_aead(struct aead_alg *alg, u32 fc, u32 mode)
 {
        if (nx_check_props(NULL, fc, mode))
@@ -573,7 +585,7 @@ static int nx_register_algs(void)
 
        nx_driver.of.status = NX_OKAY;
 
-       rc = nx_register_alg(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
+       rc = nx_register_skcipher(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
        if (rc)
                goto out;
 
@@ -637,7 +649,7 @@ static int nx_register_algs(void)
 out_unreg_cbc:
        nx_unregister_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
 out_unreg_ecb:
-       nx_unregister_alg(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
+       nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
 out:
        return rc;
 }
@@ -716,9 +728,9 @@ int nx_crypto_ctx_aes_cbc_init(struct crypto_tfm *tfm)
                                  NX_MODE_AES_CBC);
 }
 
-int nx_crypto_ctx_aes_ecb_init(struct crypto_tfm *tfm)
+int nx_crypto_ctx_aes_ecb_init(struct crypto_skcipher *tfm)
 {
-       return nx_crypto_ctx_init(crypto_tfm_ctx(tfm), NX_FC_AES,
+       return nx_crypto_ctx_init(crypto_skcipher_ctx(tfm), NX_FC_AES,
                                  NX_MODE_AES_ECB);
 }
 
@@ -752,6 +764,11 @@ void nx_crypto_ctx_exit(struct crypto_tfm *tfm)
        nx_ctx->out_sg = NULL;
 }
 
+void nx_crypto_ctx_skcipher_exit(struct crypto_skcipher *tfm)
+{
+       nx_crypto_ctx_exit(crypto_skcipher_ctx(tfm));
+}
+
 void nx_crypto_ctx_aead_exit(struct crypto_aead *tfm)
 {
        struct nx_crypto_ctx *nx_ctx = crypto_aead_ctx(tfm);
@@ -801,7 +818,8 @@ static int nx_remove(struct vio_dev *viodev)
                nx_unregister_alg(&nx_ctr3686_aes_alg,
                                  NX_FC_AES, NX_MODE_AES_CTR);
                nx_unregister_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
-               nx_unregister_alg(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
+               nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES,
+                                      NX_MODE_AES_ECB);
        }
 
        return 0;
drivers/crypto/nx/nx.h +3 -3
index 768ebae9731e..1a839ef21c4f 100644
@@ -147,9 +147,10 @@ int nx_crypto_ctx_aes_gcm_init(struct crypto_aead *tfm);
 int nx_crypto_ctx_aes_xcbc_init(struct crypto_tfm *tfm);
 int nx_crypto_ctx_aes_ctr_init(struct crypto_tfm *tfm);
 int nx_crypto_ctx_aes_cbc_init(struct crypto_tfm *tfm);
-int nx_crypto_ctx_aes_ecb_init(struct crypto_tfm *tfm);
+int nx_crypto_ctx_aes_ecb_init(struct crypto_skcipher *tfm);
 int nx_crypto_ctx_sha_init(struct crypto_tfm *tfm);
 void nx_crypto_ctx_exit(struct crypto_tfm *tfm);
+void nx_crypto_ctx_skcipher_exit(struct crypto_skcipher *tfm);
 void nx_crypto_ctx_aead_exit(struct crypto_aead *tfm);
 void nx_ctx_init(struct nx_crypto_ctx *nx_ctx, unsigned int function);
 int nx_hcall_sync(struct nx_crypto_ctx *ctx, struct vio_pfo_op *op,
@@ -176,7 +177,7 @@ void nx_debugfs_fini(struct nx_crypto_driver *);
 #define NX_PAGE_NUM(x)         ((u64)(x) & 0xfffffffffffff000ULL)
 
 extern struct crypto_alg nx_cbc_aes_alg;
-extern struct crypto_alg nx_ecb_aes_alg;
+extern struct skcipher_alg nx_ecb_aes_alg;
 extern struct aead_alg nx_gcm_aes_alg;
 extern struct aead_alg nx_gcm4106_aes_alg;
 extern struct crypto_alg nx_ctr3686_aes_alg;
--

2.23.0

Reviewed-by on v1 3/4
#6 lore raw

Re: [PATCH 3/4] crypto: nx - convert AES-CBC to skcipher API

In reply to Eric Biggers
Quoted 8 lines · Eric Biggers

From: Eric Biggers <[email protected]>

Convert the PowerPC Nest (NX) implementation of AES-CBC from the deprecated "blkcipher" API to the "skcipher" API. This is needed in order for the blkcipher API to be removed.

Quoted 205 lines
---
 drivers/crypto/nx/nx-aes-cbc.c | 78 ++++++++++++++--------------------
 drivers/crypto/nx/nx.c         | 11 ++---
 drivers/crypto/nx/nx.h         |  4 +-
 3 files changed, 41 insertions(+), 52 deletions(-)
drivers/crypto/nx/nx-aes-cbc.c +33 -45
index 482a203a9260..92e921eceed7 100644
@@ -18,11 +18,11 @@
 #include "nx.h"
 
 
-static int cbc_aes_nx_set_key(struct crypto_tfm *tfm,
-                             const u8          *in_key,
-                             unsigned int       key_len)
+static int cbc_aes_nx_set_key(struct crypto_skcipher *tfm,
+                             const u8               *in_key,
+                             unsigned int            key_len)
 {
-       struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(tfm);
+       struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
        struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
 
        nx_ctx_init(nx_ctx, HCOP_FC_AES);
@@ -50,13 +50,11 @@ static int cbc_aes_nx_set_key(struct crypto_tfm *tfm,
        return 0;
 }
 
-static int cbc_aes_nx_crypt(struct blkcipher_desc *desc,
-                           struct scatterlist    *dst,
-                           struct scatterlist    *src,
-                           unsigned int           nbytes,
-                           int                    enc)
+static int cbc_aes_nx_crypt(struct skcipher_request *req,
+                           int                      enc)
 {
-       struct nx_crypto_ctx *nx_ctx = crypto_blkcipher_ctx(desc->tfm);
+       struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+       struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
        struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
        unsigned long irq_flags;
        unsigned int processed = 0, to_process;
@@ -70,9 +68,9 @@ static int cbc_aes_nx_crypt(struct blkcipher_desc *desc,
                NX_CPB_FDM(csbcpb) &= ~NX_FDM_ENDE_ENCRYPT;
 
        do {
-               to_process = nbytes - processed;
+               to_process = req->cryptlen - processed;
 
-               rc = nx_build_sg_lists(nx_ctx, desc->info, dst, src,
+               rc = nx_build_sg_lists(nx_ctx, req->iv, req->dst, req->src,
                                       &to_process, processed,
                                       csbcpb->cpb.aes_cbc.iv);
                if (rc)
@@ -84,56 +82,46 @@ static int cbc_aes_nx_crypt(struct blkcipher_desc *desc,
                }
 
                rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
-                                  desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
+                                  req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
                if (rc)
                        goto out;
 
-               memcpy(desc->info, csbcpb->cpb.aes_cbc.cv, AES_BLOCK_SIZE);
+               memcpy(req->iv, csbcpb->cpb.aes_cbc.cv, AES_BLOCK_SIZE);
                atomic_inc(&(nx_ctx->stats->aes_ops));
                atomic64_add(csbcpb->csb.processed_byte_count,
                             &(nx_ctx->stats->aes_bytes));
 
                processed += to_process;
-       } while (processed < nbytes);
+       } while (processed < req->cryptlen);
 out:
        spin_unlock_irqrestore(&nx_ctx->lock, irq_flags);
        return rc;
 }
 
-static int cbc_aes_nx_encrypt(struct blkcipher_desc *desc,
-                             struct scatterlist    *dst,
-                             struct scatterlist    *src,
-                             unsigned int           nbytes)
+static int cbc_aes_nx_encrypt(struct skcipher_request *req)
 {
-       return cbc_aes_nx_crypt(desc, dst, src, nbytes, 1);
+       return cbc_aes_nx_crypt(req, 1);
 }
 
-static int cbc_aes_nx_decrypt(struct blkcipher_desc *desc,
-                             struct scatterlist    *dst,
-                             struct scatterlist    *src,
-                             unsigned int           nbytes)
+static int cbc_aes_nx_decrypt(struct skcipher_request *req)
 {
-       return cbc_aes_nx_crypt(desc, dst, src, nbytes, 0);
+       return cbc_aes_nx_crypt(req, 0);
 }
 
-struct crypto_alg nx_cbc_aes_alg = {
-       .cra_name        = "cbc(aes)",
-       .cra_driver_name = "cbc-aes-nx",
-       .cra_priority    = 300,
-       .cra_flags       = CRYPTO_ALG_TYPE_BLKCIPHER,
-       .cra_blocksize   = AES_BLOCK_SIZE,
-       .cra_ctxsize     = sizeof(struct nx_crypto_ctx),
-       .cra_type        = &crypto_blkcipher_type,
-       .cra_alignmask   = 0xf,
-       .cra_module      = THIS_MODULE,
-       .cra_init        = nx_crypto_ctx_aes_cbc_init,
-       .cra_exit        = nx_crypto_ctx_exit,
-       .cra_blkcipher = {
-               .min_keysize = AES_MIN_KEY_SIZE,
-               .max_keysize = AES_MAX_KEY_SIZE,
-               .ivsize      = AES_BLOCK_SIZE,
-               .setkey      = cbc_aes_nx_set_key,
-               .encrypt     = cbc_aes_nx_encrypt,
-               .decrypt     = cbc_aes_nx_decrypt,
-       }
+struct skcipher_alg nx_cbc_aes_alg = {
+       .base.cra_name          = "cbc(aes)",
+       .base.cra_driver_name   = "cbc-aes-nx",
+       .base.cra_priority      = 300,
+       .base.cra_blocksize     = AES_BLOCK_SIZE,
+       .base.cra_ctxsize       = sizeof(struct nx_crypto_ctx),
+       .base.cra_alignmask     = 0xf,
+       .base.cra_module        = THIS_MODULE,
+       .init                   = nx_crypto_ctx_aes_cbc_init,
+       .exit                   = nx_crypto_ctx_skcipher_exit,
+       .min_keysize            = AES_MIN_KEY_SIZE,
+       .max_keysize            = AES_MAX_KEY_SIZE,
+       .ivsize                 = AES_BLOCK_SIZE,
+       .setkey                 = cbc_aes_nx_set_key,
+       .encrypt                = cbc_aes_nx_encrypt,
+       .decrypt                = cbc_aes_nx_decrypt,
 };
drivers/crypto/nx/nx.c +6 -5
index 4b97081e7486..8e5367776ca0 100644
@@ -589,7 +589,7 @@ static int nx_register_algs(void)
        if (rc)
                goto out;
 
-       rc = nx_register_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
+       rc = nx_register_skcipher(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
        if (rc)
                goto out_unreg_ecb;
 
@@ -647,7 +647,7 @@ static int nx_register_algs(void)
 out_unreg_ctr3686:
        nx_unregister_alg(&nx_ctr3686_aes_alg, NX_FC_AES, NX_MODE_AES_CTR);
 out_unreg_cbc:
-       nx_unregister_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
+       nx_unregister_skcipher(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
 out_unreg_ecb:
        nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES, NX_MODE_AES_ECB);
 out:
@@ -722,9 +722,9 @@ int nx_crypto_ctx_aes_ctr_init(struct crypto_tfm *tfm)
                                  NX_MODE_AES_CTR);
 }
 
-int nx_crypto_ctx_aes_cbc_init(struct crypto_tfm *tfm)
+int nx_crypto_ctx_aes_cbc_init(struct crypto_skcipher *tfm)
 {
-       return nx_crypto_ctx_init(crypto_tfm_ctx(tfm), NX_FC_AES,
+       return nx_crypto_ctx_init(crypto_skcipher_ctx(tfm), NX_FC_AES,
                                  NX_MODE_AES_CBC);
 }
 
@@ -817,7 +817,8 @@ static int nx_remove(struct vio_dev *viodev)
                                   NX_FC_AES, NX_MODE_AES_GCM);
                nx_unregister_alg(&nx_ctr3686_aes_alg,
                                  NX_FC_AES, NX_MODE_AES_CTR);
-               nx_unregister_alg(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
+               nx_unregister_skcipher(&nx_cbc_aes_alg, NX_FC_AES,
+                                      NX_MODE_AES_CBC);
                nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES,
                                       NX_MODE_AES_ECB);
        }
drivers/crypto/nx/nx.h +2 -3
index 1a839ef21c4f..2e1a3e5e65cb 100644
@@ -146,7 +146,7 @@ int nx_crypto_ctx_aes_ccm_init(struct crypto_aead *tfm);
 int nx_crypto_ctx_aes_gcm_init(struct crypto_aead *tfm);
 int nx_crypto_ctx_aes_xcbc_init(struct crypto_tfm *tfm);
 int nx_crypto_ctx_aes_ctr_init(struct crypto_tfm *tfm);
-int nx_crypto_ctx_aes_cbc_init(struct crypto_tfm *tfm);
+int nx_crypto_ctx_aes_cbc_init(struct crypto_skcipher *tfm);
 int nx_crypto_ctx_aes_ecb_init(struct crypto_skcipher *tfm);
 int nx_crypto_ctx_sha_init(struct crypto_tfm *tfm);
 void nx_crypto_ctx_exit(struct crypto_tfm *tfm);
@@ -176,7 +176,7 @@ void nx_debugfs_fini(struct nx_crypto_driver *);
 
 #define NX_PAGE_NUM(x)         ((u64)(x) & 0xfffffffffffff000ULL)
 
-extern struct crypto_alg nx_cbc_aes_alg;
+extern struct skcipher_alg nx_cbc_aes_alg;
 extern struct skcipher_alg nx_ecb_aes_alg;
 extern struct aead_alg nx_gcm_aes_alg;
 extern struct aead_alg nx_gcm4106_aes_alg;
--

2.23.0

Reviewed-by on v1 4/4
#8 lore raw

Re: [PATCH 4/4] crypto: nx - convert AES-CTR to skcipher API

In reply to Eric Biggers
Quoted 8 lines · Eric Biggers

From: Eric Biggers <[email protected]>

Convert the PowerPC Nest (NX) implementation of AES-CTR from the deprecated "blkcipher" API to the "skcipher" API. This is needed in order for the blkcipher API to be removed.

Quoted 251 lines
---
 drivers/crypto/nx/nx-aes-ctr.c | 84 +++++++++++++++-------------------
 drivers/crypto/nx/nx.c         | 25 +++-------
 drivers/crypto/nx/nx.h         |  4 +-
 3 files changed, 46 insertions(+), 67 deletions(-)
drivers/crypto/nx/nx-aes-ctr.c +37 -47
index 05e558cefe94..6d5ce1a66f1e 100644
@@ -19,11 +19,11 @@
 #include "nx.h"
 
 
-static int ctr_aes_nx_set_key(struct crypto_tfm *tfm,
-                             const u8          *in_key,
-                             unsigned int       key_len)
+static int ctr_aes_nx_set_key(struct crypto_skcipher *tfm,
+                             const u8               *in_key,
+                             unsigned int            key_len)
 {
-       struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(tfm);
+       struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
        struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
 
        nx_ctx_init(nx_ctx, HCOP_FC_AES);
@@ -51,11 +51,11 @@ static int ctr_aes_nx_set_key(struct crypto_tfm *tfm,
        return 0;
 }
 
-static int ctr3686_aes_nx_set_key(struct crypto_tfm *tfm,
-                                 const u8          *in_key,
-                                 unsigned int       key_len)
+static int ctr3686_aes_nx_set_key(struct crypto_skcipher *tfm,
+                                 const u8               *in_key,
+                                 unsigned int            key_len)
 {
-       struct nx_crypto_ctx *nx_ctx = crypto_tfm_ctx(tfm);
+       struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
 
        if (key_len < CTR_RFC3686_NONCE_SIZE)
                return -EINVAL;
@@ -69,12 +69,10 @@ static int ctr3686_aes_nx_set_key(struct crypto_tfm *tfm,
        return ctr_aes_nx_set_key(tfm, in_key, key_len);
 }
 
-static int ctr_aes_nx_crypt(struct blkcipher_desc *desc,
-                           struct scatterlist    *dst,
-                           struct scatterlist    *src,
-                           unsigned int           nbytes)
+static int ctr_aes_nx_crypt(struct skcipher_request *req, u8 *iv)
 {
-       struct nx_crypto_ctx *nx_ctx = crypto_blkcipher_ctx(desc->tfm);
+       struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+       struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
        struct nx_csbcpb *csbcpb = nx_ctx->csbcpb;
        unsigned long irq_flags;
        unsigned int processed = 0, to_process;
@@ -83,9 +81,9 @@ static int ctr_aes_nx_crypt(struct blkcipher_desc *desc,
        spin_lock_irqsave(&nx_ctx->lock, irq_flags);
 
        do {
-               to_process = nbytes - processed;
+               to_process = req->cryptlen - processed;
 
-               rc = nx_build_sg_lists(nx_ctx, desc->info, dst, src,
+               rc = nx_build_sg_lists(nx_ctx, iv, req->dst, req->src,
                                       &to_process, processed,
                                       csbcpb->cpb.aes_ctr.iv);
                if (rc)
@@ -97,59 +95,51 @@ static int ctr_aes_nx_crypt(struct blkcipher_desc *desc,
                }
 
                rc = nx_hcall_sync(nx_ctx, &nx_ctx->op,
-                                  desc->flags & CRYPTO_TFM_REQ_MAY_SLEEP);
+                                  req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP);
                if (rc)
                        goto out;
 
-               memcpy(desc->info, csbcpb->cpb.aes_cbc.cv, AES_BLOCK_SIZE);
+               memcpy(iv, csbcpb->cpb.aes_cbc.cv, AES_BLOCK_SIZE);
 
                atomic_inc(&(nx_ctx->stats->aes_ops));
                atomic64_add(csbcpb->csb.processed_byte_count,
                             &(nx_ctx->stats->aes_bytes));
 
                processed += to_process;
-       } while (processed < nbytes);
+       } while (processed < req->cryptlen);
 out:
        spin_unlock_irqrestore(&nx_ctx->lock, irq_flags);
        return rc;
 }
 
-static int ctr3686_aes_nx_crypt(struct blkcipher_desc *desc,
-                               struct scatterlist    *dst,
-                               struct scatterlist    *src,
-                               unsigned int           nbytes)
+static int ctr3686_aes_nx_crypt(struct skcipher_request *req)
 {
-       struct nx_crypto_ctx *nx_ctx = crypto_blkcipher_ctx(desc->tfm);
+       struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
+       struct nx_crypto_ctx *nx_ctx = crypto_skcipher_ctx(tfm);
        u8 iv[16];
 
        memcpy(iv, nx_ctx->priv.ctr.nonce, CTR_RFC3686_IV_SIZE);
-       memcpy(iv + CTR_RFC3686_NONCE_SIZE,
-              desc->info, CTR_RFC3686_IV_SIZE);
+       memcpy(iv + CTR_RFC3686_NONCE_SIZE, req->iv, CTR_RFC3686_IV_SIZE);
        iv[12] = iv[13] = iv[14] = 0;
        iv[15] = 1;
 
-       desc->info = iv;
-
-       return ctr_aes_nx_crypt(desc, dst, src, nbytes);
+       return ctr_aes_nx_crypt(req, iv);
 }
 
-struct crypto_alg nx_ctr3686_aes_alg = {
-       .cra_name        = "rfc3686(ctr(aes))",
-       .cra_driver_name = "rfc3686-ctr-aes-nx",
-       .cra_priority    = 300,
-       .cra_flags       = CRYPTO_ALG_TYPE_BLKCIPHER,
-       .cra_blocksize   = 1,
-       .cra_ctxsize     = sizeof(struct nx_crypto_ctx),
-       .cra_type        = &crypto_blkcipher_type,
-       .cra_module      = THIS_MODULE,
-       .cra_init        = nx_crypto_ctx_aes_ctr_init,
-       .cra_exit        = nx_crypto_ctx_exit,
-       .cra_blkcipher = {
-               .min_keysize = AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
-               .max_keysize = AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
-               .ivsize      = CTR_RFC3686_IV_SIZE,
-               .setkey      = ctr3686_aes_nx_set_key,
-               .encrypt     = ctr3686_aes_nx_crypt,
-               .decrypt     = ctr3686_aes_nx_crypt,
-       }
+struct skcipher_alg nx_ctr3686_aes_alg = {
+       .base.cra_name          = "rfc3686(ctr(aes))",
+       .base.cra_driver_name   = "rfc3686-ctr-aes-nx",
+       .base.cra_priority      = 300,
+       .base.cra_blocksize     = 1,
+       .base.cra_ctxsize       = sizeof(struct nx_crypto_ctx),
+       .base.cra_module        = THIS_MODULE,
+       .init                   = nx_crypto_ctx_aes_ctr_init,
+       .exit                   = nx_crypto_ctx_skcipher_exit,
+       .min_keysize            = AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
+       .max_keysize            = AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
+       .ivsize                 = CTR_RFC3686_IV_SIZE,
+       .setkey                 = ctr3686_aes_nx_set_key,
+       .encrypt                = ctr3686_aes_nx_crypt,
+       .decrypt                = ctr3686_aes_nx_crypt,
+       .chunksize              = AES_BLOCK_SIZE,
 };
drivers/crypto/nx/nx.c +7 -18
index 8e5367776ca0..f03c238f5a31 100644
@@ -511,12 +511,6 @@ static bool nx_check_props(struct device *dev, u32 fc, u32 mode)
        return true;
 }
 
-static int nx_register_alg(struct crypto_alg *alg, u32 fc, u32 mode)
-{
-       return nx_check_props(&nx_driver.viodev->dev, fc, mode) ?
-              crypto_register_alg(alg) : 0;
-}
-
 static int nx_register_skcipher(struct skcipher_alg *alg, u32 fc, u32 mode)
 {
        return nx_check_props(&nx_driver.viodev->dev, fc, mode) ?
@@ -537,12 +531,6 @@ static int nx_register_shash(struct shash_alg *alg, u32 fc, u32 mode, int slot)
               crypto_register_shash(alg) : 0;
 }
 
-static void nx_unregister_alg(struct crypto_alg *alg, u32 fc, u32 mode)
-{
-       if (nx_check_props(NULL, fc, mode))
-               crypto_unregister_alg(alg);
-}
-
 static void nx_unregister_skcipher(struct skcipher_alg *alg, u32 fc, u32 mode)
 {
        if (nx_check_props(NULL, fc, mode))
@@ -593,7 +581,8 @@ static int nx_register_algs(void)
        if (rc)
                goto out_unreg_ecb;
 
-       rc = nx_register_alg(&nx_ctr3686_aes_alg, NX_FC_AES, NX_MODE_AES_CTR);
+       rc = nx_register_skcipher(&nx_ctr3686_aes_alg, NX_FC_AES,
+                                 NX_MODE_AES_CTR);
        if (rc)
                goto out_unreg_cbc;
 
@@ -645,7 +634,7 @@ static int nx_register_algs(void)
 out_unreg_gcm:
        nx_unregister_aead(&nx_gcm_aes_alg, NX_FC_AES, NX_MODE_AES_GCM);
 out_unreg_ctr3686:
-       nx_unregister_alg(&nx_ctr3686_aes_alg, NX_FC_AES, NX_MODE_AES_CTR);
+       nx_unregister_skcipher(&nx_ctr3686_aes_alg, NX_FC_AES, NX_MODE_AES_CTR);
 out_unreg_cbc:
        nx_unregister_skcipher(&nx_cbc_aes_alg, NX_FC_AES, NX_MODE_AES_CBC);
 out_unreg_ecb:
@@ -716,9 +705,9 @@ int nx_crypto_ctx_aes_gcm_init(struct crypto_aead *tfm)
                                  NX_MODE_AES_GCM);
 }
 
-int nx_crypto_ctx_aes_ctr_init(struct crypto_tfm *tfm)
+int nx_crypto_ctx_aes_ctr_init(struct crypto_skcipher *tfm)
 {
-       return nx_crypto_ctx_init(crypto_tfm_ctx(tfm), NX_FC_AES,
+       return nx_crypto_ctx_init(crypto_skcipher_ctx(tfm), NX_FC_AES,
                                  NX_MODE_AES_CTR);
 }
 
@@ -815,8 +804,8 @@ static int nx_remove(struct vio_dev *viodev)
                                   NX_FC_AES, NX_MODE_AES_GCM);
                nx_unregister_aead(&nx_gcm_aes_alg,
                                   NX_FC_AES, NX_MODE_AES_GCM);
-               nx_unregister_alg(&nx_ctr3686_aes_alg,
-                                 NX_FC_AES, NX_MODE_AES_CTR);
+               nx_unregister_skcipher(&nx_ctr3686_aes_alg,
+                                      NX_FC_AES, NX_MODE_AES_CTR);
                nx_unregister_skcipher(&nx_cbc_aes_alg, NX_FC_AES,
                                       NX_MODE_AES_CBC);
                nx_unregister_skcipher(&nx_ecb_aes_alg, NX_FC_AES,
drivers/crypto/nx/nx.h +2 -3
index 2e1a3e5e65cb..91c54289124a 100644
@@ -145,7 +145,7 @@ struct crypto_aead;
 int nx_crypto_ctx_aes_ccm_init(struct crypto_aead *tfm);
 int nx_crypto_ctx_aes_gcm_init(struct crypto_aead *tfm);
 int nx_crypto_ctx_aes_xcbc_init(struct crypto_tfm *tfm);
-int nx_crypto_ctx_aes_ctr_init(struct crypto_tfm *tfm);
+int nx_crypto_ctx_aes_ctr_init(struct crypto_skcipher *tfm);
 int nx_crypto_ctx_aes_cbc_init(struct crypto_skcipher *tfm);
 int nx_crypto_ctx_aes_ecb_init(struct crypto_skcipher *tfm);
 int nx_crypto_ctx_sha_init(struct crypto_tfm *tfm);
@@ -180,7 +180,7 @@ extern struct skcipher_alg nx_cbc_aes_alg;
 extern struct skcipher_alg nx_ecb_aes_alg;
 extern struct aead_alg nx_gcm_aes_alg;
 extern struct aead_alg nx_gcm4106_aes_alg;
-extern struct crypto_alg nx_ctr3686_aes_alg;
+extern struct skcipher_alg nx_ctr3686_aes_alg;
 extern struct aead_alg nx_ccm_aes_alg;
 extern struct aead_alg nx_ccm4309_aes_alg;
 extern struct shash_alg nx_shash_aes_xcbc_alg;
--

2.23.0

maintainer
#13 lore raw
In reply to Eric Biggers
Quoted 14 lines · Eric Biggers

This series converts the PowerPC Nest (NX) implementations of AES modes from the deprecated "blkcipher" API to the "skcipher" API. This is needed in order for the blkcipher API to be removed.

This patchset is compile-tested only, as I don't have this hardware. If anyone has this hardware, please test this patchset with CONFIG_CRYPTO_MANAGER_EXTRA_TESTS=y.

Eric Biggers (4):
crypto: nx - don't abuse blkcipher_desc to pass iv around
crypto: nx - convert AES-ECB to skcipher API
crypto: nx - convert AES-CBC to skcipher API
crypto: nx - convert AES-CTR to skcipher API

Quoted 8 lines
 drivers/crypto/nx/nx-aes-cbc.c | 81 ++++++++++++++-----------------
 drivers/crypto/nx/nx-aes-ccm.c | 40 ++++++----------
 drivers/crypto/nx/nx-aes-ctr.c | 87 +++++++++++++++-------------------
 drivers/crypto/nx/nx-aes-ecb.c | 76 +++++++++++++----------------
 drivers/crypto/nx/nx-aes-gcm.c | 24 ++++------
 drivers/crypto/nx/nx.c         | 64 ++++++++++++++-----------
 drivers/crypto/nx/nx.h         | 19 ++++----
 7 files changed, 176 insertions(+), 215 deletions(-)

All applied. Thanks.

Signature · 3 lines
Email: Herbert Xu <[email protected]>
Home Page: http://gondor.apana.org.au/~herbert/
PGP Key: http://gondor.apana.org.au/~herbert/pubkey.txt