Skip to contentSkip to conversation

crypto: Provide a function for zeroizing crypto_aes_ctx

PATCH In review Thomas Huth 3 participants 16 messages Aug 10 – Sep 4

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

v5 cover crypto: Provide a function for zeroizing crypto_aes_ctx

Several crypto drivers need to zeroize their local crypto_aes_ctx structures after use to avoid leaking key material on the stack. Currently some call sites do this with their own memzero_explicit() call, which is error-prone since it is easy to miss a return path (what already happened in a driver). Some other call sites miss to clear crypto_aes_ctx completely.

To improve this situation, the first patch introduces an aes_zeroize_ctx() helper that can be used with __cleanup() to automatically zeroize the context when it goes out of scope. The following 6 patches add this __cleanup() to spots in the code where this has been forgotten so far. The final patches change some files to do the zeroization with the new __cleanup() way instead of calling memzero_explicit() manually.

v5:
- Use aes_check_keylen() in the eip93 patch and in the 1st safexcel patch

v4:
- Updated the function description in the first patch
- Fixed "return err" bug in the "safexcel - Rework cleanup..." patch

v3:
- Renamed aes_clear_ctx() to aes_zeroize_ctx()
- Split up the safeexcel patch to rework safexcel_aead_setkey in a separate patch
- Removed goto in the padlock patch

v2:
- Rebased onto cryptodev master branch, updated the "qat" patch accordingly

Thomas Huth (10):
crypto: Provide a wrapper function for zeroizing crypto_aes_ctx
crypto: aspeed - clear the crypto_aes_ctx when done
crypto: padlock-aes - clear the crypto_aes_ctx when done
crypto: sa2ul - clear the crypto_aes_ctx when done
crypto: arm/aes-neonbs - clear the crypto_aes_ctx when done
crypto: arm64/aes-neonbs - clear the crypto_aes_ctx when done
crypto: qat - zeroize crypto_aes_ctx with __cleanup(aes_zeroize_ctx)
crypto: safexcel - Simplify the check for a valid AES key
crypto: safexcel - zeroize crypto_aes_ctx with
__cleanup(aes_zeroize_ctx)
crypto: eip93 - Simplify the check for a valid AES key

 arch/arm/crypto/aes-neonbs-glue.c             |  2 +-
 arch/arm64/crypto/aes-neonbs-glue.c           |  2 +-
 drivers/crypto/aspeed/aspeed-hace-crypto.c    |  3 +--
 .../crypto/inside-secure/eip93/eip93-aead.c   |  3 +--
 .../crypto/inside-secure/safexcel_cipher.c    | 16 +++++---------
 drivers/crypto/inside-secure/safexcel_hash.c  |  3 +--
 .../crypto/intel/qat/qat_common/qat_algs.c    |  3 +--
 drivers/crypto/padlock-aes.c                  | 22 +++++++++----------
 drivers/crypto/sa2ul.c                        |  2 +-
 include/crypto/aes.h                          | 13 +++++++++++
 10 files changed, 35 insertions(+), 34 deletions(-)
Signature · 1 line
2.55.0
#1 lore raw

PATCH v5 1/10 crypto: Provide a wrapper function for zeroizing crypto_aes_ctx

From: Thomas Huth <[email protected]>

Several crypto drivers need to zeroize their local crypto_aes_ctx structures after use to avoid leaking key material on the stack. Currently some call sites do this with their own memzero_explicit() call, which is error-prone since it is easy to miss a return path (what already happened in some drivers). Some other call sites miss to clear crypto_aes_ctx completely.

Provide an aes_zeroize_ctx() helper that can be used with __cleanup() to automatically zeroize the context when it goes out of scope.

---
 include/crypto/aes.h | 13 +++++++++++++
 1 file changed, 13 insertions(+)
