Ich hatte neulich schon einmal begonnen, über die Nutzung des Java SecurityManager zur Erhöhung der Sicherheit von Java-Anwendungen zu schreiben.

Ich möchte hier diesen Faden noch einmal aufnehmen. Letztlich beleuchte ich nach wie vor nur eine von vielen Möglichkeiten, Anwendungen und Systeme resilienter zu machen: Sandboxing beziehungsweise Partitionierung.

Die Idee dahinter: Bereiche in der Anwendung, die mit sensiblen Assets umgehen sollen, dürfen möglichst keine Schwachstellen aufweisen. Daher sollte man solche Bereiche von anderen kapseln. Das kann geschehen, indem man eine Anwendung in mehrere Prozesse aufteilt und diese über Interprozess-Kommunikationsschnittstellen miteinander Daten austauschen lässt. Die Prozesse, die mit den eigentlichen sensiblen Assets arbeiten, dürfen nur Klassen aus ausgewählten Paketen benutzen. Das lässt sich übrigens hervorragend mittels Arch_Unit sicherstellen. Alle anderen Prozesse, die off-the-shelf Komponenten benutzen werden in eine Sandbox gesperrt, die die Rechte (Dateien schreiben/öffnen, Arbeiten mit Sockets, Ausführen von Code) des jeweiligen Prozesses stark einschränkt.

Diese Prozesse dürfen mit dem sensiblen Kern nur Daten austauschen, die entweder aus der Java Standardbibliothek stammen oder dediziert für die Anwendung erstellt wurden.

Das Sandboxing einzelner Prozesse kann für Java-Anwendungen mittels des SecurityManagers geschehen. Allerdings - und da stimme ich der Begründung für die Deprecation des SecurityManagers zu - ist dieser sehr schwer zu konfigurieren und noch schwieriger ist es, dies fehlerlos zu tun - also alles zu vermeiden, das aus dem Code heraus die konfigurierten Regeln für den SecurityMAnager wieder außer Kraft setzt.

Dazu existieren diverse Ressourcen im Internet.

Ich habe hier einige Quelltexte angehängt, mit denen ich die Möglichkeit skizzieren möchte, eine solche Partitionierung umzusetzen: Ich nehme an, dass die Anwendung Multimediainhalte in Gestalt von Bitmap-Graphiken laden können muss - da in der Vergangenheit immer wieder Lücken in Decodern für Multimediainhalten gefunden wurden, stellt das eine Bedrohung dar, der wir begegnen müssen. Das wird getan, indem das Laden der Graphiken in einen eigenen Prozess ausgelagert wird. Nach erfolgreicher Dekidierung der Inhalte werden diese in eine Instanz einer Klasse gepackt, die die Java-Standardbibliothek dafür anbietet und anschließend werden diese Instanzen über eine IPC-Schnittstelle an den zweiten Prozess übergeben, der hier beispielhaft für den steht, der unsere sensigble Assets verarbeitet.

Wenn nun ein speziell dafür erstelltes Bild eine Verwundbarkeit des Dekoders für das jeweilige Bildformat auslöst, kann im schlimmsten Fall Schadcode nachgeladen werden, der aber nur im Kontext unseres sandboxed Prozesses ausgeführt wird - und damit hat er keine Möglichkeit, irgendwelchen Schaden anzurichten: Der Zugriff auf wichtige Assets ist unmöglich, da diese in einem anderen Prozess existieren und etwaige Aktionen auf dem System auszuführen, die Schaden anrichten würden ist durch das Einsperren in der Sandbox unmöglich geworden.

import javax.management.*;
import java.lang.management.ManagementFactory;

public class JMXA
{
    public static void main(String[] args) throws MalformedObjectNameException, NotCompliantMBeanException, InstanceAlreadyExistsException, MBeanRegistrationException, InterruptedException
    {
        ObjectName objectName = new ObjectName("com.baeldung.ipc:type=basic,name=test");

        MBeanServer server = ManagementFactory.getPlatformMBeanServer();
        server.registerMBean(new IPCTest(), objectName);
        while(true)
        {
            java.lang.Thread.currentThread().sleep(1000);
        }
    }
}

import javax.management.JMX;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;
import java.io.IOException;

public class JMXB
{
    public static void main(String[] args) throws IOException, MalformedObjectNameException
    {
        JMXServiceURL url = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://localhost:1234/jmxrmi");
        try (JMXConnector jmxc = JMXConnectorFactory.connect(url, null)) {
            ObjectName objectName = new ObjectName("com.baeldung.ipc:type=basic,name=test");

            IPCTestMBean mbeanProxy = JMX.newMBeanProxy(jmxc.getMBeanServerConnection(), objectName, IPCTestMBean.class, true);
            java.awt.image.RenderedImage bimg= Utilities.createTestImage(new java.awt.BasicStroke(3), Color.BLUE,0,0);
            javax.swing.ImageIcon imageIcon=new javax.swing.ImageIcon((java.awt.Image)bimg);

            mbeanProxy.sendMessage(imageIcon);
        }
    }
}

public class Utilities
{
    private Utilities()
    {
        super();
    }
    public static java.awt.image.BufferedImage createTestImage(java.awt.Stroke stroke, java.awt.Paint paint, int counter, int stepsize)
    {
        java.awt.image.BufferedImage bimg = new java.awt.image.BufferedImage(640, 480, java.awt.image.BufferedImage.TYPE_BYTE_INDEXED);
        java.awt.Graphics2D g2 = bimg.createGraphics();
        g2.setRenderingHint(java.awt.RenderingHints.KEY_ANTIALIASING, java.awt.RenderingHints.VALUE_ANTIALIAS_ON);
        g2.setPaint(java.awt.Color.WHITE);
        g2.setStroke(stroke);
        g2.fillRect(0, 0, 640, 480);
        g2.setPaint(paint);
        g2.drawOval(counter * stepsize, counter * stepsize, 200, 200);
        g2.dispose();
        return bimg;
    }
}

public interface IPCTestMBean
{
    void sendMessage(javax.swing.ImageIcon message);
}

public class IPCTest implements IPCTestMBean
{
    @Override
    public void sendMessage(javax.swing.ImageIcon message)
    {
        javax.swing.JFrame f=new javax.swing.JFrame();
        javax.swing.JLabel l=new javax.swing.JLabel(message);
        f.setContentPane(l);
        f.pack();
        f.setVisible(true);
    }
}