Security Exception

El Gestor de Seguridad

El gestor de seguridad de Java consiste en una “aplicación” que determina si ciertas operaciones potencialmente peligrosas deben o no ser permitidas: las distintas clases de Java interactuarán con el gestor de seguridad para determinar si una determinada operación debe o no ser permitida. Cada aplicación Java puede tener su propio gestor de seguridad. La clase Security Manager? (incluida en el paquete java.lang) es una clase abstracta que proporciona el interface y una implementación parcial para todos los gestores de seguridad.

Por defecto, las aplicaciones no disponen de gestor de seguridad. Es decir, el runtime de Java no crea automáticamente un gestor de seguridad, por lo que las aplicaciones podrán, en principio, acceder a cualquier tipo de operacion (aunque dicha operación esté sujeta a restricciones de seguridad).

Para modificar este comportamiento, las aplicaciones deben crear e instalar su propio gestor de seguridad.

  Los actuales paginadores y visualizadores de applets crean sus propios gestores de seguridad cuando arrancan, por lo que los applets allí ejecutados estarán “controlados” por los mismos. 

Creación de un gestor de seguridad: para crear un gestor de seguridad es necesario crear una subclase de la clase Security Manager. Dicha subclase sobrecargará varios métodos de la clase Security Manager, de modo que su comportamiento se adapte a las necesidades de la aplicación.

class New Security Manager? extends Security Manager { … }

En la siguiente tabla se muestran los métodos que se pueden sobrecargar (todos de la forma checkXXX()), dependiendo de las operaciones sobre las que queremos que el gestor de seguridad imponga restricciones.

  Operaciones sobre                    Aprobado por 

sockets checkAccept(String host, int port)

                       checkConnect(String host, int port) 
                 checkConnect(String host,int port,        executionContext) 
 checkListen(int port) 

threadscheckPackage checkAccess(Thread thread)

                      checkAccess(Thread Group? threadgroup) 

cargador de clases checkCreateClassLoader() sistema de ficheros checkDelete(String filename)

         checkLink(String library) 
           checkRead(File Descriptor? filedescriptor) 
             checkRead(String Filename) 
       checkRead(String filename, Object executionContext) 
             checkWrite(File Descriptor filedescriptor) 
                checkWrite(String filename) 

comandos del sistema checkExec(String comando) interprete checkExit(int status) paquetes checkPackageAccess(String nombrePaquete)

               checkPackageDefinition(String packageName) 

propiedades checkPropertiesAccess()

                       checkPropertyAccess(String key) 
              checkPropertyAccess(String key, String def) 

networking checkSetfactory() ventanas checkTopLevelWindow(Object ventana)

Dependiendo de la aplicación, se pueden sobrecargar algunos o todos los métodos. La implementación por defecto proporcionada por la clase Security Manager para todos los métodos es:

public void checkXXX(…) { throw new Security Exception(); }

Es decir, básicamente lo que hace es desabilitarlo todo.

 Hay que tener en cuenta todas las posibles situaciones en las que los métodos checkXXX() son llamados. Por ejemplo, el método checkAccess(Thread Group g) es invocado cada vez que se crea un grupo de “threads”, cuando se selecciona su “daemon de estado”, cuando se para, etc. Por lo tanto, es necesario asegurarse de que se conocen perfectamente todas las situaciones en las que un método de comprobación de seguridad puede ser invocado. 

Ejemplo: Veamos un ejemplo en el que el gestor de seguridad restringe el acceso, tanto de lectura como de escritura, al sistema de ficheros. La política seguida en nuestro ejemplo consiste en pedir una palabra-clave cada vez que se quiera acceder a algún fichero: si la palabra-clave es la correcta, el acceso es permitido.

import java.io.*; public class Password Security Manager? extends Security Manager {

    private String password; 
    private Buffered Reader buffy; 

    /* Constructor del gestor de seguridad */ 

    public Password Security Manager(String p, Buffered Reader b) { 
        super(); 
        this.password = p; /* Seleccionamos el password */ 
        this.buffy = b; /* Seleccionamos el fichero */ 
    } 


    /* Métodos de comprobación sobrecargados */ 

    public void checkRead(File Descriptor filedescriptor) { 
        if (!accessOK()) 
            throw new Security Exception(“Not a Chance!”); 
    } 
    public void checkRead(String filename) { 
        if (!accessOK()) 
            throw new Security Exception(“No Way!”); 
    } 
    public void checkRead(String filename, Object executionContext) { 
        if (!accessOK()) 
            throw new Security Exception(“Forget It!”); 
    } 
    public void checkWrite(File Descriptor filedescriptor) { 
        if (!accessOK()) 
            throw new Security Exception(“Not!”); 
    } 
    public void checkWrite(String filename) { 
        if (!accessOK()) 
            throw new Security Exception(“Not Even!”); 
    } 
    public void checkPropertyAccess(String s) { } 
    public void checkPropertiesAccess() { } 


    /* ============================== */ 

    private boolean accessOK() { 
        int c; 
        String response; 

        System.out.println(“What’s the secret password?”); 
        try { 
            response = buffy.readLine(); 
            if (response.equals(password)) 
                return true; 
            else 
                return false; 
        } catch (IO Exception? e) { 
            return false; 
        } 
    } 

}