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 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 the thread is blocked on 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 { // Thread-safe class
  private final Socket socket;
  private final BufferedReader in;
  private volatile boolean done = false;
  private final Object lock = new Object();

  public SocketReader(String host, int port) throws IOException {
    this.socket = new Socket(host, port);
    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) {
        readData(); 
      }      
    } catch (IOException ie) {
      // Forward to handler
    }
  }

  public void readData() 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
 IOException, InterruptedException {
    SocketReader reader =                  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
  }
}

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 shut down the thread. However, this is not useful because the thread is blocked on network IO as a consequence of using the readLine() method. Network IO is not responsive to thread interruption whne Network I/O on a java.net.Socket is being usedunresponsive to thread interruption.

// Thread-safe class 
public final class SocketReader implements Runnable { 
  // Thread-safe class
  // Other methods...
  
  public void readData() 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 the socket connection, by having terminates the blocking network I/O by closing the socket in the shutdown() method close the socket. As a result, the thread is bound to stop because the . The readLine() method will throw throws a SocketException when the socket is closed, consequently allowing the thread to 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 readData() 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();
  }
}

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/OA boolean flag can be used (as described earlier) if additional clean-up operations need to be performed. When performing asynchronous IO, a java.nio.channels.Selector may also be brought out of the blocked state by either invoking can be unblocked by invoking either its close() or its wakeup() method.

Compliant Solution (interruptible channel)

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 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 while it is reading the data, the thread receives a ClosedByInterruptException, and the channel is closed immediately. The thread's interrupt 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) throws IOException {
    sc = SocketChannel.open(new InetSocketAddress(host, port));    
  }

  
 @Override public void run() {
    ByteBuffer buf = ByteBuffer.allocate(1024);
    try {
      synchronized (lock) {
        while (!Thread.interrupted()) {
          sc.read(buf);
          // ...
        }
      }
    } catch (IOException ie) {
      // Forward to handler
    }
  }

  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();
  }
}

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. Using a SocketChannel ensures that the condition in the while loop is tested as soon as an interruption is received, despite even though the read operation being is normally a blocking operation. Invoking 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 one JDBC connection per thread. 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.

public final class DBConnector implements Runnable {
  private final String query;
  
  DBConnector(String query) {
    this.query = query; 
  }
	
  @Override public void run() {
    Connection connection;
    try {
      // Username and password are hard coded for brevity
      connection = DriverManager.getConnection(
          "jdbc:driver:name", "username", "password");  
          "username", 
          "password"
      );
      Statement stmt = connection.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 resource when the corresponding thread is blocked on a long-running activity query, such as a join query. Furthermore, it is important to provide a mechanism to close connections to prevent thread starvation, because there is a limited number of database connections available in the pool. Similar task cancellation mechanisms are required when using objects local to a method, such as sockets.

Compliant Solution (ThreadLocal)

.

Compliant Solution (Statement.cancel())

This compliant solution uses a ThreadLocal wrapper around the connection so that a thread calling the initialValue() method This compliant solution uses a ThreadLocal wrapper around the connection so that a thread that calls initialValue() 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 = query;
  }
	
  private static final 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   if(connection == nullconnectionHolder.get();
  }

  public boolean cancelStatement() { // ShutsAllows downclient connectionto whencancel nullstatement
 value is passed 		Statement tmpStmt = stmt;
    
if (tmpStmt !=   null) {
      try {
          connectiontmpStmt.closecancel();
        return true;
      } catch (SQLException e) {
          // Forward to handler 
        }	
    }
   		 return false;
  }

  @Override 
public void run() {
   } elsetry {
      if  connection (getConnection() != con;null) {
        stmt  }= getConnection().createStatement();
    }
  };

    public static Connectionif getConnection()stmt {
== null ||  return connectionHolder.get();(stmt.getConnection() != getConnection())) {
  }

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

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

  public static stmt = dbConnection.createStatement();		
  void main(String[] args) throws InterruptedException {
    ResultSetDBConnector rsconnector = stmt.executeQuery(querynew DBConnector("suitable query");
    Thread thread }= catchnew Thread(SQLException e) {connector);
      // Forward to handler	 thread.start();
    }    Thread.sleep(5000);
    // ...connector.cancelStatement();
  }

  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.shutdown();
  }
}

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