Sections

• Page:
  Rule 00. Input Validation and Data Sanitization (IDS)
• Page:
  Rule 01. Declarations and Initialization (DCL)
• Page:
  Rule 02. Expressions (EXP)
• Page:
  Rule 03. Numeric Types and Operations (NUM)
• Page:
  Rule 04. Characters and Strings (STR)
• Page:
  Rule 05. Object Orientation (OBJ)
• Page:
  Rule 06. Methods (MET)
• Page:
  Rule 07. Exceptional Behavior (ERR)
• Page:
  Rule 08. Visibility and Atomicity (VNA)
• Page:
  Rule 09. Locking (LCK)
• Page:
  Rule 10. Thread APIs (THI)
• Page:
  Rule 11. Thread Pools (TPS)
• Page:
  Rule 12. Thread-Safety Miscellaneous (TSM)
• Page:
  Rule 13. Input Output (FIO)
• Page:
  Rule 14. Serialization (SER)
• Page:
  Rule 15. Platform Security (SEC)
• Page:
  Rule 16. Runtime Environment (ENV)
• Page:
  Rule 17. Java Native Interface (JNI)
• Page:
  Rule 49. Miscellaneous (MSC)
• Page:
  Rule 50. Android (DRD)

Rule Listing

• Page:
  DCL00-J. Prevent class initialization cycles
• Page:
  DCL01-J. Do not reuse public identifiers from the Java Standard Library
• Page:
  DCL02-J. Do not modify the collection's elements during an enhanced for statement
• Page:
  ENV00-J. Do not sign code that performs only unprivileged operations
• Page:
  ENV01-J. Place all security-sensitive code in a single JAR and sign and seal it
• Page:
  ENV02-J. Do not trust the values of environment variables
• Page:
  ENV03-J. Do not grant dangerous combinations of permissions
• Page:
  ENV04-J. Do not disable bytecode verification
• Page:
  ENV05-J. Do not deploy an application that can be remotely monitored
• Page:
  ENV06-J. Production code must not contain debugging entry points
• Page:
  ERR00-J. Do not suppress or ignore checked exceptions
• Page:
  ERR01-J. Do not allow exceptions to expose sensitive information
• Page:
  ERR02-J. Prevent exceptions while logging data
• Page:
  ERR03-J. Restore prior object state on method failure
• Page:
  ERR04-J. Do not complete abruptly from a finally block
• Page:
  ERR05-J. Do not let checked exceptions escape from a finally block
• Page:
  ERR06-J. Do not throw undeclared checked exceptions
• Page:
  ERR07-J. Do not throw RuntimeException, Exception, or Throwable
• Page:
  ERR08-J. Do not catch NullPointerException or any of its ancestors
• Page:
  ERR09-J. Do not allow untrusted code to terminate the JVM
• Page:
  EXP00-J. Do not ignore values returned by methods
• Page:
  EXP01-J. Do not use a null in a case where an object is required
• Page:
  EXP02-J. Do not use the Object.equals() method to compare two arrays
• Page:
  EXP03-J. Do not use the equality operators when comparing values of boxed primitives
• Page:
  EXP04-J. Do not pass arguments to certain Java Collections Framework methods that are a different type than the collection parameter type
• Page:
  EXP05-J. Do not follow a write by a subsequent write or read of the same object within an expression
• Page:
  EXP06-J. Expressions used in assertions must not produce side effects
• Page:
  EXP07-J. Prevent loss of useful data due to weak references
• Page:
  FIO00-J. Do not operate on files in shared directories
• Page:
  FIO01-J. Create files with appropriate access permissions
• Page:
  FIO02-J. Detect and handle file-related errors
• Page:
  FIO03-J. Remove temporary files before termination
• Page:
  FIO04-J. Release resources when they are no longer needed
• Page:
  FIO05-J. Do not expose buffers created using the wrap() or duplicate() methods to untrusted code
• Page:
  FIO06-J. Do not create multiple buffered wrappers on a single byte or character stream
• Page:
  FIO07-J. Do not let external processes block on IO buffers
• Page:
  FIO08-J. Distinguish between characters or bytes read from a stream and -1
• Page:
  FIO09-J. Do not rely on the write() method to output integers outside the range 0 to 255
• Page:
  FIO10-J. Ensure the array is filled when using read() to fill an array
• Page:
  FIO11-J. Do not convert between strings and bytes without specifying a valid character encoding
