vsprintf: BUG on %n
Subsystems (2)
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
@@ -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
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
Signed-off-by Kees Cook <[email protected]>--- lib/vsprintf.c | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-)lib/vsprintf.c +5
-8@@ -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 :
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
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 thewarn_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
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 thewarn_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
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.
Andrew Morton
maintainerQuoted 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 ;)