include/crypto/aes.h +13 -0
index 3279cfa546085..e70607249ae5c 100644
@@ -159,6 +159,19 @@ static inline int aes_check_keylen(size_t keylen)
 int aes_expandkey(struct crypto_aes_ctx *ctx, const u8 *in_key,
 		  unsigned int key_len);
 
+/**
+ * aes_zeroize_ctx - Clear a crypto_aes_ctx structure
+ * @ctx:	The location of the context that should be zeroized
+ *
+ * Explicitly fills the crypto_aes_ctx with zeroes. This should be done
+ * once the context is not required anymore to avoid that its contents
+ * are leaked on the stack or heap (if not using kfree_sensitive()).
+ */
+static inline void aes_zeroize_ctx(struct crypto_aes_ctx *ctx)
+{
+	memzero_explicit(ctx, sizeof(*ctx));
+}
+
 /*
  * The following functions are temporarily exported for use by the AES mode
  * implementations in arch/$(SRCARCH)/crypto/.  These exports will go away when
Signature · 1 line
2.55.0
#4 lore raw

PATCH v5 2/10 crypto: aspeed - clear the crypto_aes_ctx when done

In reply to Thomas Huth

From: Thomas Huth <[email protected]>

Declare the gen_aes_key with __cleanup(aes_zeroize_ctx) to avoid that its contents could be leaking via the stack when the function returns. And since it is only required in one branch of the if-statement there, move it to that block, too.

---
 drivers/crypto/aspeed/aspeed-hace-crypto.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
drivers/crypto/aspeed/aspeed-hace-crypto.c +1 -2
index fa201dae1f81b..e7d3f611df05c 100644
@@ -576,7 +576,6 @@ static int aspeed_aes_setkey(struct crypto_skcipher *cipher, const u8 *key,
 {
 	struct aspeed_cipher_ctx *ctx = crypto_skcipher_ctx(cipher);
 	struct aspeed_hace_dev *hace_dev = ctx->hace_dev;
-	struct crypto_aes_ctx gen_aes_key;
 
 	CIPHER_DBG(hace_dev, "keylen: %d bits\n", (keylen * 8));
 
@@ -585,9 +584,9 @@ static int aspeed_aes_setkey(struct crypto_skcipher *cipher, const u8 *key,
 		return -EINVAL;
 
 	if (ctx->hace_dev->version == AST2500_VERSION) {
+		struct crypto_aes_ctx gen_aes_key __cleanup(aes_zeroize_ctx);
 		aes_expandkey(&gen_aes_key, key, keylen);
 		memcpy(ctx->key, gen_aes_key.key_enc, AES_MAX_KEYLENGTH);
-
 	} else {
 		memcpy(ctx->key, key, keylen);
 	}
Signature · 1 line
2.55.0
#5 lore raw

PATCH v5 3/10 crypto: padlock-aes - clear the crypto_aes_ctx when done

In reply to Thomas Huth

From: Thomas Huth <[email protected]>

Clear the crypto_aes_ctx structure via __cleanup(aes_zeroize_ctx) when we're done with it to avoid that key data could leak on the stack.

And since __cleanup() (and __free()) should not be mixed with "gotos" in the same function, turn the goto statement here into a proper block of the related if-statement.

---
 drivers/crypto/padlock-aes.c | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)
drivers/crypto/padlock-aes.c +10 -12
index 1be549a07a219..400a889e924d7 100644
@@ -109,7 +109,7 @@ static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
 {
 	struct aes_ctx *ctx = aes_ctx(tfm);
 	const __le32 *key = (const __le32 *)in_key;
-	struct crypto_aes_ctx gen_aes;
+	struct crypto_aes_ctx gen_aes __cleanup(aes_zeroize_ctx);
 	int cpu;
 
 	if (key_len % 8)
@@ -137,20 +137,18 @@ static int aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
 	ctx->cword.decrypt.ksize = ctx->cword.encrypt.ksize;
 
 	/* Don't generate extended keys if the hardware can do it. */
