Los errores y su tratamiento representan una clase de API. Los errores relacionados con el tratamiento de errores son tan comunes que se merecen una sección por sí mismos. Tal como sucede con los "abusos de la API", hay dos formas de presentar una vulnerabilidad de seguridad relacionada con los errores: la más común es tratar los errores inadecuadamente (o no llegar a hacerlo). La segunda es producir errores que dan demasiada información (a posibles atacantes) o que son difíciles de tratar.
NullPointerException
.NullPointerException
bajo tres circunstancias: NullPointerException
para señalar una condición de error.NullPointerException
.
try {
mysteryMethod();
}
catch (NullPointerException npe) {
}
NullReferenceException
.NullReferenceException
bajo tres circunstancias: NullReferenceException
para señalar una condición de error.NullReferenceException
.
try {
MysteryMethod();
}
catch (NullReferenceException npe) {
}
finally
provocará que las excepciones se pierdan.finally
provocará que todas las excepciones que se puedan lanzar en el bloque try se descarten.MagicException
lanzada por la segunda llamada para doMagic
con true
transferido a ella nunca se entregará al autor de llamada. La instrucción return dentro del bloque finally
provocará que la excepción se descarte.
public class MagicTrick {
public static class MagicException extends Exception { }
public static void main(String[] args) {
System.out.println("Watch as this magical code makes an " +
"exception disappear before your very eyes!");
System.out.println("First, the kind of exception handling " +
"you're used to:");
try {
doMagic(false);
} catch (MagicException e) {
// An exception will be caught here
e.printStackTrace();
}
System.out.println("Now, the magic:");
try {
doMagic(true);
} catch (MagicException e) {
// No exception caught here, the finally block ate it
e.printStackTrace();
}
System.out.println("tada!");
}
public static void doMagic(boolean returnFromFinally)
throws MagicException {
try {
throw new MagicException();
}
finally {
if (returnFromFinally) {
return;
}
}
}
}
finally
provocará que las excepciones se pierdan.finally
provocará que todas las excepciones que se puedan lanzar en el bloque try se descarten.exception
lanzada por la segunda llamada para doMagic
con True
transferido a ella nunca se entregará al autor de llamada. La instrucción RETURN dentro del bloque finally
provocará que la excepción se descarte."disappear before your very eyes!" . PHP_EOL;
echo "First, the kind of exception handling " .
"you're used to:" . PHP_EOL;
try {
doMagic(False);
} catch (exception $e) {
// An exception will be caught here
echo $e->getMessage();
}
echo "Now, the magic:" . PHP_EOL;
try {
doMagic(True);
} catch (exception $e) {
// No exception caught here, the finally block ate it
echo $e->getMessage();
}
echo "Tada!" . PHP_EOL;
function doMagic($returnFromFinally) {
try {
throw new Exception("Magic Exception" . PHP_EOL);
}
finally {
if ($returnFromFinally) {
return;
}
}
}
?>
ThreadDeath
no se vuelve a lanzar, el subproceso en cuestión podría no acabar.ThreadDeath
solo deben filtrarse si una aplicación tiene que limpiar después de finalizar de forma asíncrona. Si se filtra un error ThreadDeath
, es importante que se vuelva a lanzar para que el subproceso finalice realmente. El propósito de lanzar ThreadDeath
es detener un subproceso. Si ThreadDeath
es absorbido, puede impedir que un subproceso se detenga y dé lugar a un comportamiento inesperado, puesto que quien haya lanzado originalmente ThreadDeath
espera que el subproceso se detenga.ThreadDeath
, pero no lo vuelve a lanzar.
try
{
//some code
}
catch(ThreadDeath td)
{
//clean up code
}
throw
dentro de un bloque finally
rompe la progresión lógica de try-catch-finally
.finally
siempre se ejecutan después de su bloque try-catch
correspondiente y se utilizan frecuentemente para liberar recursos asignados, como controladores de archivos o cursores de base de datos. Lanzar una excepción en un bloque finally
puede derivar el código de limpieza crítico, puesto que la ejecución normal del programa se interrumpirá. stmt.close()
se deriva cuando se lanza la FileNotFoundException
.
public void processTransaction(Connection conn) throws FileNotFoundException
{
FileInputStream fis = null;
Statement stmt = null;
try
{
stmt = conn.createStatement();
fis = new FileInputStream("badFile.txt");
...
}
catch (FileNotFoundException fe)
{
log("File not found.");
}
catch (SQLException se)
{
//handle error
}
finally
{
if (fis == null)
{
throw new FileNotFoundException();
}
if (stmt != null)
{
try
{
stmt.close();
}
catch (SQLException e)
{
log(e);
}
}
}
}
javax.net.ssl.SSLHandshakeException
, javax.net.ssl.SSLKeyException
y javax.net.ssl.SSLPeerUnverifiedException
transmiten errores importantes relacionados con una conexión SSL. Si estos errores no se administran explícitamente, la conexión puede dejarse en un estado inesperado y potencialmente inseguro.