自定义java.policy配置(如何让你的类禁止读写文件？禁止创建Socket对象？)

最近做的项目有一个特殊的需求，由于系统是CS的，客户端需要自己编写JAVA类上传至服务器运行，整个流程如下：

1.客户端编写JAVA类，并实现特定接口

2.由客户端的JAVA编译器将其编译成class

3.客户端通过socket将class文件上传至服务器

4.服务器将class文件放至自己的classpath中，加载并执行

问题出在最后一步上，服务器虽然由我们完全控制，客户端编写的类虽然需要实现特定的接口，但执行具体内容不在我们控制范围内。也就是说，客户端上传的类中，完全可能写一段程序，读取服务器的所有文件，然后上传给另一台客户端可控制的机器上，这样就很容易地窃取了我们的整个系统。为了避免这种情况，能想到的解决方案有：

1.服务器接收到客户端上传的class后，不立即执行，而是增加一个审核的步骤，当上传的class通过审核后，才能够执行

2.让客户端上传的class在独立的沙箱中运行，类似于applet

第一种方案理论上是可行的，但是审核的步骤靠程序来实现相当困难，你需要先反编译class，然后再检查里面是否有类似file.listFiles(),reader.read(byte[] arr)这样的调用，这几乎无法实现。因为JAVA读取文件的方式有很多种，并且创建对象的方式也有很多种，可以直接new，也可以使用反射去创建，甚至调用读取方法也不直接调用，而使用反射去调，你如何使用程序去检查呢？那么能不能把审核的这一步骤交给人来做呢，安排一工作人员在class上传后先看看里面有没有恶意代码。这当然是可以的，但不是多出一个人员成本了吗？

第二种方案是比较理想的，即把你想控制的访问权限通过配置的方式告诉JVM，剩下的工作交给JVM来做。

虽然有了方向，但由于以前没有做过类似的功能，所以决定先上网搜一把。搜索的关键字为“java.policy配置”或“java沙箱模型”。不过很遗憾，文章虽然有很多，但经过自己动手测试才发现，写文章的人几乎没有人真正实践过，要么互相抄袭，要么就是随便翻译一下国外的文章。没办法，还是看JDK的文档吧，原文地址如下：

http://docs.oracle.com/javase/1.5.0/docs/guide/security/PolicyFiles.html

虽然写的不是很详细，但还算到位，关键的地方都写到了。经过一番摸索，终于实现了我想要的功能，客户端上传的代码如果有读写文件或者创建socket对象的操作，程序就会报权限不足的错误。这个功能的实现不需要修改服务器的代码，实在是太棒了。现将主要步骤分享如下：

1.启动SecurityManager开关

默认情况下，JVM是不启动安全检查的，所以要想让程序在沙箱中运行，必须将开关打开。打开的方式有两种，一种是在启动运行中追加JVM参数-Djava.security.manager，还有一种方式是在程序中直接设置：System.setSecurityManager(new SecurityManager());，这两种方式是等价的

2.修改jvm自带的java.policy文件，

java.policy文件位于%JAVA_HOME%/ jre/lib/security/下，默认内容如下：

// Standard extensions get all permissions by default

grant codeBase "file:${{java.ext.dirs}}/*" {
	permission java.security.AllPermission;
};

// default permissions granted to all domains

grant { 
	// Allows any thread to stop itself using the java.lang.Thread.stop()
	// method that takes no argument.
	// Note that this permission is granted by default only to remain
	// backwards compatible.
	// It is strongly recommended that you either remove this permission
	// from this policy file or further restrict it to code sources
	// that you specify, because Thread.stop() is potentially unsafe.
	// See "http://java.sun.com/notes" for more information.
	permission java.lang.RuntimePermission "stopThread";

	// allows anyone to listen on un-privileged ports
	permission java.net.SocketPermission "localhost:1024-", "listen";

	// "standard" properies that can be read by anyone

	permission java.util.PropertyPermission "java.version", "read";
	permission java.util.PropertyPermission "java.vendor", "read";
	permission java.util.PropertyPermission "java.vendor.url", "read";
	permission java.util.PropertyPermission "java.class.version", "read";
	permission java.util.PropertyPermission "os.name", "read";
	permission java.util.PropertyPermission "os.version", "read";
	permission java.util.PropertyPermission "os.arch", "read";
	permission java.util.PropertyPermission "file.separator", "read";
	permission java.util.PropertyPermission "path.separator", "read";
	permission java.util.PropertyPermission "line.separator", "read";

	permission java.util.PropertyPermission "java.specification.version", "read";
	permission java.util.PropertyPermission "java.specification.vendor", "read";
	permission java.util.PropertyPermission "java.specification.name", "read";

	permission java.util.PropertyPermission "java.vm.specification.version", "read";
	permission java.util.PropertyPermission "java.vm.specification.vendor", "read";
	permission java.util.PropertyPermission "java.vm.specification.name", "read";
	permission java.util.PropertyPermission "java.vm.version", "read";
	permission java.util.PropertyPermission "java.vm.vendor", "read";
	permission java.util.PropertyPermission "java.vm.name", "read";
};

 

