Una mala calidad del código lleva a un comportamiento no predecible. Desde la perspectiva de un usuario, muchas veces también supone una usabilidad limitada. Pero para un atacante es una oportunidad para atacar al sistema de formas insospechadas.
NaN
siempre es un error.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.NaN
.
...
if (result == Double.NaN){
//something went wrong
throw new RuntimeException("Something went wrong, NaN found");
}
...
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.this
antes de que el objeto se inicialice por completo, lo que a su vez puede suponer vulnerabilidad.
...
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;
}
}
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");
}
}
}
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.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.GetType().FullName == "CompanyX.Transaction.Monetary")
{
processTransaction(inputReader);
}
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();
...
}
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::class.qualifiedName == "com.example.TrustedClass") {
input = inputReader.getInput()
...
}
x = NULL
y x != NULL
siempre serán falsas.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 2: la siguiente instrucción siempre será falsa.
checkNull BOOLEAN := x = NULL;
checkNotNull BOOLEAN := x != NULL;
equals()
, no con ==
o !=
.==
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.
if (args[0] == STRING_CONSTANT) {
logger.info("miracle");
}
==
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.