xplenty-jruby_sandbox 0.2.4-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d06b08e73589246267426b4e93121d583a168c01
+  data.tar.gz: b72fcac1cc5956601d781cde42d74bae26516cf6
+SHA512:
+  metadata.gz: cc6380715019cb8f27918bca1f673e7164d90631495ae1821fdf57ed31707cf16575dfc7c69c288cc01517447a1866e91a61f69de907c633c3238cfc1c7e7eca
+  data.tar.gz: d0ae61acb863f50a86df5dca25eb9630c74ceee64bbe6487aef1d54629ef890a045a796014dc4779b461b373e36a112d5964dc1dad1227ff7f1feb8634c06a3b

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+.bundle
+.ruby-gemset
+Gemfile.lock
+lib/sandbox/sandbox.jar
+pkg/*
+tags
+tmp
+.DS_Store

data/.ruby-version

@@ -0,0 +1 @@
+jruby-1.7.9

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - jruby-19mode

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# JRuby Sandbox Changelog
+
+## 0.2.3 (April 24, 2014)
+
+* [SECURITY] Remove access to Object#java\_import.

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in jruby_sandbox.gemspec
+gemspec
+
+# this fork has some recent work done for 1.9, like File.foreach
+gem 'fakefs', :git => 'git://github.com/codeschool/fakefs.git', :require => 'fakefs/safe', :ref => "6ae3212e3dab013b4b5e290d1aceba6466b30dec"

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006 Ola Bini <ola@ologix.com>
+Copyright (c) 2011 Dray Lacy and Eric Allam
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+JRuby Sandbox
+=============
+
+[![Build Status](https://travis-ci.org/omghax/jruby-sandbox.png?branch=master)](https://travis-ci.org/omghax/jruby-sandbox)
+
+The JRuby sandbox is a reimplementation of \_why's freaky freaky sandbox
+in JRuby, and is heavily based on [javasand][1] by Ola Bini, but updated
+for JRuby 1.7.
+
+## Prerequisites
+
+This gem was developed against JRuby 1.7.6, and is known to work with 1.7.8,
+but has not been tested against other versions, so proceed at your own risk.
+The Travis CI configuration specifies the `jruby-19mode` target, which floats
+between exact versions of JRuby. At the time of writing, this is currently
+JRuby 1.7.8. You can see a list of Travis CI's provided rubies [here][2]. As
+long as the build is green you should be good to go.
+
+Installing JRuby is simple with RVM:
+
+    rvm install jruby-1.7.6
+
+## Building
+
+To build the JRuby extension, run `rake compile`. This will build the
+`lib/sandbox/sandbox.jar` file, which `lib/sandbox.rb` loads.
+
+## Basic Usage
+
+Sandbox gives you a self-contained JRuby interpreter in which to eval
+code without polluting the host environment.
+
+    >> require "sandbox"
+    => true
+    >> sand = Sandbox::Full.new
+    => #<Sandbox::Full:0x46377e2a>
+    >> sand.eval("x = 1 + 2") # we've defined x in the sandbox
+    => 3
+    >> sand.eval("x")
+    => 3
+    >> x # but it hasn't leaked out into the host interpreter
+    NameError: undefined local variable or method `x' for #<Object:0x11cdc190>
+
+There's also `Sandbox::Full#require`, which lets you invoke `Kernel#require`
+directly for the sandbox, so you can load any trusted core libraries. Note that
+this is a direct binding to `Kernel#require`, so it will only load ruby stdlib
+libraries (i.e. no rubygems support yet).
+
+## Sandbox::Safe usage
+
+Sandbox::Safe exposes an `#activate!` method which will lock down the sandbox,
+removing unsafe methods. Before calling `#activate!`, Sandbox::Safe is the same
+as Sandbox::Full.
+
+    >> require 'sandbox'
+    => true
+    >> sand = Sandbox.safe
+    => #<Sandbox::Safe:0x17072b90>
+    >> sand.eval %{`echo HELLO`}
+    => "HELLO\n"
+    >> sand.activate!
+    >> sand.eval %{`echo HELLO`}
+    Sandbox::SandboxException: NoMethodError: undefined method ``' for main:Object
+
+Sandbox::Safe works by whitelisting methods to keep, and removing the rest.
+Checkout sandbox.rb for which methods are kept.
+
+Sandbox::Safe.activate! will also isolate the sandbox environment from the
+filesystem using FakeFS.
+
+     >> require 'sandbox'
+     => true
+     >> s = Sandbox.safe
+     => #<Sandbox::Safe:0x3fdb8a73>
+     >> s.eval('Dir["/"]')
+     => ["/"]
+     >> s.eval('Dir["/*"]')
+     => ["/Applications", "/bin", "/cores", "/dev", etc.]
+     > s.activate!
+     >> s.eval('Dir["/*"]')
+     => []
+     > Dir['/*']
+     => ["/Applications", "/bin", "/cores", "/dev", etc.]
+
+## Known Issues / TODOs
+
+  * There is currently no timeout support, so it's possible for a
+    sandbox to loop indefinitely and block the host interpreter.
+
+[1]: http://ola-bini.blogspot.com/2006/12/freaky-freaky-sandbox-has-come-to-jruby.html
+[2]: http://about.travis-ci.org/docs/user/ci-environment/#Ruby-(aka-common)-VM-images

data/Rakefile

@@ -0,0 +1,24 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/javaextensiontask'
+
+Rake::JavaExtensionTask.new('sandbox') do |ext|
+  jruby_home = RbConfig::CONFIG['prefix']
+  ext.ext_dir = 'ext/java'
+  ext.lib_dir = 'lib/sandbox'
+  jars = ["#{jruby_home}/lib/jruby.jar"] + FileList['lib/*.jar']
+  ext.classpath = jars.map { |x| File.expand_path(x) }.join(':')
+end
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rspec_opts = ['--backtrace']
+end
+
+# Make sure the jar is up to date before running specs
+task :spec => :compile
+
+task :default => :spec

data/ext/java/sandbox/BoxedClass.java

@@ -0,0 +1,35 @@
+package sandbox;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.Block;
+
+@JRubyClass(name="BoxedClass")
+public class BoxedClass {
+  protected static RubyClass createBoxedClassClass(final Ruby runtime) {
+    RubyClass cObject = runtime.getObject();
+    RubyClass cBoxedClass = runtime.defineClass("BoxedClass", cObject, cObject.getAllocator());
+    cBoxedClass.defineAnnotatedMethods(BoxedClass.class);
+
+    return cBoxedClass;
+  }
+
+  @JRubyMethod(module=true, rest=true)
+  public static IRubyObject method_missing(IRubyObject recv, IRubyObject[] args, Block block) {
+    IRubyObject[] args2 = new IRubyObject[args.length - 1];
+    System.arraycopy(args, 1, args2, 0, args2.length);
+    String name = args[0].toString();
+
+    SandboxFull box = (SandboxFull) SandboxFull.getLinkedBox(recv);
+    return box.runMethod(recv, name, args2, block);
+  }
+
+  @JRubyMethod(name="new", meta=true, rest=true)
+  public static IRubyObject _new(IRubyObject recv, IRubyObject[] args, Block block) {
+    SandboxFull box = (SandboxFull) SandboxFull.getLinkedBox(recv);
+    return box.runMethod(recv, "new", args, block);
+  }
+}

data/ext/java/sandbox/SandboxFull.java

@@ -0,0 +1,317 @@
+package sandbox;
+
+import java.util.Collection;
+import java.util.Map;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyInstanceConfig;
+import org.jruby.RubyKernel;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.CompatVersion;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.internal.runtime.methods.DynamicMethod;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.common.IRubyWarnings;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.DynamicScope;
+
+
+@JRubyClass(name="Sandbox::Full")
+public class SandboxFull extends RubyObject {
+  protected static ObjectAllocator FULL_ALLOCATOR = new ObjectAllocator() {
+    public IRubyObject allocate(Ruby runtime, RubyClass klass) {
+      return new SandboxFull(runtime, klass);
+    }
+  };
+
+  private Ruby wrapped;
+  private DynamicScope currentScope;
+
+  protected SandboxFull(Ruby runtime, RubyClass type) {
+    super(runtime, type);
+    reload();
+  }
+
+  @JRubyMethod
+  public IRubyObject reload() {
+    RubyInstanceConfig cfg = new RubyInstanceConfig();
+    cfg.setObjectSpaceEnabled(getRuntime().getInstanceConfig().isObjectSpaceEnabled());
+    cfg.setInput(getRuntime().getInstanceConfig().getInput());
+    cfg.setOutput(getRuntime().getInstanceConfig().getOutput());
+    cfg.setError(getRuntime().getInstanceConfig().getError());
+    cfg.setCompatVersion(CompatVersion.RUBY1_9);
+    cfg.setScriptFileName("(sandbox)");
+
+    SandboxProfile profile = new SandboxProfile(this);
+    cfg.setProfile(profile);
+
+    wrapped = Ruby.newInstance(cfg);
+    currentScope = wrapped.getCurrentContext().getCurrentScope();
+
+    BoxedClass.createBoxedClassClass(wrapped);
+
+    return this;
+  }
+
+  @JRubyMethod(required=1)
+  public IRubyObject eval(IRubyObject str) {
+    try {
+      IRubyObject result = wrapped.evalScriptlet(str.asJavaString(), currentScope);
+      return unbox(result);
+    } catch (RaiseException e) {
+      String msg = e.getException().callMethod(wrapped.getCurrentContext(), "message").asJavaString();
+      String path = e.getException().type().getName();
+      RubyClass eSandboxException = (RubyClass) getRuntime().getClassFromPath("Sandbox::SandboxException");
+      throw new RaiseException(getRuntime(), eSandboxException, path + ": " + msg, false);
+    } catch (Exception e) {
+      e.printStackTrace();
+      getRuntime().getWarnings().warn(IRubyWarnings.ID.MISCELLANEOUS, "NativeException: " + e);
+      return getRuntime().getNil();
+    }
+  }
+
+  @JRubyMethod(name="import", required=1)
+  public IRubyObject _import(IRubyObject klass) {
+    if (!(klass instanceof RubyModule)) {
+      throw getRuntime().newTypeError(klass, getRuntime().getClass("Module"));
+    }
+    String name = ((RubyModule) klass).getName();
+    importClassPath(name, false);
+    return getRuntime().getNil();
+  }
+
+  @JRubyMethod(required=1)
+  public IRubyObject ref(IRubyObject klass) {
+    if (!(klass instanceof RubyModule)) {
+      throw getRuntime().newTypeError(klass, getRuntime().getClass("Module"));
+    }
+    String name = ((RubyModule) klass).getName();
+    importClassPath(name, true);
+    return getRuntime().getNil();
+  }
+
+  private RubyModule importClassPath(String path, final boolean link) {
+    RubyModule runtimeModule = getRuntime().getObject();
+    RubyModule wrappedModule = wrapped.getObject();
+
+    if (path.startsWith("#")) {
+      throw getRuntime().newArgumentError("can't import anonymous class " + path);
+    }
+
+    for (String name : path.split("::")) {
+      runtimeModule = (RubyModule) runtimeModule.getConstantAt(name);
+      // Create the module when it did not exist yet...
+      if (wrappedModule.const_defined_p(wrapped.getCurrentContext(), wrapped.newString(name)).isFalse()) {
+        // The BoxedClass takes the place of Object as top of the inheritance
+        // hierarchy. As a result, we can intercept all new instances that are
+        // created and all method_missing calls.
+        RubyModule sup = wrapped.getClass("BoxedClass");
+        if (!link && runtimeModule instanceof RubyClass) {
+          // If we're importing a class, recursively import all of its
+          // superclasses as well.
+          sup = importClassPath(runtimeModule.getSuperClass().getName(), true);
+        }
+        
+        RubyClass klass = (RubyClass) sup;
+        if (wrappedModule == wrapped.getObject()) {
+          
+          if (link || runtimeModule instanceof RubyClass) { // if this is a ref and not an import
+            wrappedModule = wrapped.defineClass(name, klass, klass.getAllocator());
+          } else {
+            wrappedModule = wrapped.defineModule(name);
+          }
+          
+        } else {
+          if (runtimeModule instanceof RubyClass) {
+            wrappedModule = wrappedModule.defineClassUnder(name, klass, klass.getAllocator());
+          } else {
+            wrappedModule = wrappedModule.defineModuleUnder(name);
+          }
+          
+        }
+      } else {
+        // ...or just resolve it, if it was already known
+        wrappedModule = (RubyModule) wrappedModule.getConstantAt(name);
+      }
+      
+      // Check the consistency of the hierarchy
+      if (runtimeModule instanceof RubyClass) {
+        if (!link && !runtimeModule.getSuperClass().getName().equals(wrappedModule.getSuperClass().getName())) {
+          throw getRuntime().newTypeError("superclass mismatch for class " + runtimeModule.getSuperClass().getName());
+        }
+      }
+
+      if (link || runtimeModule instanceof RubyClass) {
+        linkObject(runtimeModule, wrappedModule);
+      } else {
+        copyMethods(runtimeModule, wrappedModule);
+      }
+    }
+
+    return runtimeModule;
+  }
+
+  private void copyMethods(RubyModule from, RubyModule to) {
+    to.getMethodsForWrite().putAll(from.getMethods());
+    to.getSingletonClass().getMethodsForWrite().putAll(from.getSingletonClass().getMethods());
+  }
+
+  @JRubyMethod(required=2)
+  public IRubyObject keep_methods(IRubyObject className, IRubyObject methods) {
+    RubyModule module = wrapped.getModule(className.asJavaString());
+    if (module != null) {
+      keepMethods(module, methods.convertToArray());
+    }
+    return methods;
+  }
+
+  @JRubyMethod(required=2)
+  public IRubyObject keep_singleton_methods(IRubyObject className, IRubyObject methods) {
+    RubyModule module = wrapped.getModule(className.asJavaString()).getSingletonClass();
+    if (module != null) {
+      keepMethods(module, methods.convertToArray());
+    }
+    return methods;
+  }
+
+  private void keepMethods(RubyModule module, Collection retain) {
+    for (Map.Entry<String, DynamicMethod> methodEntry : module.getMethods().entrySet()) {
+      String methodName = methodEntry.getKey();
+      if (!retain.contains(methodName)) {
+        removeMethod(module, methodName);
+      }
+    }
+  }
+
+  @JRubyMethod(required=2)
+  public IRubyObject remove_method(IRubyObject className, IRubyObject methodName) {
+    RubyModule module = wrapped.getModule(className.asJavaString());
+    if (module != null) {
+      removeMethod(module, methodName.asJavaString());
+    }
+    return getRuntime().getNil();
+  }
+
+  @JRubyMethod(required=2)
+  public IRubyObject remove_singleton_method(IRubyObject className, IRubyObject methodName) {
+    RubyModule module = wrapped.getModule(className.asJavaString()).getSingletonClass();
+    if (module != null) {
+      removeMethod(module, methodName.asJavaString());
+    }
+    return getRuntime().getNil();
+  }
+
+  private void removeMethod(RubyModule module, String methodName) {
+    // System.err.println("removing method " + methodName + " from " + module.inspect().asJavaString());
+    module.removeMethod(wrapped.getCurrentContext(), methodName);
+  }
+
+  @JRubyMethod(required=1)
+  public IRubyObject load(IRubyObject str) {
+    try {
+      wrapped.getLoadService().load(str.asJavaString(), true);
+      return getRuntime().getTrue();
+    } catch (RaiseException e) {
+      e.printStackTrace();
+      return getRuntime().getFalse();
+    }
+  }
+
+  @JRubyMethod(required=1)
+  public IRubyObject require(IRubyObject str) {
+    try {
+      IRubyObject result = RubyKernel.require(wrapped.getKernel(), wrapped.newString(str.asJavaString()), Block.NULL_BLOCK);
+      return unbox(result);
+    } catch (RaiseException e) {
+      e.printStackTrace();
+      return getRuntime().getFalse();
+    }
+  }
+
+  private IRubyObject unbox(IRubyObject obj) {
+    return box(obj);
+  }
+
+  private IRubyObject rebox(IRubyObject obj) {
+    return box(obj);
+  }
+
+  private IRubyObject box(IRubyObject obj) {
+    if (obj.isImmediate()) {
+      return cross(obj);
+    } else {
+      // If this object already existed and was returned from the wrapped
+      // runtime on an earlier occasion, it will already contain a link to its
+      // brother in the regular runtime and we can safely return that link.
+      IRubyObject link = getLinkedObject(obj);
+      if (!link.isNil()) {
+        IRubyObject box = getLinkedBox(obj);
+        if (box == this) return link;
+      }
+
+      // Is the class already known on both sides of the fence?
+      IRubyObject klass = constFind(obj.getMetaClass().getRealClass().getName());
+      link = getRuntime().getNil();
+      if (!klass.isNil()) {
+        link = getLinkedObject(klass);
+      }
+
+      if (link.isNil()) {
+        return cross(obj);
+      } else {
+        IRubyObject v = ((RubyClass)klass).allocate();
+        linkObject(obj, v);
+        return v;
+      }
+    }
+  }
+
+  private IRubyObject cross(IRubyObject obj) {
+    IRubyObject dumped = wrapped.getModule("Marshal").callMethod(wrapped.getCurrentContext(), "dump", obj);
+    return getRuntime().getModule("Marshal").callMethod(getRuntime().getCurrentContext(), "load", dumped);
+  }
+
+  protected static IRubyObject getLinkedObject(IRubyObject arg) {
+    IRubyObject object = arg.getRuntime().getNil();
+    if (arg.getInstanceVariables().hasInstanceVariable("__link__")) {
+      object = (IRubyObject) arg.getInstanceVariables().getInstanceVariable("__link__");
+    }
+    return object;
+  }
+
+  protected static IRubyObject getLinkedBox(IRubyObject arg) {
+    IRubyObject object = arg.getRuntime().getNil();
+    if (arg.getInstanceVariables().hasInstanceVariable("__box__")) {
+      object = (IRubyObject) arg.getInstanceVariables().getInstanceVariable("__box__");
+    }
+    return object;
+  }
+
+  private void linkObject(IRubyObject runtimeObject, IRubyObject wrappedObject) {
+    wrappedObject.getInstanceVariables().setInstanceVariable("__link__", runtimeObject);
+    wrappedObject.getInstanceVariables().setInstanceVariable("__box__", this);
+  }
+
+  private IRubyObject constFind(String path) {
+    try {
+      return wrapped.getClassFromPath(path);
+    } catch (Exception e) {
+      return wrapped.getNil();
+    }
+  }
+
+  protected IRubyObject runMethod(IRubyObject recv, String name, IRubyObject[] args, Block block) {
+    IRubyObject[] args2 = new IRubyObject[args.length];
+    for (int i = 0; i < args.length; i++) {
+      args2[i] = unbox(args[i]);
+    }
+    IRubyObject recv2 = unbox(recv);
+    IRubyObject result = recv2.callMethod(getRuntime().getCurrentContext(), name, args2, block);
+    return rebox(result);
+  }
+}

data/ext/java/sandbox/SandboxModule.java

@@ -0,0 +1,39 @@
+package sandbox;
+
+import org.jruby.Profile;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class SandboxModule {
+  /**
+   * Create the Sandbox module and add it to the Ruby runtime.
+   */
+  public static RubyModule createSandboxModule(final Ruby runtime) {
+    RubyModule mSandbox = runtime.defineModule("Sandbox");
+    mSandbox.defineAnnotatedMethods(SandboxModule.class);
+
+    RubyClass cObject = runtime.getObject();
+    RubyClass cSandboxFull = mSandbox.defineClassUnder("Full", cObject, SandboxFull.FULL_ALLOCATOR);
+    cSandboxFull.defineAnnotatedMethods(SandboxFull.class);
+    RubyClass cStandardError = runtime.getStandardError();
+    RubyClass cSandboxException = mSandbox.defineClassUnder("SandboxException", cStandardError, cStandardError.getAllocator());
+
+    return mSandbox;
+  }
+
+  @JRubyClass(name="Sandbox::SandboxException", parent="StandardError")
+  public static class SandboxException {}
+
+  @JRubyMethod(name="current", meta=true)
+  public static IRubyObject s_current(IRubyObject recv) {
+    Profile prof = recv.getRuntime().getProfile();
+    if (prof instanceof SandboxProfile) {
+      return ((SandboxProfile) prof).getSandbox();
+    }
+    return recv.getRuntime().getNil();
+  }
+}