-	if (aes_hw_extkey_available(key_len))
-		goto ok;
+	if (!aes_hw_extkey_available(key_len)) {
+		ctx->D = ctx->d_data;
+		ctx->cword.encrypt.keygen = 1;
+		ctx->cword.decrypt.keygen = 1;
 
-	ctx->D = ctx->d_data;
-	ctx->cword.encrypt.keygen = 1;
-	ctx->cword.decrypt.keygen = 1;
+		if (aes_expandkey(&gen_aes, in_key, key_len))
+			return -EINVAL;
 
-	if (aes_expandkey(&gen_aes, in_key, key_len))
-		return -EINVAL;
-
-	memcpy(ctx->E, gen_aes.key_enc, AES_MAX_KEYLENGTH);
-	memcpy(ctx->D, gen_aes.key_dec, AES_MAX_KEYLENGTH);
+		memcpy(ctx->E, gen_aes.key_enc, AES_MAX_KEYLENGTH);
+		memcpy(ctx->D, gen_aes.key_dec, AES_MAX_KEYLENGTH);
+	}
 
-ok:
 	for_each_online_cpu(cpu)
 		if (&ctx->cword.encrypt == per_cpu(paes_last_cword, cpu) ||
 		    &ctx->cword.decrypt == per_cpu(paes_last_cword, cpu))
Signature · 1 line
2.55.0
#6 lore raw

PATCH v5 4/10 crypto: sa2ul - clear the crypto_aes_ctx when done

In reply to Thomas Huth

From: Thomas Huth <[email protected]>

Clear the crypto_aes_ctx structure via __cleanup(aes_zeroize_ctx) when we're done with it to avoid that key data could leak on the stack.

---
 drivers/crypto/sa2ul.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/crypto/sa2ul.c +1 -1
