A Java applet downloaded from the Web runs in either a Java-enabled Web browser or a Java appletviewer, which is provided in the J2SE bundle. From a security standpoint, Java applets downloaded from the Internet or from any remote sources are restricted from reading and writing files and making network connections on client host systems. They are also restricted from starting other programs, loading libraries, or making native calls on the client host system. In general, applets downloaded from a network or remote sources are considered untrusted. An applet can be considered trusted, based on the following factors:
In a Web browser, a Java plug-in provides a common framework and enables secure deployment of applets in the browser using the JRE. While downloading an applet, the Java plug-in enables the browser to install all the class files and then render the applet. A security manager (SecurityManager implementation) will be automatically installed during startup whenever an applet starts running in a Java-enabled Web browser. No downloaded applets are allowed to access resources in the client host unless they are explicitly granted permission using an entry in a Java security policy file. Example 3-10 is source code for an applet named WriteFileApplet that attempts to create and to write to a file named AppletGenrtdFile in the local directory. Example 3-10. WriteFileApplet.javaimport java.awt.*; import java.io.*; import java.lang.*; import java.applet.*; public class WriteFileApplet extends Applet { String myFile = "/tmp/AppletGenrtdFile"; File f = new File(myFile); DataOutputStream dos; public void init() { String osname = System.getProperty("os.name"); if (osname.indexof("Windows") != -1) { myFile="C:" + file.separator + "AppletGenrtdFile"; } } public void paint(Graphics g) { try { dos = new DataOutputStream(new BufferedOutputStream (new FileOutputStream(myFile),128)); dos.writeChars("This is an Applet generated file\n"); dos.flush(); g.drawString("Success: Writing file" + myFile, 10, 10); } catch (SecurityException se) { g.drawString("Write Failed: Security exception: " + se, 10, 10); } catch (IOException ioe) { g.drawString("Write Failed:I/O exception" + ioe, 10, 10); } } } To run the applet, you need to compile the source code using javac and then you may choose to deploy this applet class along with an HTML page in a Web server. To do so, create an HTML file (see Example 3-11) called WriteFileApplet.html. Example 3-11. WriteFileApplet.html<html><head> <title> Core Security Patterns Example: Applet Security</title></head><body> <h1> WriteFileApplet: Writing Files in the Client host </h1> <hr> <APPLET CODE = WriteFileApplet.class WIDTH=400 HEIGHT=40> </APPLET> <hr></body> </html> To execute this applet using an appletviewer, run the following : appletviewer http://coresecuritypatterns.com/WriteFileApplet.html When executing this applet, you should receive the SecurityException in the applet window. This applet shouldn't be able to write the file, because it does not have a security policy with a file permission to write in the user's home directory. Now, let's use the following policy file WriteAppletPolicy, which grants a write permission. To do so, create a policy file (see Example 3-12) called WriteAppletPolicy.policy in the working directory: Example 3-12. WriteAppletPolicy.policygrant { permission java.io.FilePermission "<<ALL FILES>>","write"; }; To test the applet using an appletviewer, you may choose to use the -J-Djava.security.policy=WriteAppletPolicy.policy option on the JVM command line, or you can explicitly specify your policy file in the JVM security properties file in the <JAVA_HOME>/jre/lib/security directory: policy.url.3=file:/export/xyz/WriteAppletpolicy.policy Example 3-13 shows running the WriteFileApplet applet with the WriteAppletPolicy policy file from the command-line interface. Example 3-13. Running appletviewer using a Java security policyappletviewer -J-Djava.security.policy=WriteAppletPolicy.policy http://coresecuritypatterns.com/WriteFileApplet.html You should be able to run the WriteFileApplet applet successfully without a SecurityException, and it should also be able to create and write the file AppletGenrtdFile in the client's local directory. Now let's explore the concept of signed applets. Signed AppletsThe Java 2 platform introduced the notion of signed applets. Signing an applet ensures that an applet's origin and its integrity are guaranteed by a certificate authority (CA) and that it can be trusted to run with the permissions granted in the policy file. The J2SE bundle provides a set of security tools that allows the end users and administrators to sign applets and applications, and also to define local security policy. This is done by attaching a digital signature to the applet that indicates who developed the applet and by specifying a local security policy in a policy file mentioning the required access to local system resources. The Java 2 platform requires an executable applet class to be packaged into a JAR file before it is signed. The JAR file is signed using the private key of the applet creator. The signature is verified using its public key by the client user of the JAR file. The public key certificate is sent along with the JAR file to any client recipients who will use the applet. The client who receives the certificate uses it to authenticate the signature on the JAR file. To sign the applet, we need to obtain a certificate that is capable of code signing. For all production purposes, you must always obtain a certificate from a CA such as VeriSign, Thawte, or some other CA. The Java 2 platform introduced new key management tools to facilitate support for creating signed applets:
Let's take a look at the procedure involved in creating a signed applet using our previous WriteFileApplet applet example. The following steps are involved on the originating host environment responsible for developing and deploying the signed applet:
In addition to the previous steps, the following steps are involved in the client's environment:
|