data/ext/java/sandbox/SandboxProfile.java

@@ -0,0 +1,22 @@
+package sandbox;
+
+import org.jruby.Profile;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class SandboxProfile implements Profile {
+  private IRubyObject sandbox;
+
+  public SandboxProfile(IRubyObject sandbox) {
+    this.sandbox = sandbox;
+  }
+
+  public IRubyObject getSandbox() {
+    return sandbox;
+  }
+
+  public boolean allowBuiltin(String name) { return true; }
+  public boolean allowClass(String name) { return true; }
+  public boolean allowModule(String name) { return true; }
+  public boolean allowLoad(String name) { return true; }
+  public boolean allowRequire(String name) { return true; }
+}

data/ext/java/sandbox/SandboxService.java

@@ -0,0 +1,17 @@
+package sandbox;
+
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class SandboxService implements BasicLibraryService {
+  public boolean basicLoad(Ruby runtime) throws IOException {
+    init(runtime);
+    return true;
+  }
+
+  private void init(Ruby runtime) {
+    SandboxModule.createSandboxModule(runtime);
+  }
+}

data/jruby_sandbox.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sandbox/version"
+
+Gem::Specification.new do |s|
+  s.name        = "xplenty-jruby_sandbox"
+  s.version     = Sandbox::VERSION
+  s.platform    = "java"
+  s.authors     = ["Dray Lacy", "Eric Allam", "Moty Michaely"]
+  s.email       = ["dray@envylabs.com", "eric@envylabs.com", "moty.mi@gmail.com"]
+  s.homepage    = "http://github.com/xplenty/jruby-sandbox"
+  s.summary     = "Sandbox support for JRuby"
+  s.description = "A version of _why's Freaky Freaky Sandbox for JRuby."
+
+  s.rubyforge_project = "jruby_sandbox"
+
+  s.files         = `git ls-files`.split("\n") + ["lib/sandbox/sandbox.jar"]
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "fakefs"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rake-compiler"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "yard"
+end

data/lib/sandbox/prelude.rb

@@ -0,0 +1,19 @@
+# Alternate "safer" versions of Ruby methods. Mostly non-blocking.
+[Fixnum, Bignum, Float].each do |klass|
+  klass.class_eval do
+    # A very weak version of pow, it doesn't work on Floats, but it's gonna
+    # fill the most common uses for now.
+    def **(x)
+      case x
+      when 0; 1
+      when 1; self
+      else
+        y = 1
+        while 0 <= (x -= 1) do
+          y *= self
+        end
+        y
+      end
+    end
+  end
+end