Methods can return values to communicate failure or success or to update local objects or fields. Security risks can arise when method return values are ignored or when the invoking method fails to take suitable action. Consequently, programs must not ignore method return values.
When getter methods are named after an action, a programmer could fail to realize that a return value is expected. For example, the only purpose of the ProcessBuilder.redirectErrorStream()
method is to report via return value whether the process builder successfully merged standard error and standard output. The method that actually performs redirection of the error stream is the overloaded single-argument method ProcessBuilder.redirectErrorStream(boolean)
.
This noncompliant code example attempts to delete a file but fails to check whether the operation has succeeded:
public void deleteFile(){ File someFile = new File("someFileName.txt"); // Do something with someFile someFile.delete(); } |
This compliant solution checks the Boolean value returned by the delete()
method and handles any resulting errors:
public void deleteFile(){ File someFile = new File("someFileName.txt"); // Do something with someFile if (!someFile.delete()) { // Handle failure to delete the file } } |
This noncompliant code example ignores the return value of the String.replace()
method, failing to update the original string. The String.replace()
method cannot modify the state of the String
(because String
objects are immutable); rather, it returns a reference to a new String
object containing the modified string.
public class Replace { public static void main(String[] args) { String original = "insecure"; original.replace('i', '9'); System.out.println(original); } } |
It is especially important to process the return values of immutable object methods. Although many methods of mutable objects operate by changing some internal state of the object, methods of immutable objects cannot change the object and often return a mutated new object, leaving the original object unchanged.
This compliant solution correctly updates the String
reference original
with the return value from the String.replace()
method:
public class Replace { public static void main(String[] args) { String original = "insecure"; original = original.replace('i', '9'); System.out.println(original); } } |
Ignoring method return values can lead to unexpected program behavior.
Rule | Severity | Likelihood | Remediation Cost | Priority | Level |
---|---|---|---|---|---|
EXP00-J | Medium | Probable | Medium | P8 | L2 |
Tool | Version | Checker | Description |
---|---|---|---|
CodeSonar | JAVA.NULL.RET.UNCHECKED | Call Might Return Null (Java) | |
Coverity | 7.5 | CHECKED_RETURN | Implemented |
Parasoft Jtest | CERT.EXP00.NASSIG CERT.EXP00.AECB | Ensure method and constructor return values are used Avoid "try", "catch" and "finally" blocks with empty bodies | |
PVS-Studio | V6010, V6101 | ||
SonarQube | Return values from functions without side effects should not be ignored Return values should not be ignored when they contain the operation status code | ||
SpotBugs | RV_RETURN_VALUE_IGNORED | Implemented |
VOID EXP12-CPP. Do not ignore values returned by functions or methods | |
Passing Parameters and Return Values [CSJ] | |
CWE-252, Unchecked Return Value |
[API 2006] | |
Misusing | |
[Seacord 2015] |