Buffer overflows and safe string handling

What happens in memory

void greet(const char *input) {
    char name[8];
    strcpy(name, input);     /* no size check */
    printf("Hi %s\n", name);
}
/* greet("Ravishankar Iyer") writes 17 bytes into an 8-byte array */

stack (simplified, addresses grow downward):
| other local data      |
| name[8]               |  ← the copy starts here…
| saved frame pointer   |  ← …and continues over these
| return address        |  ← overwriting this can redirect the program

If an attacker controls the input, overwriting the return address can make the program jump to code of the attacker's choosing. This "stack smashing" technique has been behind many famous incidents, from the 1988 Morris worm to bugs found in routers and media players today. Heap overflows (module 6) are just as dangerous.

Unsafe and safer functions

Habits that prevent overflows

1. Pass the buffer size along with every buffer: void copy_name(char *dst, size_t dst_size, const char *src).
2. Check lengths before copying: if (strlen(src) >= dst_size) reject or truncate deliberately.
3. Use sizeof buf at the point where buf is declared as an array; inside functions you only have the size you were passed.
4. Validate input lengths at the boundary (where data enters the program).
5. Handle truncation: snprintf returns the length it wanted to write; compare with the size.

int copy_name(char *dst, size_t dst_size, const char *src) {
    size_t len = strlen(src);
    if (len >= dst_size) return -1;       /* would not fit: refuse */
    memcpy(dst, src, len + 1);            /* copy including '\0' */
    return 0;
}

Compiler and runtime protections

gcc -std=c17 -Wall -Wextra -O2 -D_FORTIFY_SOURCE=2 -fstack-protector-strong prog.c -o prog
gcc -std=c17 -g -fsanitize=address,undefined prog.c -o prog_test   # while testing

• -fstack-protector-strong places a "canary" value before the return address and aborts if it changes ("stack smashing detected").
• -D_FORTIFY_SOURCE=2 (needs optimisation, -O1 or higher) makes glibc check sizes in strcpy, memcpy and friends where the size is known at compile time.
• AddressSanitizer (-fsanitize=address) reports the exact line of any out-of-bounds read or write during testing (module 11).
• Operating-system defences (ASLR, non-executable stacks) make exploitation harder, but they do not fix the bug.