index d865fd4a098cb..f1a7c2cc7a1af 100644
@@ -465,7 +465,7 @@ static void sa_prepare_iopads(struct algo_data *data, const u8 *key,
 /* Derive the inverse key used in AES-CBC decryption operation */
 static inline int sa_aes_inv_key(u8 *inv_key, const u8 *key, u16 key_sz)
 {
-	struct crypto_aes_ctx ctx;
+	struct crypto_aes_ctx ctx __cleanup(aes_zeroize_ctx);
 	int key_pos;
 
 	if (aes_expandkey(&ctx, key, key_sz)) {
Signature · 1 line
2.55.0
#7 lore raw

PATCH v5 5/10 crypto: arm/aes-neonbs - clear the crypto_aes_ctx when done

In reply to Thomas Huth

From: Thomas Huth <[email protected]>

Clear the crypto_aes_ctx structure via __cleanup(aes_zeroize_ctx) when we're done with it to avoid that key data could leak on the stack.

---
 arch/arm/crypto/aes-neonbs-glue.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
arch/arm/crypto/aes-neonbs-glue.c +1 -1
index c49ddafc54f34..f0c8bfd2ac8fc 100644
@@ -60,7 +60,7 @@ static int aesbs_setkey(struct crypto_skcipher *tfm, const u8 *in_key,
 			unsigned int key_len)
 {
 	struct aesbs_ctx *ctx = crypto_skcipher_ctx(tfm);
-	struct crypto_aes_ctx rk;
+	struct crypto_aes_ctx rk __cleanup(aes_zeroize_ctx);
 	int err;
 
 	err = aes_expandkey(&rk, in_key, key_len);
Signature · 1 line
2.55.0
#8 lore raw

PATCH v5 6/10 crypto: arm64/aes-neonbs - clear the crypto_aes_ctx when done

In reply to Thomas Huth

From: Thomas Huth <[email protected]>

Clear the crypto_aes_ctx structure via __cleanup(aes_zeroize_ctx) when we're done with it to avoid that key data could leak on the stack.

---
 arch/arm64/crypto/aes-neonbs-glue.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
arch/arm64/crypto/aes-neonbs-glue.c +1 -1
index 5bcbac9798931..c2f3eac0ca661 100644
@@ -247,7 +247,7 @@ static int aesbs_xts_setkey(struct crypto_skcipher *tfm, const u8 *in_key,
 			    unsigned int key_len)
 {
 	struct aesbs_xts_ctx *ctx = crypto_skcipher_ctx(tfm);
-	struct crypto_aes_ctx rk;
+	struct crypto_aes_ctx rk __cleanup(aes_zeroize_ctx);
 	int err;
 
 	err = xts_verify_key(tfm, in_key, key_len);
Signature · 1 line
2.55.0
#9 lore raw

PATCH v5 7/10 crypto: qat - zeroize crypto_aes_ctx with __cleanup(aes_zeroize_ctx)

In reply to Thomas Huth

From: Thomas Huth <[email protected]>

A recent patch by Giovanni Cabiddu already added a memzero_explicit() for the crypto_aes_ctx in the qat_alg_xts_reverse_key() function, but since we introduced __cleanup(aes_zeroize_ctx) markers in previous commits in many spots of the code already, let's use it here now, too, to have the same code pattern everywhere.

---
 drivers/crypto/intel/qat/qat_common/qat_algs.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
drivers/crypto/intel/qat/qat_common/qat_algs.c +1 -2
index 91663805d9e60..cb669fb661625 100644
@@ -388,7 +388,7 @@ static void qat_alg_skcipher_init_enc(struct qat_alg_skcipher_ctx *ctx,
 static void qat_alg_xts_reverse_key(const u8 *key_forward, unsigned int keylen,
 				    u8 *key_reverse)
 {
-	struct crypto_aes_ctx aes_expanded;
+	struct crypto_aes_ctx aes_expanded __cleanup(aes_zeroize_ctx);
 	int nrounds;
 	u8 *key;
 
@@ -405,7 +405,6 @@ static void qat_alg_xts_reverse_key(const u8 *key_forward, unsigned int keylen,
 		memcpy(key_reverse + AES_BLOCK_SIZE, key - AES_BLOCK_SIZE,
 		       AES_BLOCK_SIZE);
 	}
-	memzero_explicit(&aes_expanded, sizeof(aes_expanded));
 }
 
 static void qat_alg_skcipher_init_dec(struct qat_alg_skcipher_ctx *ctx,
Signature · 1 line
2.55.0
#10 lore raw

PATCH v5 8/10 crypto: safexcel - Simplify the check for a valid AES key

In reply to Thomas Huth

From: Thomas Huth <[email protected]>

safexcel_aead_setkey() currently uses aes_expandkey() to check for a valid AES key, but then does not use the crypto_aes_ctx afterwards anymore, i.e. this is just a wasteful way of checking the key length, and thus aes_check_keylen() should be used instead.
This also fixes a potential leak of sensitive data via the stack, since this function forgot to zeroize crypto_aes_ctx before returning to the caller.

---
 drivers/crypto/inside-secure/safexcel_cipher.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
drivers/crypto/inside-secure/safexcel_cipher.c +1 -2
index a8349b684693e..f07d043c67d45 100644
@@ -407,7 +407,6 @@ static int safexcel_aead_setkey(struct crypto_aead *ctfm, const u8 *key,
 	struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
 	struct safexcel_crypto_priv *priv = ctx->base.priv;
 	struct crypto_authenc_keys keys;
-	struct crypto_aes_ctx aes;
 	int err = -EINVAL, i;
 	const char *alg;
 
@@ -438,7 +437,7 @@ static int safexcel_aead_setkey(struct crypto_aead *ctfm, const u8 *key,
 			goto badkey;
 		break;
 	case SAFEXCEL_AES:
-		err = aes_expandkey(&aes, keys.enckey, keys.enckeylen);
+		err = aes_check_keylen(keys.enckeylen);
 		if (unlikely(err))
 			goto badkey;
 		break;
Signature · 1 line
2.55.0
#12 lore raw

PATCH v5 9/10 crypto: safexcel - zeroize crypto_aes_ctx with __cleanup(aes_zeroize_ctx)

In reply to Thomas Huth

From: Thomas Huth <[email protected]>

The code clears the crypto_aes_ctx in most cases already with memzero_explicit(), but safexcel_skcipher_aesxts_setkey() runs aes_expandkey() twice, and in case the second call fails, the context from the first call is leaked.

To fix this issue and to avoid future similar problems, let's use the new __cleanup(aes_zeroize_ctx) mechanism to make sure that we always clear the crypto_aes_ctx in all cases.

---
 drivers/crypto/inside-secure/safexcel_cipher.c | 13 ++++---------
 drivers/crypto/inside-secure/safexcel_hash.c   |  3 +--
 2 files changed, 5 insertions(+), 11 deletions(-)
drivers/crypto/inside-secure/safexcel_cipher.c +4 -9
index f07d043c67d45..b031cb9652ec3 100644
@@ -375,7 +375,7 @@ static int safexcel_skcipher_aes_setkey(struct crypto_skcipher *ctfm,
 	struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
 	struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
 	struct safexcel_crypto_priv *priv = ctx->base.priv;
-	struct crypto_aes_ctx aes;
+	struct crypto_aes_ctx aes __cleanup(aes_zeroize_ctx);
 	int ret, i;
 
 	ret = aes_expandkey(&aes, key, len);
@@ -396,7 +396,6 @@ static int safexcel_skcipher_aes_setkey(struct crypto_skcipher *ctfm,
 
 	ctx->key_len = len;
 
-	memzero_explicit(&aes, sizeof(aes));
 	return 0;
 }
 
@@ -1361,7 +1360,7 @@ static int safexcel_skcipher_aesctr_setkey(struct crypto_skcipher *ctfm,
 	struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
 	struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
 	struct safexcel_crypto_priv *priv = ctx->base.priv;
-	struct crypto_aes_ctx aes;
+	struct crypto_aes_ctx aes __cleanup(aes_zeroize_ctx);
 	int ret, i;
 	unsigned int keylen;
 
@@ -1387,7 +1386,6 @@ static int safexcel_skcipher_aesctr_setkey(struct crypto_skcipher *ctfm,
 
 	ctx->key_len = keylen;
 
-	memzero_explicit(&aes, sizeof(aes));
 	return 0;
 }
 
@@ -2541,7 +2539,7 @@ static int safexcel_skcipher_aesxts_setkey(struct crypto_skcipher *ctfm,
 	struct crypto_tfm *tfm = crypto_skcipher_tfm(ctfm);
 	struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
 	struct safexcel_crypto_priv *priv = ctx->base.priv;
-	struct crypto_aes_ctx aes;
+	struct crypto_aes_ctx aes __cleanup(aes_zeroize_ctx);
 	int ret, i;
 	unsigned int keylen;
 
@@ -2589,7 +2587,6 @@ static int safexcel_skcipher_aesxts_setkey(struct crypto_skcipher *ctfm,
 
 	ctx->key_len = keylen << 1;
 
-	memzero_explicit(&aes, sizeof(aes));
 	return 0;
 }
 
@@ -2755,12 +2752,11 @@ static int safexcel_aead_ccm_setkey(struct crypto_aead *ctfm, const u8 *key,
 	struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
 	struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
 	struct safexcel_crypto_priv *priv = ctx->base.priv;
-	struct crypto_aes_ctx aes;
+	struct crypto_aes_ctx aes __cleanup(aes_zeroize_ctx);
 	int ret, i;
 
 	ret = aes_expandkey(&aes, key, len);
 	if (ret) {
-		memzero_explicit(&aes, sizeof(aes));
 		return ret;
 	}
 
@@ -2789,7 +2785,6 @@ static int safexcel_aead_ccm_setkey(struct crypto_aead *ctfm, const u8 *key,
 	else
 		ctx->hash_alg = CONTEXT_CONTROL_CRYPTO_ALG_XCBC128;
 
-	memzero_explicit(&aes, sizeof(aes));
 	return 0;
 }
 
drivers/crypto/inside-secure/safexcel_hash.c +1 -2
index 3402e570d045c..20c17eb09495e 100644
@@ -1905,7 +1905,7 @@ static int safexcel_cbcmac_setkey(struct crypto_ahash *tfm, const u8 *key,
 				 unsigned int len)
 {
 	struct safexcel_ahash_ctx *ctx = crypto_tfm_ctx(crypto_ahash_tfm(tfm));
-	struct crypto_aes_ctx aes;
+	struct crypto_aes_ctx aes __cleanup(aes_zeroize_ctx);
 	int ret, i;
 
 	ret = aes_expandkey(&aes, key, len);
@@ -1928,7 +1928,6 @@ static int safexcel_cbcmac_setkey(struct crypto_ahash *tfm, const u8 *key,
 	}
 	ctx->cbcmac  = true;
 
-	memzero_explicit(&aes, sizeof(aes));
 	return 0;
 }
 
Signature · 1 line
2.55.0
#13 lore raw

PATCH v5 10/10 crypto: eip93 - Simplify the check for a valid AES key

In reply to Thomas Huth

From: Thomas Huth <[email protected]>

eip93_aead_setkey() currently uses aes_expandkey() to check for a valid AES key, but then does not use the crypto_aes_ctx afterwards anymore, i.e. this is just a wasteful way of checking the key length, and thus aes_check_keylen() should be used instead.
This also fixes a potential leak of sensitive data via the stack, since this function forgot to zeroize crypto_aes_ctx before returning to the caller.

---
 drivers/crypto/inside-secure/eip93/eip93-aead.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
drivers/crypto/inside-secure/eip93/eip93-aead.c +1 -2
index 2bbd0af7b0e0e..0b7a899b14d76 100644
@@ -92,7 +92,6 @@ static int eip93_aead_setkey(struct crypto_aead *ctfm, const u8 *key,
 	struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
 	struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(tfm);
 	struct crypto_authenc_keys keys;
-	struct crypto_aes_ctx aes;
 	struct sa_record *sa_record = ctx->sa_record;
 	u32 nonce = 0;
 	int ret;
@@ -126,7 +125,7 @@ static int eip93_aead_setkey(struct crypto_aead *ctfm, const u8 *key,
 
 		break;
 	case EIP93_ALG_AES:
-		ret = aes_expandkey(&aes, keys.enckey, keys.enckeylen);
+		ret = aes_check_keylen(keys.enckeylen);
 		if (ret)
 			return ret;
 
Signature · 1 line
2.55.0
maintainer Acked-by on v5 8/10
#11 lore raw

Re: [PATCH v5 08/10] crypto: safexcel - Simplify the check for a valid AES key

In reply to Thomas Huth
Quoted 10 lines · Thomas Huth

From: Thomas Huth <[email protected]>

safexcel_aead_setkey() currently uses aes_expandkey() to check for a valid AES key, but then does not use the crypto_aes_ctx afterwards anymore, i.e. this is just a wasteful way of checking the key length, and thus aes_check_keylen() should be used instead.
This also fixes a potential leak of sensitive data via the stack, since this function forgot to zeroize crypto_aes_ctx before returning to the caller.

Quoted 2 lines

Thanks!

Quoted 28 lines
---
 drivers/crypto/inside-secure/safexcel_cipher.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
drivers/crypto/inside-secure/safexcel_cipher.c +1 -2
index a8349b684693e..f07d043c67d45 100644
@@ -407,7 +407,6 @@ static int safexcel_aead_setkey(struct crypto_aead *ctfm, const u8 *key,
 	struct safexcel_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
 	struct safexcel_crypto_priv *priv = ctx->base.priv;
 	struct crypto_authenc_keys keys;
-	struct crypto_aes_ctx aes;
 	int err = -EINVAL, i;
 	const char *alg;
 
@@ -438,7 +437,7 @@ static int safexcel_aead_setkey(struct crypto_aead *ctfm, const u8 *key,
 			goto badkey;
 		break;
 	case SAFEXCEL_AES:
-		err = aes_expandkey(&aes, keys.enckey, keys.enckeylen);
+		err = aes_check_keylen(keys.enckeylen);
 		if (unlikely(err))
 			goto badkey;
 		break;
Signature · 1 line
2.55.0
maintainer Reviewed-by on v5 10/10
#14 lore raw

Re: [PATCH v5 10/10] crypto: eip93 - Simplify the check for a valid AES key

In reply to Thomas Huth
Quoted 10 lines · Thomas Huth

From: Thomas Huth <[email protected]>

eip93_aead_setkey() currently uses aes_expandkey() to check for a valid AES key, but then does not use the crypto_aes_ctx afterwards anymore, i.e. this is just a wasteful way of checking the key length, and thus aes_check_keylen() should be used instead.
This also fixes a potential leak of sensitive data via the stack, since this function forgot to zeroize crypto_aes_ctx before returning to the caller.

Quoted 2 lines
Quoted 28 lines
---
 drivers/crypto/inside-secure/eip93/eip93-aead.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)
drivers/crypto/inside-secure/eip93/eip93-aead.c +1 -2
index 2bbd0af7b0e0e..0b7a899b14d76 100644
@@ -92,7 +92,6 @@ static int eip93_aead_setkey(struct crypto_aead *ctfm, const u8 *key,
 	struct crypto_tfm *tfm = crypto_aead_tfm(ctfm);
 	struct eip93_crypto_ctx *ctx = crypto_tfm_ctx(tfm);
 	struct crypto_authenc_keys keys;
-	struct crypto_aes_ctx aes;
 	struct sa_record *sa_record = ctx->sa_record;
 	u32 nonce = 0;
 	int ret;
@@ -126,7 +125,7 @@ static int eip93_aead_setkey(struct crypto_aead *ctfm, const u8 *key,
 
 		break;
 	case EIP93_ALG_AES:
-		ret = aes_expandkey(&aes, keys.enckey, keys.enckeylen);
+		ret = aes_check_keylen(keys.enckeylen);
 		if (ret)
 			return ret;
 
Signature · 1 line
2.55.0
#2 lore raw

Re: [PATCH v5 01/10] crypto: Provide a wrapper function for zeroizing crypto_aes_ctx

In reply to Thomas Huth
Quoted 28 lines · Thomas Huth

From: Thomas Huth <[email protected]>

Several crypto drivers need to zeroize their local crypto_aes_ctx structures after use to avoid leaking key material on the stack. Currently some call sites do this with their own memzero_explicit() call, which is error-prone since it is easy to miss a return path (what already happened in some drivers). Some other call sites miss to clear crypto_aes_ctx completely.

Provide an aes_zeroize_ctx() helper that can be used with __cleanup() to automatically zeroize the context when it goes out of scope.

---
  include/crypto/aes.h | 13 +++++++++++++
  1 file changed, 13 insertions(+)
include/crypto/aes.h +2 -0
index 3279cfa546085..e70607249ae5c 100644
@@ -159,6 +159,19 @@ static inline int aes_check_keylen(size_t keylen)
  int aes_expandkey(struct crypto_aes_ctx *ctx, const u8 *in_key,
  		  unsigned int key_len);
 
+/**
+ * aes_zeroize_ctx - Clear a crypto_aes_ctx structure

include/crypto/aes.h static inline int aes_check_keylen(size_t keylen) · line 173

Quoted 10 lines
include/crypto/aes.h +10 -0
+ * @ctx:	The location of the context that should be zeroized
+ *
+ * Explicitly fills the crypto_aes_ctx with zeroes. This should be done
+ * once the context is not required anymore to avoid that its contents
+ * are leaked on the stack or heap (if not using kfree_sensitive()).
+ */
+static inline void aes_zeroize_ctx(struct crypto_aes_ctx *ctx)
+{
+	memzero_explicit(ctx, sizeof(*ctx));
+}

Hi Herbert!

Just a quick note: I've included an updated version of this patch in the series that targets libcrypto here:

https://lore.kernel.org/linux-crypto/[email protected]/

... so I think I'll best resubmit the remaining patches of this series here once the libcrypto series got accepted.

Thomas

maintainer
#3 lore raw

Re: [PATCH v5 01/10] crypto: Provide a wrapper function for zeroizing crypto_aes_ctx

Quoted 8 lines · Thomas Huth

Just a quick note: I've included an updated version of this patch in the series that targets libcrypto here:

https://lore.kernel.org/linux-crypto/[email protected]/

... so I think I'll best resubmit the remaining patches of this series here once the libcrypto series got accepted.

OK, sure.

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
maintainer
#15 lore raw
In reply to Thomas Huth
Quoted 43 lines · Thomas Huth

Several crypto drivers need to zeroize their local crypto_aes_ctx structures after use to avoid leaking key material on the stack. Currently some call sites do this with their own memzero_explicit() call, which is error-prone since it is easy to miss a return path (what already happened in a driver). Some other call sites miss to clear crypto_aes_ctx completely.

To improve this situation, the first patch introduces an aes_zeroize_ctx() helper that can be used with __cleanup() to automatically zeroize the context when it goes out of scope. The following 6 patches add this __cleanup() to spots in the code where this has been forgotten so far. The final patches change some files to do the zeroization with the new __cleanup() way instead of calling memzero_explicit() manually.

v5:
- Use aes_check_keylen() in the eip93 patch and in the 1st safexcel patch

v4:
- Updated the function description in the first patch
- Fixed "return err" bug in the "safexcel - Rework cleanup..." patch

v3:
- Renamed aes_clear_ctx() to aes_zeroize_ctx()
- Split up the safeexcel patch to rework safexcel_aead_setkey in a separate patch
- Removed goto in the padlock patch

v2:
- Rebased onto cryptodev master branch, updated the "qat" patch accordingly

Thomas Huth (10):
crypto: Provide a wrapper function for zeroizing crypto_aes_ctx
crypto: aspeed - clear the crypto_aes_ctx when done
crypto: padlock-aes - clear the crypto_aes_ctx when done
crypto: sa2ul - clear the crypto_aes_ctx when done
crypto: arm/aes-neonbs - clear the crypto_aes_ctx when done
crypto: arm64/aes-neonbs - clear the crypto_aes_ctx when done
crypto: qat - zeroize crypto_aes_ctx with __cleanup(aes_zeroize_ctx)
crypto: safexcel - Simplify the check for a valid AES key
crypto: safexcel - zeroize crypto_aes_ctx with
__cleanup(aes_zeroize_ctx)
crypto: eip93 - Simplify the check for a valid AES key

Quoted 14 lines
 arch/arm/crypto/aes-neonbs-glue.c             |  2 +-
 arch/arm64/crypto/aes-neonbs-glue.c           |  2 +-
 drivers/crypto/aspeed/aspeed-hace-crypto.c    |  3 +--
 .../crypto/inside-secure/eip93/eip93-aead.c   |  3 +--
 .../crypto/inside-secure/safexcel_cipher.c    | 16 +++++---------
 drivers/crypto/inside-secure/safexcel_hash.c  |  3 +--
 .../crypto/intel/qat/qat_common/qat_algs.c    |  3 +--
 drivers/crypto/padlock-aes.c                  | 22 +++++++++----------
 drivers/crypto/sa2ul.c                        |  2 +-
 include/crypto/aes.h                          | 13 +++++++++++
 10 files changed, 35 insertions(+), 34 deletions(-)
Signature · 1 line
2.55.0

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