Many file-related security vulnerabilities result from a program accessing an unintended file object. This often happens because file names are only loosely bound to underlying file objects. File names provide no information regarding the nature of the file object itself. Furthermore, the binding of a file name to a file object is reevaluated each time the file name is used in an operation. This reevaluation can introduce a time-of-check, time-of-use (TOCTOU) race condition into an application. Objects of type
java.io.File and of type
java.nio.file.Path are bound to underlying file objects by the operating system only when the file is accessed.
java.io.File constructors and the
delete() rely solely on file names for file identification. The same holds for the
java.nio.file.Path.get() methods for creating
Path objects and the
delete methods of
java.nio.file.Files. Use all of these methods with caution.
Fortunately, files can often be identified by other attributes in addition to the file name—for example, by comparing file creation time or modification times. Information about a file that has been created and closed can be stored and then used to validate the identity of the file when it is reopened. Comparing multiple attributes of the file increases the likelihood that the reopened file is the same file that was previously opened.
File identification is less crucial for applications that maintain their files in secure directories where they can be accessed only by the owner of the file and (possibly) by a system administrator (see FIO00-J. Do not operate on files in shared directories).
Noncompliant Code Example
In this noncompliant code example, the file identified by the string
filename is opened, processed, closed, and then reopened for reading:
Because the binding between the file name and the underlying file object is reevaluated when the
BufferedReader is created, this code cannot guarantee that the file opened for reading is the same file that was previously opened for writing. An attacker might have replace the original file (with a symbolic link, for example) between the first call to
close() and the subsequent creation of the
Noncompliant Code Example (
In this noncompliant code example, the programmer attempts to ensure that the file opened for reading is the same as the file previously opened for writing by calling the method
Pathobjects are equal then this method returns
truewithout checking if the file exists.
isSameFile() may simply check that the paths to the two files are the same and cannot detect if the file at that path had been replaced by a different file between the two open operations.
Compliant Solution (Multiple Attributes)
This compliant solution checks the creation and last-modified times of the files to increase the likelihood that the file opened for reading is the same file that was written:
Although this solution is reasonably secure, a determined attacker could create a symbolic link with the same creation and last-modified times as the original file. Also, a TOCTOU race condition occurs between the time the file's attributes are first read and the time the file is first opened. Likewise, another TOCTOU condition occurs the second time the attributes are read and the file is reopened.
Compliant Solution (POSIX
In environments that support the
fileKey attribute, a more reliable approach is to check that the
fileKey attributes of the two files are the same. The
fileKey attribute is an object that "uniquely identifies the file" [API 2011], as shown in this compliant solution:
This approach will not work on all platforms. For example, on Windows 7 Enterprise Edition, all
fileKey attributes are null.
The file key returned by the
fileKey() method is guaranteed to be unique only if the file system and files remain static. A file system may reuse an identifier, for example, after a file is deleted. Like the previous compliant solution, there is a TOCTOU race window between the time the file's attributes are first read and the time the file is first opened. Another TOCTOU condition occurs the second time the attributes are read and the file is reopened.
Compliant Solution (
A better approach is to avoid reopening a file. The following compliant solution demonstrates use of a
RandomAccessFile, which can be opened for both reading and writing. Because the file is only closed automatically by the
try-with-resources statement, no race condition can occur.
Noncompliant Code Example (File Size)
This noncompliant code example tries to ensure that the file it opens contains exactly 1024 bytes:
This code is subject to a TOCTOU race condition between when the file size is checked and when the file is opened. If an attacker replaces a 1024-byte file with another file during this race window, he or she can cause this program to open any file, defeating the check.
Compliant Solution (File Size)
This compliant solution uses the
FileChannel.size() method to obtain the file size. Because this method is applied to the
FileInputStream only after the file has been opened, this solution eliminates the race window.
Attackers frequently exploit file-related vulnerabilities to cause programs to access an unintended file. Proper file identification is necessary to prevent exploitation.