Skip to contentSkip to conversation

security: keys: Use kvfree_sensitive in a few places

PATCH Superseded Alex Dewar 4 participants 8 messages Sep 11, 2020 – Sep 14, 2020

Subsystems (2)
lore
Share & tools
lore

Alex Dewar

author
#0 lore raw

PATCH 1/1 security: keys: Use kvfree_sensitive in a few places

In big_key.c, there are a few places where memzero_explicit + kvfree is used. It is better to use kvfree_sensitive instead, which is more readable and also prevents the compiler from eliding the call to memzero_explicit. Fix this.

---
 security/keys/big_key.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)
security/keys/big_key.c +3 -6
index 691347dea3c1..d17e5f09eeb8 100644
@@ -121,8 +121,7 @@ int big_key_preparse(struct key_preparsed_payload *prep)
 		*path = file->f_path;
 		path_get(path);
 		fput(file);
-		memzero_explicit(buf, enclen);
-		kvfree(buf);
+		kvfree_sensitive(buf, enclen);
 	} else {
 		/* Just store the data in a buffer */
 		void *data = kmalloc(datalen, GFP_KERNEL);
@@ -140,8 +139,7 @@ int big_key_preparse(struct key_preparsed_payload *prep)
 err_enckey:
 	kfree_sensitive(enckey);
 error:
-	memzero_explicit(buf, enclen);
-	kvfree(buf);
+	kvfree_sensitive(buf, enclen);
 	return ret;
 }
 
@@ -273,8 +271,7 @@ long big_key_read(const struct key *key, char *buffer, size_t buflen)
 err_fput:
 		fput(file);
 error:
-		memzero_explicit(buf, enclen);
-		kvfree(buf);
+		kvfree_sensitive(buf, enclen);
 	} else {
 		ret = datalen;
 		memcpy(buffer, key->payload.data[big_key_data], datalen);
Signature · 1 line
2.28.0
#1 lore raw
Quoted 4 lines · Alex Dewar

In big_key.c, there are a few places where memzero_explicit + kvfree is used. It is better to use kvfree_sensitive instead, which is more readable and also prevents the compiler from eliding the call to memzero_explicit. Fix this.

That last bit is untrue: the compiler can't elide memzero_explicit ... that's why it has the explicit suffix.

The original problem was a lot of people do memset(.., 0, ..); kfree() which the compiler can elide if it understands the memory is going out of scope. Or the even more problematic memset(..., 0, ...) on a stack variable before it goes out of scope.

We can argue about readability but there's no secret leak here.

James

author
#2 lore raw
Quoted 9 lines · James Bottomley
Quoted 4 lines · Alex Dewar

In big_key.c, there are a few places where memzero_explicit + kvfree is used. It is better to use kvfree_sensitive instead, which is more readable and also prevents the compiler from eliding the call to memzero_explicit. Fix this.

That last bit is untrue: the compiler can't elide memzero_explicit ... that's why it has the explicit suffix.

Quoted 6 lines

The original problem was a lot of people do memset(.., 0, ..); kfree() which the compiler can elide if it understands the memory is going out of scope. Or the even more problematic memset(..., 0, ...) on a stack variable before it goes out of scope.

We can argue about readability but there's no secret leak here.

Ahh, my mistake. Thanks for the explanation.

I'll send a v2 with an updated commit message. I think it would still make sense to use kfree_sensitive here as on next-20200911 this is the last use of kzfree in the tree and it would be nice to excise it altogether.

Best,
Alex

Quoted 3 lines

James

author
#3 lore raw
Quoted 15 lines · Alex Dewar
Quoted 14 lines · James Bottomley
Quoted 4 lines · Alex Dewar

In big_key.c, there are a few places where memzero_explicit + kvfree is used. It is better to use kvfree_sensitive instead, which is more readable and also prevents the compiler from eliding the call to memzero_explicit. Fix this.

That last bit is untrue: the compiler can't elide memzero_explicit ... that's why it has the explicit suffix.

The original problem was a lot of people do memset(.., 0, ..); kfree() which the compiler can elide if it understands the memory is going out of scope. Or the even more problematic memset(..., 0, ...) on a stack variable before it goes out of scope.

Quoted 8 lines
Quoted 1 line

We can argue about readability but there's no secret leak here.

Ahh, my mistake. Thanks for the explanation.

I'll send a v2 with an updated commit message. I think it would still make sense to use kfree_sensitive here as on next-20200911 this is the last use of kzfree in the tree and it would be nice to excise it altogether.

Ignore this! I thought we were talking about a different patch :-/

I'll send a respin with a better commit message anyways.

Cheers :-)

Quoted 7 lines

Best,
Alex

Quoted 3 lines

James

author
#4 lore raw

PATCH v2 1/1 security: keys: Use kvfree_sensitive in a few places

In reply to Alex Dewar

In big_key.c, there are a few places where memzero_explicit + kvfree is used. Replace these with a single call to kvfree_sensitive, to make the code more readable.

