Entwicklung und Konzepte der Java-Sicherheit, Teil 3: Applet-Sicherheit

Das frühe Wachstum von Java wurde durch Code vorangetrieben, der über ein Netzwerk heruntergeladen werden kann, besser bekannt als Applets. Die Applet-Sicherheit hat sich mit dem Wachstum von Java weiterentwickelt und ist heute aufgrund der Vielzahl von Java-Versionen, handelsüblichen Browsern und Plug-Ins eine Quelle häufiger Verwirrung.

Dieser Artikel, der dritte in der Reihe, behandelt die verschiedenen Anforderungen für die sichere Ausführung von Java-Code, der aus einem Netzwerk heruntergeladen wurde. Obwohl mobiler Code kein revolutionäres Konzept ist, stellen Java und das Internet die Computersicherheit vor einzigartige Herausforderungen. Die Entwicklung der Java-Architektur und ihre Auswirkungen auf die Java-Kernsicherheit wurden in Teil 1 und 2 erörtert. Dieser Artikel verfolgt einen anderen Ansatz: einen praktischen Ansatz, um alle Konzepte durch die Bereitstellung eines einfachen Applets zu verknüpfen, das in das lokale Dateisystem schreibt .

Entwicklung und Konzepte der Java-Sicherheit: Lesen Sie die gesamte Serie!

  • Teil 1: In dieser Einführungsübersicht lernen Sie Konzepte und Begriffe zur Computersicherheit kennen
  • Teil 2: Entdecken Sie die Vor- und Nachteile der Java-Sicherheit
  • Teil 3: Bewältigen Sie die Sicherheit von Java-Applets mit Vertrauen
  • Teil 4: Erfahren Sie, wie optionale Pakete die Java-Sicherheit erweitern und verbessern
  • Teil 5: J2SE 1.4 bietet zahlreiche Verbesserungen der Java-Sicherheit

Der Kern des Beispiel-Applets ist die Kryptografie mit öffentlichem Schlüssel, die weiter oben in dieser Reihe vorgestellt wurde. Mit dem privaten Schlüssel des Unterzeichners signierter Code kann auf Clientcomputern ausgeführt werden, sobald der dem Unterzeichner entsprechende öffentliche Schlüssel auf dem jeweiligen Computer als vertrauenswürdig eingestuft wird. Wir werden auch diskutieren, wie Richtliniendateien, die Berechtigungen und Schlüsselspeicher zuweisen, als Repository für öffentliche und private Schlüssel verwendet werden können. Darüber hinaus werden wir die Java 2 SDK-Sicherheitstools und Netscape-Tools hervorheben signtool, da sie die Bereitstellung ermöglichen.

Dieser Artikel beschreibt die Entwicklung der Java-Sicherheit, beginnend mit der Anwendungssicherheit in der ersten Version von Java 2 bis hin zur neuesten Version von Java 2, Version 1.3. Dieser Ansatz hilft dabei, die Konzepte schrittweise einzuführen, angefangen bei sehr einfachen Konzepten bis hin zu einem ziemlich fortgeschrittenen Beispiel.

Diese Serie soll keinen umfassenden Leitfaden zur Computersicherheit bieten. Computersicherheit ist ein vielschichtiges Thema, das verschiedene Disziplinen, Abteilungen und Kulturen berührt. Nach Investitionen in Technologien sollten Investitionen in die Schulung des Personals, die strikte Durchsetzung von Richtlinien und die regelmäßige Überprüfung der gesamten Sicherheitsrichtlinie erfolgen.

Hinweis: Dieser Artikel enthält ein laufendes Java-Applet, mit dem Applet-Sicherheitsprobleme demonstriert werden sollen. Lesen Sie unten für weitere Details.

Anwendungssicherheit

Beginnen wir unsere Untersuchung mit einem Blick auf die Anwendungssicherheit. In Teil 2 haben wir gesehen, wie sich die Java-Sicherheit von einem Sandbox-Modell zu einem fein abgestimmten Sicherheitsmodell entwickelt hat. Wir haben auch festgestellt, dass Anwendungen (lokaler Code) standardmäßig eine freie Herrschaft erhalten und nicht der gleichen Kontrolle unterliegen wie Applets (vom Netzwerk herunterladbarer Code), die normalerweise als nicht vertrauenswürdig eingestuft werden. In einer Änderung gegenüber der Vergangenheit können Sicherheitsanwendungen in Java 2 optional der gleichen Kontrollebene unterliegen wie Applets.

