Buffer overflow attacks in Operating Systems - Mini Project: Build & Apply

Understanding Buffer Overflow Attacks

📖 Scenario: You are learning about computer security. One common problem is a buffer overflow attack, where a program writes more data into a memory space than it can hold. This can cause unexpected behavior or let attackers run harmful code.Imagine a simple program that stores a username in a small box (buffer). If someone tries to put a very long name in that box, it might overflow and cause trouble.

🎯 Goal: Build a simple example that shows how a buffer overflow can happen by creating a fixed-size buffer and then trying to add more data than it can hold.

📋 What You'll Learn

Create a fixed-size buffer to hold a username

Set a maximum allowed length for the username

Write code to check if the input username fits in the buffer

Show what happens if the username is too long

💡 Why This Matters

🌍 Real World

Buffer overflow attacks are a common security problem in software. Understanding them helps protect programs from crashes and hacking.

💼 Career

Security analysts, software developers, and system administrators need to know about buffer overflows to write safe code and defend systems.

1

Create a fixed-size buffer

Create a character array called buffer with size 8 to hold a username.

Operating Systems

# Create a character array called buffer with size 8
# Your code here

Hint

Use char buffer[8]; to create a buffer that can hold 7 characters plus a null terminator.

2

Set maximum allowed username length

Create an integer variable called max_length and set it to 7 to limit the username length.

Operating Systems

char buffer[8];
// Define max_length as 7
# Your code here

Hint

This variable will help check if the username fits in the buffer.

3

Check if username fits in buffer

Write an if statement that checks if the length of a username string called input is less than or equal to max_length. Use strlen(input) to get the length.

Operating Systems

char buffer[8];
int max_length = 7;
// Check if input length is within max_length
# Your code here

Hint

This check prevents overflow by ensuring the input fits.

4

Show overflow risk when input is too long

Inside the else block of the if statement, add a comment that says // buffer overflow risk to indicate danger when input is too long.

Operating Systems

char buffer[8];
int max_length = 7;
if (strlen(input) <= max_length) {
    // safe to copy
} else {
    // buffer overflow risk
    # Your code here
}

Hint

This comment helps understand where the problem happens.

Practice

1. What is a buffer overflow attack in simple terms?

easy

A. Putting more data into a memory space than it can hold

B. Deleting data from memory intentionally

C. Encrypting data to protect it

D. Backing up data to a safe location

Solution

1. Step 1: Understand what a buffer is

   A buffer is a small area in memory used to store data temporarily.

2. Step 2: Define buffer overflow

   Buffer overflow happens when more data is put into this area than it can hold, causing errors or security risks.

3. Final Answer:

   Putting more data into a memory space than it can hold -> Option A

4. Quick Check:

   Buffer overflow = Too much data in small memory [OK]

Hint: Too much data in small space causes overflow [OK]

Common Mistakes:

• Confusing overflow with data deletion
• Thinking encryption is overflow
• Mixing backup with overflow

2. Which of the following is the correct way to prevent buffer overflow in programming?

easy

A. Using unlimited memory without checks

B. Ignoring input size and trusting user data

C. Checking input size before storing it in memory

D. Allowing programs to crash to fix errors

Solution

1. Step 1: Identify safe programming practice

   Safe programming means checking input size before storing it to avoid overflow.

2. Step 2: Evaluate options

   Ignoring input or using unlimited memory without checks is unsafe; allowing crashes is not prevention.

3. Final Answer:

   Checking input size before storing it in memory -> Option C

4. Quick Check:

   Input size check = Prevent overflow [OK]

Hint: Always check input size before storing [OK]

Common Mistakes:

• Trusting user input blindly
• Assuming memory is unlimited
• Ignoring program crashes

3. Consider this code snippet in C-like pseudocode:

char buffer[5];
strcpy(buffer, "HelloWorld");

What will likely happen when this code runs?

medium

A. The program stores "Hello" safely and ignores the rest

B. The program crashes or behaves unpredictably due to overflow

C. The program automatically resizes buffer to fit the string

D. The program throws a syntax error before running

Solution

1. Step 1: Analyze buffer size and input

   The buffer can hold 5 characters, but the string "HelloWorld" has 10 characters.

2. Step 2: Understand strcpy behavior

   strcpy copies all characters without checking size, causing overflow beyond buffer limits.

3. Final Answer:

   The program crashes or behaves unpredictably due to overflow -> Option B

4. Quick Check:

   Copying too large string = Crash or error [OK]

Hint: Copying bigger string than buffer causes crash [OK]

Common Mistakes:

• Assuming partial copy happens safely
• Thinking buffer resizes automatically
• Confusing syntax error with runtime error

4. Identify the error in this pseudocode that causes a buffer overflow:

char data[4];
input = getUserInput();
for i in range(len(input)) {
  data[i] = input[i];
}

medium

A. The data array is declared with too many elements

B. The input is not converted to uppercase

C. The loop uses the wrong variable name

D. The loop does not check if i exceeds data size

Solution

1. Step 1: Examine loop and array size

   The data array has size 4, but the loop runs for the full length of input without limit.

2. Step 2: Identify missing boundary check

   Without checking if i < 4, the loop writes beyond data's memory, causing overflow.

3. Final Answer:

   The loop does not check if i exceeds data size -> Option D

4. Quick Check:

   Missing boundary check = Overflow risk [OK]

Hint: Always check loop limits against buffer size [OK]

Common Mistakes:

• Ignoring array size limits
• Focusing on unrelated input format
• Confusing variable names

5. A program uses a buffer of size 8 to store user input. Which approach best prevents buffer overflow while allowing flexible input length?

hard

A. Use dynamic memory allocation to resize buffer as needed

B. Use a fixed buffer and truncate input longer than 8 characters

C. Ignore input size and trust user to enter short data

D. Allow buffer overflow and handle errors after crash

Solution

1. Step 1: Understand fixed buffer limits

   Fixed buffer size limits input length, truncation loses data, ignoring size risks overflow.

2. Step 2: Evaluate dynamic allocation benefits

   Dynamic memory allocation adjusts buffer size to input length, preventing overflow and preserving data.

3. Final Answer:

   Use dynamic memory allocation to resize buffer as needed -> Option A

4. Quick Check:

   Dynamic resizing = Safe flexible input [OK]

Hint: Resize buffer dynamically to fit input safely [OK]

Common Mistakes:

• Relying on truncation losing data
• Trusting user input blindly
• Ignoring errors after overflow