Home > Articles > Programming > Java

  • Print
  • + Share This
  • 💬 Discuss
This chapter is from the book

Java Applet Security

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:

  • Applets installed on a local filesystem or executed on a localhost.
  • Signed applets provide a way to verify that the applet is downloaded from a reliable source and can be trusted to run with the permissions granted in the policy file.

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.java

import 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.policy

grant {
  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 policy

appletviewer
 -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 Applets

The 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:

  • The keytool is used to create pairs of public and private keys, to import and display certificate chains, to export certificates, and to generate X.509 v1 self-signed certificates.
  • The jarsigner tool is used to sign JAR files and also to verify the authenticity of the signature(s) of signed JAR files.
  • The policytool is used to create and modify the security policy configuration files.

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:

  1. Compile the Applet source code to an executable class. Use the javac command to compile the WritefileApplet.java class. The output from the javac command is the WriteFileApplet.class.
    javac WriteFileApplet.java
    
  2. Package the compiled class into a JAR file. Use the jar utility with the cvf option to create a new JAR file with verbose mode (v), and specify the archive file name (f).
    jar cvf WriteFileApplet.jar WriteFileApplet.class
    
  3. Generate key pairs. Using the keytool utility, create the key pair and self-signed certificate (for testing purposes only). The JAR file is signed with the creator's private key and the signature is verified by the communicating peer of the JAR file with the public key in the pair.
    keytool -genkey -alias signapplet -keystore mykeystore
    -keypass mykeypass
    -storepass mystorepass
    
    This keytool -genkey command generates a key pair that is identified by the alias signapplet. Subsequent keytool commands are required to use this alias and the key password (-keypass mykeypass) to access the private key in the generated pair. The generated key pair is stored in a keystore database called mykeystore (-keystore mykeystore) in the current directory and is accessed with the mystorepass password (-storepass mystorepass). The command also prompts the signer to input information about the certificate, such as name, organization, location, and so forth.
  4. Sign the JAR file. Using the jarsigner utility (see Example 3-14), sign the JAR file and verify the signature on the JAR files.

    Example 3-14. Signing an applet using jarsigner tool

    jarsigner -keystore mykeystore -storepass mystorepass
    -keypass mykeypass -signedjar  SignedWriteFileApplet.jar
    WriteFileApplet.jar signapplet
    
    The -storepass mystorepass and -keystore mykeystore options specify the keystore database and password where the private key for signing the JAR file is stored. The -keypass mykeypass option is the password to the private key, SignedWriteFileApplet.jar is the name of the signed JAR file, and signapplet is the alias to the private key. jarsigner extracts the certificate from the keystore and attaches it to the generated signature of the signed JAR file.
  5. Export the public key certificate. The public key certificate will be sent with the JAR file to the end user who will use it to authenticate the signed applet. To have trusted interactions, the end user must have a copy of those public keys in its keystore. This is accomplished by exporting the public key certificate from the originating JAR signer keystore as a binary certificate file and then importing it into the client's keystore as a trusted certificate. Using the keytool, export the certificate from mykeystore to a file named mycertificate.cer as follows:
    keytool -export -keystore mykeystore
    -storepass mystorepass
            -alias signapplet -file mycertificate.cer
    
  6. Deploy the JAR and certificate files. They should be deployed to a distribution directory on a Web server. Additionally, create a Web page embedding the applet and the JAR. As shown in Example 3-15, the applet tag must use the following syntax.

    Example 3-15. Deploying a signedapplet Jar

    <applet code=WriteFileApplet.class
    archive="SignedWriteFileApplet.jar" codebase="/export/home/ws/"
                             width=400 height=40>
    </applet>
    

In addition to the previous steps, the following steps are involved in the client's environment:

  1. Import certificate as a trusted certificate. To download and execute the signed applet, you must import the trusted public key certificate (provided by the issuer) into a keystore database. The Java runtime will use this client-side keystore to store its trusted certificates and to authenticate the signed applet. Using the Keytool utility, import the trusted certificate provided by the issuer (see Example 3-16).

    Example 3-16. Importing a certificate

    keytool -import -alias clientcer –file mycertificate.cer
                -keystore clientstore -storepass clientpass
    
  2. Create the policy file. Create a policy file client.policy, which grants the applet to have permission for creating and writing to the file "AppletGenrtdFile" in the client's local directory (see Example 3-17).

    Example 3-17. Sample policy file (Client.policy)

    keystore "/export/home/clientstore";
    grant SignedBy "clientcer" {
      permission java.io.FilePermission "<<ALL FILES>>",   "write";
    };
    
  3. Run and test the applet using appletviewer. The appletviewer tool runs the HTML document specified in the URL, which displays the applet in its own window. To run the applet using the client policy file, enter the following at the command line (see Example 3-18).

    Example 3-18. Testing the applet using the client policy

    appletviewer -J-Djava.security.policy=client.policy
           http://coresecuritypatterns.com/SignedWriteFileApplet.html
    
  • + Share This
  • 🔖 Save To Your Account

Discussions

comments powered by Disqus