Zunächst ein kurzer Hinweis writeFile.javazum Code, der in diesem Artikel zur Veranschaulichung der Sicherheitsfunktionen in Java 2 verwendet wird. Dieses Programm ist eine leicht modifizierte Version des von Sun bereitgestellten Applet-Codes, der über das Web verfügbar ist, um einige der Funktionen von Java 2 zu veranschaulichen Sicherheit. Das Programm, das geändert wurde, um Anwendungsunterstützung bereitzustellen, versucht, eine Datei im lokalen Dateisystem zu erstellen und zu schreiben. Der Zugriff auf ein lokales Dateisystem wird vom Sicherheitsmanager überprüft. Wir werden in diesem Artikel sehen, wie dieser bestimmte Vorgang auf sichere Weise zugelassen werden kann.

/ ** * Standardmäßig löst dies eine Sicherheitsausnahme als Applet aus. * * Mit JDK 1.2 Appletviewer *, wenn Sie Ihr System so konfigurieren, dass von "Duke" * signierte und von der Java Software Website heruntergeladene Applets gewährt werden, um eine Datei * in Ihr / tmp-Verzeichnis (oder in die Datei mit dem Namen "C: \ tmpfoo" zu schreiben "auf einem * Windows-System), dann kann dieses Applet ausgeführt werden. * * @version JDK 1.2 * @author Marianne Mueller * @Modifiziert von Raghavan Srinivas [Rags] * / import java.awt. *; import java.io. *; import java.lang. *; import java.applet. *; öffentliche Klasse writeFile erweitert Applet {String myFile = "/ tmp / foo"; Datei f = neue Datei (myFile); DataOutputStream dos; public void init () {String osname = System.getProperty ("os.name"); if (osname.indexOf ("Windows")! = -1) {myFile = "C:" + File.separator + "tmpfoo";}} public void paint (Grafik g) {try {dos = neuer DataOutputStream (neuer BufferedOutputStream (neuer FileOutputStream (myFile), 128)); dos.writeBytes ("Katzen können dich hypnotisieren, wenn du es am wenigsten erwartest \ n"); dos.flush (); dos.close (); g.drawString ("Erfolgreich in die Datei mit dem Namen" + myFile + "geschrieben - sehen Sie es sich an!", 10, 10); } catch (SecurityException e) {g.drawString ("writeFile: gefangene Sicherheitsausnahme", 10, 10); } catch (IOException ioe) {g.drawString ("writeFile: gefangene E / A-Ausnahme", 10, 10); }} public static void main (String args []) {Frame f = neuer Frame ("writeFile"); writeFile writefile = new writeFile (); writefile.init (); writefile.start (); f.add ("Center", Schreibdatei); f.setSize (300, 100); f.show (); }}}}}}Katzen können dich hypnotisieren, wenn du es am wenigsten erwartest \ n "); dos.flush (); dos.close (); g.drawString (" Erfolgreich in die Datei mit dem Namen "+ myFile +" geschrieben - sieh sie dir an ! ", 10, 10);} catch (SecurityException e) {g.drawString (" writeFile: gefangene Sicherheitsausnahme ", 10, 10);} catch (IOException ioe) {g.drawString (" writeFile: catch i / o Ausnahme ", 10, 10);}} public static void main (String args []) {Frame f = neuer Frame (" writeFile "); writeFile writefile = new writeFile (); writefile.init (); writefile.start ( ); f.add ("Center", Schreibdatei); f.setSize (300, 100); f.show ();}}Katzen können Sie hypnotisieren, wenn Sie es am wenigsten erwarten \ n "); dos.flush (); dos.close (); g.drawString (" Erfolgreich in die Datei mit dem Namen "+ myFile +" geschrieben - sehen Sie sie sich an ! ", 10, 10);} catch (SecurityException e) {g.drawString (" writeFile: gefangene Sicherheitsausnahme ", 10, 10);} catch (IOException ioe) {g.drawString (" writeFile: catch i / o Ausnahme ", 10, 10);}} public static void main (String args []) {Frame f = neuer Frame (" writeFile "); writeFile writefile = new writeFile (); writefile.init (); writefile.start ( ); f.add ("Center", Schreibdatei); f.setSize (300, 100); f.show ();}}} catch (SecurityException e) {g.drawString ("writeFile: gefangene Sicherheitsausnahme", 10, 10); } catch (IOException ioe) {g.drawString ("writeFile: gefangene E / A-Ausnahme", 10, 10); }} public static void main (String args []) {Frame f = neuer Frame ("writeFile"); writeFile writefile = new writeFile (); writefile.init (); writefile.start (); f.add ("Center", Schreibdatei); f.setSize (300, 100); f.show (); }}} catch (SecurityException e) {g.drawString ("writeFile: gefangene Sicherheitsausnahme", 10, 10); } catch (IOException ioe) {g.drawString ("writeFile: gefangene E / A-Ausnahme", 10, 10); }} public static void main (String args []) {Frame f = neuer Frame ("writeFile"); writeFile writefile = new writeFile (); writefile.init (); writefile.start (); f.add ("Center", Schreibdatei); f.setSize (300, 100); f.show (); }}

