在允许用户提交自己的代码以由服务器运行的模拟服务器环境中，任何用户提交的代码在沙箱中运行显然是有利的，这与 Applet 在浏览器中的情况不同。我希望能够利用 JVM 本身，而不是添加另一个 VM 层来隔离这些提交的组件。
使用现有的 Java 沙箱模型似乎可以实现这种限制，但是是否有一种动态方法可以仅针对正在运行的应用程序的用户提交部分启用该限制？
问问题
23307 次
7 回答
115
在自己的线程中运行不受信任的代码。例如，这可以防止无限循环等问题，并使未来的步骤更容易。让主线程等待线程完成，如果时间过长，使用 Thread.stop 将其终止。Thread.stop 已被弃用，但由于不受信任的代码不应访问任何资源，因此将其杀死是安全的。
在该线程上设置一个SecurityManager 。创建一个 SecurityManager 的子类，它覆盖checkPermission(Permission perm)以简单地为除少数几个权限之外的所有权限抛出SecurityException 。这里有一个方法列表和它们所需的权限：Java TM 6 SDK中的权限。
使用自定义 ClassLoader 加载不受信任的代码。您的类加载器将被不受信任的代码使用的所有类调用，因此您可以执行诸如禁用对单个 JDK 类的访问之类的操作。要做的事情是有一个允许的 JDK 类的白名单。
您可能希望在单独的 JVM 中运行不受信任的代码。虽然前面的步骤可以使代码安全，但隔离代码仍然可以做一件烦人的事情：尽可能多地分配内存，这会导致主应用程序的可见占用空间增加。
JSR 121：应用程序隔离 API 规范旨在解决这个问题，但遗憾的是它还没有实现。
这是一个非常详细的话题，我主要是在脑海中写下这一切。
但无论如何，一些不完美的，使用风险自负，可能有错误（伪）代码：
类加载器
class MyClassLoader extends ClassLoader {
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
if (name is white-listed JDK class) return super.loadClass(name);
return findClass(name);
}
@Override
public Class findClass(String name) {
byte[] b = loadClassData(name);
return defineClass(name, b, 0, b.length);
}
private byte[] loadClassData(String name) {
// load the untrusted class data here
}
}
安全管理器
class MySecurityManager extends SecurityManager {
private Object secret;
public MySecurityManager(Object pass) { secret = pass; }
private void disable(Object pass) {
if (pass == secret) secret = null;
}
// ... override checkXXX method(s) here.
// Always allow them to succeed when secret==null
}
线
class MyIsolatedThread extends Thread {
private Object pass = new Object();
private MyClassLoader loader = new MyClassLoader();
private MySecurityManager sm = new MySecurityManager(pass);
public void run() {
SecurityManager old = System.getSecurityManager();
System.setSecurityManager(sm);
runUntrustedCode();
sm.disable(pass);
System.setSecurityManager(old);
}
private void runUntrustedCode() {
try {
// run the custom class's main method for example:
loader.loadClass("customclassname")
.getMethod("main", String[].class)
.invoke(null, new Object[]{...});
} catch (Throwable t) {}
}
}
于 2009-02-02T06:49:38.380 回答
18
显然，这样的方案引发了各种安全问题。Java 有一个严格的安全框架，但它并不是微不足道的。不应该忽视搞砸它并让非特权用户访问重要系统组件的可能性。
除了这个警告之外，如果您以源代码的形式获取用户输入，您需要做的第一件事就是将其编译为 Java 字节码。AFIAK，这不能在本地完成，因此您需要对 javac 进行系统调用，并将源代码编译为磁盘上的字节码。这是一个可以用作此起点的教程。 编辑：正如我在评论中了解到的，您实际上可以使用javax.tools.JavaCompiler从源代码本地编译 Java 代码
一旦有了 JVM 字节码，就可以使用ClassLoader 的 defineClass函数将其加载到 JVM 中。要为这个加载的类设置一个安全上下文，你需要指定一个ProtectionDomain。ProtectionDomain的最小构造函数需要 CodeSource 和PermissionCollection。PermissionCollection 是您在这里主要使用的对象 - 您可以使用它来指定加载的类具有的确切权限。这些权限最终应该由 JVM 的AccessController强制执行。
这里有很多可能的错误点，在你实施任何东西之前，你应该非常小心地完全理解一切。
于 2009-02-02T06:24:53.330 回答
12
Java-Sandbox是一个用于执行具有有限权限的 Java 代码的库。
它可用于仅允许访问一组列入白名单的类和资源。它似乎无法限制对单个方法的访问。它使用带有自定义类加载器和安全管理器的系统来实现这一点。
我没有使用过它，但它看起来设计得很好并且记录得很好。
@waqas 给出了一个非常有趣的答案，解释了如何实现自己。但是将此类安全关键和复杂的代码留给专家会更安全。
注意：该项目自 2013 年以来没有更新，创建者将其描述为“实验性”。它的主页已经消失，但 Source Forge 条目仍然存在。
改编自项目网站的示例代码：
SandboxService sandboxService = SandboxServiceImpl.getInstance();
// Configure context
SandboxContext context = new SandboxContext();
context.addClassForApplicationLoader(getClass().getName());
context.addClassPermission(AccessType.PERMIT, "java.lang.System");
// Whithout this line we get a SandboxException when touching System.out
context.addClassPermission(AccessType.PERMIT, "java.io.PrintStream");
String someValue = "Input value";
class TestEnvironment implements SandboxedEnvironment<String> {
@Override
public String execute() throws Exception {
// This is untrusted code
System.out.println(someValue);
return "Output value";
}
};
// Run code in sandbox. Pass arguments to generated constructor in TestEnvironment.
SandboxedCallResult<String> result = sandboxService.runSandboxed(TestEnvironment.class,
context, this, someValue);
System.out.println(result.get());
于 2013-11-17T21:13:07.513 回答
6
要解决已接受答案中的问题，即自定义SecurityManager将应用于 JVM 中的所有线程，而不是基于每个线程，您可以创建一个SecurityManager可以为特定线程启用/禁用的自定义，如下所示：
import java.security.Permission;
public class SelectiveSecurityManager extends SecurityManager {
private static final ToggleSecurityManagerPermission TOGGLE_PERMISSION = new ToggleSecurityManagerPermission();
ThreadLocal<Boolean> enabledFlag = null;
public SelectiveSecurityManager(final boolean enabledByDefault) {
enabledFlag = new ThreadLocal<Boolean>() {
@Override
protected Boolean initialValue() {
return enabledByDefault;
}
@Override
public void set(Boolean value) {
SecurityManager securityManager = System.getSecurityManager();
if (securityManager != null) {
securityManager.checkPermission(TOGGLE_PERMISSION);
}
super.set(value);
}
};
}
@Override
public void checkPermission(Permission permission) {
if (shouldCheck(permission)) {
super.checkPermission(permission);
}
}
@Override
public void checkPermission(Permission permission, Object context) {
if (shouldCheck(permission)) {
super.checkPermission(permission, context);
}
}
private boolean shouldCheck(Permission permission) {
return isEnabled() || permission instanceof ToggleSecurityManagerPermission;
}
public void enable() {
enabledFlag.set(true);
}
public void disable() {
enabledFlag.set(false);
}
public boolean isEnabled() {
return enabledFlag.get();
}
}
ToggleSecurirtyManagerPermission只是一个简单的实现，java.security.Permission以确保只有授权代码才能启用/禁用安全管理器。它看起来像这样：
import java.security.Permission;
public class ToggleSecurityManagerPermission extends Permission {
private static final long serialVersionUID = 4812713037565136922L;
private static final String NAME = "ToggleSecurityManagerPermission";
public ToggleSecurityManagerPermission() {
super(NAME);
}
@Override
public boolean implies(Permission permission) {
return this.equals(permission);
}
@Override
public boolean equals(Object obj) {
if (obj instanceof ToggleSecurityManagerPermission) {
return true;
}
return false;
}
@Override
public int hashCode() {
return NAME.hashCode();
}
@Override
public String getActions() {
return "";
}
}
于 2014-08-26T02:32:08.690 回答
5
这是该问题的线程安全解决方案：
package de.unkrig.commons.lang.security;
import java.security.AccessControlContext;
import java.security.Permission;
import java.security.Permissions;
import java.security.ProtectionDomain;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;
import de.unkrig.commons.nullanalysis.Nullable;
/**
* This class establishes a security manager that confines the permissions for code executed through specific classes,
* which may be specified by class, class name and/or class loader.
* <p>
* To 'execute through a class' means that the execution stack includes the class. E.g., if a method of class {@code A}
* invokes a method of class {@code B}, which then invokes a method of class {@code C}, and all three classes were
* previously {@link #confine(Class, Permissions) confined}, then for all actions that are executed by class {@code C}
* the <i>intersection</i> of the three {@link Permissions} apply.
* <p>
* Once the permissions for a class, class name or class loader are confined, they cannot be changed; this prevents any
* attempts (e.g. of the confined class itself) to release the confinement.
* <p>
* Code example:
* <pre>
* Runnable unprivileged = new Runnable() {
* public void run() {
* System.getProperty("user.dir");
* }
* };
*
* // Run without confinement.
* unprivileged.run(); // Works fine.
*
* // Set the most strict permissions.
* Sandbox.confine(unprivileged.getClass(), new Permissions());
* unprivileged.run(); // Throws a SecurityException.
*
* // Attempt to change the permissions.
* {
* Permissions permissions = new Permissions();
* permissions.add(new AllPermission());
* Sandbox.confine(unprivileged.getClass(), permissions); // Throws a SecurityException.
* }
* unprivileged.run();
* </pre>
*/
public final
class Sandbox {
private Sandbox() {}
private static final Map<Class<?>, AccessControlContext>
CHECKED_CLASSES = Collections.synchronizedMap(new WeakHashMap<Class<?>, AccessControlContext>());
private static final Map<String, AccessControlContext>
CHECKED_CLASS_NAMES = Collections.synchronizedMap(new HashMap<String, AccessControlContext>());
private static final Map<ClassLoader, AccessControlContext>
CHECKED_CLASS_LOADERS = Collections.synchronizedMap(new WeakHashMap<ClassLoader, AccessControlContext>());
static {
// Install our custom security manager.
if (System.getSecurityManager() != null) {
throw new ExceptionInInitializerError("There's already a security manager set");
}
System.setSecurityManager(new SecurityManager() {
@Override public void
checkPermission(@Nullable Permission perm) {
assert perm != null;
for (Class<?> clasS : this.getClassContext()) {
// Check if an ACC was set for the class.
{
AccessControlContext acc = Sandbox.CHECKED_CLASSES.get(clasS);
if (acc != null) acc.checkPermission(perm);
}
// Check if an ACC was set for the class name.
{
AccessControlContext acc = Sandbox.CHECKED_CLASS_NAMES.get(clasS.getName());
if (acc != null) acc.checkPermission(perm);
}
// Check if an ACC was set for the class loader.
{
AccessControlContext acc = Sandbox.CHECKED_CLASS_LOADERS.get(clasS.getClassLoader());
if (acc != null) acc.checkPermission(perm);
}
}
}
});
}
// --------------------------
/**
* All future actions that are executed through the given {@code clasS} will be checked against the given {@code
* accessControlContext}.
*
* @throws SecurityException Permissions are already confined for the {@code clasS}
*/
public static void
confine(Class<?> clasS, AccessControlContext accessControlContext) {
if (Sandbox.CHECKED_CLASSES.containsKey(clasS)) {
throw new SecurityException("Attempt to change the access control context for '" + clasS + "'");
}
Sandbox.CHECKED_CLASSES.put(clasS, accessControlContext);
}
/**
* All future actions that are executed through the given {@code clasS} will be checked against the given {@code
* protectionDomain}.
*
* @throws SecurityException Permissions are already confined for the {@code clasS}
*/
public static void
confine(Class<?> clasS, ProtectionDomain protectionDomain) {
Sandbox.confine(
clasS,
new AccessControlContext(new ProtectionDomain[] { protectionDomain })
);
}
/**
* All future actions that are executed through the given {@code clasS} will be checked against the given {@code
* permissions}.
*
* @throws SecurityException Permissions are already confined for the {@code clasS}
*/
public static void
confine(Class<?> clasS, Permissions permissions) {
Sandbox.confine(clasS, new ProtectionDomain(null, permissions));
}
// Code for 'CHECKED_CLASS_NAMES' and 'CHECKED_CLASS_LOADERS' omitted here.
}
请给出意见！
铜
阿诺
于 2014-06-14T23:07:19.777 回答
4
好吧，现在给出任何建议或解决方案已经很晚了，但我仍然面临着类似的问题，更多的是面向研究的。基本上，我试图为电子学习平台中的 Java 课程的编程作业提供规定和自动评估。
- 一种方法可能是，为每个学生创建一个单独的虚拟机（不是 JVM），但实际的虚拟机具有最低配置可能的操作系统。
- 根据您的编程语言安装 JRE for Java 或库，无论您希望学生在这些机器上编译和执行哪种。
我知道这听起来很复杂而且任务很多，但是 Oracle Virtual Box 已经提供了 Java API 来动态创建或克隆虚拟机。 https://www.virtualbox.org/sdkref/index.html（注意，即使 VMware 也提供 API 来做同样的事情）
对于最小尺寸和配置的 Linux 发行版，您可以在这里参考http://www.slitaz.org/en/，
所以现在如果学生搞砸了或试图这样做，可能是内存或文件系统或网络、套接字，他可能会损坏他自己的虚拟机。
在这些 VM 内部，您还可以提供额外的安全性，例如 Java 的 Sandbox（安全管理器）或在 Linux 上创建用户特定帐户，从而限制访问。
希望这可以帮助 ！！
于 2015-03-12T23:51:06.373 回答
1
您可能需要使用自定义SecurityManger和/或AccessController。有关详细信息，请参阅Sun的Java 安全架构和其他安全文档。
于 2009-02-02T05:44:16.780 回答