Wie blockiert man den Zugriff auf einige Klassen, wenn man groovige Skripte von Java ausführt?

Question

Ich bin ziemlich neu zu groovy, und Skripte in Java im Allgemeinen, und ich wirklich hoffe, es gibt eine einfache Lösung für mein Problem. In unserer Anwendung können die Benutzer groovy Skripte ausführen, die sie selbst schreiben, und wir müssen steuern, was diese Skripte können und was nicht. Ich lese viele Dinge über Sandboxing groovy, aber entweder ich sehe falsche Orte oder ich übersehe das Offensichtliche. Um es einfach zu machen, habe ich ein kleines Beispiel, das das Problem zeigt. Das ist mein Klassenlader die java.lang.System entfernt, geladen und verfügbar zu Skripten verhindern sollten:

public class MyClassLoader extends ClassLoader { 

    @Override 
    public Class<?> loadClass(String name) throws ClassNotFoundException { 
     if (name.startsWith("java.lang.System")) { 
      throw new ClassNotFoundException("Class not found: " + name); 
     } 
     return super.loadClass(name); 
    } 
} 

Und das ist ein einfaches Programm, das zu nennen versucht System.currentTimeMillis():

public static void main(String[] args) { 
    String code = "java.lang.System.currentTimeMillis();"; 
    ClassLoader classLoader = new MyClassLoader(); 
    Thread.currentThread().setContextClassLoader(classLoader); 

    GroovyShell shell = new GroovyShell(); 
    Script script = shell.parse(code); 
    Object result = script.run(); 
    log.debug(result); 
} 

MyClassLoader wirft Ausnahmen für java.lang.SystemBeanInfo und java.lang.SystemCustomizer, aber der Code wird ausgeführt. Gleiche passiert, wenn ich javax.script Klassen verwenden:

ScriptEngineManager factory = new ScriptEngineManager(); 
ScriptEngine engine = factory.getEngineByName("Groovy"); 
Object o = engine.eval(code); 
log.debug(o); 

Und wenn ich es mit JavaScript-Engine versuchen, es funktioniert wie erwartet (nur „Groovy“ mit „JavaScript“ in dem obigen Beispiel ersetzen).

Kann mir jemand dabei helfen? BTW, ich benutze groovy-all-1.8.8.jar, mit jdk1.7.0_55.

Dank

Answer 1

Ich kann Groovy Sandbox für diesen Zweck empfehlen. Im Gegensatz zu SecureASTCustomizer wird geprüft, ob eine Ausführung zur Laufzeit dynamisch erlaubt ist. Es fängt alle Methodenaufrufe, Objektzuordnungen, Eigenschaften-/Attributzugriffe, Array-Zugriffe usw. ab - und Sie haben somit eine sehr genaue Kontrolle darüber, was Sie zulassen (White-Listing).

Natürlich ist die Konfiguration, was erlaubt ist, sehr wichtig. Zum Beispiel möchten Sie möglicherweise zulassen, String s verwenden und Methoden wie substring, aber wahrscheinlich nicht die execute Methode auf String, die mit etwas wie 'rm -R ~/*'.execute() ausgenutzt werden könnte. Das Erstellen einer Konfiguration, die wirklich sicher ist, ist eine Herausforderung, und es ist schwieriger, je mehr Sie zulassen.

Nachteil der Groovy Sandbox ist, dass der Code mit dem Interceptor registriert ausgeführt werden muss und Sie eine Leistungseinbuße während der Ausführung haben.

Dieses Bild [1] zeigt ein Beispiel aus einem Projekt, in dem wir Groovy Sandbox für Groovy-Code verwendet haben, der vom Benutzer eingegeben wurde.Der Code wird das Skript Valide - also, wenn die Aussage dort tatsächlich als ein Teil davon ausgeführt werden würde, würde die Anwendung beendet haben, bevor ich den Screenshot machen konnte;)

Answer 2

