Cuando se hace una comparación con NaN, siempre se evalúa como false, excepto en el caso del operador !=, que siempre se evalúa como true, puesto que NaN no está ordenado.

Ejemplo 1: el siguiente ejemplo intenta asegurarse de que una variable no es NaN.

  ...
  if (result == Double.NaN){
    //something went wrong
    throw new RuntimeException("Something went wrong, NaN found");
  }
  ...

Así se intenta comprobar que result no es NaN. Sin embargo, si se utiliza el operador == con NaN siempre da como resultado un valor de false, así que esta comprobación nunca produce la excepción.

Cuando el constructor llama a una función que se puede sobrescribir, el usuario malintencionado puede tener acceso a la referencia de this antes de que el objeto se inicialice por completo, lo que a su vez puede suponer vulnerabilidad.

Ejemplo 1: el siguiente ejemplo llama a un método que se puede sobrescribir.

  ...
  class User {
    private String username;
    private boolean valid;
    public User(String username, String password){
      this.username = username;
      this.valid = validateUser(username, password);
    }
    public boolean validateUser(String username, String password){
      //validate user is real and can authenticate
      ...
    }
    public final boolean isValid(){
      return valid;
    }
  }

Como la función validateUser y la clase no son final, significa que se pueden sobrescribir y, en consecuencia, al inicializar una variable en la subclase que sobrescribe dicha función, será posible eludir la funcionalidad validateUser. Por ejemplo:

  ...
  class Attacker extends User{
    public Attacker(String username, String password){
      super(username, password);
    }
    public boolean validateUser(String username, String password){
      return true;
    }
  }
  ...
  class MainClass{
    public static void main(String[] args){
      User hacker = new Attacker("Evil", "Hacker");
      if (hacker.isValid()){
        System.out.println("Attack successful!");
      }else{
        System.out.println("Attack failed");
      }
    }
  }

El código en el Example 1 imprime "¡Ataque satisfactorio!" porque la clase Attacker sobrescribe la función validateUser(), llamada desde el constructor de la superclase User, y Java comprobará primero la subclase en busca de funciones llamadas desde el constructor.

Los usuarios malintencionados pueden duplicar deliberadamente nombres de clase para hacer que un programa ejecute código malicioso. Por este motivo, los nombres de clase no son buenos identificadores de tipo y no deben usarse como fundamento para otorgar confianza a un objeto determinado.

Ejemplo 1: El siguiente código determina si confiar o no en una entrada de un objeto inputReader en función de su nombre de clase. Si un usuario malintencionado es capaz de suministrar una implementación de inputReader que ejecute comandos maliciosos, el código no puede diferenciar entre las versiones benignas y maliciosas del objeto.

if (inputReader.getClass().getName().equals("com.example.TrustedClass")) {
   input = inputReader.getInput();
   ...
}

Este campo ha sido anotado con FortifyNonNegative, que se usa para indicar que los valores negativos no están permitidos.

En PL/SQL, el valor de NULL es indeterminado. No es igual a ningún valor, ni incluso a otro valor NULL. Además, un valor null nunca es igual a otro valor.

Ejemplo 1: la siguiente instrucción siempre será falsa.

checkNull BOOLEAN := x = NULL;

Ejemplo 2: la siguiente instrucción siempre será falsa.

checkNotNull BOOLEAN := x != NULL;

Este programa usa == o != para comparar la igualdad de dos cadenas; es decir, compara la igualdad de dos objetos, no de sus valores. Hay muchas probabilidades de que dos referencias nunca sean iguales.

Ejemplo 1: nunca debe tomarse la siguiente rama.

  if (args[0] == STRING_CONSTANT) {
      logger.info("miracle");
  }

Los operadores == y != solo se comportarán según lo previsto cuando se utilicen para comparar cadenas dentro de objetos iguales. La forma más común para que esto ocurra es que las cadenas sean internas. De este modo, las cadenas se añaden a un grupo de objetos que la clase String mantiene. Una vez que la cadena se interna, todos los usos de dicha cadena emplearán el mismo objeto y los operadores de igualdad se comportarán según lo previsto. Todos los literales de cadena y las constantes con valor de cadena se internan automáticamente. Otras cadenas pueden internarse manualmente llamando String.intern(), lo que devolverá una instancia canónica de la cadena actual, creando una si fuera necesario.

Este campo ha sido anotado con FortifyNonZero, que se usa para indicar que cero no es un valor permitido.