Durch Ausführen des in einer Java 2-Laufzeitumgebung generierten Bytecodes (Standard Edition, JRE) kann die Anwendung die Datei im lokalen Dateisystem standardmäßig ändern, da die Standardrichtlinie Java 2-Anwendungen keinem Sicherheitsmanager unterwirft. Diese Richtlinie ist gerechtfertigt, da Anwendungen normalerweise lokal generierter Code sind und nicht über das Netzwerk heruntergeladen werden. Die folgende Befehlszeile erzeugt das in Abbildung 1 gezeigte Fenster, das angibt, dass die Datei erstellt und beschrieben wurde.

$ java writeFile 

Um den Code dem Java 2-Sicherheitsmanager zu unterwerfen, rufen Sie die folgende Befehlszeile auf, die die in Abbildung 2 angegebenen Ergebnisse liefern soll. Beachten Sie, dass die Anwendung eine Sicherheitsausnahme generiert hat, die durch den Versuch verursacht wurde, das lokale Dateisystem zu ändern. Der explizit enthaltene Sicherheitsmanager hat die Ausnahme generiert.

$ java -Djava.security.manager writeFile 

Die oben dargestellten Fälle sind extreme Beispiele für Sicherheitspolitik. Im ersteren Fall unterlag der Antrag keiner Kontrolle; in letzterem unterlag es einer sehr strengen Kontrolle. In den meisten Fällen muss die Richtlinie irgendwo dazwischen festgelegt werden.

Sie können eine Zwischenrichtlinie mithilfe einer Richtliniendatei erstellen. Erstellen Sie dazu eine Richtliniendatei, die all.policyim Arbeitsverzeichnis aufgerufen wird :

gewähren {Erlaubnis java.io.FilePermission "<>", "schreiben"; };

Wenn Sie denselben Code mit der folgenden Befehlszeile ausführen, können Sie das lokale Dateisystem ändern:

$ java -Djava.security.manager -Djava.security.policy = all.policy writeFile 

In diesem Beispiel unterlag die Anwendung dem Sicherheitsmanager, die gesamte Richtlinie wurde jedoch von der Richtliniendatei gesteuert, mit der alle Dateien im lokalen Dateisystem geändert werden konnten. Eine strengere Richtlinie könnte darin bestanden haben, nur die relevante Datei zu ändern - tmpfooin diesem Fall.

Ich werde später in diesem Artikel weitere Details der Richtliniendatei, einschließlich der Syntax der Einträge, behandeln. Aber zuerst schauen wir uns die Applet-Sicherheit an und stellen sie der Anwendungssicherheit gegenüber.

Applet-Sicherheit

Bisher haben wir die Anwendungssicherheit untersucht. Daher können die meisten Sicherheitsfunktionen über die Befehlszeile aufgerufen und geändert werden. Die Bereitstellung einer ausreichend sicheren und dennoch etwas flexiblen Richtlinie in einer Applet-Umgebung erweist sich als wesentlich schwieriger. Wir beginnen mit der Bereitstellung eines Applets in Appletviewer. Wir werden uns später die vom Browser bereitgestellten Applets ansehen.

