rufus-eval 0.1

data/README.txt

@@ -0,0 +1,87 @@
+
+= rufus-eval
+
+The gem 'rufus-eval' is providing eval_safely() and instance_eval_safely(). The "safely" qualifier comes from playing with the $SAFE level. 
+
+Hopefully in the near future, something like a sandbox will be used to eval code 'safely'... Playing with Ruby2Ruby would be another alternative. Ruby 1.9 will maybe yield a decent answer to that code security issue.
+
+This rufus-eval currently doesn't work with JRuby (which doesn't respect the safe levels). The JRuby team is working closely with the Ruby team, so, waiting for future releases of [J]Ruby.
+
+
+== getting it
+
+    sudo gem install rufus-eval
+
+or at
+
+http://rubyforge.org/frs/?group_id=4812
+
+
+== usage
+
+    require 'rubygems'
+    require 'rufus/eval'
+
+    Rufus::eval_safely "5 * 5", 4
+        # => 25
+
+    class Toto
+    end
+    
+    Rufus::instance_eval_safely Toto.new, "@toto_name='surf'", 4
+        # => Insecure: can't modify instance variable (SecurityError)
+
+    t = Rufus::eval_safely "class Toto\ndef to_s\n"ok"; end; Toto.new", 4
+        # => extending class prohibited (SecurityError)
+
+    # ...
+
+The two methods provided are eval_safely and instance_eval_safely. Both take at least a string of source code and a safety level (2 to 4) as arguments. 
+
+The instance_eval_safely method takes an instance as first argument (the eval will be done in the 'context' of that instance).
+
+The eval_safely method takes a last optional argument, usually filled with the local binding()
+
+    def my_eval_method
+
+        a = 3
+        b = 7
+
+        Rufus::eval_safely("a * b", 4, binding())
+    end
+
+
+= dependencies
+
+None.
+
+
+== mailing list
+
+On the rufus-ruby list[http://groups.google.com/group/rufus-ruby] :
+
+    http://groups.google.com/group/rufus-ruby
+
+
+== issue tracker
+
+http://rubyforge.org/tracker/?atid=18584&group_id=4812&func=browse
+
+
+== source
+
+http://rufus.rubyforge.org/svn/trunk/eval
+
+    svn checkout http://rufus.rubyforge.org/svn/trunk/eval
+
+
+== author
+
+John Mettraux, jmettraux@gmail.com 
+http://jmettraux.wordpress.com
+
+
+== license
+
+MIT
+

data/lib/rufus/eval.rb

@@ -0,0 +1,146 @@
+#
+#--
+# Copyright (c) 2007-2008, John Mettraux, jmettraux@gmail.com
+#
+# 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.
+#++
+#
+
+#
+# "made in Japan"
+#
+# john.mettraux@openwfe.org
+#
+
+
+module Rufus
+
+    #--
+    # Runs some remote code (uri) at a different $SAFE level.
+    #
+    #def OpenWFE.load_safely (uri, safe_level)
+    #    source = ""
+    #    source << "#\n"
+    #    source << "# loaded from #{uri}\n"
+    #    source << "#\n"
+    #    source << open(uri).read
+    #    load_eval_safely(source, safe_level)
+    #end
+    #
+    #
+    # Makes sure that a piece of Ruby code is run at certain safe level.
+    # Saves in a temp file that is reloaded in its own anonymous namespace.
+    #
+    # (no binding passing allowed like in the basic Kernel.eval() method).
+    #
+    #def OpenWFE.load_eval_safely (code, safe_level)
+    #    tmpfname = 
+    #        "#{Dir.tmpdir}/"+
+    #        "owfe_#{code.object_id}_#{Time.new.to_f}.tmp.rb"
+    #    File.open tmpfname, "w" do |file|
+    #        file.print code
+    #    end
+    #    Thread.new do
+    #        $SAFE = safe_level
+    #        load(tmpfname, true)
+    #    end.join
+    #    begin
+    #        File.delete tmpfname
+    #    rescue Excpetion => e
+    #        # ignore
+    #    end
+    #end
+    #++
+
+    #
+    # Runs some code within an instance's realm at a certain safety level.
+    #
+    def Rufus.instance_eval_safely (instance, code, safe_level)
+
+        return instance.instance_eval(code) if on_jruby?
+
+        code.untaint
+
+        r = nil
+
+        Thread.new do
+            $SAFE = safe_level
+            r = instance.instance_eval(code)
+        end.join
+
+        raise "cannot TAMPER with JRUBY_VERSION" if on_jruby?
+
+        r
+    end
+
+    #
+    # Runs an eval() call at a certain safety level.
+    #
+    def Rufus.eval_safely (code, safe_level, binding=nil)
+
+        return eval(code, binding) if on_jruby?
+
+        code.untaint
+
+        binding.taint
+
+        r = nil
+
+        Thread.new do
+            $SAFE = safe_level
+            r = eval code, binding
+        end.join
+
+        raise "cannot TAMPER with JRUBY_VERSION" if on_jruby?
+
+        r
+    end
+
+    #--
+    # evals "requires" at the current safe level and the rest of the code
+    # at the requested safety level.
+    #
+    #def OpenWFE.eval_r_safely (code, safe_level, binding=nil)
+    #    code.untaint
+    #    c = ""
+    #    code.split("\n").each do |line|
+    #        if line.match "^ *require " and not line.index(";")
+    #            eval(line, binding)
+    #        else
+    #            c << line
+    #            c << "\n"
+    #        end
+    #    end
+    #    eval_safely(c, safe_level, binding)
+    #end
+    #++
+
+    protected
+
+        #
+        # Returns true if the JRUBY_VERSION is defined.
+        # (beware : something else than JRuby may have defined it).
+        #
+        def Rufus.on_jruby?
+
+            defined?(JRUBY_VERSION) != nil
+        end
+    
+end
+

data/test/test.rb

@@ -0,0 +1,84 @@
+
+#
+# Testing rufus-eval
+#
+# John Mettraux at openwfe.org
+#
+
+require 'tempfile'
+
+require 'test/unit'
+require 'rufus/eval'
+
+
+class EvalTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    #def test_0
+    #    assert_not_nil dotest("print ''", 4)
+    #    assert_not_nil dotest2("print ''", 4)
+    #    assert_nil dotest("print ''", 2)
+    #    assert_nil dotest2("print ''", 2)
+    #end
+
+    def test_1
+
+        if Rufus::on_jruby?
+            puts
+            puts "skipping safe tests as JRuby doesn't support $SAFE levels..."
+            return
+        end
+
+        assert_not_nil dotest3(STDOUT, "self.print ''", 4)
+        assert_nil dotest3(STDOUT, "self.print ''", 2)
+
+        assert_not_nil dotest3(nil, "print ''", 4)
+        assert_nil dotest3(nil, "print ''", 2)
+    end
+
+    protected
+
+        #def dotest (code, level)
+        #    tf = Tempfile.new "safely_test_temp.rb"
+        #    tf.puts code
+        #    tf.close
+        #    e = nil
+        #    begin
+        #        OpenWFE::load_safely(tf.path, level)
+        #    rescue Exception => e
+        #    end
+        #    File.delete(tf.path)
+        #    e
+        #end
+
+        #def dotest2 (code, level)
+        #    begin
+        #        OpenWFE::load_eval_safely(code, level)
+        #    rescue Exception => e
+        #        return e
+        #    end
+        #    nil
+        #end
+
+        def dotest3 (instance, code, level)
+
+            begin
+                if instance
+                    Rufus::instance_eval_safely instance, code, level
+                else
+                    Rufus::eval_safely code, level
+                end
+            rescue Exception => e
+                return e
+            end
+
+            nil
+        end
+
+end
+

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+name: rufus-eval
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- John Mettraux
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-01-25 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: 
+email: jmettraux@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- lib/rufus
+- lib/rufus/eval.rb
+- test/test.rb
+- README.txt
+has_rdoc: true
+homepage: http://rufus.rubyforge.org/rufus-eval
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 0.9.5
+signing_key: 
+specification_version: 2
+summary: an eval method, a bit safer
+test_files: 
+- test/test.rb