Some one can explain this behavior ? just 2 lines of code

Question

Kindly explain this snippet:

#include <stdio.h>

int puts(const char *str) {
    fputs("Hello world!\n", stdout);
}

int main() {
    printf("Goodbye\n");
}

Output : Hello world! return 13

GCC replaces the call of the puts and printf simple string + newline. — BLUEPIXY, Oct 23 '14 at 09:14
Just shows what you can do by replacing innocent-looking library functions with your own code. After all, you could call home there, or transfer cent fractions if this is banking software, or insert a line into /etc/passwd if this is ever running as root. — Peter - Reinstate Monica, Oct 23 '14 at 09:19
btw: Is there a away to access stdlib's puts in this program? I'd guess not with standard means. Perhaps with some gcc magic? Because for the egg of a disgruntled employee the new puts should probably emulate the old puts, which would be easiest done by calling it after executing the malicious bit. — Peter - Reinstate Monica, Oct 23 '14 at 09:21
@PeterSchneider: You are already far outside the standard, so of course you need more UB or compiler-magic. — Deduplicator, Oct 23 '14 at 09:23
This code isn't standard compliant, as the user is not allowed to re-define standard library identifiers. — Lundin, Oct 23 '14 at 09:52

score 10 · Answer 1 · edited May 23 '17 at 11:33

10

It is compiler specific. You get this behavior with GCC. Here are some details.

since you #include <stdio.h> (actually because you are in a hosted environment) the puts is that of the C99 standard, and redefining it is undefined behavior
the GCC compiler has some optimizations to transform some printf to a sequence of faster puts. This is legal, since you have included <stdio.h> (and the C99 standard defines what printf should do in that case; GCC goes thru __builtin_printf as an intermediate step)

If you compile with -ffreestanding you won't observe that.

Your question is very close to this one; so this answer is also relevant.

edited May 23 '17 at 11:33

Community

1
1

answered Oct 23 '14 at 09:14

Basile Starynkevitch

223,805
18
296
547

No probably about it, it's straight UB. And it is legal because he's compiling for a hosted environment, the includes don't matter. – Deduplicator Oct 23 '14 at 09:18
This is legal, since it does not change the observable behavior for a conforming program. – Deduplicator Oct 23 '14 at 09:24

glglgl · Answer 2 · 2014-10-27T07:23:41.390

I compiled the program with gcc x.c -S -o-. It gave me

[...]
main:
.LFB1:
        .cfi_startproc
        pushl   %ebp
        .cfi_def_cfa_offset 8
        .cfi_offset 5, -8
        movl    %esp, %ebp
        .cfi_def_cfa_register 5
        andl    $-16, %esp
        subl    $16, %esp
        movl    $.LC1, (%esp)
        call    puts
        leave
        .cfi_restore 5
        .cfi_def_cfa 4, 4
        ret
        .cfi_endproc
.LFE1:

so indeed the printf call is replaced with puts in GCC, as they have the same semantics.

score 6 · Answer 3 · answered Oct 23 '14 at 09:14

My guess would be that the compiler changes the call to printf() into a call to puts(), since there's no need for printf() due to no formatting. Also the string is terminated by a newline, which fits puts(). The compiler didn't see your scary overload of a library function coming, so it got "fooled".

Some one can explain this behavior ? just 2 lines of code

3 Answers3

Linked