Implementing a secure class loader..

Question

Hello,
We have a custom class loader which loads in custom packages from the database or from the file system. We want to ensure that these custom classes do not read or write into the file system. I want to restrict access to these classes when creating them. I read that by setting the proper permissions when defining the class, this could be possible. Here is my implementation of the class loader :
import java.io.File;
import java.io.FileInputStream;
import java.io.FilePermission;
import java.io.IOException;
import java.net.SocketPermission;
import java.net.URL;
import java.security.AccessController;
import java.security.CodeSource;
import java.security.PermissionCollection;
import java.security.Permissions;
import java.security.PrivilegedExceptionAction;
import java.security.SecureClassLoader;
public class TestClassLoader extends SecureClassLoader {
        JarParser jp;
        public TestClassLoader(JarParser jp) {
          super();
                this.jp = jp;
        public Class findClass(final String name) throws ClassNotFoundException {
               try {
                   return(Class)
                           AccessController.doPrivileged (
                                 new PrivilegedExceptionAction() {
                                               public Object run() throws ClassNotFoundException {
                                                     byte[] buf = null;
                                                        try {
                                                           if(jp == null)
                                                                  throw new ClassNotFoundException("Jar file not found");
                                                                String className = name.replace( '.', '/' ) + ".class";
                                                                buf = jp.getResource(className);
                                                                if(buf == null || buf.length == 0)
                                                                      throw new ClassNotFoundException("Class not found");
                                                                CodeSource cs = getCodeSource(name);
                                                                return defineClass(name, buf, 0, buf.length, cs);
                                                       catch(Exception e) {
                                                            throw new ClassNotFoundException(name, e);
               catch(Exception e) {
                    throw new ClassNotFoundException(name, e);
      * @param name
     protected CodeSource getCodeSource(String name) {
               try {
                   return new CodeSource(new URL("file", "localhost", name), null);
               catch(Exception e){
                     e.printStackTrace();
                return null;
        protected PermissionCollection getPermissions(CodeSource cs) {
          PermissionCollection pc = new Permissions();
                pc.add(new RuntimePermission("exitVM"));
                pc.add(new FilePermission("${user.home}${/}*", "read"));
                pc.add(new FilePermission("${user.dir}${/}*", "read"));
         pc.add(new SocketPermission("localhost", "resolve"));
                return pc;
        public static void main(String[] args) {
                try {
                   byte[] bytes = new byte[8192];
                  long ttlBytesRead = 0;
                  int noOfBytesToRead = 0;
                        File readFile = new File("test.jar");
                        // "length" here indicates the total no of bytes to read.
                      // This is equal to the file size sans the offset value.
                        long length = readFile.length();
                        Long temp;
                      FileInputStream readFis = null;
                        // Create the RandomAccessFile
                  try{
                             readFis = new FileInputStream(readFile);
                       catch(Exception e) {
                            throw new IOException(e.getMessage());
                       long tempLong;
                  StringBuffer buffer = new StringBuffer();
                        do {
                            if ((length - ttlBytesRead) > 8192)
                                     tempLong = 8192;
                                else
                                    tempLong = (length - ttlBytesRead);
                             temp = new Long((length - ttlBytesRead) > 8192 ? 8192 : (length - ttlBytesRead));
                               noOfBytesToRead = temp.intValue();
                              if(noOfBytesToRead == 0)
                                        break;
                          // Read the specified no of bytes into the byte
                                // array from the file.
                         try {
                                   readFis.read(bytes,0,noOfBytesToRead);
                               catch(Exception e1) {
                                   throw new IOException(e1.getMessage());
                               String str  = new String(bytes, 0, noOfBytesToRead);
                            buffer.append(str);
                                ttlBytesRead += noOfBytesToRead;
                        } while(ttlBytesRead < length);
                 try {
                           readFis.close();
                       catch(Exception e1) {}
                        JarParser jp = new JarParser("test.jar", buffer.toString().getBytes());
                 TestClassLoader tcl = new TestClassLoader(jp);
                  Class class1 = tcl.findClass("com.test.TestFileWrite");
                 Object obj = class1.newInstance();
               catch(Exception e) {
                    e.printStackTrace();
}JarParser is the class which parses through the jar file and caches the contents as bytes.
The test.jar contains a single class which writes into the user's home directory. As you can see, I have granted only read access on the home dir.
When I run this however, the newly loaded class does manage to write into the file system with no problems. Is there anything further that I need to do to enable restriction on the file system ?
Thanks.

Answer 1

If I've been reading correctly, they don't want you
subclassing SecurityManager for security any more.
Everything should be handled by the AccessController
using Permission objects. The easiest way to configure
the AccessController is through policy files.erg. where did you read this? I checked the 1.5.0 beta API just now, and nothing is officially deprecated.
:{  I don't have time to figure out the AccessController API right now.
I have yet to find a good tutorial on the matter of
security and classloaders. If anyone has a good
reference, it would be much appreciated.I second that.
And as a temporary solution (because we're already behind schedule), I went ahead and wrote my own SecurityManager, using the ideas I mentioned above.
I'm posting it at the site below in case anyone can offer any feedback (such as pointing out fatal weaknesses). We tried yesterday for an hour or so to break it, and it withstood all our tests; but security is not our specialty, so there's probably room for improvement.
(I'd post it in this message, but it's a wee bit large.)
www.personal.utulsa.edu/~jeremy-wood/software/ThreadBasedSecurityManager.java
(And if it passes your scrutiny and looks useful, feel free to use it. But note the disclaimers.)