Most package builders apply their own CFLAGS, often set during the make
invocation. The trace-cmd internal CFLAGS is overriden in this case.
Make sure the important flags are appended.
Signed-off-by: Chase Douglas <[email protected]>
---
Makefile | 6 +++++-
1 files changed, 5 insertions(+), 1 deletions(-)
diff --git a/Makefile b/Makefile
index a278510..08fc4ca 100644
--- a/Makefile
+++ b/Makefile
@@ -183,7 +183,11 @@ KERNELSHARK_VERSION = $(KS_VERSION).$(KS_PATCHLEVEL).$(KS_EXTRAVERSION)
INCLUDES = -I. -I/usr/local/include $(CONFIG_INCLUDES)
-CFLAGS = -g -Wall $(CONFIG_FLAGS) $(INCLUDES) $(PLUGIN_DIR_SQ)
+# Set compile option CFLAGS if not set elsewhere
+CFLAGS ?= -g -Wall
+
+# Append required CFLAGS
+override CFLAGS += $(CONFIG_FLAGS) $(INCLUDES) $(PLUGIN_DIR_SQ)
ifeq ($(VERBOSE),1)
Q =
--
1.7.0.4
Passing n > sizeof(string) to snprintf can cause a glibc buffer overflow
condition. We know the exact size of nsecs_str, so use it instead of
math that may overflow.
Signed-off-by: Chase Douglas <[email protected]>
---
trace-ftrace.c | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
diff --git a/trace-ftrace.c b/trace-ftrace.c
index af9ac8d..ee7c6dc 100644
--- a/trace-ftrace.c
+++ b/trace-ftrace.c
@@ -148,7 +148,7 @@ static void print_graph_duration(struct trace_seq *s, unsigned long long duratio
/* Print nsecs (we don't want to exceed 7 numbers) */
if ((s->len - len) < 7) {
- snprintf(nsecs_str, 8 - (s->len - len), "%03lu", nsecs_rem);
+ snprintf(nsecs_str, sizeof(nsecs_str), "%03lu", nsecs_rem);
trace_seq_printf(s, ".%s", nsecs_str);
}
--
1.7.0.4
On Sun, 13 Jun 2010 13:11:48 EDT, Chase Douglas said:
> Passing n > sizeof(string) to snprintf can cause a glibc buffer overflow
> condition. We know the exact size of nsecs_str, so use it instead of
> math that may overflow.
> /* Print nsecs (we don't want to exceed 7 numbers) */
> if ((s->len - len) < 7) {
> - snprintf(nsecs_str, 8 - (s->len - len), "%03lu", nsecs_rem);
> + snprintf(nsecs_str, sizeof(nsecs_str), "%03lu", nsecs_rem);
We only get into this code after we've checked that the length is under 7
characters. How much overflow can happen as long as the sizeof(nsecs_str) is a
sane size (like at least 8 chars)? Probably a better bet would be doing the
right thing and 'BUILD_BUG_ON(sizeof(nsecs_str) < 8);'?
On Sun, 2010-06-13 at 16:52 -0400, [email protected] wrote:
> On Sun, 13 Jun 2010 13:11:48 EDT, Chase Douglas said:
> > Passing n > sizeof(string) to snprintf can cause a glibc buffer overflow
> > condition. We know the exact size of nsecs_str, so use it instead of
> > math that may overflow.
>
> > /* Print nsecs (we don't want to exceed 7 numbers) */
> > if ((s->len - len) < 7) {
> > - snprintf(nsecs_str, 8 - (s->len - len), "%03lu", nsecs_rem);
> > + snprintf(nsecs_str, sizeof(nsecs_str), "%03lu", nsecs_rem);
>
> We only get into this code after we've checked that the length is under 7
> characters. How much overflow can happen as long as the sizeof(nsecs_str) is a
> sane size (like at least 8 chars)? Probably a better bet would be doing the
> right thing and 'BUILD_BUG_ON(sizeof(nsecs_str) < 8);'?
nsecs_str is a local variable defined just above this block of code as:
char nsecs_str[5];
I was hitting cases where s->len == 64 and len == 63, leading to the
size argument of snprintf being 7 on a 5 byte string. I didn't delve too
much into the reasoning for the if statement, but I think it's math is
not actually related to the size of nsecs_rem but to some other string
length.
-- Chase
On Sun, 13 Jun 2010 17:01:34 EDT, Chase Douglas said:
> On Sun, 2010-06-13 at 16:52 -0400, [email protected] wrote:
> > On Sun, 13 Jun 2010 13:11:48 EDT, Chase Douglas said:
> > > Passing n > sizeof(string) to snprintf can cause a glibc buffer overflow
> > > condition. We know the exact size of nsecs_str, so use it instead of
> > > math that may overflow.
> >
> > > /* Print nsecs (we don't want to exceed 7 numbers) */
> > > if ((s->len - len) < 7) {
> > > - snprintf(nsecs_str, 8 - (s->len - len), "%03lu", nsecs_rem);
> > > + snprintf(nsecs_str, sizeof(nsecs_str), "%03lu", nsecs_rem);
> >
> > We only get into this code after we've checked that the length is under 7
> > characters. How much overflow can happen as long as the sizeof(nsecs_str) is a
> > sane size (like at least 8 chars)? Probably a better bet would be doing the
> > right thing and 'BUILD_BUG_ON(sizeof(nsecs_str) < 8);'?
>
> nsecs_str is a local variable defined just above this block of code as:
>
> char nsecs_str[5];
>
> I was hitting cases where s->len == 64 and len == 63, leading to the
> size argument of snprintf being 7 on a 5 byte string. I didn't delve too
> much into the reasoning for the if statement, but I think it's math is
> not actually related to the size of nsecs_rem but to some other string
> length.
This is starting to smell like that patch is just papering over a bug...
I saw that '8 -' and made the rash assumption that was the size of the array.
Is 5 in fact big enough and the 's->len - len' calculation is broken, or
should it be bigger? As you noted, that length calculation is looking a tad
sketchy. (And if we're stuck with '5' because it's a magic number for
somebody's formatting purposes, maybe it needs to be a #define?)
On Mon, 2010-06-14 at 17:40 -0400, [email protected] wrote:
> On Sun, 13 Jun 2010 17:01:34 EDT, Chase Douglas said:
> > On Sun, 2010-06-13 at 16:52 -0400, [email protected] wrote:
> > > On Sun, 13 Jun 2010 13:11:48 EDT, Chase Douglas said:
> > > > Passing n > sizeof(string) to snprintf can cause a glibc buffer overflow
> > > > condition. We know the exact size of nsecs_str, so use it instead of
> > > > math that may overflow.
> > >
> > > > /* Print nsecs (we don't want to exceed 7 numbers) */
> > > > if ((s->len - len) < 7) {
> > > > - snprintf(nsecs_str, 8 - (s->len - len), "%03lu", nsecs_rem);
> > > > + snprintf(nsecs_str, sizeof(nsecs_str), "%03lu", nsecs_rem);
> > >
> > > We only get into this code after we've checked that the length is under 7
> > > characters. How much overflow can happen as long as the sizeof(nsecs_str) is a
> > > sane size (like at least 8 chars)? Probably a better bet would be doing the
> > > right thing and 'BUILD_BUG_ON(sizeof(nsecs_str) < 8);'?
> >
> > nsecs_str is a local variable defined just above this block of code as:
> >
> > char nsecs_str[5];
> >
> > I was hitting cases where s->len == 64 and len == 63, leading to the
> > size argument of snprintf being 7 on a 5 byte string. I didn't delve too
> > much into the reasoning for the if statement, but I think it's math is
> > not actually related to the size of nsecs_rem but to some other string
> > length.
>
> This is starting to smell like that patch is just papering over a bug...
>
> I saw that '8 -' and made the rash assumption that was the size of the array.
> Is 5 in fact big enough and the 's->len - len' calculation is broken, or
> should it be bigger? As you noted, that length calculation is looking a tad
> sketchy. (And if we're stuck with '5' because it's a magic number for
> somebody's formatting purposes, maybe it needs to be a #define?)
>
Ouch, this is worse than that. this code was cut & pasted almost
directly from the Linux kernel (kernel/trace/trace_function_graph.c).
And it looks like any bug here is also a bug there. The difference is
that if we trigger the bug there we crash the kernel :-p
-- Steve
On Mon, Jun 14, 2010 at 08:16:03PM -0400, Steven Rostedt wrote:
> On Mon, 2010-06-14 at 17:40 -0400, [email protected] wrote:
> > On Sun, 13 Jun 2010 17:01:34 EDT, Chase Douglas said:
> > > On Sun, 2010-06-13 at 16:52 -0400, [email protected] wrote:
> > > > On Sun, 13 Jun 2010 13:11:48 EDT, Chase Douglas said:
> > > > > Passing n > sizeof(string) to snprintf can cause a glibc buffer overflow
> > > > > condition. We know the exact size of nsecs_str, so use it instead of
> > > > > math that may overflow.
> > > >
> > > > > /* Print nsecs (we don't want to exceed 7 numbers) */
> > > > > if ((s->len - len) < 7) {
> > > > > - snprintf(nsecs_str, 8 - (s->len - len), "%03lu", nsecs_rem);
> > > > > + snprintf(nsecs_str, sizeof(nsecs_str), "%03lu", nsecs_rem);
> > > >
> > > > We only get into this code after we've checked that the length is under 7
> > > > characters. How much overflow can happen as long as the sizeof(nsecs_str) is a
> > > > sane size (like at least 8 chars)? Probably a better bet would be doing the
> > > > right thing and 'BUILD_BUG_ON(sizeof(nsecs_str) < 8);'?
> > >
> > > nsecs_str is a local variable defined just above this block of code as:
> > >
> > > char nsecs_str[5];
> > >
> > > I was hitting cases where s->len == 64 and len == 63, leading to the
> > > size argument of snprintf being 7 on a 5 byte string. I didn't delve too
> > > much into the reasoning for the if statement, but I think it's math is
> > > not actually related to the size of nsecs_rem but to some other string
> > > length.
> >
> > This is starting to smell like that patch is just papering over a bug...
> >
> > I saw that '8 -' and made the rash assumption that was the size of the array.
> > Is 5 in fact big enough and the 's->len - len' calculation is broken, or
> > should it be bigger? As you noted, that length calculation is looking a tad
> > sketchy. (And if we're stuck with '5' because it's a magic number for
> > somebody's formatting purposes, maybe it needs to be a #define?)
> >
>
> Ouch, this is worse than that. this code was cut & pasted almost
> directly from the Linux kernel (kernel/trace/trace_function_graph.c).
> And it looks like any bug here is also a bug there. The difference is
> that if we trigger the bug there we crash the kernel :-p
I must be missing the purpose of this patch.
log10(nsecs_rem) can't exceed 3 characters as it is the rest of
a division per 1000.
The goal of this:
if (len < 7) {
snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem)
is to avoid having a duration that exceeds 7 characters, so formatted nsecs
be shrinked on need.
For example:
75000.567
would be shrinked to 75000.56, and that's the point.
if (len < 7) is not a security guard, it is a formatting convenience
to get a fixed column length.
The security guard is the mathematics that tells us log10(n % 1000) < 4.
In fact nsecs_str could be even of size 4 rather than 5.
On Tue, 2010-06-15 at 14:49 +0200, Frederic Weisbecker wrote:
> On Mon, Jun 14, 2010 at 08:16:03PM -0400, Steven Rostedt wrote:
> > On Mon, 2010-06-14 at 17:40 -0400, [email protected] wrote:
> > > On Sun, 13 Jun 2010 17:01:34 EDT, Chase Douglas said:
> > > > On Sun, 2010-06-13 at 16:52 -0400, [email protected] wrote:
> > > > > On Sun, 13 Jun 2010 13:11:48 EDT, Chase Douglas said:
> > > > > > Passing n > sizeof(string) to snprintf can cause a glibc buffer overflow
> > > > > > condition. We know the exact size of nsecs_str, so use it instead of
> > > > > > math that may overflow.
> > > > >
> > > > > > /* Print nsecs (we don't want to exceed 7 numbers) */
> > > > > > if ((s->len - len) < 7) {
> > > > > > - snprintf(nsecs_str, 8 - (s->len - len), "%03lu", nsecs_rem);
> > > > > > + snprintf(nsecs_str, sizeof(nsecs_str), "%03lu", nsecs_rem);
> > > > >
> > > > > We only get into this code after we've checked that the length is under 7
> > > > > characters. How much overflow can happen as long as the sizeof(nsecs_str) is a
> > > > > sane size (like at least 8 chars)? Probably a better bet would be doing the
> > > > > right thing and 'BUILD_BUG_ON(sizeof(nsecs_str) < 8);'?
> > > >
> > > > nsecs_str is a local variable defined just above this block of code as:
> > > >
> > > > char nsecs_str[5];
> > > >
> > > > I was hitting cases where s->len == 64 and len == 63, leading to the
> > > > size argument of snprintf being 7 on a 5 byte string. I didn't delve too
> > > > much into the reasoning for the if statement, but I think it's math is
> > > > not actually related to the size of nsecs_rem but to some other string
> > > > length.
> > >
> > > This is starting to smell like that patch is just papering over a bug...
> > >
> > > I saw that '8 -' and made the rash assumption that was the size of the array.
> > > Is 5 in fact big enough and the 's->len - len' calculation is broken, or
> > > should it be bigger? As you noted, that length calculation is looking a tad
> > > sketchy. (And if we're stuck with '5' because it's a magic number for
> > > somebody's formatting purposes, maybe it needs to be a #define?)
> > >
> >
> > Ouch, this is worse than that. this code was cut & pasted almost
> > directly from the Linux kernel (kernel/trace/trace_function_graph.c).
> > And it looks like any bug here is also a bug there. The difference is
> > that if we trigger the bug there we crash the kernel :-p
>
>
> I must be missing the purpose of this patch.
>
> log10(nsecs_rem) can't exceed 3 characters as it is the rest of
> a division per 1000.
>
> The goal of this:
>
> if (len < 7) {
> snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem)
>
> is to avoid having a duration that exceeds 7 characters, so formatted nsecs
> be shrinked on need.
>
> For example:
>
> 75000.567
>
> would be shrinked to 75000.56, and that's the point.
>
> if (len < 7) is not a security guard, it is a formatting convenience
> to get a fixed column length.
>
> The security guard is the mathematics that tells us log10(n % 1000) < 4.
> In fact nsecs_str could be even of size 4 rather than 5.
I agree that there is no *real* security issue here because of the
length of the string that snprintf would generate. However, glibc still
barfs when you pass in a size parameter larger than the string. Without
this patch, trace-cmd is unusable for me; glibc aborts as soon as the
condition is hit. I found this as I was packaging trace-cmd for Ubuntu,
so maybe glibc in other distributions is behaving differently?
-- Chase
On Tue, Jun 15, 2010 at 09:04:58AM -0400, Chase Douglas wrote:
> On Tue, 2010-06-15 at 14:49 +0200, Frederic Weisbecker wrote:
> > On Mon, Jun 14, 2010 at 08:16:03PM -0400, Steven Rostedt wrote:
> > > On Mon, 2010-06-14 at 17:40 -0400, [email protected] wrote:
> > > > On Sun, 13 Jun 2010 17:01:34 EDT, Chase Douglas said:
> > > > > On Sun, 2010-06-13 at 16:52 -0400, [email protected] wrote:
> > > > > > On Sun, 13 Jun 2010 13:11:48 EDT, Chase Douglas said:
> > > > > > > Passing n > sizeof(string) to snprintf can cause a glibc buffer overflow
> > > > > > > condition. We know the exact size of nsecs_str, so use it instead of
> > > > > > > math that may overflow.
> > > > > >
> > > > > > > /* Print nsecs (we don't want to exceed 7 numbers) */
> > > > > > > if ((s->len - len) < 7) {
> > > > > > > - snprintf(nsecs_str, 8 - (s->len - len), "%03lu", nsecs_rem);
> > > > > > > + snprintf(nsecs_str, sizeof(nsecs_str), "%03lu", nsecs_rem);
> > > > > >
> > > > > > We only get into this code after we've checked that the length is under 7
> > > > > > characters. How much overflow can happen as long as the sizeof(nsecs_str) is a
> > > > > > sane size (like at least 8 chars)? Probably a better bet would be doing the
> > > > > > right thing and 'BUILD_BUG_ON(sizeof(nsecs_str) < 8);'?
> > > > >
> > > > > nsecs_str is a local variable defined just above this block of code as:
> > > > >
> > > > > char nsecs_str[5];
> > > > >
> > > > > I was hitting cases where s->len == 64 and len == 63, leading to the
> > > > > size argument of snprintf being 7 on a 5 byte string. I didn't delve too
> > > > > much into the reasoning for the if statement, but I think it's math is
> > > > > not actually related to the size of nsecs_rem but to some other string
> > > > > length.
> > > >
> > > > This is starting to smell like that patch is just papering over a bug...
> > > >
> > > > I saw that '8 -' and made the rash assumption that was the size of the array.
> > > > Is 5 in fact big enough and the 's->len - len' calculation is broken, or
> > > > should it be bigger? As you noted, that length calculation is looking a tad
> > > > sketchy. (And if we're stuck with '5' because it's a magic number for
> > > > somebody's formatting purposes, maybe it needs to be a #define?)
> > > >
> > >
> > > Ouch, this is worse than that. this code was cut & pasted almost
> > > directly from the Linux kernel (kernel/trace/trace_function_graph.c).
> > > And it looks like any bug here is also a bug there. The difference is
> > > that if we trigger the bug there we crash the kernel :-p
> >
> >
> > I must be missing the purpose of this patch.
> >
> > log10(nsecs_rem) can't exceed 3 characters as it is the rest of
> > a division per 1000.
> >
> > The goal of this:
> >
> > if (len < 7) {
> > snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem)
> >
> > is to avoid having a duration that exceeds 7 characters, so formatted nsecs
> > be shrinked on need.
> >
> > For example:
> >
> > 75000.567
> >
> > would be shrinked to 75000.56, and that's the point.
> >
> > if (len < 7) is not a security guard, it is a formatting convenience
> > to get a fixed column length.
> >
> > The security guard is the mathematics that tells us log10(n % 1000) < 4.
> > In fact nsecs_str could be even of size 4 rather than 5.
>
> I agree that there is no *real* security issue here because of the
> length of the string that snprintf would generate. However, glibc still
> barfs when you pass in a size parameter larger than the string. Without
> this patch, trace-cmd is unusable for me; glibc aborts as soon as the
> condition is hit. I found this as I was packaging trace-cmd for Ubuntu,
> so maybe glibc in other distributions is behaving differently?
Ah, I see what you mean. So the check is made on runtime, right?
But your patch breaks the nsec adaptive size reduction that keeps a fixed
column size.
What about:
if (len < 7) {
- snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
+ snprintf(nsecs_str, min(sizeof(nsecs_rem), 8 - len), "%03lu", nsecs_rem);
On Tue, 2010-06-15 at 15:10 +0200, Frederic Weisbecker wrote:
> On Tue, Jun 15, 2010 at 09:04:58AM -0400, Chase Douglas wrote:
> > On Tue, 2010-06-15 at 14:49 +0200, Frederic Weisbecker wrote:
> > > On Mon, Jun 14, 2010 at 08:16:03PM -0400, Steven Rostedt wrote:
> > > > On Mon, 2010-06-14 at 17:40 -0400, [email protected] wrote:
> > > > > On Sun, 13 Jun 2010 17:01:34 EDT, Chase Douglas said:
> > > > > > On Sun, 2010-06-13 at 16:52 -0400, [email protected] wrote:
> > > > > > > On Sun, 13 Jun 2010 13:11:48 EDT, Chase Douglas said:
> > > > > > > > Passing n > sizeof(string) to snprintf can cause a glibc buffer overflow
> > > > > > > > condition. We know the exact size of nsecs_str, so use it instead of
> > > > > > > > math that may overflow.
> > > > > > >
> > > > > > > > /* Print nsecs (we don't want to exceed 7 numbers) */
> > > > > > > > if ((s->len - len) < 7) {
> > > > > > > > - snprintf(nsecs_str, 8 - (s->len - len), "%03lu", nsecs_rem);
> > > > > > > > + snprintf(nsecs_str, sizeof(nsecs_str), "%03lu", nsecs_rem);
> > > > > > >
> > > > > > > We only get into this code after we've checked that the length is under 7
> > > > > > > characters. How much overflow can happen as long as the sizeof(nsecs_str) is a
> > > > > > > sane size (like at least 8 chars)? Probably a better bet would be doing the
> > > > > > > right thing and 'BUILD_BUG_ON(sizeof(nsecs_str) < 8);'?
> > > > > >
> > > > > > nsecs_str is a local variable defined just above this block of code as:
> > > > > >
> > > > > > char nsecs_str[5];
> > > > > >
> > > > > > I was hitting cases where s->len == 64 and len == 63, leading to the
> > > > > > size argument of snprintf being 7 on a 5 byte string. I didn't delve too
> > > > > > much into the reasoning for the if statement, but I think it's math is
> > > > > > not actually related to the size of nsecs_rem but to some other string
> > > > > > length.
> > > > >
> > > > > This is starting to smell like that patch is just papering over a bug...
> > > > >
> > > > > I saw that '8 -' and made the rash assumption that was the size of the array.
> > > > > Is 5 in fact big enough and the 's->len - len' calculation is broken, or
> > > > > should it be bigger? As you noted, that length calculation is looking a tad
> > > > > sketchy. (And if we're stuck with '5' because it's a magic number for
> > > > > somebody's formatting purposes, maybe it needs to be a #define?)
> > > > >
> > > >
> > > > Ouch, this is worse than that. this code was cut & pasted almost
> > > > directly from the Linux kernel (kernel/trace/trace_function_graph.c).
> > > > And it looks like any bug here is also a bug there. The difference is
> > > > that if we trigger the bug there we crash the kernel :-p
> > >
> > >
> > > I must be missing the purpose of this patch.
> > >
> > > log10(nsecs_rem) can't exceed 3 characters as it is the rest of
> > > a division per 1000.
> > >
> > > The goal of this:
> > >
> > > if (len < 7) {
> > > snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem)
> > >
> > > is to avoid having a duration that exceeds 7 characters, so formatted nsecs
> > > be shrinked on need.
> > >
> > > For example:
> > >
> > > 75000.567
> > >
> > > would be shrinked to 75000.56, and that's the point.
> > >
> > > if (len < 7) is not a security guard, it is a formatting convenience
> > > to get a fixed column length.
> > >
> > > The security guard is the mathematics that tells us log10(n % 1000) < 4.
> > > In fact nsecs_str could be even of size 4 rather than 5.
> >
> > I agree that there is no *real* security issue here because of the
> > length of the string that snprintf would generate. However, glibc still
> > barfs when you pass in a size parameter larger than the string. Without
> > this patch, trace-cmd is unusable for me; glibc aborts as soon as the
> > condition is hit. I found this as I was packaging trace-cmd for Ubuntu,
> > so maybe glibc in other distributions is behaving differently?
>
>
> Ah, I see what you mean. So the check is made on runtime, right?
> But your patch breaks the nsec adaptive size reduction that keeps a fixed
> column size.
>
> What about:
>
> if (len < 7) {
> - snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
> + snprintf(nsecs_str, min(sizeof(nsecs_rem), 8 - len), "%03lu", nsecs_rem);
That seems good to me, I'll send another patch around for trace-cmd.
Thanks,
-- Chase