Resource leak occurs when a program makes a private resource—such as a file handle, memory segment, database connection, or temporary file—accessible to a…
Resource leak occurs when a program makes a private resource—such as a file handle, memory segment, database connection, or temporary file—accessible to a different user, process, or security context without first clearing or invalidating any sensitive data it may contain. This can expose confidential information that was intended to remain private, even if the resource itself is later properly closed or deallocated.
Resource leak typically arises when a program reuses or shares a resource without resetting its state. For example, a web application might reuse a database connection pool without clearing cached query results, or a file might be opened in append mode without truncating previous contents. In multi-user or multi-process environments, a resource allocated by one user may be handed to another without sanitization. Similarly, memory allocated for one request may be reused for another without zeroing sensitive data first. The core issue is a gap between the logical end of one resource's "private" lifecycle and the point at which it is actually cleared or made inaccessible.
Exposure of residual data can lead to unauthorized disclosure of passwords, API keys, personal information, or other secrets that were processed in a previous context. In shared hosting environments, this can allow one tenant to read another tenant's data. In multi-threaded applications, race conditions combined with resource reuse can leak session tokens or authentication credentials. The severity depends on what data was stored in the resource and who gains access to it.
import tempfile
import os
def process_user_file(user_id, data):
# Reuse a temporary file without clearing previous contents
temp_file = "/tmp/shared_buffer.txt"
with open(temp_file, "a") as f: # Append mode — old data remains
f.write(data)
return temp_file
# User A writes sensitive data
process_user_file(1, "User A's secret: password123")
# User B later accesses the same file
with open("/tmp/shared_buffer.txt", "r") as f:
print(f.read()) # User B can see User A's dataWhy it's vulnerable:
The file is opened in append mode without clearing previous contents, allowing subsequent users to read data written by earlier users. The resource is shared across security boundaries without sanitization.
import tempfile
import os
def process_user_file(user_id, data):
# Create a new, isolated temporary file for each operation
fd, temp_file = tempfile.mkstemp(prefix=f"user_{user_id}_")
try:
with os.fdopen(fd, "w") as f:
f.write(data)
return temp_file
finally:
# Ensure cleanup happens
if os.path.exists(temp_file):
os.remove(temp_file)
# Each user gets a fresh, isolated file
process_user_file(1, "User A's secret: password123")
process_user_file(2, "User B's secret: otherkey456")<?php
// Reuse a shared temporary file without clearing it
$temp_file = "/tmp/cache.txt";
function store_user_data($user_id, $data) {
global $temp_file;
// File is opened in append mode; old data persists
file_put_contents($temp_file, $data, FILE_APPEND);
}
// User A stores data
store_user_data(1, "User A's API key: sk_live_abc123");
// User B later reads the same file
$cached = file_get_contents($temp_file);
echo $cached; // User B sees User A's key
?>Why it's vulnerable:
The shared file is appended to without being cleared between users, allowing residual data from one user to be read by another. No isolation or sanitization occurs.
<?php
function store_user_data($user_id, $data) {
// Create a unique, isolated file for each user
$temp_file = tempnam(sys_get_temp_dir(), "user_" . $user_id . "_");
// Write data to the isolated file
file_put_contents($temp_file, $data);
// Process the data...
// Clean up: securely delete the file
if (file_exists($temp_file)) {
unlink($temp_file);
}
}
// Each user gets a fresh, isolated file
store_user_data(1, "User A's API key: sk_live_abc123");
store_user_data(2, "User B's API key: sk_live_xyz789");
?>tempfile.mkstemp() (Python) or tempnam() (PHP) to create isolated, unique temporary files; avoid hardcoded or predictable paths.
Check application logs and temporary directories for unexpected files or data. If you notice that temporary files persist longer than expected, contain data from multiple users, or are world-readable, investigate whether resources are being properly isolated and cleared. In multi-tenant or shared hosting environments, verify that one user's session or request cannot access files or memory allocated to another user.
