Page History

The write() method, defined in the class java.io.OutputStream, takes an argument of type int intended to be between 0 and the value of which must be in the range 0 to 255. Because a value of type int may well could be outside of this range, failure to range check may lead to can result in the truncation of the higher-order bits of the input.unmigrated-wiki-markupargument.

The general contract for the {{write()}} method says that it writes one byte is written to the output stream. The byte to be written constitutes the eight lower -order bits of the argument {{b}}, passed to the {{write()}} method. The 24 method; the 24 high-order bits of {{b}} are ignored . \[[API 06|AA. Java References#API 06]\](see java.io.OutputStream.write() [API 2014] for more information).

Noncompliant Code Example

The This noncompliant code example accepts a value from the user without validating it. Any value with more than eight bits set that is not in the range of 0 to 255 is truncated. For instance, write(303) prints / on ASCII-based systems because the lower-order 8 bits of 303 are preserved used while the top 24 high-order bits are lost ignored (303 mod % 256 is 47 and / has = 47, which is the ASCII code 47for /). That is, the result is the remainder modulo 256 of the absolute value of the inputinput divided by 256.

class ConsoleWrite {
  public static void main(String[] args) { 
    // Any input value > 255 will result in unexpected output
    System.out.write(Integer.valueOf(args[0].toString()));
    System.out.flush();
  }
}

Compliant Solution

...

(Range-Check Inputs)

This compliant solution prints the corresponding character only if the input integer is in the proper range. If the input is outside the representable range of an int, the Integer.valueOf() method throws a NumberFormatException. If the input can be represented by an int but is outside the range required by write(), this code throws an ArithmeticException

Use alternative means to output integers such as the System.out.print* methods.

class ConsoleWrite {
  public static void main(String[] args) { 
    System.out.println(args[0]);
  }
}

Compliant Solution (2)

Alternatively, perform range checking to be compliant. While this particular solution still does not display the original invalid integer correctly, it behaves well when the corresponding read() method is used to convert the byte back to a value of type int. This is because it guarantees that the byte will contain representable data.

class FileWrite {
  public static void main(String[] args) throws NumberFormatException, IOException { 

              FileOutputStream  out = new FileOutputStream("output.txt");   
    //Perform range checking
    if(Integer.valueOf(args[0]) >= 0 && Integer.valueOf(args[0]) <= 255) {
      out.write(throws NumberFormatException, IOException { 
    // Perform range checking  
    int value = Integer.valueOf(args[0].toString()));
     if System.out.flush();
    }
    else {
      //handle error (value < 0 || value > 255) {
      throw new ArithmeticException("Value is out of range");
    }
  
    System.out.write(value);
    System.out.flush(); 
  }
}

Compliant Solution (

...

writeInt())

In this This compliant solution , uses the writeInt() method of the DataOutputStream class is used. , which can output the entire range of values representable as an int:

class FileWrite {
    public static void main(String[] args) throws NumberFormatException, IOException { 

                   FileOutputStream  out = new FileOutputStream("output.txt");  throws 
NumberFormatException, IOException { 
    DataOutputStream dos = new DataOutputStream(System.out);
      dos.writeInt(Integer.valueOf(args[0].toString()));
      dos.close();
      System.out.closeflush(); 
  }     
}

Risk Assessment

Using the write() method to output integers may outside the range 0 to 255 will result in unexpected valuestruncation.

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]\] method [write()|http://java.sun.com/javase/6/docs/api/java/io/OutputStream.html#write(int)]
\[[Harold 99|AA. Java References#Harold 99]\]

Automated detection of all uses of the write() method is straightforward. Sound determination of whether the truncating behavior is correct is not feasible in the general case. Heuristic checks could be useful.

Related Guidelines

Bibliography

...

Image Added Image Added Image AddedINT30-J. Range check before casting integers to narrower types      06. Integers (INT)      INT33-J. Do not cast numeric types to wider floating-point types without range checking