• Page:
  FIO12-J. Provide methods to read and write little-endian data
• Page:
  FIO13-J. Do not log sensitive information outside a trust boundary
• Page:
  FIO14-J. Perform proper cleanup at program termination
• Page:
  FIO15-J. Do not reset a servlet's output stream after committing it
• Page:
  FIO16-J. Canonicalize path names before validating them
• Page:
  IDS00-J. Prevent SQL injection
• Page:
  IDS01-J. Normalize strings before validating them
• Page:
  IDS02-J. Canonicalize path names before validating them
• Page:
  IDS03-J. Do not log unsanitized user input
• Page:
  IDS04-J. Safely extract files from ZipInputStream
• Page:
  IDS05-J. Use a safe subset of ASCII for file and path names
• Page:
  IDS06-J. Exclude unsanitized user input from format strings
• Page:
  IDS07-J. Sanitize untrusted data passed to the Runtime.exec() method
• Page:
  IDS08-J. Sanitize untrusted data included in a regular expression
• Page:
  IDS09-J. Specify an appropriate locale when comparing locale-dependent data
• Page:
  IDS10-J. Don't form strings containing partial characters
• Page:
  IDS11-J. Perform any string modifications before validation
• Page:
  IDS13-J. Use compatible character encodings on both sides of file or network IO
• Page:
  IDS14-J. Do not trust the contents of hidden form fields
• Page:
  IDS15-J. Do not allow sensitive information to leak outside a trust boundary
• Page:
  IDS16-J. Prevent XML Injection
• Page:
  IDS17-J. Prevent XML External Entity Attacks
• Page:
  JNI00-J. Define wrappers around native methods
• Page:
  JNI01-J. Safely invoke standard APIs that perform tasks using the immediate caller's class loader instance (loadLibrary)
• Page:
  JNI02-J. Do not assume object references are constant or unique
• Page:
  JNI03-J. Do not use direct pointers to Java objects in JNI code
• Page:
  JNI04-J. Do not assume that Java strings are null-terminated
• Page:
  LCK00-J. Use private final lock objects to synchronize classes that may interact with untrusted code
• Page:
  LCK01-J. Do not synchronize on objects that may be reused
• Page:
  LCK02-J. Do not synchronize on the class object returned by getClass()
• Page:
  LCK03-J. Do not synchronize on the intrinsic locks of high-level concurrency objects
• Page:
  LCK04-J. Do not synchronize on a collection view if the backing collection is accessible
• Page:
  LCK05-J. Synchronize access to static fields that can be modified by untrusted code
• Page:
  LCK06-J. Do not use an instance lock to protect shared static data
• Page:
  LCK07-J. Avoid deadlock by requesting and releasing locks in the same order
• Page:
  LCK08-J. Ensure actively held locks are released on exceptional conditions
• Page:
  LCK09-J. Do not perform operations that can block while holding a lock
• Page:
  LCK10-J. Use a correct form of the double-checked locking idiom
• Page:
  LCK11-J. Avoid client-side locking when using classes that do not commit to their locking strategy
• Page:
  MET00-J. Validate method arguments
• Page:
  MET01-J. Never use assertions to validate method arguments
• Page:
  MET02-J. Do not use deprecated or obsolete classes or methods
• Page:
  MET03-J. Methods that perform a security check must be declared private or final
• Page:
  MET04-J. Do not increase the accessibility of overridden or hidden methods
• Page:
  MET05-J. Ensure that constructors do not call overridable methods
• Page:
  MET06-J. Do not invoke overridable methods in clone()
• Page:
  MET07-J. Never declare a class method that hides a method declared in a superclass or superinterface
• Page:
  MET08-J. Preserve the equality contract when overriding the equals() method
• Page:
  MET09-J. Classes that define an equals() method must also define a hashCode() method
• Page:
  MET10-J. Follow the general contract when implementing the compareTo() method
• Page:
  MET11-J. Ensure that keys used in comparison operations are immutable
• Page:
  MET12-J. Do not use finalizers
• Page:
  MET13-J. Do not assume that reassigning method arguments modifies the calling environment
• Page:
  MSC00-J. Use SSLSocket rather than Socket for secure data exchange
• Page:
  MSC01-J. Do not use an empty infinite loop
• Page:
  MSC02-J. Generate strong random numbers
• Page:
  MSC03-J. Never hard code sensitive information
• Page:
  MSC04-J. Do not leak memory
• Page:
  MSC05-J. Do not exhaust heap space