Die Java-Code-Richtlinie wird in erster Linie von CodeSourcezwei Informationen bestimmt: dem Ort, an dem der Code stammt, und der Person, die ihn signiert hat.

Appletviewer

Erstellen Sie eine Datei writeFile.htmlmit dem folgenden Inhalt:

  Java-Sicherheitsbeispiel: Schreiben von Dateien 
   

Running the applet with the following command line would result in the window shown in Figure 3:

$ appletviewer writeFile.html 

Notice that -- in contrast to what would happen with an application -- the applet generated an exception since the applet is subject to the security manager by default. The installation can be governed by a customizable policy, if required. Running the following command line:

appletviewer -J"-Djava.security.policy=all.policy" writeFile.html 

would, as you might expect, allow modification of the tmpfoo file, since this was permitted in accordance with the policy file.

Browsers

Applet security in browsers strives to prevent untrusted applets from performing potentially dangerous operations, while simultaneously allowing optimal access to trusted applets. Applet security deployment in browsers is substantially different from what we have seen so far, primarily due to the following reasons:

  • A default lack of trust in code downloaded over the network
  • Insufficient access to the command-line options for running the JVM, since the JVM is hosted in the context of a browser
  • Inadequate support for some of the latest security features in the JVMs bundled with browsers

As for the first problem, to obviate the potential problems resulting from running untrusted code, earlier versions of Java used the sandbox model (see "Sidebar 1: Sandbox Model"). Trust is a largely philosophical or emotional issue, rather than a technical issue; however, technology can help. For example, Java code can be signed using certificates. In this example, the signer implicitly vouches for the code by signing it. The onus is ultimately upon the user running the code to trust the signing entity or not, given that these certificates guarantee that the code was indeed signed by the intended person or organization.

The second problem stems from the lack of access to the options for running the JVM in the browser context. For example, there is no simple way to deploy and use customized policy files as we could in the previous example. Instead, such policies will have to be set by files based on the JRE installation. Customized class loaders or security managers cannot be installed easily.

The third problem, the lack of support for the latest versions of the JRE in the default JVM with the browser, is solved by using the Java plug-in (see "Sidebar 2: Java Plug-in Primer"). Indeed, an underlying issue is that modification of policy files is not very straightforward. Since applets may be deployed on thousands or even millions of client machines, there might be environments where users might not have a good understanding of security or may not be acquainted with methods for modifying the policy file. The Java plug-in provides a workaround, although it's recommended to use policy files wherever practical and applicable.

Next, we'll look in more detail at applet security involving code-signing examples in a browser environment with a Java plug-in. We will confine the discussion to Java plug-in version 1.3 unless explicitly stated otherwise.

The Java plug-in and security

The Java plug-in supports the standard Java 2 SDK, Standard Edition (J2SE), including the security model. All applets run under the standard applet security manager, which prevents potentially malicious applets from performing dangerous operations, such as reading local files. RSA-signed applets can be deployed using the Java plug-in. Additionally, the Java plug-in attempts to run applets in an identical way in both Netscape Navigator and Internet Explorer by avoiding browser-specific resources. This ensures that an RSA-signed applet will run identically in both browsers with the Java plug-in. The Java plug-in also supports HTTPS, a secure version of HTTP.

In order for a plug-in-enhanced browser to trust an applet and grant it all privileges or a set of fine-grained permissions (as specified in a J2EE policy file), the user has to preconfigure his or her cache of trusted signer certificates (the .keystore file in JRE 1.3) to add the applet's signer to it. However, this solution does not scale well if the applet needs to be deployed on thousands of client machines, and may not always be feasible because users may not know in advance who signed the applet that they are trying to run. Also, earlier versions of the Java plug-in supported code signing using DSA, which is not as widely prevalent as RSA.

A new class loader, sun.plugin.security.PluginClassLoader in the Java plug-in 1.3, overcomes the limitations mentioned above. It implements support for RSA verification and dynamic trust management.

The Software Development Kit (SDK) tools

The three tools dealing with security, available as part of the Java 2 SDK, are:

  • keytool -- Manages keystores and certificates
  • jarsigner -- Generates and verifies JAR signatures
  • policytool -- Manages policy files via a GUI-based tool

We will look at some of these tools' important options in the sections below. Refer to Resources for more detailed documentation associated with particular tools.