Skip to contentSkip to conversation

vsprintf: BUG on %n

PATCH In review Kees Cook 4 participants 7 messages Jan 27, 2014 – Jan 28, 2014

Subsystems (2)
lore
Share & tools
lore

Kees Cook

author
#0 lore raw

PATCH 1/1 vsprintf: BUG on %n

Now that there has been a full release of the kernel, and all users of %n have been dropped, switch to %n use triggering a BUG. Ignoring arguments could be used to assist in information leaks if an arbitrary format string was under the control of an attacker.

---
 lib/vsprintf.c |   13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)
lib/vsprintf.c +5 -8
index 185b6d300ebc..a27fd7f61325 100644
@@ -1735,15 +1735,12 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
 		case FORMAT_TYPE_NRCHARS: {
 			/*
 			 * Since %n poses a greater security risk than
-			 * utility, ignore %n and skip its argument.
+			 * utility, it should not be implemented. Instead,
+			 * BUG when encountering %n, since there are no
+			 * legitimate users and skipping arguments could
+			 * assist information leak attacks.
 			 */
-			void *skip_arg;
-
-			WARN_ONCE(1, "Please remove ignored %%n in '%s'\n",
-					old_fmt);
-
-			skip_arg = va_arg(args, void *);
-			break;
+			BUG();
 		}
 
 		default:
Signature · 6 lines
1.7.9.5


-- 
Kees Cook
Chrome OS Security
#1 lore raw
Quoted 4 lines · Kees Cook

Now that there has been a full release of the kernel, and all users of %n have been dropped, switch to %n use triggering a BUG. Ignoring arguments could be used to assist in information leaks if an arbitrary format string was under the control of an attacker.

Not sure I follow the reasoning. %n no longer does anything in the kernel, so there is no risk if it does manage to find its way into a printed string. BUG() is for unrecoverable errors, which this clearly isn't.

Information leaks via injectable strings are still possible if an attacker can insert %x, %d, etc. %n is more problematic since it allows for code injection, which is why it got removed. %n is not however, required to get an infoleak via a format string, so I think the summary is also a bit misleading.

~Ryan

Quoted 32 lines
---
 lib/vsprintf.c |   13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)
lib/vsprintf.c +5 -8
index 185b6d300ebc..a27fd7f61325 100644
@@ -1735,15 +1735,12 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
 		case FORMAT_TYPE_NRCHARS: {
 			/*
 			 * Since %n poses a greater security risk than
-			 * utility, ignore %n and skip its argument.
+			 * utility, it should not be implemented. Instead,
+			 * BUG when encountering %n, since there are no
+			 * legitimate users and skipping arguments could
+			 * assist information leak attacks.
 			 */
-			void *skip_arg;
-
-			WARN_ONCE(1, "Please remove ignored %%n in '%s'\n",
-					old_fmt);
-
-			skip_arg = va_arg(args, void *);
-			break;
+			BUG();
 		}
 
 		default:
author
#2 lore raw
Quoted 10 lines · Ryan Mallon
Quoted 4 lines · Kees Cook

Now that there has been a full release of the kernel, and all users of %n have been dropped, switch to %n use triggering a BUG. Ignoring arguments could be used to assist in information leaks if an arbitrary format string was under the control of an attacker.

Not sure I follow the reasoning. %n no longer does anything in the kernel, so there is no risk if it does manage to find its way into a printed string. BUG() is for unrecoverable errors, which this clearly isn't.

Quoted 5 lines

Information leaks via injectable strings are still possible if an attacker can insert %x, %d, etc. %n is more problematic since it allows for code injection, which is why it got removed. %n is not however, required to get an infoleak via a format string, so I think the summary is also a bit misleading.

Yeah, I'm a bit uncomfortable with the BUG() too. The issue with %n is that it would produce no output at all to skip arguments. With other things, you have to take up output space, which may be limited. How about just not skipping the argument? Leave the warn_on, etc?

-Kees

Signature · 2 lines
Kees Cook
Chrome OS Security
#3 lore raw
Quoted 17 lines · Kees Cook
Quoted 10 lines · Ryan Mallon
Quoted 4 lines · Kees Cook

Now that there has been a full release of the kernel, and all users of %n have been dropped, switch to %n use triggering a BUG. Ignoring arguments could be used to assist in information leaks if an arbitrary format string was under the control of an attacker.

Not sure I follow the reasoning. %n no longer does anything in the kernel, so there is no risk if it does manage to find its way into a printed string. BUG() is for unrecoverable errors, which this clearly isn't.

Quoted 5 lines

Information leaks via injectable strings are still possible if an attacker can insert %x, %d, etc. %n is more problematic since it allows for code injection, which is why it got removed. %n is not however, required to get an infoleak via a format string, so I think the summary is also a bit misleading.

Quoted 4 lines

Yeah, I'm a bit uncomfortable with the BUG() too. The issue with %n is that it would produce no output at all to skip arguments. With other things, you have to take up output space, which may be limited. How about just not skipping the argument? Leave the warn_on, etc?

If you are trying to catch in kernel users of %n, then the warning is probably fine. I don't think the presense of a %n in a format string, without any injection vulnerability is going to cause a problem.

If you are trying to catch %n being injected by a malicious user into a vulnerable string then a warning is fine as long as the string doesn't allow code injection through some other means. I don't think you can easily prevent infoleaks at runtime, since any vulnerable can have %x, %s, or whatever injected to leak information on the stack. There was some work on detecting potentially vulnerable strings at compile time I think?

The reason to get rid of %n is to remove the ability to escalate an infoleak on a vulnerable format string into code execution. Vulnerable strings and infoleaks via them are really a separate issue, and detecting %n does nothing to solve them.

