crypto: caam - fix pkcs1pad(rsa-caam, sha256) failure because of invalid input (c3725f7c) · Commits · 戴 / test

drivers/crypto/caam/caampkc.c

+72 −17

Original line number	Diff line number	Diff line
		@@ -24,6 +24,10 @@
		sizeof(struct rsa_priv_f2_pdb))
		#define DESC_RSA_PRIV_F3_LEN (2 * CAAM_CMD_SZ + \
		sizeof(struct rsa_priv_f3_pdb))
		#define CAAM_RSA_MAX_INPUT_SIZE 512 /* for a 4096-bit modulus */

		/* buffer filled with zeros, used for padding */
		static u8 *zero_buffer;

		static void rsa_io_unmap(struct device dev, struct rsa_edesc edesc,
		struct akcipher_request *req)
		@@ -168,6 +172,13 @@ static void rsa_priv_f3_done(struct device dev, u32 desc, u32 err,
		akcipher_request_complete(req, err);
		}

		/**
		* Count leading zeros, need it to strip, from a given scatterlist
		*
		* @sgl : scatterlist to count zeros from
		* @nbytes: number of zeros, in bytes, to strip
		* @flags : operation flags
		*/
		static int caam_rsa_count_leading_zeros(struct scatterlist *sgl,
		unsigned int nbytes,
		unsigned int flags)
		@@ -187,7 +198,8 @@ static int caam_rsa_count_leading_zeros(struct scatterlist *sgl,
		lzeros = 0;
		len = 0;
		while (nbytes > 0) {
		while (len && !*buff) {
		/* do not strip more than given bytes */
		while (len && !*buff && lzeros < nbytes) {
		lzeros++;
		len--;
		buff++;
		@@ -218,6 +230,7 @@ static struct rsa_edesc rsa_edesc_alloc(struct akcipher_request req,
		struct caam_rsa_ctx *ctx = akcipher_tfm_ctx(tfm);
		struct device *dev = ctx->dev;
		struct caam_rsa_req_ctx *req_ctx = akcipher_request_ctx(req);
		struct caam_rsa_key *key = &ctx->key;
		struct rsa_edesc *edesc;
		gfp_t flags = (req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP) ?
		GFP_KERNEL : GFP_ATOMIC;
		@@ -225,21 +238,37 @@ static struct rsa_edesc rsa_edesc_alloc(struct akcipher_request req,
		int sgc;
		int sec4_sg_index, sec4_sg_len = 0, sec4_sg_bytes;
		int src_nents, dst_nents;
		unsigned int diff_size = 0;
		int lzeros;

		lzeros = caam_rsa_count_leading_zeros(req->src, req->src_len, sg_flags);
		if (req->src_len > key->n_sz) {
		/*
		* strip leading zeros and
		* return the number of zeros to skip
		*/
		lzeros = caam_rsa_count_leading_zeros(req->src, req->src_len -
		key->n_sz, sg_flags);
		if (lzeros < 0)
		return ERR_PTR(lzeros);

		req->src_len -= lzeros;
		req->src = scatterwalk_ffwd(req_ctx->src, req->src, lzeros);
		} else {
		/*
		* input src is less then n key modulus,
		* so there will be zero padding
		*/
		diff_size = key->n_sz - req->src_len;
		}

		src_nents = sg_nents_for_len(req->src, req->src_len);
		dst_nents = sg_nents_for_len(req->dst, req->dst_len);

		if (src_nents > 1)
		sec4_sg_len = src_nents;

		if (!diff_size && src_nents == 1)
		sec4_sg_len = 0; /* no need for an input hw s/g table */
		else
		sec4_sg_len = src_nents + !!diff_size;
		sec4_sg_index = sec4_sg_len;
		if (dst_nents > 1)
		sec4_sg_len += pad_sg_nents(dst_nents);
		else
		@@ -266,12 +295,14 @@ static struct rsa_edesc rsa_edesc_alloc(struct akcipher_request req,
		}

		edesc->sec4_sg = (void )edesc + sizeof(edesc) + desclen;
		if (diff_size)
		dma_to_sec4_sg_one(edesc->sec4_sg, ctx->padding_dma, diff_size,
		0);

		if (sec4_sg_index)
		sg_to_sec4_sg_last(req->src, src_nents, edesc->sec4_sg +
		!!diff_size, 0);

		sec4_sg_index = 0;
		if (src_nents > 1) {
		sg_to_sec4_sg_last(req->src, src_nents, edesc->sec4_sg, 0);
		sec4_sg_index += src_nents;
		}
		if (dst_nents > 1)
		sg_to_sec4_sg_last(req->dst, dst_nents,
		edesc->sec4_sg + sec4_sg_index, 0);
		@@ -292,6 +323,10 @@ static struct rsa_edesc rsa_edesc_alloc(struct akcipher_request req,

		edesc->sec4_sg_bytes = sec4_sg_bytes;

		print_hex_dump_debug("caampkc sec4_sg@" __stringify(__LINE__) ": ",
		DUMP_PREFIX_ADDRESS, 16, 4, edesc->sec4_sg,
		edesc->sec4_sg_bytes, 1);

		return edesc;

		sec4_sg_fail:
		@@ -981,6 +1016,15 @@ static int caam_rsa_init_tfm(struct crypto_akcipher *tfm)
		return PTR_ERR(ctx->dev);
		}

		ctx->padding_dma = dma_map_single(ctx->dev, zero_buffer,
		CAAM_RSA_MAX_INPUT_SIZE - 1,
		DMA_TO_DEVICE);
		if (dma_mapping_error(ctx->dev, ctx->padding_dma)) {
		dev_err(ctx->dev, "unable to map padding\n");
		caam_jr_free(ctx->dev);
		return -ENOMEM;
		}

		return 0;
		}

		@@ -990,6 +1034,8 @@ static void caam_rsa_exit_tfm(struct crypto_akcipher *tfm)
		struct caam_rsa_ctx *ctx = akcipher_tfm_ctx(tfm);
		struct caam_rsa_key *key = &ctx->key;

		dma_unmap_single(ctx->dev, ctx->padding_dma, CAAM_RSA_MAX_INPUT_SIZE -
		1, DMA_TO_DEVICE);
		caam_rsa_free_key(key);
		caam_jr_free(ctx->dev);
		}
		@@ -1030,17 +1076,26 @@ int caam_pkc_init(struct device *ctrldev)
		if (!pk_inst)
		return 0;

		/* allocate zero buffer, used for padding input */
		zero_buffer = kzalloc(CAAM_RSA_MAX_INPUT_SIZE - 1, GFP_DMA \|
		GFP_KERNEL);
		if (!zero_buffer)
		return -ENOMEM;

		err = crypto_register_akcipher(&caam_rsa);
		if (err)
		if (err) {
		kfree(zero_buffer);
		dev_warn(ctrldev, "%s alg registration failed\n",
		caam_rsa.base.cra_driver_name);
		else
		} else {
		dev_info(ctrldev, "caam pkc algorithms registered in /proc/crypto\n");
		}

		return err;
		}

		void caam_pkc_exit(void)
		{
		kfree(zero_buffer);
		crypto_unregister_akcipher(&caam_rsa);
		}

drivers/crypto/caam/caampkc.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -89,10 +89,12 @@ struct caam_rsa_key {
		* caam_rsa_ctx - per session context.
		* @key : RSA key in DMA zone
		* @dev : device structure
		* @padding_dma : dma address of padding, for adding it to the input
		*/
		struct caam_rsa_ctx {
		struct caam_rsa_key key;
		struct device *dev;
		dma_addr_t padding_dma;
		};

		/**

Admin message