The software properly checks for the existence of a lock, but the lock can be externally controlled or influenced by an actor that is outside of the intended sphere of control.
Extended Description
This prevents the software from acting on associated resources or performing other behaviors that are controlled by the presence of the lock. Relevant locks might include an exclusive lock or mutex, or modifying a shared resource that is treated as a lock. If the lock can be held for an indefinite period of time, then the denial of service could be permanent.
When an attacker can control a lock, the program may wait indefinitely
until the attacker releases the lock, causing a denial of service to
other users of the program. This is especially problematic if there is a
blocking operation on the lock.
Detection Methods
White Box
Automated code analysis techniques might not be able to reliably
detect this weakness, since the application's behavior and general
security model dictate which resource locks are critical. Interpretation
of the weakness might require knowledge of the environment, e.g. if the
existence of a file is used as a lock, but the file is created in a
world-writable directory.
Demonstrative Examples
Example 1
This code tries to obtain a lock for a file, then writes to it.
(Bad Code)
Example
Language: PHP
function writeToLog($message){
$logfile = fopen("logFile.log", "a");
//attempt to get logfile lock
if (flock($logfile, LOCK_EX)) {
fwrite($logfile,$message);
// unlock logfile
flock($logfile, LOCK_UN);
}
else {
print "Could not obtain lock on logFile.log, message not
recorded\n";
}
}
fclose($logFile);
PHP by default will wait indefinitely until a file lock is released.
If an attacker is able to obtain the file lock, this code will pause
execution, possibly leading to denial of service for other users. Note
that in this case, if an attacker can perform an flock() on the file,
they may already have privileges to destroy the log file. However, this
still impacts the execution of other programs that depend on
flock().
Critical file can be opened with exclusive read
access by user, preventing application of security policy. Possibly related
to improper permissions, large-window race condition.
Product does not check if it can write to a log file, allowing attackers to avoid logging by accessing the file using an exclusive lock. Overlaps unchecked error condition. This is not quite CWE-412, but close.
Potential Mitigations
Phases: Architecture and Design; Implementation
Use any access control that is offered by the functionality that is
offering the lock.
Phases: Architecture and Design; Implementation
Use unpredictable names or identifiers for the locks. This might not
always be possible or feasible.
Phase: Architecture and Design
Consider modifying your code to use non-blocking synchronization
methods.
This overlaps Insufficient Resource Pool when the "pool" is of size 1. It
can also be resultant from race conditions, although the timing window could
be quite large in some cases.
Taxonomy Mappings
Mapped Taxonomy Name
Node ID
Fit
Mapped Node Name
PLOVER
Unrestricted Critical Resource Lock
7 Pernicious Kingdoms
Deadlock
OWASP Top Ten 2004
A9
CWE_More_Specific
Denial of Service
CERT Java Secure Coding
LCK00-J
Use private final lock objects to synchronize classes that may
interact with untrusted code
CERT Java Secure Coding
LCK07-J
Avoid deadlock by requesting and releasing locks in the same
order
Description
