jruby-safe 0.2.2-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7d4c4406a2d5008327fa781205106f933f84d15d
+  data.tar.gz: d09fc7ecc14e297a1c676cd0b61d15c87bef0bf5
+SHA512:
+  metadata.gz: 620de9cf546f5cd64d3e55a5c392be8598536ab9f2352da7d684344bd6bc1ccded760bba49f625e97fd0afec5dcd94acb02c9474763f65abe54e0e06982880df
+  data.tar.gz: c2c28c23359031787148a6d7dbf563f00843e94bc99640ba36baaa990ef2c93eb89f197b02ee622d02e9b5dc9c4e1eac53cc42733e50b33aca1e64e55aceed03

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+.ruby-gemset
+lib/sandbox/sandbox.jar
+pkg/*
+tags
+tmp
+vendor

data/.ruby-version

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

data/.travis.yml

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

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/Gemfile.lock

@@ -0,0 +1,40 @@
+GIT
+  remote: git://github.com/codeschool/fakefs.git
+  revision: 6ae3212e3dab013b4b5e290d1aceba6466b30dec
+  ref: 6ae3212e3dab013b4b5e290d1aceba6466b30dec
+  specs:
+    fakefs (0.4.0)
+
+PATH
+  remote: .
+  specs:
+    jruby-safe (0.2.2-java)
+      fakefs
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    rake (0.9.2)
+    rake-compiler (0.7.9)
+      rake
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    yard (0.7.2)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  fakefs!
+  jruby-safe!
+  rake
+  rake-compiler
+  rspec
+  yard

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,71 @@
+JRuby Safe
+=============
+
+The JRuby safe is a clone of [jruby-sandbox](https://github.com/omghax/jruby-sandbox)
+
+## Building
+
+To build the JRuby extension, run `rake compile`. This will build the
+`lib/sandbox/sandbox.jar` file, which `lib/sandbox.rb` loads.
+
+## Testing
+
+    $ bundle install --path vendor/bundle
+    $ bundle exec rake spec
+
+## 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.]

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,356 @@
+package sandbox;
+
+import java.util.Collection;
+import java.util.Map;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyBinding;
+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.Binding;
+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;
+  }
+
+  private static abstract class EvalBinding {
+    public abstract Binding convertToBinding(IRubyObject scope);
+  }
+
+  private static EvalBinding evalBinding19 = new EvalBinding() {
+    @Override
+    public Binding convertToBinding(IRubyObject scope) {
+      if (scope instanceof RubyBinding) {
+        return ((RubyBinding)scope).getBinding().cloneForEval();
+      } else {
+        throw scope.getRuntime().newTypeError("wrong argument type " + scope.getMetaClass() + " (expected Binding)");
+      }
+    }
+  };
+
+  @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(required=2)
+  public IRubyObject eval_with_binding(IRubyObject str, IRubyObject argBinding) {
+    try {
+      //IRubyObject result = wrapped.evalScriptlet(str.asJavaString());
+      //boolean bindingGiven = args.length > 1 && !args[1].isNil();
+      //Binding binding = bindingGiven ? evalBinding.convertToBinding(args[1]) : context.currentBinding();
+      Binding binding = evalBinding19.convertToBinding(argBinding);
+      DynamicScope scope = binding.getEvalScope(getRuntime());
+      IRubyObject result = wrapped.evalScriptlet(str.asJavaString(), scope);
+      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);
+  }
+}