Many programs accept untrusted data originating from unvalidated users, network connections, and other untrusted sources and then pass the (modified or unmodified) data across a trust boundary to a different trusted domain. Frequently the data is in the form of a string with some internal syntactic structure, which the subsystem must parse. Such data must be sanitized , both because the subsystem may be unprepared to handle the malformed input and because unsanitized input may include an injection attack.

In particular, programs must sanitize all string data that is passed to command interpreters or parsers so that the resulting string is innocuous in the context in which it will be is parsed or interpreted.

Many command interpreters and parsers provide their own sanitization and validation methods. When available, their use is preferred over custom sanitization techniques because homegrown custom developed sanitization can often neglect special cases or hidden complexities in the parser. Another problem with custom sanitization code is that it may not be adequately maintained when new capabilities are added to the command interpreter or parser software.

SQL Injection

An A SQL injection vulnerability arises when the original SQL query can be altered to form an altogether different query. Execution of this altered query may result in information leaks or data modification. The primary means of preventing SQL injection are sanitizing and validating untrusted input and parameterizing the queryqueries.

Suppose a database contains user names and passwords used to authenticate users of the system. The user names have a string size limit of 8. The passwords have a size limit of 20.

An A SQL command to authenticate a user might take the form:

...

However, if an attacker can substitute any arbitrary strings for <USERNAME> and <PASSWORD>, they can perform an a SQL injection by using the following string for <USERNAME>:

...

SELECT * FROM db_user WHERE username='validuser' OR '1'='1' AND password=<PASSWORD>

If validuser is actually a valid user name, this SELECT statement will select selects the validuser record in the table. The reason the password is never checked is because username='validuser' is true; consequently the items after the OR are not tested. As long as the components after the OR generate a syntactically correct SQL expression, the attacker is granted the access of validuser.

...

SELECT * FROM db_user WHERE username='anything' AND password='' OR '1'='1'

This time, the '1'='1' tautology disables both user name and password validation, and the attacker is falsely logged in without knowing a correct login ID or password.

Noncompliant Code Example

...

Unfortunately, this code example permits an a SQL injection attack because the SQL statement sqlString accepts unsanitized input arguments. The attack scenario outlined above previously would work as described.

class Login {
  public Connection getConnection() throws SQLException {
    DriverManager.registerDriver(new
            com.microsoft.jdbc.sqlserver.jdbc.SQLServerDriver());
    String dbConnection = 
      PropertyManager.getProperty("db.connection");
    // can hold some value like
    // "jdbc:microsoft:sqlserver://<HOST>:1433,<UID>,<PWD>"
    return DriverManager.getConnection(dbConnection);
  }

  String hashPassword(char[] password) {
    // create hash of password
  }

  public void doPrivilegedAction(String username, char[] password)
  throws SQLException {
    Connection connection = getConnection();
    if (connection == null) {
      // handle error
    }
    try {
      String pwd = hashPassword(password);

    String  String sqlString = "SELECT * FROM db_user WHERE username = '" 
                         + username +
                         "' AND password = '" + pwd + "'";
      Statement stmt = connection.createStatement();
      ResultSet rs = stmt.executeQuery(sqlString);

      if (!rs.next()) {
    	    throw new SecurityException(
          "User name or password incorrect"
        );
      }

      // Authenticated; proceed
    }
}

This code example also does not address how to safely shut down the connection. For information on how to do this, see rule FIO04-J. Close resources when they are no longer needed.

Compliant Solution (PreparedStatement)

 finally {
      try {
        connection.close();
      } catch (SQLException x) {
        // forward to handler
      }
    }
  }
}

Compliant Solution (PreparedStatement)

Fortunately, the JDBC library provides an Fortunately, the JDBC library provides an API for building SQL commands that sanitize untrusted data. The java.sql.PreparedStatement class properly escapes input strings, preventing SQL injection when used properly. This is an example of component-based sanitization.

This compliant solution modifies the doPrivilegedAction() method to use a PreparedStatement instead of java.sql.Statement. This code also validates the length of the username argument, preventing an attacker from submitting an arbitrarily long user name.

