Joven hacker sonriendo

Hackeamos su software

cero falsos positivos

Inteligencia experta + automatización eficaz

Crear permisos personalizados

Nuestros ethical hackers explican que son los permisos y la importancia de estos a la hora de controlar y proteger la información. Además, mediante un ejemplo realizado en Java, enseñan la manera de crear permisos personalizados para las diferentes aplicaciones.

Necesidad

Se requiere crear permisos personalizados a una aplicación hecha en Java.

Contexto

A continuación se describen las circunstancias bajo las cuales la siguiente solución tiene sentido:

  1. Se dispone de un compilador estándar de Java.

Solución

Uno de los temas más recurrentes o, mejor dicho, tener presente a la hora de trabajar con la seguridad informática, es la administración de permisos. Dicha administración de permisos es de suma importancia puesto que a la final, es lo que determina que o quien puede acceder a un recurso.

En palabras más técnicas, un permiso es el poder que se le otorga a un usuario, componente o funcionalidad de un sistema de interactuar con dicho sistema de una manera controlada. Por lo tanto, la importancia de los permisos radica en que se debe definir y controlar de manera adecuada que personas indeseadas no accedan, ni conozcan y/o manipulen la información del sistema.

Entonces, para establecer permisos personalizados en Java, se debe tener en cuenta que el código está representado bajo un objeto CodeSource. Dicho objeto incluye tanto la ubicación del código dentro del sistema de archivos como un conjunto de certificados digitales que han sido usados para firmar el código fuente.

  1. Para crear un permiso personalizado es necesario crear una clase que herede de java.security.BasicPermission. Dicha clase representa la implementación de un permiso básico donde se especifique el nombre del objetivo a proteger.

    CustomPermission.java
    1
    2
    3
    import java.security.BasicPermission;
    
    public class CustomPermission extends BasicPermission {
    
  2. Después, se crea una instancia de la clase java.security.BasicPermission. Para ello hay que invocar el constructor de dicha clase pasándole como parámetro el nombre del objetivo involucrado en el permiso.

    1
    2
    3
    4
      public CustomPermission(String perm) {
        super(perm);
      }
    }
    
  3. Una vez creado el permiso, se crea una clase que habilite el gestor de seguridad para verificar si el código que realiza la invocación de alguno de los servicios expuestos tiene los permisos necesarios para poder consumirlos.

    api.java
    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class API {
      public static void ControlMethod() {
        SecurityManager securityManager = System.getSecurityManager();
        if (securityManager != null) {
          securityManager.checkPermission(new CustomPermission("permission"));
        }
        System.out.println("Method was executing satisfly");
      }
    }
    
  4. Posteriormente, se crea la clase encargada de invocar el servicio ControlMethod de la clase API. Esta nueva clase debe tener los permisos necesarios para poder realizar la invocación de manera satisfactoria.

    authorized.java
    1
    2
    3
    4
    5
    public class Authorized {
      public static void main(String[] args) {
        API.metodoControlado();
      }
    }
    
  5. Como siguiente paso, se crea la clase Malware que invocará el método Authorized.main.

    malware.java
    1
    2
    3
    4
    5
    public class Malware {
      public static void main(String[] args) {
        CLIAutorizado.main(null);
      }
    }
    
  6. También habrá que crear la clase NotAuthorized que llamará directamente el método API.ControlMethod.

    notauthorized.java
    1
    2
    3
    4
    5
    public class NotAuthorized {
      public static void main(String[] args) {
        API.metodoControlado();
      }
    }
    
  7. Por último, se crea el archivo de políticas java.policy, donde el campo codeBase indica la ubicación del código fuente y se le otorga el permiso al código que se encuentre en esa ubicación. En este caso, las clases que se encuentran en las ubicaciones src/api y src/authorized (CustomPermission, API, Authorized) tienen habilitado el permiso.

    policy.java
    1
    2
    3
    4
    5
    6
    grant codebase "file:src/api/" {
      permission CustomPermission "permission";
    };
    grant codebase "file:src/autorizado/" {
      permission CustomPermission "permission";
    };
    
  8. Se compila y ejecuta.

    compile.bash
    1
    2
    3
    4
    $ javac src/api/*.java
    $ javac -classpath .:src/api src/authorized/Authorized.java
    $ javac -classpath src/Authorized:src/api src/malware/Malware.java
    $ javac -classpath .:src/api src/notauthorized/NotAuthorized.java
    
  9. Clase Authorized.

    1
    2
    3
    $ java -classpath src/api:src/autorizado -Djava.security.manager
      -Djava.security.policy==java.policy Authorized
    Method was executing satisfly
    
  10. Clases Malware y NotAuthorized

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    $ java -classpath src/api:src/malicioso:src/autorizado -Djava.security.manager
      -Djava.security.policy==java.policy Malware
    Exception in thread "main" java.security.AccessControlException: access denied
      (CustomPermission permission)
       at java.security.AccessControlContext.checkPermission(AccessControlContext.java:393)
       at java.security.AccessController.checkPermission(AccessController.java:553)
       at java.lang.SecurityManager.checkPermission(SecurityManager.java:549)
       at API.ControlMethod(API.java:8)
       at Authorized.main(Authorized.java:7)
       at Malware.main(Malware.java:7)
    
    $ java -classpath src/api:src/no_autorizado/ -Djava.security.manager
      -Djava.security.policy==java.policy NotAuthorized
    Exception in thread "main" java.security.AccessControlException: access denied
     (CustomPermission permiso)
      at java.security.AccessControlContext.checkPermission(AccessControlContext.java:393)
      at java.security.AccessController.checkPermission(AccessController.java:553)
      at java.lang.SecurityManager.checkPermission(SecurityManager.java:549)
      at API.ControlMethod(API.java:8)
      at NotAuthorized.main(NotAuthorized.java:8)
    

Descargas

Puedes descargar el código fuente pulsando en los siguientes enlaces:

BasicPermission.java Clase BasicPermission.

API.java Clase API.

Authorized.java Clase Authorized.

Malware.java Clase Malware.

NotAuthorized.java Clase NotAuthorized.




Haz un comentario

Estado de los servicios - Términos de Uso