LCK00-J
while (true) {
Thread.sleep(Integer.MAX_VALUE); // Indefinitely delay someObject
}
}
The untrusted code attempts to acquire a lock on the class object’s monitor and, upon succeeding, introduces an indefinite delay that prevents the synchronized changeValue() method from acquiring the same lock.
A compliant solution must comply with guideline “LCK05-J. Synchronize access to static fields that may be modified by untrusted code” on page 59. However, in the untrusted code, the attacker intentionally violates guideline “LCK09-J. Do not perform operations that may block while holding a lock” on page 77.
3.1.7Compliant Solution (Static)
Thread-safe public classes that may interact with untrusted code and use intrinsic synchronization over the class object must be refactored to use a static private final lock object and block synchronization.
public class SomeObject {
private static final Object lock = new Object(); // private final lock object
public static void changeValue() {
synchronized (lock) { // Locks on the private Object // ...
}
}
}
In this compliant solution, changeValue() obtains a lock on a static private Object that is inaccessible to the caller.
CMU/SEI-2010-TR-015 | 45
LCK00-J
3.1.8Exceptions
LCK00-EX1: A class may violate this guideline, if all the following conditions are met:
•It sufficiently documents that callers must not pass objects of this class to untrusted code.
•The class does not invoke methods on objects of any untrusted classes that violate this guideline directly or indirectly.
•The synchronization policy of the class is documented properly.
A client may use a class that violates this guideline, if all the following conditions are met:
•The class does not pass objects of this class to untrusted code.
•The class does not use any untrusted classes that violate this guideline directly or indirectly.
LCK00-EX2: If a superclass of the class documents that it supports client-side locking and synchronizes on its class object, the class can support client-side locking in the same way and document this policy.
LCK00-EX3: A package-private class may violate this guideline because its accessibility protects against untrusted callers. However, this condition should be documented explicitly so that trusted code within the same package does not reuse or change the lock object inadvertently.
3.1.9Risk Assessment
Exposing the class object to untrusted code can result in a denial of service.
Guideline |
Severity |
Likelihood |
Remediation Cost |
Priority |
Level |
|
|
|
|
|
|
LCK00-J |
low |
probable |
medium |
P4 |
L3 |
3.1.10 References
[Bloch 2001] Item 52: “Document Thread Safety”
CMU/SEI-2010-TR-015 | 46
LCK01-J
3.2LCK01-J. Do not synchronize on objects that may be reused
Misuse of synchronization primitives is a common source of concurrency issues. Synchronizing on objects that may be reused can result in deadlock and nondeterministic behavior.
3.2.1Noncompliant Code Example (Boolean Lock Object)
This noncompliant code example synchronizes on a Boolean lock object.
private final Boolean initialized = Boolean.FALSE;
public void doSomething() { synchronized (initialized) {
// ...
}
}
The Boolean type is unsuitable for locking purposes because it allows only two values: true and false. Boolean literals containing the same value share unique instances of the Boolean class in the JVM. In this example, initialized references the instance corresponding to the value false. If any other code inadvertently synchronizes on a Boolean literal with the value false, the lock instance is reused and the system can become unresponsiveness or deadlocked.
3.2.2Noncompliant Code Example (Boxed Primitive)
This noncompliant code example locks on a boxed Integer object.
int lock = 0;
private final Integer Lock = lock; // Boxed primitive Lock is shared
public void doSomething() { synchronized (Lock) {
// ...
}
}
Boxed types may use the same instance for a range of integer values and consequently suffer from the same problem as Boolean constants. If the value of the primitive can be represented as a byte, the wrapper object is reused. Note that the use of the boxed Integer wrapper object is insecure; instances of the Integer object constructed using the new operator (new Integer(value)) are unique and not reused. In general, holding a lock on any data type that contains a boxed value is insecure.
CMU/SEI-2010-TR-015 | 47
LCK01-J
3.2.3Compliant Solution (Integer)
This compliant solution recommends locking on a non-boxed Integer. The doSomething() method synchronizes using the intrinsic lock of the Integer instance, Lock.
int lock = 0;
private final Integer Lock = new Integer(lock);
public void doSomething() { synchronized (Lock) {
// ...
}
}
When explicitly constructed, an Integer object has a unique reference and its own intrinsic lock that is not shared with other Integer objects or boxed integers having the same value. While this is an acceptable solution, it can cause maintenance problems because developers can incorrectly assume that boxed integers are appropriate lock objects. A more appropriate solution is to synchronize on a private final lock object as described in the compliant solution in Section 3.2.7.
3.2.4Noncompliant Code Example (Interned String Object)
This noncompliant code example locks on an interned String object.
private final String lock = new String("LOCK").intern();
public void doSomething() { synchronized (lock) {
// ...
}
}
According to the Java API class java.lang.String documentation [Sun 2009c]
When the intern() method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.
Consequently, an interned String object behaves like a global variable in the JVM. As demonstrated in this noncompliant code example, even if every instance of an object maintains its own lock field, the field references a common String constant. Locking on String constants has the same problem as locking on Boolean constants.
Additionally, hostile code from any other package can exploit this vulnerability, if the class is accessible. (For more information, see guideline “LCK00-J. Use private final lock objects to synchronize classes that may interact with untrusted code” on page 41.)
CMU/SEI-2010-TR-015 | 48