%n should probably just be treated the same as any other %FOO which is not a valid format string directive. Keeping the warning might be useful for kernel developers who don't know that they shouldn't be using it. Then again, sparse, checkpatch or code review might be the better place to do that.

~Ryan

author
#4 lore raw
Quoted 27 lines · Ryan Mallon
Quoted 17 lines · Kees Cook
Quoted 10 lines · Ryan Mallon
Quoted 4 lines · Kees Cook

Now that there has been a full release of the kernel, and all users of %n have been dropped, switch to %n use triggering a BUG. Ignoring arguments could be used to assist in information leaks if an arbitrary format string was under the control of an attacker.

Not sure I follow the reasoning. %n no longer does anything in the kernel, so there is no risk if it does manage to find its way into a printed string. BUG() is for unrecoverable errors, which this clearly isn't.

Quoted 5 lines

Information leaks via injectable strings are still possible if an attacker can insert %x, %d, etc. %n is more problematic since it allows for code injection, which is why it got removed. %n is not however, required to get an infoleak via a format string, so I think the summary is also a bit misleading.

Quoted 4 lines

Yeah, I'm a bit uncomfortable with the BUG() too. The issue with %n is that it would produce no output at all to skip arguments. With other things, you have to take up output space, which may be limited. How about just not skipping the argument? Leave the warn_on, etc?

If you are trying to catch in kernel users of %n, then the warning is probably fine. I don't think the presense of a %n in a format string, without any injection vulnerability is going to cause a problem.

Quoted 7 lines

If you are trying to catch %n being injected by a malicious user into a vulnerable string then a warning is fine as long as the string doesn't allow code injection through some other means. I don't think you can easily prevent infoleaks at runtime, since any vulnerable can have %x, %s, or whatever injected to leak information on the stack. There was some work on detecting potentially vulnerable strings at compile time I think?

Yeah, that's in my tree. Since gcc loves reporting false positives, I haven't wanted to try to push it into mainline. But with Fengguang Wu's robots doing the builds, I've been trying to keep real flaws out of the tree.

Quoted 4 lines

The reason to get rid of %n is to remove the ability to escalate an infoleak on a vulnerable format string into code execution. Vulnerable strings and infoleaks via them are really a separate issue, and detecting %n does nothing to solve them.

Right, I totally agree.

Quoted 5 lines

%n should probably just be treated the same as any other %FOO which is not a valid format string directive. Keeping the warning might be useful for kernel developers who don't know that they shouldn't be using it. Then again, sparse, checkpatch or code review might be the better place to do that.

In that regard, then, I think we should just not skip the argument. (Imagine, as an attacker trying to find some deep value on the stack, but using %x would fill up the buffer that is being written to. %n doing arg-skipping would help in that case.)

I'll send a different patch.

-Kees

Signature · 2 lines
Kees Cook
Chrome OS Security
#5 lore raw
In reply to Kees Cook
Quoted 4 lines · Kees Cook

Now that there has been a full release of the kernel, and all users of %n have been dropped, switch to %n use triggering a BUG. Ignoring arguments could be used to assist in information leaks if an arbitrary format string was under the control of an attacker.

[]

lib/vsprintf.c

Quoted 1 line
lib/vsprintf.c +0 -0

[]

Quoted 8 lines
lib/vsprintf.c +3 -1
@@ -1735,15 +1735,12 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
 		case FORMAT_TYPE_NRCHARS: {
 			/*
 			 * Since %n poses a greater security risk than
-			 * utility, ignore %n and skip its argument.
+			 * utility, it should not be implemented. Instead,
+			 * BUG when encountering %n, since there are no
+			 * legitimate users and skipping arguments could

lib/vsprintf.c int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) · line 1743

Quoted 10 lines
lib/vsprintf.c +2 -7
+			 * assist information leak attacks.
 			 */
-			void *skip_arg;
-
-			WARN_ONCE(1, "Please remove ignored %%n in '%s'\n",
-					old_fmt);
-
-			skip_arg = va_arg(args, void *);
-			break;
+			BUG();

BUGs should be avoided where possible.

I think using BUG here isn't necessary or good.

maintainer
#6 lore raw
Quoted 29 lines · On Mon, 27 Jan 2014 15:12:34 -0800 Joe Perches <[email protected]> wrote:
Quoted 4 lines · Kees Cook

Now that there has been a full release of the kernel, and all users of %n have been dropped, switch to %n use triggering a BUG. Ignoring arguments could be used to assist in information leaks if an arbitrary format string was under the control of an attacker.

[]

lib/vsprintf.c

Quoted 1 line
lib/vsprintf.c +0 -0

[]

Quoted 8 lines
lib/vsprintf.c +3 -1
@@ -1735,15 +1735,12 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
 		case FORMAT_TYPE_NRCHARS: {
 			/*
 			 * Since %n poses a greater security risk than
-			 * utility, ignore %n and skip its argument.
+			 * utility, it should not be implemented. Instead,
+			 * BUG when encountering %n, since there are no
+			 * legitimate users and skipping arguments could

lib/vsprintf.c int vsnprintf(char *buf, size_t size, const char *fmt, va_list args) · line 1743

Quoted 10 lines
lib/vsprintf.c +2 -7
+			 * assist information leak attacks.
 			 */
-			void *skip_arg;
-
-			WARN_ONCE(1, "Please remove ignored %%n in '%s'\n",
-					old_fmt);
-
-			skip_arg = va_arg(args, void *);
-			break;
+			BUG();

BUGs should be avoided where possible.

Quoted 2 lines

I think using BUG here isn't necessary or good.

Good point(s).

In fact the patch makes the kernel less secure - it provides a way for people to make the kernel crash if they a) are able to inject printk control strings and b) don't know about %s ;)