This weakness occurs when code fails to anticipate and handle edge cases, error states, or unusual inputs that fall outside normal operation. Rather than…
This weakness occurs when code fails to anticipate and handle edge cases, error states, or unusual inputs that fall outside normal operation. Rather than gracefully managing these scenarios, the software either crashes, behaves unpredictably, or leaves itself in an unsafe state. Unhandled exceptions can expose sensitive information, enable denial-of-service attacks, or create security gaps that attackers can exploit.
Developers often write code that works correctly for the "happy path"—the expected sequence of inputs and operations—but neglect to handle what happens when things go wrong. This might include null or empty values where data is expected, network timeouts, file-not-found errors, permission denials, or resource exhaustion. When these conditions occur, the application either crashes with an unhandled exception, silently fails in an unsafe way, or continues executing with corrupted state. The root cause is typically insufficient error checking, missing try-catch blocks, or assumptions that certain conditions will never happen.
Unhandled exceptions can lead to information disclosure (stack traces revealing internal paths or database structure), denial of service (repeated crashes consuming resources), or security bypass (logic that assumes a resource exists when it doesn't, skipping validation). In web applications, an unhandled exception during authentication might allow an attacker to bypass login checks. In file-processing systems, missing checks for file-not-found or permission errors could lead to processing the wrong file or exposing error details to users.
import json
def process_user_data(user_id):
# Assumes file always exists and is valid JSON
with open(f"user_{user_id}.json") as f:
data = json.load(f)
# Assumes 'email' key always present
email = data['email']
send_notification(email)
return "Success"Why it's vulnerable:
The code does not check whether the file exists, whether it contains valid JSON, or whether the required 'email' key is present. Any of these conditions will raise an unhandled exception, crashing the function and potentially exposing error details.
import json
import os
def process_user_data(user_id):
try:
if not os.path.exists(f"user_{user_id}.json"):
return "Error: User file not found"
with open(f"user_{user_id}.json") as f:
data = json.load(f)
if not isinstance(data, dict) or 'email' not in data:
return "Error: Invalid user data"
email = data['email']
send_notification(email)
return "Success"
except (IOError, json.JSONDecodeError) as e:
# Log the error securely, do not expose details to user
log_error(f"Failed to process user {user_id}")
return "Error: Unable to process request"<?php
function fetch_user_profile($user_id) {
// Assumes database connection and query always succeed
$result = mysqli_query($conn, "SELECT name, email FROM users WHERE id = $user_id");
$user = mysqli_fetch_assoc($result);
// Assumes row always exists
echo "User: " . $user['name'];
return $user;
}
?>Why it's vulnerable:
The code does not check whether the query succeeded, whether any rows were returned, or whether the expected keys exist in the result. A failed query or missing user will cause an unhandled error.
<?php
function fetch_user_profile($user_id) {
if (!is_numeric($user_id)) {
return array('error' => 'Invalid user ID');
}
$stmt = $conn->prepare("SELECT name, email FROM users WHERE id = ?");
if (!$stmt) {
error_log("Database prepare failed");
return array('error' => 'Database error');
}
$stmt->bind_param("i", $user_id);
if (!$stmt->execute()) {
error_log("Query execution failed");
return array('error' => 'Database error');
}
$result = $stmt->get_result();
if (!$result) {
error_log("Result retrieval failed");
return array('error' => 'Database error');
}
$user = $result->fetch_assoc();
if (!$user) {
return array('error' => 'User not found');
}
return $user;
}
?>Look for stack traces or error messages appearing in user-facing pages or logs, unexpected application crashes when processing unusual inputs, or inconsistent behavior when files are missing or network calls time out. Review your application logs for unhandled exception patterns and test your application with missing or malformed data to identify gaps in error handling.
