Page History

The recommendations suggested in the guideline CON13-J. Ensure that threads are stopped cleanly are insufficient to terminate a thread that is blocked on an operation involving network or file input-output (IO). 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.

Code Block

bgColor	#FFcccc

// 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 = new SocketReader("somehost", 25              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 one, example but uses thread interruption to shut down the thread. Network IO is not responsive to thread interruption when I/O on a java.net.Socket is being usedunresponsive to thread interruption.

Code Block

bgColor	#FFcccc

// 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(              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 resumes the thread by having terminates the blocking network I/O by closing the socket in the shutdown() method close the socket. The readLine() method throws a SocketException when the socket is closed which lets , 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.

Code Block

bgColor	#ccccff


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();
    Thread thread = new Thread(reader      throws IOException, InterruptedException {
    SocketReader reader = new SocketReader("somehost", 25);
    Thread thread = new Thread(reader);
    thread.start();
    Thread.sleep(1000); 
    reader.shutdown();
  }
}

The finally block executes after After the shutdown() method is called . Because from main(), the finally block also in readData() executes and calls shutdown() again, closing the socket will be closed twice. The second call has no effect if for a second time. However, when the socket has already been closed, this second call does nothing.

When performing asynchronous IOI/O, 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.

A boolean flag can be used (as shown earlier) if additional operations need to 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 IO 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 interrupt interrupted status is also set.

Code Block

bgColor	#ccccff


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                   throws IOException, InterruptedException {
    SocketReader reader = new SocketReader("somehost", 25);
    Thread thread = new Thread(reader);
    thread.start();
    Thread.sleep(1000);
    thread.interrupt();
  }
}

This 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.

Code Block

bgColor	#FFcccc


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

Other than helping thread cancellation, a mechanism to close connections also prevents thread starvation because threads can be allowed to fairly share 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 sockets.

Unfortunately database connections, like sockets, are not inherently interruptible. So this design does not permit a client Database connections, like sockets, 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.

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.

Code Block

bgColor	#ccccff


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 codednew forThreadLocal<Connection>() brevity{
      Connection  connection = DriverManager.getConnectionnull;

    @Override public Connection initialValue() {
  ("jdbc:driver:name", "username", "password");  	try {
   	     // ...
        }connection catch= DriverManager.getConnection(SQLException
 e) {
        // Forward to handler "jdbc:driver:name", 
      }
      return connection;"username", 
    }
		
    @Override public void set(Connection con) { "password"
      if(connection == null);
 { // Shuts down connection when} nullcatch value(SQLException ise) passed{
 		       
// Forward to handler
     try {}
         return connection.close();
    }
  };

  }public catchConnection getConnection(SQLException e) {
    return connectionHolder.get();
  }

  public boolean cancelStatement() { // ForwardAllows client to handlercancel statement
    Statement tmpStmt = stmt;
 }	   if (tmpStmt != null) 		{
      try {
      } else { tmpStmt.cancel();
        connectionreturn = contrue; 
      } catch (SQLException e) {
    }    // Forward to handler
      };

  public static Connection getConnection() { }
    return connectionHolder.get()false;
  }

  @Override public static void shutdownConnectionrun() {
 // Allows client try to{
 close connection anytime
   if connectionHolder.set((getConnection() != null);
  }
{
  public void run() {
    Connection dbConnectionstmt = getConnection().createStatement();
    Statement stmt;
    try {}
      if (stmt = dbConnection.createStatement();		= null || (stmt.getConnection() != getConnection())) {
        throw new IllegalStateException();
      }
      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.

Rule	Severity	Likelihood	Remediation Cost	Priority	Level
CON24- J	low	probable	medium	P4	L3

Automated Detection

TODO

Related Vulnerabilities

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

References

Wiki Markup

\[[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.

Rule	Severity	Likelihood	Remediation Cost	Priority	Level
THI04-J	Low	Probable	Medium	P4	L3

Bibliography

[API 2014]	Class `Thread` Interface `ExecutorService` Interface `Statement`
[Darwin 2004]	Section 24.3, "Stopping a Thread"
[Goetz 2006]	Chapter 7, "Cancellation and Shutdown"
[JavaThreads 2004]	Section 2.4, "Two Approaches to Stopping a Thread"
[JDK7 2008]	Java Thread Primitive Deprecation
[JPL 2006]	Section 14.12.1, "Don't Stop" Section 23.3.3, "Shutdown Strategies"

...

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

Space shortcuts

Page tree

Versions Compared

Old Version 13

New Version Current

Key

Noncompliant Code Example (

Blocking I/O, Volatile Flag)

Noncompliant Code Example (

Blocking I/O, Interruptible)

Compliant Solution (

Close Socket Connection)

Compliant Solution (

Interruptible Channel)

Noncompliant Code Example (

Database Connection)

Compliant Solution (

`Statement.cancel()`)

Risk Assessment

Automated Detection

Related Vulnerabilities

References

Risk Assessment

Bibliography

Space shortcuts

Page tree

Page History

Versions Compared

Old Version 13

New Version Current

Key

Noncompliant Code Example (

Blocking I/O, Volatile Flag)

Noncompliant Code Example (

Blocking I/O, Interruptible)

Compliant Solution (

Close Socket Connection)

Compliant Solution (

Interruptible Channel)

Noncompliant Code Example (

Database Connection)

Compliant Solution (

Statement.cancel())

Risk Assessment

Automated Detection

Related Vulnerabilities

References

Risk Assessment

Bibliography

`Statement.cancel()`)