tmakin/ack-tegra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

crypto: tegra - Do not use fixed size buffers

Browse Source 
[ Upstream commit 1cb328da4e8f34350c61a2b6548766c79b4bb64c ]

Allocate the buffer based on the request instead of a fixed buffer
length. In operations which may require larger buffer size, a fixed
buffer may fail.

Fixes: 0880bb3b00 ("crypto: tegra - Add Tegra Security Engine driver")
Signed-off-by: Akhil R <akhilrajeev@nvidia.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
Stable-dep-of: 1ddaff40c08a ("crypto: tegra - Fix IV usage for AES ECB")
Signed-off-by: Sasha Levin <sashal@kernel.org>
This commit is contained in:
Akhil R
2025-02-24 14:46:02 +05:30
committed by Greg Kroah-Hartman
parent 28ec10e58d
commit 9ebc2053b8
3 changed files with 89 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drivers/crypto/tegra/tegra-se-aes.c
+64 -60
View File
@@ -263,12 +263,6 @@ static int tegra_aes_do_one_req(struct crypto_engine *engine, void *areq)
unsigned int cmdlen; unsigned int cmdlen;
int ret; int ret;
rctx->datbuf.buf = dma_alloc_coherent(se->dev, SE_AES_BUFLEN,
&rctx->datbuf.addr, GFP_KERNEL);
if (!rctx->datbuf.buf)
return -ENOMEM;
rctx->datbuf.size = SE_AES_BUFLEN;
rctx->iv = (u32 *)req->iv; rctx->iv = (u32 *)req->iv;
rctx->len = req->cryptlen; rctx->len = req->cryptlen;
@@ -278,6 +272,12 @@ static int tegra_aes_do_one_req(struct crypto_engine *engine, void *areq)
rctx->len += AES_BLOCK_SIZE - (rctx->len % AES_BLOCK_SIZE); rctx->len += AES_BLOCK_SIZE - (rctx->len % AES_BLOCK_SIZE);
} }
rctx->datbuf.size = rctx->len;
rctx->datbuf.buf = dma_alloc_coherent(se->dev, rctx->datbuf.size,
&rctx->datbuf.addr, GFP_KERNEL);
if (!rctx->datbuf.buf)
return -ENOMEM;
scatterwalk_map_and_copy(rctx->datbuf.buf, req->src, 0, req->cryptlen, 0); scatterwalk_map_and_copy(rctx->datbuf.buf, req->src, 0, req->cryptlen, 0);
/* Prepare the command and submit for execution */ /* Prepare the command and submit for execution */
@@ -289,7 +289,7 @@ static int tegra_aes_do_one_req(struct crypto_engine *engine, void *areq)
scatterwalk_map_and_copy(rctx->datbuf.buf, req->dst, 0, req->cryptlen, 1); scatterwalk_map_and_copy(rctx->datbuf.buf, req->dst, 0, req->cryptlen, 1);
/* Free the buffer */ /* Free the buffer */
dma_free_coherent(ctx->se->dev, SE_AES_BUFLEN, dma_free_coherent(ctx->se->dev, rctx->datbuf.size,
rctx->datbuf.buf, rctx->datbuf.addr); rctx->datbuf.buf, rctx->datbuf.addr);
crypto_finalize_skcipher_request(se->engine, req, ret); crypto_finalize_skcipher_request(se->engine, req, ret);
@@ -1120,6 +1120,11 @@ static int tegra_ccm_crypt_init(struct aead_request *req, struct tegra_se *se,
rctx->assoclen = req->assoclen; rctx->assoclen = req->assoclen;
rctx->authsize = crypto_aead_authsize(tfm); rctx->authsize = crypto_aead_authsize(tfm);
if (rctx->encrypt)
rctx->cryptlen = req->cryptlen;
else
rctx->cryptlen = req->cryptlen - rctx->authsize;
memcpy(iv, req->iv, 16); memcpy(iv, req->iv, 16);
ret = tegra_ccm_check_iv(iv); ret = tegra_ccm_check_iv(iv);
@@ -1148,30 +1153,26 @@ static int tegra_ccm_do_one_req(struct crypto_engine *engine, void *areq)
struct tegra_se *se = ctx->se; struct tegra_se *se = ctx->se;
int ret; int ret;
ret = tegra_ccm_crypt_init(req, se, rctx);
if (ret)
return ret;
/* Allocate buffers required */ /* Allocate buffers required */
rctx->inbuf.buf = dma_alloc_coherent(ctx->se->dev, SE_AES_BUFLEN, rctx->inbuf.size = rctx->assoclen + rctx->authsize + rctx->cryptlen + 100;
rctx->inbuf.buf = dma_alloc_coherent(ctx->se->dev, rctx->inbuf.size,
&rctx->inbuf.addr, GFP_KERNEL); &rctx->inbuf.addr, GFP_KERNEL);
if (!rctx->inbuf.buf) if (!rctx->inbuf.buf)
return -ENOMEM; return -ENOMEM;
rctx->inbuf.size = SE_AES_BUFLEN; rctx->outbuf.size = rctx->assoclen + rctx->authsize + rctx->cryptlen + 100;
rctx->outbuf.buf = dma_alloc_coherent(ctx->se->dev, rctx->outbuf.size,
rctx->outbuf.buf = dma_alloc_coherent(ctx->se->dev, SE_AES_BUFLEN,
&rctx->outbuf.addr, GFP_KERNEL); &rctx->outbuf.addr, GFP_KERNEL);
if (!rctx->outbuf.buf) { if (!rctx->outbuf.buf) {
ret = -ENOMEM; ret = -ENOMEM;
goto outbuf_err; goto outbuf_err;
} }
rctx->outbuf.size = SE_AES_BUFLEN;
ret = tegra_ccm_crypt_init(req, se, rctx);
if (ret)
goto out;
if (rctx->encrypt) { if (rctx->encrypt) {
rctx->cryptlen = req->cryptlen;
/* CBC MAC Operation */ /* CBC MAC Operation */
ret = tegra_ccm_compute_auth(ctx, rctx); ret = tegra_ccm_compute_auth(ctx, rctx);
if (ret) if (ret)
@@ -1182,8 +1183,6 @@ static int tegra_ccm_do_one_req(struct crypto_engine *engine, void *areq)
if (ret) if (ret)
goto out; goto out;
} else { } else {
rctx->cryptlen = req->cryptlen - ctx->authsize;
/* CTR operation */ /* CTR operation */
ret = tegra_ccm_do_ctr(ctx, rctx); ret = tegra_ccm_do_ctr(ctx, rctx);
if (ret) if (ret)
@@ -1196,11 +1195,11 @@ static int tegra_ccm_do_one_req(struct crypto_engine *engine, void *areq)
} }
out: out:
dma_free_coherent(ctx->se->dev, SE_AES_BUFLEN, dma_free_coherent(ctx->se->dev, rctx->inbuf.size,
rctx->outbuf.buf, rctx->outbuf.addr); rctx->outbuf.buf, rctx->outbuf.addr);
outbuf_err: outbuf_err:
dma_free_coherent(ctx->se->dev, SE_AES_BUFLEN, dma_free_coherent(ctx->se->dev, rctx->outbuf.size,
rctx->inbuf.buf, rctx->inbuf.addr); rctx->inbuf.buf, rctx->inbuf.addr);
crypto_finalize_aead_request(ctx->se->engine, req, ret); crypto_finalize_aead_request(ctx->se->engine, req, ret);
@@ -1216,23 +1215,6 @@ static int tegra_gcm_do_one_req(struct crypto_engine *engine, void *areq)
struct tegra_aead_reqctx *rctx = aead_request_ctx(req); struct tegra_aead_reqctx *rctx = aead_request_ctx(req);
int ret; int ret;
/* Allocate buffers required */
rctx->inbuf.buf = dma_alloc_coherent(ctx->se->dev, SE_AES_BUFLEN,
&rctx->inbuf.addr, GFP_KERNEL);
if (!rctx->inbuf.buf)
return -ENOMEM;
rctx->inbuf.size = SE_AES_BUFLEN;
rctx->outbuf.buf = dma_alloc_coherent(ctx->se->dev, SE_AES_BUFLEN,
&rctx->outbuf.addr, GFP_KERNEL);
if (!rctx->outbuf.buf) {
ret = -ENOMEM;
goto outbuf_err;
}
rctx->outbuf.size = SE_AES_BUFLEN;
rctx->src_sg = req->src; rctx->src_sg = req->src;
rctx->dst_sg = req->dst; rctx->dst_sg = req->dst;
rctx->assoclen = req->assoclen; rctx->assoclen = req->assoclen;
@@ -1246,6 +1228,21 @@ static int tegra_gcm_do_one_req(struct crypto_engine *engine, void *areq)
memcpy(rctx->iv, req->iv, GCM_AES_IV_SIZE); memcpy(rctx->iv, req->iv, GCM_AES_IV_SIZE);
rctx->iv[3] = (1 << 24); rctx->iv[3] = (1 << 24);
/* Allocate buffers required */
rctx->inbuf.size = rctx->assoclen + rctx->authsize + rctx->cryptlen;
rctx->inbuf.buf = dma_alloc_coherent(ctx->se->dev, rctx->inbuf.size,
&rctx->inbuf.addr, GFP_KERNEL);
if (!rctx->inbuf.buf)
return -ENOMEM;
rctx->outbuf.size = rctx->assoclen + rctx->authsize + rctx->cryptlen;
rctx->outbuf.buf = dma_alloc_coherent(ctx->se->dev, rctx->outbuf.size,
&rctx->outbuf.addr, GFP_KERNEL);
if (!rctx->outbuf.buf) {
ret = -ENOMEM;
goto outbuf_err;
}
/* If there is associated data perform GMAC operation */ /* If there is associated data perform GMAC operation */
if (rctx->assoclen) { if (rctx->assoclen) {
ret = tegra_gcm_do_gmac(ctx, rctx); ret = tegra_gcm_do_gmac(ctx, rctx);
@@ -1269,11 +1266,11 @@ static int tegra_gcm_do_one_req(struct crypto_engine *engine, void *areq)
ret = tegra_gcm_do_verify(ctx->se, rctx); ret = tegra_gcm_do_verify(ctx->se, rctx);
out: out:
dma_free_coherent(ctx->se->dev, SE_AES_BUFLEN, dma_free_coherent(ctx->se->dev, rctx->outbuf.size,
rctx->outbuf.buf, rctx->outbuf.addr); rctx->outbuf.buf, rctx->outbuf.addr);
outbuf_err: outbuf_err:
dma_free_coherent(ctx->se->dev, SE_AES_BUFLEN, dma_free_coherent(ctx->se->dev, rctx->inbuf.size,
rctx->inbuf.buf, rctx->inbuf.addr); rctx->inbuf.buf, rctx->inbuf.addr);
/* Finalize the request if there are no errors */ /* Finalize the request if there are no errors */
@@ -1500,6 +1497,11 @@ static int tegra_cmac_do_update(struct ahash_request *req)
return 0; return 0;
} }
rctx->datbuf.buf = dma_alloc_coherent(se->dev, rctx->datbuf.size,
&rctx->datbuf.addr, GFP_KERNEL);
if (!rctx->datbuf.buf)
return -ENOMEM;
/* Copy the previous residue first */ /* Copy the previous residue first */
if (rctx->residue.size) if (rctx->residue.size)
memcpy(rctx->datbuf.buf, rctx->residue.buf, rctx->residue.size); memcpy(rctx->datbuf.buf, rctx->residue.buf, rctx->residue.size);
@@ -1525,6 +1527,9 @@ static int tegra_cmac_do_update(struct ahash_request *req)
tegra_cmac_copy_result(ctx->se, rctx); tegra_cmac_copy_result(ctx->se, rctx);
dma_free_coherent(ctx->se->dev, rctx->datbuf.size,
rctx->datbuf.buf, rctx->datbuf.addr);
return ret; return ret;
} }
@@ -1539,10 +1544,20 @@ static int tegra_cmac_do_final(struct ahash_request *req)
if (!req->nbytes && !rctx->total_len && ctx->fallback_tfm) { if (!req->nbytes && !rctx->total_len && ctx->fallback_tfm) {
return crypto_shash_tfm_digest(ctx->fallback_tfm, return crypto_shash_tfm_digest(ctx->fallback_tfm,
rctx->datbuf.buf, 0, req->result); NULL, 0, req->result);
}
if (rctx->residue.size) {
rctx->datbuf.buf = dma_alloc_coherent(se->dev, rctx->residue.size,
&rctx->datbuf.addr, GFP_KERNEL);
if (!rctx->datbuf.buf) {
ret = -ENOMEM;
goto out_free;
}
memcpy(rctx->datbuf.buf, rctx->residue.buf, rctx->residue.size);
} }
memcpy(rctx->datbuf.buf, rctx->residue.buf, rctx->residue.size);
rctx->datbuf.size = rctx->residue.size; rctx->datbuf.size = rctx->residue.size;
rctx->total_len += rctx->residue.size; rctx->total_len += rctx->residue.size;
rctx->config = tegra234_aes_cfg(SE_ALG_CMAC, 0); rctx->config = tegra234_aes_cfg(SE_ALG_CMAC, 0);
@@ -1568,8 +1583,10 @@ static int tegra_cmac_do_final(struct ahash_request *req)
writel(0, se->base + se->hw->regs->result + (i * 4)); writel(0, se->base + se->hw->regs->result + (i * 4));
out: out:
dma_free_coherent(se->dev, SE_SHA_BUFLEN, if (rctx->residue.size)
rctx->datbuf.buf, rctx->datbuf.addr); dma_free_coherent(se->dev, rctx->datbuf.size,
rctx->datbuf.buf, rctx->datbuf.addr);
out_free:
dma_free_coherent(se->dev, crypto_ahash_blocksize(tfm) * 2, dma_free_coherent(se->dev, crypto_ahash_blocksize(tfm) * 2,
rctx->residue.buf, rctx->residue.addr); rctx->residue.buf, rctx->residue.addr);
return ret; return ret;
@@ -1681,28 +1698,15 @@ static int tegra_cmac_init(struct ahash_request *req)
rctx->residue.buf = dma_alloc_coherent(se->dev, rctx->blk_size * 2, rctx->residue.buf = dma_alloc_coherent(se->dev, rctx->blk_size * 2,
&rctx->residue.addr, GFP_KERNEL); &rctx->residue.addr, GFP_KERNEL);
if (!rctx->residue.buf) if (!rctx->residue.buf)
goto resbuf_fail; return -ENOMEM;
rctx->residue.size = 0; rctx->residue.size = 0;
rctx->datbuf.buf = dma_alloc_coherent(se->dev, SE_SHA_BUFLEN,
&rctx->datbuf.addr, GFP_KERNEL);
if (!rctx->datbuf.buf)
goto datbuf_fail;
rctx->datbuf.size = 0;
/* Clear any previous result */ /* Clear any previous result */
for (i = 0; i < CMAC_RESULT_REG_COUNT; i++) for (i = 0; i < CMAC_RESULT_REG_COUNT; i++)
writel(0, se->base + se->hw->regs->result + (i * 4)); writel(0, se->base + se->hw->regs->result + (i * 4));
return 0; return 0;
datbuf_fail:
dma_free_coherent(se->dev, rctx->blk_size, rctx->residue.buf,
rctx->residue.addr);
resbuf_fail:
return -ENOMEM;
} }
static int tegra_cmac_setkey(struct crypto_ahash *tfm, const u8 *key, static int tegra_cmac_setkey(struct crypto_ahash *tfm, const u8 *key,
drivers/crypto/tegra/tegra-se-hash.c
+25 -13
View File
@@ -332,6 +332,11 @@ static int tegra_sha_do_update(struct ahash_request *req)
return 0; return 0;
} }
rctx->datbuf.buf = dma_alloc_coherent(ctx->se->dev, rctx->datbuf.size,
&rctx->datbuf.addr, GFP_KERNEL);
if (!rctx->datbuf.buf)
return -ENOMEM;
/* Copy the previous residue first */ /* Copy the previous residue first */
if (rctx->residue.size) if (rctx->residue.size)
memcpy(rctx->datbuf.buf, rctx->residue.buf, rctx->residue.size); memcpy(rctx->datbuf.buf, rctx->residue.buf, rctx->residue.size);
@@ -368,6 +373,9 @@ static int tegra_sha_do_update(struct ahash_request *req)
if (!(rctx->task & SHA_FINAL)) if (!(rctx->task & SHA_FINAL))
tegra_sha_copy_hash_result(se, rctx); tegra_sha_copy_hash_result(se, rctx);
dma_free_coherent(ctx->se->dev, rctx->datbuf.size,
rctx->datbuf.buf, rctx->datbuf.addr);
return ret; return ret;
} }
@@ -380,7 +388,17 @@ static int tegra_sha_do_final(struct ahash_request *req)
u32 *cpuvaddr = se->cmdbuf->addr; u32 *cpuvaddr = se->cmdbuf->addr;
int size, ret = 0; int size, ret = 0;
memcpy(rctx->datbuf.buf, rctx->residue.buf, rctx->residue.size); if (rctx->residue.size) {
rctx->datbuf.buf = dma_alloc_coherent(se->dev, rctx->residue.size,
&rctx->datbuf.addr, GFP_KERNEL);
if (!rctx->datbuf.buf) {
ret = -ENOMEM;
goto out_free;
}
memcpy(rctx->datbuf.buf, rctx->residue.buf, rctx->residue.size);
}
rctx->datbuf.size = rctx->residue.size; rctx->datbuf.size = rctx->residue.size;
rctx->total_len += rctx->residue.size; rctx->total_len += rctx->residue.size;
@@ -397,8 +415,10 @@ static int tegra_sha_do_final(struct ahash_request *req)
memcpy(req->result, rctx->digest.buf, rctx->digest.size); memcpy(req->result, rctx->digest.buf, rctx->digest.size);
out: out:
dma_free_coherent(se->dev, SE_SHA_BUFLEN, if (rctx->residue.size)
rctx->datbuf.buf, rctx->datbuf.addr); dma_free_coherent(se->dev, rctx->datbuf.size,
rctx->datbuf.buf, rctx->datbuf.addr);
out_free:
dma_free_coherent(se->dev, crypto_ahash_blocksize(tfm), dma_free_coherent(se->dev, crypto_ahash_blocksize(tfm),
rctx->residue.buf, rctx->residue.addr); rctx->residue.buf, rctx->residue.addr);
dma_free_coherent(se->dev, rctx->digest.size, rctx->digest.buf, dma_free_coherent(se->dev, rctx->digest.size, rctx->digest.buf,
@@ -534,19 +554,11 @@ static int tegra_sha_init(struct ahash_request *req)
if (!rctx->residue.buf) if (!rctx->residue.buf)
goto resbuf_fail; goto resbuf_fail;
rctx->datbuf.buf = dma_alloc_coherent(se->dev, SE_SHA_BUFLEN,
&rctx->datbuf.addr, GFP_KERNEL);
if (!rctx->datbuf.buf)
goto datbuf_fail;
return 0; return 0;
datbuf_fail:
dma_free_coherent(se->dev, rctx->blk_size, rctx->residue.buf,
rctx->residue.addr);
resbuf_fail: resbuf_fail:
dma_free_coherent(se->dev, SE_SHA_BUFLEN, rctx->datbuf.buf, dma_free_coherent(se->dev, rctx->digest.size, rctx->digest.buf,
rctx->datbuf.addr); rctx->digest.addr);
digbuf_fail: digbuf_fail:
return -ENOMEM; return -ENOMEM;
} }
drivers/crypto/tegra/tegra-se.h
-2
View File
@@ -340,8 +340,6 @@
#define SE_CRYPTO_CTR_REG_COUNT 4 #define SE_CRYPTO_CTR_REG_COUNT 4
#define SE_MAX_KEYSLOT 15 #define SE_MAX_KEYSLOT 15
#define SE_MAX_MEM_ALLOC SZ_4M #define SE_MAX_MEM_ALLOC SZ_4M
#define SE_AES_BUFLEN 0x8000
#define SE_SHA_BUFLEN 0x2000
#define SHA_FIRST BIT(0) #define SHA_FIRST BIT(0)
#define SHA_UPDATE BIT(1) #define SHA_UPDATE BIT(1)