Java security: Plugins de Sandboxing cargados a través de URLClassLoader

Resumen de la pregunta: ¿Cómo puedo modificar el código a continuación para que el código cargado dinámicamente y no confiable se ejecute en un sandbox de seguridad mientras el resto de la aplicación permanece sin restricciones? ¿Por qué URLClassLoader no lo maneja como dice que lo hace?

EDITAR: Actualizado para responder a Ani B.

EDICIÓN 2: Agregado PluginSecurityManager actualizado.

Mi aplicación tiene un mecanismo de plug-in donde un tercero puede proporcionar un JAR que contiene una clase que implementa una interfaz particular. Usando URLClassLoader, puedo cargar esa clase e instanciarla, no hay problema. Debido a que el código es potencialmente no confiable, necesito evitar que se comporte mal. Por ejemplo, corro el código del complemento en un hilo separado para que pueda matarlo si entra en un bucle infinito o simplemente toma demasiado tiempo. Pero tratar de establecer una caja de arena de seguridad para ellos para que no puedan hacer cosas como hacer conexiones de red o acceder a archivos en el disco duro me está haciendo positivamente batty. Mi los esfuerzos siempre resultan en no tener ningún efecto en el complemento (tiene los mismos permisos que la aplicación) o también restringir la aplicación. Quiero que el código de la aplicación principal sea capaz de hacer casi todo lo que quiera, pero el código del complemento que se bloquee.

La documentación y los recursos en línea sobre el tema son complejos, confusos y contradictorios. He leído en varios lugares (como esta pregunta) que necesito proporcionar un SecurityManager personalizado, pero cuando pruébelo Me encuentro con problemas porque el JVM perezoso-carga las clases en el FRASCO. Así que puedo instanciarlo muy bien, pero si llamo a un método en el objeto cargado que instancie otra clase del mismo TARRO, explota porque se le niega el derecho a leer del TARRO.

Teóricamente, podría poner un cheque en FilePermission en mi SecurityManager para ver si está tratando de cargar fuera de su propio TARRO. Eso está bien, pero la documentación de URLClassLoader dice: "Las clases que se cargan por defecto solo se les concede permiso para acceder a las URL especificadas cuando se creó el URLClassLoader."Entonces, ¿por qué necesito un SecurityManager personalizado? ¿No debería URLClassLoader manejar esto? ¿Por qué no?

Aquí hay un ejemplo simplificado que reproduce el problema:

Aplicación principal (de confianza)

PluginTest.java

package test.app;

import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;

import test.api.Plugin;

public class PluginTest {
    public static void pluginTest(String pathToJar) {
        try {
            File file = new File(pathToJar);
            URL url = file.toURI().toURL();
            URLClassLoader cl = new URLClassLoader(new java.net.URL[] { url });
            Class<?> clazz = cl.loadClass("test.plugin.MyPlugin");
            final Plugin plugin = (Plugin) clazz.newInstance();
            PluginThread thread = new PluginThread(new Runnable() {
                @Override
                public void run() {
                    plugin.go();
                }
            });
            thread.start();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

Plugin.java

package test.api;

public interface Plugin {
    public void go();
}

PluginSecurityManager.java

package test.app;

public class PluginSecurityManager extends SecurityManager {
    private boolean _sandboxed;

    @Override
    public void checkPermission(Permission perm) {
        check(perm);
    } 

    @Override
    public void checkPermission(Permission perm, Object context) {
        check(perm);
    }

    private void check(Permission perm) {
        if (!_sandboxed) {
            return;
        }

        // I *could* check FilePermission here, but why doesn't
        // URLClassLoader handle it like it says it does?

        throw new SecurityException("Permission denied");
    }

    void enableSandbox() {
    _sandboxed = true;
    }

    void disableSandbox() {
        _sandboxed = false;
    }
}

PluginThread.java

package test.app;

class PluginThread extends Thread {
    PluginThread(Runnable target) {
        super(target);
    }

    @Override
    public void run() {
        SecurityManager old = System.getSecurityManager();
        PluginSecurityManager psm = new PluginSecurityManager();
        System.setSecurityManager(psm);
        psm.enableSandbox();
        super.run();
        psm.disableSandbox();
        System.setSecurityManager(old);
    }
}

Plugin JAR (untrusted)

MyPlugin.java

package test.plugin;

public MyPlugin implements Plugin {
    @Override
    public void go() {
        new AnotherClassInTheSamePlugin(); // ClassNotFoundException with a SecurityManager
        doSomethingDangerous(); // permitted without a SecurityManager
    }

    private void doSomethingDangerous() {
        // use your imagination
    }
}

ACTUALIZACIÓN: Lo cambié para que justo antes de que el código del complemento esté a punto de ejecutarse, notifique al PluginSecurityManager para que sepa con qué fuente de clase está trabajando. Entonces solo permitirá accesos a archivos en archivos bajo esa clase ruta de origen. Esto también tiene la ventaja de que solo puedo configurar el administrador de seguridad una vez al comienzo de mi aplicación, y solo actualizarlo cuando ingrese y deje el código del complemento.

Esto casi resuelve el problema, pero no responde a mi otra pregunta: ¿Por qué URLClassLoader no maneja esto por mí como dice que lo hace? Dejaré esta pregunta abierta por un tiempo más para ver si alguien tiene una respuesta a esa pregunta. Si es así, esa persona recibirá la respuesta aceptada. De lo contrario, Lo adjudicaré a Ani B. en la presunción de que la documentación URLClassLoader miente y que su consejo para hacer un SecurityManager personalizado es correcto.

El PluginThread tendrá que establecer la propiedad classSource en el PluginSecurityManager, que es la ruta a los archivos de clase. PluginSecurityManager ahora se ve algo como esto:

package test.app;

public class PluginSecurityManager extends SecurityManager {
    private String _classSource;

    @Override
    public void checkPermission(Permission perm) {
        check(perm);
    } 

    @Override
    public void checkPermission(Permission perm, Object context) {
        check(perm);
    }

    private void check(Permission perm) {
        if (_classSource == null) {
            // Not running plugin code
            return;
        }

        if (perm instanceof FilePermission) {
            // Is the request inside the class source?
            String path = perm.getName();
            boolean inClassSource = path.startsWith(_classSource);

            // Is the request for read-only access?
            boolean readOnly = "read".equals(perm.getActions());

            if (inClassSource && readOnly) {
                return;
            }
        }

        throw new SecurityException("Permission denied: " + perm);
    }

    void setClassSource(String classSource) {
    _classSource = classSource;
    }
}