里面定义了JAVA程序默认的权限，第一个grant定义了系统属性${{java.ext.dirs}}路径下的所有的class及jar(/*号表示所有class和jar，如果只是/则表示所有class但不包括jar)拥有所有的操作权限(java.security.AllPermission)，java.ext.dirs对应路径为%JAVA_HOME%/jre/lib/ext目录，而第二个grant后面定义了所有JAVA程序都拥有的权限，包括停止线程、启动Socket 服务器、读取部分系统属性。由于我要禁止客户端的class类启动socket，所以需删除或注释掉下面这句：

permission java.net.SocketPermission "localhost:1024-", "listen";

3.指定自己的policy文件，为了便于理解，这里我举个例子。假设客户端的class我放在C:/tmp目录下，假设类的代码如下：

package com.test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;

public class PolicyTest {

	public static void main(String[] args) {
		try {
			Class clazz = Class.forName("java.lang.Object");
			Object o = clazz.newInstance();
			Method m = o.getClass().getDeclaredMethod("toString");
			m.invoke(o);
			System.out.println("reflect access ok");
		} catch (Throwable e) {
			System.out.println(e.getMessage());
		}

		try {
			String userdir = System.getProperty("user.home");
			System.out.println("property read ok");
			// File f = new File(userdir + "/conf/x.properties");
		} catch (Throwable e) {
			System.out.println(e.getMessage());
		}

		try {
			ServerSocket s = new ServerSocket(8889);
			System.out.println("create socket server ok");
		} catch (Throwable e) {
			System.out.println(e.getMessage());
		}

		try {
			Socket s2 = new Socket("localhost", 8889);
			s2.close();
			System.out.println("create socket client ok");
		} catch (Throwable e) {
			System.out.println(e.getMessage());
		}

		File file = new File("C:/test.txt");
		try {
			read(file);
			System.out.println("file read ok");
		} catch (Throwable e) {
			System.out.println(e.getMessage());
		}

		try {
			write(file);
			System.out.println("file write ok");
		} catch (Throwable e) {
			System.out.println(e.getMessage());
		}
	}

	private static void read(File file) throws Throwable {
		InputStream in = null;
		BufferedReader reader = null;
		try {
			in = new FileInputStream(file);
			reader = new BufferedReader(new InputStreamReader(in));
			String temp = null;
			while ((temp = reader.readLine()) != null) {
				// System.out.println("read-->" + temp);
			}
		} catch (Throwable e) {
			throw e;
		} finally {
			if (in != null) {
				in.close();
			}
			if (reader != null) {
				reader.close();
			}
		}
	}

	private static void write(File file) throws Throwable {
		FileWriter fw = new FileWriter(file);
		for (int i = 0; i < 10; i++) {
			String temp = new java.util.Date() + " " + new java.util.Random().nextLong();
			// System.out.println("write-->" + temp);
			fw.write(temp + "\r\n");
		}
		fw.flush();
		fw.close();
	}

}

代码很简单，包括使用反射、读取系统属性、创建socket、读写文件的操作，把编译后的class放至C:/tmp/com/test目录下，然后在C:/tmp目录用命令行下执行java com.test.PolicyTest，可以看到，操作都可以成功：

但如果执行java -Djava.security.manager com.test.PolicyTest，你会看到以下结果：

很明显，由于我们启动了安全检查，这里的操作全部失败。现在，到了编写自己的policy文件的时候了，我取名为my.policy，内容如下： 

grant codeBase "file:/C:/tmp/*" {
    permission java.security.AllPermission;
};

我把这个文件也放在C:/tmp下，然后执行
java -Djava.security.manager -Djava.security.policy=my.policy com.test.PolicyTest

由于我分配的是AllPermission，所以全部操作都能成功，但这不是我想要的。我希望使用反射和读取系统属性能成功，而创建socket和读写文件要失败，于是更改my.policy：

grant codeBase "file:/C:/tmp/*" {
    permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
    permission java.lang.RuntimePermission "accessDeclaredMembers";
    permission java.util.PropertyPermission "*", " read,write";
};

然后再次执行java -Djava.security.manager -Djava.security.policy=my.policy com.test.PolicyTest

达到理想效果了，反射和系统属性读取没有问题，socket创建及文件读写被禁止。

4.通过上面的PolicyTest示例，得出解决我的问题的方案是，把服务器的class和客户端class分别放在不同的classpath 下，以windows为例(如果是在linux上，只需要更改对应的路径即可)，假设服务器的class文件放在C:/classes/local下，而客户端上传的class放在C:/classes/remote下，my.policy放在C:/classes下，内容为：

grant codeBase "file:/C:/classes/local/*" {
    permission java.security.AllPermission;
};
grant codeBase "file:/C:/classes/remote/*" {
    permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
    permission java.lang.RuntimePermission "accessDeclaredMembers";
    permission java.util.PropertyPermission "*", " read,write";
};

对应的启动脚本为java -Djava.security.manager -Djava.security.policy=C:/classes/my.policy -classpath C:/classes/local;C:/classes/remote xx.MainClass注意：如果是linux，除了更改对应路径外，还需要把classpath中的;号改为:号。

5.大功告成！你可能会问，我怎么知道有哪些权限可以配置，如何配置呢？除了看官方的文档说明外，还有一个小技巧。就是实现自己的SecurityManager，然后覆盖checkPermission(Permission perm)方法，如下：

package com.test;
import java.security.Permission;
public class MySecurityManager extends SecurityManager {
 public void checkPermission(Permission perm) {
  System.out.println("perm=" + perm);
  super.checkPermission(perm);
 }
}

为了让MySecurityManager有效，你可以直接在代码中通过System.setSecurityManager(new MySecurityManager());设置，或者在JVM参数中设置-Djava.security.manager=com.test.MySecurityManager，这两种方式是一样的，运行方式还是一样：java -Djava.security.manager=com.test.MySecurityManager -Djava.security.policy=my.policy com.test.PolicyTest

内容太多，未显示全，不过可以看到，你需要获取的权限都被打印了出来。