Page History

Recommendations discussed in the guideline CON13-J. Ensure that threads are stopped cleanly are insufficient to terminate a thread that is blocked on a blocking operation such as network or file input-output (IO). Consequently, threads and tasks should Threads and tasks that block on operations involving network or file I/O must provide callers with an explicit termination mechanism to prevent denial-of-service (DoS) vulnerabilities.

Noncompliant Code Example (

...

Blocking I/O, Volatile Flag)

This noncompliant code example uses a volatile done flag to indicate that it whether is safe to shutdown shut down the thread, as suggested in CON13THI05-J. Ensure that threads are stopped cleanly. Do not use Thread.stop() to terminate threads. However, this does not help in terminating when the thread because it is blocked on some network IO I/O as a consequence of using invoking the readLine() method. , it cannot respond to the newly set flag until the network I/O is complete. Consequently, thread termination may be indefinitely delayed.

// Thread-safe class 
public final class SocketReader implements Runnable { 
  private final Socket socket;
  private final BufferedReader in;
  private volatile boolean done = false;
  private final Object lock = new Object();

  privatepublic boolean isRunning = false; // Reduces the need to synchronize time consuming operations
  public static class MultipleUseException extends RuntimeException {};

  public SocketReader() throws IOException {SocketReader(String host, int port) throws IOException {
    this.socket = new Socket(host, port);
    this.socketin = new Socket("somehost", 25);
BufferedReader(
     this.in = new BufferedReader(new InputStreamReader(this.socket.getInputStream())
    );
  }
  
  // Only one thread can use the socket at a particular time
  @Override public void run() {
    try {
      synchronized (lock) {
        if readData(isRunning) {
          throw new MultipleUseException();
        }
        isRunning = true;
      }
      execute();
    } catch (IOException ie) {
      // Forward to handler
    }
  }

  public void executereadData() throws IOException {
    String string;
    while (!done && (string = in.readLine()) != null) {
      // Blocks until end of stream (null)
    }
  }

  public void shutdown() {
    done = true;
  }

  public static void main(String[] args) throws 
                          throws IOException, InterruptedException {
    SocketReader reader = new SocketReader("somehost", 25);
    Thread thread = new Thread(reader);
    thread.start();
    Thread.sleep(1000);
    reader.shutdown(); // Shut down the thread
  }
}

Note that the Runnable object prevents itself from being run in multiple threads using an isRunning flag. If one thread tries to invoke run() after another thread has already done so, an unchecked exception is thrown.

...

Noncompliant Code Example (Blocking I/O, Interruptible)

This noncompliant code example is similar to the preceding example but uses thread interruption to indicate that it is safe to shutdown the thread, as suggested in CON13-J. Ensure that threads are stopped cleanly. However, this is not useful because the thread is blocked on some network IO as a consequence of using the readLine() method. Network I/O is not responsive shut down the thread. Network I/O on a java.net.Socket is unresponsive to thread interruption.

class SocketReader implements // Thread-safe class 
public final class SocketReader implements Runnable { 
  // Other methods...
  
  public void executereadData() throws IOException {
    String string;
    while (!Thread.interrupted() && (string = in.readLine()) != null) { 
      // Blocks until end of stream (null)
    }
  }
  
  public static void main(String[] args) 
                          throws IOException, InterruptedException {
    SocketReader reader = new SocketReader("somehost", 25);
    Thread thread = new Thread(reader);
    thread.start();
    Thread.sleep(1000); 
    thread.interrupt();
 //  }
Interrupt the thread
  }
}

Compliant Solution (

...

Close Socket Connection)

This compliant solution closes terminates the blocking network I/O by closing the socket connection, by having in the shutdown() method. The readLine() method close throws a SocketException when the socket . As a result, is closed, consequently allowing the thread is bound to stop because of a SocketExceptionto proceed. Note that there it is no way impossible to keep the connection alive if while simultaneously halting the thread is to be both cleanly halted and immediately.

public final class SocketReader implements Runnable {
  // Other methods...
  
  public void executereadData() throws IOException {
    String string;
    try {
      while ((string = in.readLine()) != null) { 
        // Blocks until end of stream (null)
      }
    } finally {
      shutdown();
    }
  }
  
  public void shutdown() throws IOException {
    socket.close();
  }

  public static void main(String[] args) 
                          throws IOException, InterruptedException {
    SocketReader reader = new SocketReader("somehost", 25);
    Thread thread = new Thread(reader);
    thread.start();
    Thread.sleep(1000); 
    reader.shutdown();
  }
}

A boolean flag can be used (as described earlier) if additional clean-up operations need to be performed. When performing asynchronous I/O, a java.nio.channels.Selector may also be brought out of the blocked state by either invoking its close() or wakeup() method.

Compliant Solution (interruptible channel)

This compliant solution uses an interruptible channel, SocketChannel instead of a Socket connection. If the thread performing the network IO is interrupted using the Thread.interrupt() method, for instance, while reading the data, the thread receives a ClosedByInterruptException and the channel is closed immediately. The thread's interrupt status is also set.

After the shutdown() method is called from main(), the finally block in readData() executes and calls shutdown() again, closing the socket for a second time. However, when the socket has already been closed, this second call does nothing.

When performing asynchronous I/O, a java.nio.channels.Selector can be unblocked by invoking either its close() or its wakeup() method.

When additional operations must be performed after emerging from the blocked state, use a boolean flag to indicate pending termination. When supplementing the code with such a flag, the shutdown() method should also set the flag to false so that the thread can cleanly exit from the while loop.

Compliant Solution (Interruptible Channel)

This compliant solution uses an interruptible channel, java.nio.channels.SocketChannel, instead of a Socket connection. If the thread performing the network I/O is interrupted using the Thread.interrupt() method while it is reading the data, the thread receives a ClosedByInterruptException, and the channel is closed immediately. The thread's interrupted status is also set.

public final class SocketReader implements Runnable {
  private final SocketChannel sc;
  private final Object lock = new Object();

  public SocketReader(String host, int port

class SocketReader implements Runnable {
  private final SocketChannel sc;
  private final Object lock = new Object();
  private boolean isRunning = false;
  private class MultipleUseException extends RuntimeException {};
  
  public SocketReader() throws IOException {
    sc = SocketChannel.open(new InetSocketAddress("somehost"host, 25port));    
  }

  
 @Override public void run() {
    synchronizedByteBuffer (lock) {
 buf = ByteBuffer.allocate(1024);
     if (isRunning)try {
      synchronized  throw new MultipleUseException(lock); {
      }
  while    isRunning = true;(!Thread.interrupted()) {
    }

    ByteBuffer buf = ByteBuffersc.allocateread(1024buf);
    try {
      synchronized (lock) {
        while (!Thread.interrupted()) {
          sc.read(buf);
          // ...
        }
      }
    } catch (IOException ie) {
      // Forward to handler
    }
  }

  public static void main(String[] args) throws
 IOException,                          throws IOException, InterruptedException {
    SocketReader reader = new SocketReader("somehost", 25);
    Thread thread = new Thread(reader);
    thread.start();
    Thread.sleep(1000);
    thread.interrupt();
  }
}

This method technique interrupts the current thread, however. However, it only stops the thread only because the code polls the interrupted flag using the method thread's interrupted status with the Thread.interrupted(), method and shuts down terminates the thread when it is interrupted. Invoking the Using a SocketChannel ensures that the condition in the while loop is tested as soon as an interruption is received, even though the read is normally a blocking operation. Similarly, invoking the interrupt() method of a thread that is blocked because of on a java.nio.channels.Selector also causes the that thread to awaken.

Noncompliant Code Example (

...

Database Connection)

This noncompliant code example shows a thread-safe DBConnector class DBConnector that creates a one JDBC connection per thread, that is, the connection belonging . Each connection belongs to one thread and is not shared by other threads. This is a common use - case because JDBC connections are not meant intended to be shared by multiplesingle-threadsthreaded.

class DBConnector implements Runnable {
  final String query;
  private final Object lock = new Object();
  private boolean isRunning = false;
  private class MultipleUseException extends RuntimeException {};
  
  DBConnector(String query) {
    this.query = query; 
  }
	
  public void run() {
    synchronized (lock) public final class DBConnector implements Runnable {
  private final String query;

 if DBConnector(isRunningString query) {
        throw new MultipleUseException();
      }
      isRunningthis.query = truequery;
  }

  @Override public void run() }
{
    Connection conconnection;
    try {
      // Username and password are hard coded for brevity
      conconnection = DriverManager.getConnection(
          "jdbc:driver:name", "username","password");  name", 
          "username", 
          "password"
      );
      Statement stmt = conconnection.createStatement();
      ResultSet rs = stmt.executeQuery(query);
      // ...
    } catch (SQLException e) {
      // Forward to handler
    }
    // ... 
  }  


  public static void main(String[] args) throws InterruptedException {
    DBConnector connector = new DBConnector(/* "suitable query */");
    Thread thread = new Thread(connector);
    thread.start();
    Thread.sleep(5000);
    thread.interrupt();
  }
}

Unfortunately database Database connections, like sockets, are not inherently interruptible. So this design does not permit a client lack inherent interruptibility. Consequently, this design fails to support the client's attempts to cancel a task by closing it if the corresponding thread is blocked on a long running activity such as a join query. Furthermore, it is important to provide a mechanism to close connections to prevent thread starvation caused because of the limited number of database connections available in the pool. Similar task cancellation mechanisms are required when using objects local to a method, such as socketsthe resource when the corresponding thread is blocked on a long-running query, such as a join.

Compliant Solution (

...

Statement.cancel())

This compliant solution uses a ThreadLocal wrapper around the connection so that a thread that calls calling the initialValue() method obtains a unique connection instance. The advantage of this approach is that a shutdownConnection() method can be provided so that clients external to the class can also close the connection when the corresponding thread is blocked, or is performing some time consuming activityThis approach allows provision of a cancelStatement() so that other threads or clients can interrupt a long-running query when required. The cancelStatement() method invokes the Statement.cancel() method.

public final class DBConnector implements Runnable {
  private final String query;
  private volatile Statement stmt;

  DBConnector(String query) {
    this.query =
class DBConnector implements Runnable {
  final String query;
  }

   DBConnector(String query) {
private static final ThreadLocal<Connection> connectionHolder = 
                            this.query = query;
  }
	
  private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() {
    Connection connection = null;

    @Override public Connection initialValue() {		
      try {
        // ...
 Username and password are hard coded for brevity
	connection = DriverManager.getConnection(
            ("jdbc:driver:name", 
            "username","password"); 
          	  "password"
  	      );
      } catch (SQLException e) {
        // Forward to handler
      }
      return connection;
    }
		
   };

 @Override public voidConnection setgetConnection(Connection con) {
    return connectionHolder.get();
  }

  if(connection == nullpublic boolean cancelStatement() { // Shuts down connection when null value is passed 		        Allows client to cancel statement
    Statement tmpStmt = stmt;
    if (tmpStmt != null) {
        try {
          connectiontmpStmt.closecancel();
        } catch (SQLException e) {return true;
      } catch (SQLException  // Forward to handler 
 e) {
       }	 // Forward to handler
   		   }
    }
    return false;
  } else {

  @Override public void run() {
  connection = con;try {
      }
    }if (getConnection() != null) {
  };

  public static Connection getConnection() {
   stmt return= connectionHoldergetConnection().getcreateStatement();
  }

  public static void shutdownConnection() { // Allows client to close connection anytime
    connectionHolder.set(null);
  }

  public void run() {
    Connection dbConnection = getConnection}
      if (stmt == null || (stmt.getConnection() != getConnection())) {
        throw new IllegalStateException();
    Statement  stmt;}
    try {
 ResultSet rs =   stmt = dbConnection.createStatementexecuteQuery(query);		
      ResultSet rs = stmt.executeQuery(query);// ...
    } catch (SQLException e) {
      // Forward to handler	 
    }    
    // ...
  }

  public static void main(String[] args) throws InterruptedException {
    DBConnector connector = new DBConnector(/* "suitable query */");
    Thread thread = new Thread(connector);
    thread.start();
    Thread.sleep(5000);
    connector.shutdowncancelStatement();
  }
}

Risk Assessment

Failing to provide facilities for thread shutdown can cause non-responsiveness and denial of service.

Automated Detection

TODO

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

References

\[[API 06|AA. Java References#API 06]\] Class Thread, method {{stop}}, interface ExecutorService
\[[Darwin 04|AA. Java References#Darwin 04]\] 24.3 Stopping a Thread
\[[JDK7 08|AA. Java References#JDK7 08]\] Concurrency Utilities, More information: Java Thread Primitive Deprecation 
\[[JPL 06|AA. Java References#JPL 06]\] 14.12.1. Don't stop and 23.3.3. Shutdown Strategies
\[[JavaThreads 04|AA. Java References#JavaThreads 04]\] 2.4 Two Approaches to Stopping a Thread
\[[Goetz 06|AA. Java References#Goetz 06]\] Chapter 7: Cancellation and shutdown

The Statement.cancel() method cancels the query, provided the database management system (DBMS) and driver both support cancellation. It is impossible to cancel the query if either the DBMS or the driver fail to support cancellation.

According to the Java API, Interface Statement documentation [API 2014]

By default, only one ResultSet object per Statement object can be open at the same time. As a result, if the reading of one ResultSet object is interleaved with the reading of another, each must have been generated by different Statement objects.

This compliant solution ensures that only one ResultSet is associated with the Statement belonging to an instance, and, consequently, only one thread can access the query results.

Risk Assessment

Failure to provide facilities for thread termination can cause nonresponsiveness and DoS.

Bibliography

...

Image Added Image Added Image AddedCON12-J. Avoid deadlock by requesting and releasing locks in the same order      11. Concurrency (CON)      VOID CON14-J. Ensure atomicity of 64-bit operations