Buffer overflow attacks in Operating Systems - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is a buffer overflow attack?

Which of the following best describes a buffer overflow attack?

A An attack where extra data is written beyond the buffer's boundary, potentially overwriting adjacent memory.

B An attack that encrypts data in a buffer to prevent access.

C An attack that deletes all data stored in a buffer intentionally.

D An attack that compresses buffer data to save memory space.

💡 Hint

Think about what happens when a program writes more data than a buffer can hold.

A buffer overflow attack happens when a program writes more data to a buffer than it can hold, causing the extra data to overwrite adjacent memory. This can lead to unexpected behavior or security vulnerabilities.

📋 Factual

intermediate

Common cause of buffer overflow

What is a common programming mistake that leads to buffer overflow vulnerabilities?

A Encrypting data before storing it in buffers.

B Using dynamic memory allocation properly.

C Using fixed-size buffers without checking input length.

D Using high-level languages that manage memory automatically.

💡 Hint

Consider what happens if input data is longer than the buffer size.

Not checking the length of input before copying it into a fixed-size buffer can cause data to overflow the buffer, leading to vulnerabilities.

🚀 Application

advanced

Effect of buffer overflow on program behavior

What is a likely result if a buffer overflow overwrites a program's return address on the stack?

A The program may jump to malicious code and execute it.

B The program will automatically fix the overwritten address and continue safely.

C The program will compress the stack to prevent errors.

D The program will encrypt the return address to protect it.

💡 Hint

Think about what happens when the return address points somewhere unexpected.

If the return address on the stack is overwritten, the program may jump to an attacker-controlled location, allowing execution of malicious code.

🔍 Analysis

advanced

Why do modern systems use stack canaries?

What is the main purpose of stack canaries in preventing buffer overflow attacks?

A To compress stack data for faster execution.

B To increase the size of the buffer to avoid overflow.

C To encrypt the stack memory to prevent access.

D To detect if the stack has been overwritten before function returns.

💡 Hint

Consider how a program can know if its stack was tampered with.

Stack canaries are special values placed before the return address. If a buffer overflow overwrites the stack, the canary value changes, allowing the program to detect the attack and stop execution.

❓ Reasoning

expert

Why is using safe functions important to prevent buffer overflow?

Given two functions: strcpy() and strncpy(), why is strncpy() considered safer in preventing buffer overflow?

A <code>strncpy()</code> automatically allocates more memory for the buffer.

B <code>strncpy()</code> limits the number of characters copied, preventing overflow if used correctly.

C <code>strcpy()</code> encrypts the string while copying, which <code>strncpy()</code> does not.

D <code>strncpy()</code> compresses the string to fit the buffer size.

💡 Hint

Think about how limiting copied data size helps avoid overflow.

strncpy() allows specifying the maximum number of characters to copy, which helps prevent writing beyond the buffer size if used properly. strcpy() does not check length and can cause overflow.

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