Vielleicht möchten Sie mit einem CompilerConfiguration bei der Verwendung eines SecureASTCustomizer in Verbindung interessiert sein. Wenn Sie sich mit Sicherheit befassen, ist eine explizite Whitelist möglicherweise besser als eine Blacklist.

def s = new SecureASTCustomizer() 
s.importsWhiteList = [ 'a.legal.Klass', 'other.legal.Klass' ] 

def c = new CompilerConfiguration() 
c.addCompilationCustomizers(s) 

def sh = new GroovyShell(c) 

Werfen Sie einen Blick auf diese Klasse, es enthält eine Menge von Optionen, die bereit sind zu verwenden.

Answer 3

import groovy.lang.GroovyClassLoader; 
import groovy.lang.GroovyShell; 
import groovy.lang.Script; 

public class SandboxGroovyClassLoader extends ClassLoader { 

public SandboxGroovyClassLoader(ClassLoader parent) { 
    super(parent); 
} 

@Override 
public Class<?> loadClass(String name) throws ClassNotFoundException { 
    if (name.startsWith("java.lang.System")) 
     return null; 
    return super.loadClass(name); 
} 

@Override 
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { 
    if (name.startsWith("java.lang.System")) 
     return null; 
    return super.loadClass(name, resolve); 
} 

static void runWithGroovyClassLoader() throws Exception { 
    System.out.println("Begin runWithGroovyClassLoader"); 

    String code = "def hello_world() { java.lang.System.currentTimeMillis(); };"; 

    GroovyClassLoader groovyClassLoader = new GroovyClassLoader(); 
    Class<?> scriptClass = groovyClassLoader.parseClass(code); 
    Object scriptInstance = scriptClass.newInstance(); 
    Object result = scriptClass.getDeclaredMethod("hello_world", new Class[] {}).invoke(scriptInstance, new Object[] {}); 
    System.out.println(result); 
    groovyClassLoader.close(); 
    System.out.println("End runWithGroovyClassLoader"); 
} 

static void runWithSandboxGroovyClassLoader() throws Exception { 
    System.out.println("Begin runWithSandboxGroovyClassLoader"); 
    ClassLoader parentClassLoader = SandboxGroovyClassLoader.class.getClassLoader(); 
    SandboxGroovyClassLoader classLoader = new SandboxGroovyClassLoader(parentClassLoader); 

    String code = "def hello_world() { java.lang.System.currentTimeMillis(); };"; 

    GroovyClassLoader groovyClassLoader = new GroovyClassLoader(classLoader); 
    Class<?> scriptClass = groovyClassLoader.parseClass(code); 
    Object scriptInstance = scriptClass.newInstance(); 
    Object result = scriptClass.getDeclaredMethod("hello_world", new Class[] {}).invoke(scriptInstance, new Object[] {}); 
    System.out.println(result); 
    groovyClassLoader.close(); 
    System.out.println("End runWithSandboxGroovyClassLoader"); 
} 

static void runWithSandboxGroovyShellClassLoader() throws Exception { 
    System.out.println("Begin runWithSandboxGroovyShellClassLoader"); 

    String code = "java.lang.System.currentTimeMillis();"; 

    ClassLoader parentClassLoader = SandboxGroovyClassLoader.class.getClassLoader(); 
    SandboxGroovyClassLoader classLoader = new SandboxGroovyClassLoader(parentClassLoader); 
    Thread.currentThread().setContextClassLoader(classLoader); 

    GroovyShell shell = new GroovyShell(); 
    Script script = shell.parse(code); 
    Object result = script.run(); 
    System.out.println(result); 
    System.out.println("End runWithSandboxGroovyShellClassLoader"); 
} 

public static void main(String[] args) throws Exception { 

    runWithGroovyClassLoader(); 
    runWithSandboxGroovyClassLoader(); 
    runWithSandboxGroovyShellClassLoader(); 

} 
} 

Ist es was willst du?