This compliant solution modifies the doPrivilegedAction() method to use a PreparedStatement instead of java.sql.Statement. This code also validates the length of the username argument, preventing an attacker from submitting an arbitrarily long user name.

  public void doPrivilegedAction(
    String username, char[] password
  ) throws SQLException {
    Connection connection = getConnection();
    if (connection == null) {
      // handle error
    }
    try {
      String pwd = hashPassword(password);

      // Ensure that the length of user name is legitimate
      if ((username.length() > 8) {
        // Handle error
      }

      String sqlString = 
        "select * from db_user where username=? and password=?";
      PreparedStatement stmt = connection.prepareStatement(sqlString);

  public void doPrivilegedAction(String username, char[] password) throws SQLException {
    Connection connection = getConnection();
    if (connection == null) {
      // handle errorstmt.setString(1, username);
    }
    String pwd = hashPassword(passwordstmt.setString(2, pwd);

    // Ensure that the length of userResultSet namers is legitimate
= stmt.executeQuery();
      if (username!rs.lengthnext() > 8) {
      // Handle error
throw new SecurityException("User name }

or    String sqlString = "select * from db_user where username=? and password=?";password incorrect");
      }

    PreparedStatement  stmt// = connection.prepareStatement(sqlString);
Authenticated, proceed
     stmt.setString(1, username);} finally {
    stmt.setString(2, pwd);  try {
    ResultSet  rs = stmtconnection.executeQueryclose();
    if  } catch (!rs.next())SQLException x) {
      throw new SecurityException("User name or password incorrect"); // forward to handler
      }

    // Authenticated; proceed}
  }

Use the set*() methods of the PreparedStatement class to enforce strong type checking. This mitigates the SQL injection vulnerability because the input is properly escaped by automatic entrapment within double quotes. Note that prepared statements must be used even with queries that insert data into the database.

This code example also does not address how to safely shut down the connection. For information on how to do this, see rule FIO04-J. Close resources when they are no longer needed.

XML Injection

Because of its platform independence, flexibility, and relative simplicity, the extensible markup language (XML) has found use in applications ranging from remote procedure calls to systematic storage, exchange, and retrieval of data. However, because of its versatility, XML is vulnerable to a wide spectrum of attacks. One such attack is called XML Injectioninjection.

A user who has the ability to provide structured XML as input can override the contents of an XML document by injecting XML tags in data fields. These tags are interpreted and classified by an XML parser as executable content and, as a result, may cause certain data members to be overridden.

...

A malicious user might input the following string instead of a simple number in the quantity field.

1</quantity><price>1<quantity><price>1.0</price><quantity>1

Consequently, the XML resolves to the following block:

<item>
  <description>Widget</description>
  <price>500.0</price>
  <quantity>1</quantity><price>1.0</price><quantity>1</quantity>
</item>

A Simple API for XML (SAX) parser (org.xml.sax and javax.xml.parsers.SAXParser) interprets the above XML such that the second price field overrides the first, leaving the price of the item as $1. Even when it is not possible to perform such an attack, the attacker may be able to inject special characters, such as comment blocks and CDATA delimiters, which distort corrupt the meaning of the XML.

Noncompliant Code Example

...

private void createXMLStream(BufferedOutputStream outStream, String quantity)
 
                             String quantity) throws IOException {
  String xmlString;
  xmlString = "<item>\n<description>Widget</description>\n<price>500n" +
              "<price>500.0</price>\n" +
              "<quantity>" + quantity + "</quantity></item>";
  outStream.write(xmlString.getBytes());
  outStream.flush();
}

...

Depending on the specific data and command interpreter or parser to which data is being sent, appropriate methods must be used to sanitize untrusted user input. This compliant solution uses whitelisting to sanitize the input. In this compliant solution, the method requires that the quantity field must be a number between 0 and 9.

private void createXMLStream(BufferedOutputStream outStream, 
                  
private void createXMLStream(BufferedOutputStream outStream, String quantity)
           String quantity) throws IOException {
  // Write XML string if quantity contains numbers only (whitelisting).
  // Blacklisting of invalid characters can alsobe performed 
 be done// in conjunction.

  if (!Pattern.matches("[0-9]+", quantity)) {
    // Format violation
  }

  String xmlString = "<item>\n<description>Widget</description>\n<price>500</
  String xmlString = "<item>\n<description>Widget</description>\n" +
                     "<price>500</price>\n" +
                     "<quantity>" + quantity + "</quantity></item>";
  outStream.write(xmlString.getBytes());
  outStream.flush();
}

...

A more general mechanism for checking XML for attempted injection is to validate it using a Document Type Definition (DTD) or schema. The schema must be rigidly defined to prevent injections from being mistaken for valid XML. Here is a suitable schema for validating our XML snippet:

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="item">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="description" type="xs:string"/>
      <xs:element name="price" type="xs:decimal"/>
      <xs:element name="quantity" type="xs:integer"/>      
    </xs:sequence>
  </xs:complexType>
</xs:element>
</xs:schema>

This compliant code example employs this schema to prevent XML injection from succeeding. The schema is avaialble as the file schema.xsd. It also relies on the CustomResolver class to prevent XXE attacks. This class, as well as XXE attacks, are described in the subsequent code examples.

private void createXMLStream(BufferedOutputStream outStream,
                             String quantity) throws IOException {
  String xmlString;
  xmlString = "<item>\n<description>Widget</description>\n" +
     throws IOException {
  String xmlString;
  xmlString = "<item>\n<description>Widget</description>\n<price>500<price>500.0</price>\n" +
              "<quantity>" + quantity + "</quantity></item>";
  InputSource xmlStream = new InputSource(
    new StringReader(xmlString)
  );

  // Build a validating SAX parser using our schema
  SchemaFactory sf
    = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
  DefaultHandler defHandler = new DefaultHandler() {
      public void warning(SAXParseException s)
        throws SAXParseException {throw s;}
      public void error(SAXParseException s)
        throws SAXParseException {throw s;}
      public void fatalError(SAXParseException s)
        throws SAXParseException {throw s;}
    };
  StreamSource ss = new StreamSource(new File("schema.xsd"));
  try {
    Schema schema = sf.newSchema(ss);
    SAXParserFactory spf = SAXParserFactory.newInstance();
    spf.setSchema(schema);
    SAXParser saxParser = spf.newSAXParser();
    // To set the custom entity resolver,
    // an XML reader needs to be created
    XMLReader reader = saxParser.getXMLReader(); 
    reader.setEntityResolver(new CustomResolver());
    saxParser.parse(xmlStream, defHandler);
  } catch (ParserConfigurationException x) {
    throw new IOException("Unable to validate XML", x);
  } catch (SAXException x) {
    throw new IOException("Invalid quantity", x);
  }

  // Our XML is valid, proceed
  outStream.write(xmlString.getBytes());
  outStream.flush();
}

Using a schema or DTD to validate XML is handy convenient when receiving XML that may have been loaded with unsanitized input. If such an XML string has not yet been built, then sanitizing input before constructing XML will yield yields better performance.

XML External Entity Attacks (XXE)

An XML document can be dynamically constructed from smaller logical blocks called entities. Entities can be either internal, external, or parameter-based. External entities allow the inclusion of XML data from external files.

...

An attacker may attempt to cause denial of service or program crashes by manipulating the URI of the entity to refer to special files existing on the local file system, for example, by specifying /dev/random or /dev/tty as input URIs. This may crash or block the program indefinitely. This is called an XML External Entity external entity (XXE) attack. Because inclusion of replacement text from an external entity is optional, not all XML processors are vulnerable to external entity attacks.

...

This noncompliant code example attempts to parse the file evil.xml, reports any errors, and exits. However, a SAX or a DOM (Document Object Model) parser will attempt to access the URL specified by the SYSTEM attribute, which means it will attempt to read the contents of the local /dev/tty file. On POSIX systemsystems, reading this file causes the program to block until input data is supplied to the machine's console. Consequently, an attacker can use this malicious XML file to cause the program to hang.

...

This noncompliant code example may also violate rule ERR01-J . Do not allow exceptions to expose sensitive information if the information contained in the exceptions is considered sensitive.

Compliant Solution (EntityResolver)

...

class CustomResolver implements EntityResolver {
  public InputSource resolveEntity(String publicId, String systemId)
    throws SAXException, IOException {

    // check for known good entities
    String entityPath = "/home/username/java/xxe/file";
    if (systemId.equals(entityPath)) {
      System.out.println("Resolving entity: " + publicId +
                         " " + systemId);
      return new InputSource(entityPath);
    } else {
      return new InputSource(); // Disallow unknown entities
                                // by returning a blank path
    }
  }
}

class XXE {
  private static void receiveXMLStream(InputStream inStream,
                                       DefaultHandler defaultHandler)
      throws ParserConfigurationException, SAXException, IOException {
    SAXParserFactory factory = SAXParserFactory.newInstance();
    SAXParser saxParser = factory.newSAXParser();

    // To set the Entity Resolver, an XML reader needs to be created
    XMLReader reader = saxParser.getXMLReader();
    reader.setEntityResolver(new CustomResolver());
    reader.setErrorHandler(defaultHandler);

    InputSource is = new InputSource(inStream);
    reader.parse(is);
  }

  public static void main(String[] args)
      throws ParserConfigurationException, SAXException, IOException {
    receiveXMLStream(new FileInputStream("evil.xml"), 
                     new DefaultHandler());
  }
}

...

Failure to sanitize user input before processing or storing it can lead to result in injection attacks.

Related

...

CERT C Secure Coding Standard

...

STR02-C. Sanitize data passed to complex subsystems

...

CERT C++ Secure Coding Standard

...

STR02-CPP. Sanitize data passed to complex subsystems

Vulnerabilities

CVE-2008-2370

...

| describes a vulnerability in Apache Tomcat 4.1.0 through 4.1.37, 5.5.0 through 5.5.26, and 6.0.0 through 6.0.16. When a RequestDispatcher is used, Tomcat performs path normalization before removing the query string from the URI, which allows remote attackers to conduct directory traversal attacks and read arbitrary files via a .. (dot dot) in a request parameter.

Related Guidelines

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

...

...