---
v2 - Update commit message as per James Bottomley's suggestion

 security/keys/big_key.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)
security/keys/big_key.c +3 -6
index 691347dea3c1..d17e5f09eeb8 100644
@@ -121,8 +121,7 @@ int big_key_preparse(struct key_preparsed_payload *prep)
 		*path = file->f_path;
 		path_get(path);
 		fput(file);
-		memzero_explicit(buf, enclen);
-		kvfree(buf);
+		kvfree_sensitive(buf, enclen);
 	} else {
 		/* Just store the data in a buffer */
 		void *data = kmalloc(datalen, GFP_KERNEL);
@@ -140,8 +139,7 @@ int big_key_preparse(struct key_preparsed_payload *prep)
 err_enckey:
 	kfree_sensitive(enckey);
 error:
-	memzero_explicit(buf, enclen);
-	kvfree(buf);
+	kvfree_sensitive(buf, enclen);
 	return ret;
 }
 
@@ -273,8 +271,7 @@ long big_key_read(const struct key *key, char *buffer, size_t buflen)
 err_fput:
 		fput(file);
 error:
-		memzero_explicit(buf, enclen);
-		kvfree(buf);
+		kvfree_sensitive(buf, enclen);
 	} else {
 		ret = datalen;
 		memcpy(buffer, key->payload.data[big_key_data], datalen);
Signature · 1 line
2.28.0
#5 lore raw
In reply to Alex Dewar

Hi,

same patch

https://lkml.org/lkml/2020/8/27/168

Thanks,
Denis

Quoted 45 lines · Alex Dewar

In big_key.c, there are a few places where memzero_explicit + kvfree is used. It is better to use kvfree_sensitive instead, which is more readable and also prevents the compiler from eliding the call to memzero_explicit. Fix this.

---
 security/keys/big_key.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)
security/keys/big_key.c +3 -6
index 691347dea3c1..d17e5f09eeb8 100644
@@ -121,8 +121,7 @@ int big_key_preparse(struct key_preparsed_payload *prep)
 		*path = file->f_path;
 		path_get(path);
 		fput(file);
-		memzero_explicit(buf, enclen);
-		kvfree(buf);
+		kvfree_sensitive(buf, enclen);
 	} else {
 		/* Just store the data in a buffer */
 		void *data = kmalloc(datalen, GFP_KERNEL);
@@ -140,8 +139,7 @@ int big_key_preparse(struct key_preparsed_payload *prep)
 err_enckey:
 	kfree_sensitive(enckey);
 error:
-	memzero_explicit(buf, enclen);
-	kvfree(buf);
+	kvfree_sensitive(buf, enclen);
 	return ret;
 }
 
@@ -273,8 +271,7 @@ long big_key_read(const struct key *key, char *buffer, size_t buflen)
 err_fput:
 		fput(file);
 error:
-		memzero_explicit(buf, enclen);
-		kvfree(buf);
+		kvfree_sensitive(buf, enclen);
 	} else {
 		ret = datalen;
 		memcpy(buffer, key->payload.data[big_key_data], datalen);
author
#6 lore raw
Quoted 8 lines · Denis Efremov

Hi,

same patch

https://lkml.org/lkml/2020/8/27/168

Thanks,
Denis

Ah ok. Sorry for the noise!

Quoted 47 lines · Alex Dewar
Quoted 45 lines

In big_key.c, there are a few places where memzero_explicit + kvfree is used. It is better to use kvfree_sensitive instead, which is more readable and also prevents the compiler from eliding the call to memzero_explicit. Fix this.

---
  security/keys/big_key.c | 9 +++------
  1 file changed, 3 insertions(+), 6 deletions(-)
security/keys/big_key.c +3 -6
index 691347dea3c1..d17e5f09eeb8 100644
@@ -121,8 +121,7 @@ int big_key_preparse(struct key_preparsed_payload *prep)
  		*path = file->f_path;
  		path_get(path);
  		fput(file);
-		memzero_explicit(buf, enclen);
-		kvfree(buf);
+		kvfree_sensitive(buf, enclen);
  	} else {
  		/* Just store the data in a buffer */
  		void *data = kmalloc(datalen, GFP_KERNEL);
@@ -140,8 +139,7 @@ int big_key_preparse(struct key_preparsed_payload *prep)
  err_enckey:
  	kfree_sensitive(enckey);
  error:
-	memzero_explicit(buf, enclen);
-	kvfree(buf);
+	kvfree_sensitive(buf, enclen);
  	return ret;
  }
 
@@ -273,8 +271,7 @@ long big_key_read(const struct key *key, char *buffer, size_t buflen)
  err_fput:
  		fput(file);
  error:
-		memzero_explicit(buf, enclen);
-		kvfree(buf);
+		kvfree_sensitive(buf, enclen);
  	} else {
  		ret = datalen;
  		memcpy(buffer, key->payload.data[big_key_data], datalen);