nodewrap 0.5.0

data/lib/nwobfusc.rb

@@ -0,0 +1,57 @@
+# A code obfuscator for Ruby.  It works by getting a dump of the node
+# tree, then wrapping it with a lightweight loader.
+#
+# NOTE: This code is for demonstration purposes only!  It has not been
+# extensively tested, and I cannot guarantee that it works in all cases
+# (I don't even know what the corner cases are).  If you wish to use
+# this in a commercial product, please verify that the code is correctly
+# loaded.
+#
+# Usage:
+#
+#   $ cat test.rb
+#   def foo
+#     1+1
+#   end
+#   
+#   puts foo()
+#
+#   $ ruby -rnwobfusc test.rb > test2.rb
+#   $ ruby test2.rb
+#   2
+
+require 'nodewrap'
+
+def obfusc(begin_nodes, n)
+  # The outputted code must do the following:
+  #   1. Evaluate each of the begin nodes (BEGIN {...}).
+  #   2. Evaluate the main node.
+  puts <<-END
+require 'nodewrap'
+if RUBY_VERSION != "#{RUBY_VERSION}" then
+  $stderr.puts "Wrong Ruby version; please use #{RUBY_VERSION}"
+  exit 1
+end
+begin_nodes = Marshal.load(#{Marshal.dump(begin_nodes).inspect})
+n = Marshal.load(#{Marshal.dump(n).inspect})
+begin_nodes.each do |node|
+  node.eval(self)
+end
+n.eval(self)
+  END
+end
+
+begin_nodes = []
+set_trace_func proc {
+  n = $ruby_eval_tree
+  if defined?($ruby_eval_tree_begin) and $ruby_eval_tree_begin then
+    n.pretty_print($stderr)
+    begin_nodes << $ruby_eval_tree_begin
+  end
+  if n then
+    # TODO: Do I need to include ruby_dyna_vars?
+    obfusc(begin_nodes, n)
+    exit
+  end
+}
+

data/lib/procsig.rb

@@ -0,0 +1,182 @@
+require 'node_to_a'
+
+class Proc
+  class Arguments
+    include Enumerable
+
+    def initialize(names, multiple_assignment, rest_arg)
+      @names = names
+      @multiple_assignment = multiple_assignment
+      @rest_arg = rest_arg
+    end
+
+    def unspecified
+      if defined?(VM) and defined?(VM::InstructionSequence) then
+        # YARV
+        return @names.length == 0
+      else
+        # pre-YARV
+        @names.nil?
+      end
+    end
+
+    def single_assignment
+      !@multiple_assignment
+    end
+
+    def multiple_assignment
+      @multiple_assignment
+    end
+
+    def names
+      @names
+    end
+
+    def [](idx)
+      @names[idx]
+    end
+
+    def each(&block)
+      (@names || []).each(&block)
+    end
+
+    def size
+      @names.size
+    end
+
+    def rest_arg
+      @rest_arg
+    end
+
+    def empty_last_arg
+      if defined?(VM) and defined?(VM::InstructionSequence) then
+        # YARV
+        return (@rest_arg and @names[-1] == nil)
+      else
+        # pre-YARV
+        return (@names.size == 1 and not @rest_arg)
+      end
+    end
+  end
+
+  # Return an Arguments object representing the arguments in the order
+  # in which they appear in the argument list.
+  def arguments
+    has_rest_arg = self.has_rest_arg
+
+    if self.respond_to?(:var) and self.var then
+      # pre-YARV
+      case self.var
+      when Node::DASGN_CURR
+        return Arguments.new([ self.var.vid ], false, has_rest_arg ? 0 : nil)
+      when Node::MASGN
+        if self.var.head then
+          a = self.var.head.to_a
+          args = a.map { |n| n.vid }
+        else
+          args = []
+        end
+        if self.var.args then
+          args.push(self.var.args.vid)
+        end
+        return Arguments.new(args, true, has_rest_arg ? args.size - 1: nil)
+      when Fixnum
+        return Arguments.new([], false, has_rest_arg ? 0 : nil)
+      else
+        raise "Unexpected node type: #{self.var.class}"
+      end
+    elsif
+      # YARV
+      iseq = self.body
+      local_vars = iseq.local_table
+      has_rest_arg = iseq.arg_rest != -1
+      has_block_arg = iseq.arg_block != -1
+      num_args = \
+        iseq.argc + \
+        iseq.arg_opt_table.size + \
+        (has_rest_arg ? 1 : 0) + \
+        (has_block_arg ? 1 : 0)
+      puts "argc=#{iseq.argc}, opt_table.size=#{iseq.arg_opt_table.size}"
+      puts "has_rest_arg=#{has_rest_arg}, has_block_arg=#{has_block_arg}"
+      names = local_vars[0...num_args]
+      # TODO: masgn
+      return Arguments.new(names, true, has_rest_arg ? -1 : nil)
+    else
+      return Arguments.new(nil, false, nil)
+    end
+  end
+
+  # Return true if the proc has a rest arg
+  def has_rest_arg
+    if self.respond_to?(:var) then
+      # pre-YARV
+      has_rest_arg = false
+      if self.var then
+        if self.var.class == Node::MASGN then
+          if self.var.args then
+            has_rest_arg = true
+          end
+        end
+      end
+    else
+      # YARV
+      rest = self.body.arg_rest
+      has_rest_arg = (rest >= 0 ? rest - 1 : nil)
+    end
+    return has_rest_arg
+  end
+
+  # Return a hash mapping each argument name to a description of that
+  # argument.
+  def argument_info
+    args = self.arguments()
+
+    info = {}
+    args.each do |name|
+      info[name] = name.to_s
+    end
+
+    # Rest arg
+    if args.rest_arg then
+      rest_name = args[args.rest_arg]
+      if rest_name then
+        info[rest_name] = "*#{rest_name}"
+      end
+    end
+
+    return info
+  end
+
+  class Signature
+    attr_reader :args, :arg_info
+
+    def initialize(args, arg_info)
+      @args = args
+      @arg_info = arg_info
+    end
+
+    def to_s
+      if @args.unspecified then
+        return ""
+      elsif @args.multiple_assignment then
+        if @args.empty_last_arg then
+          params = @args.map{ |n| arg_info[n] }
+          return "|#{@arg_info[@args[0]]},|"
+        else
+          params = @args.map{ |n| arg_info[n] }
+          return "|#{params.join(', ')}|"
+        end
+      else
+        return "|#{@arg_info[@args[0]]}|"
+      end
+    end
+  end
+
+  # Return a String representing the method's signature.
+  def signature
+    return Signature.new(
+        arguments(),
+        argument_info)
+  end
+end
+

data/lib/test.rb

@@ -0,0 +1,8 @@
+class Foo
+  def bar=
+    return 1
+  end
+end
+
+f = Foo.new
+f.bar = (1, 2)

data/metaconfig

@@ -0,0 +1,10 @@
+add_path_config(
+  'ruby-source-path',
+  nil,
+  'path to the ruby source code')
+
+add_config(
+  'without-tests',
+  'yes/no',
+  'no',
+  'does not run tests')

data/post-config.rb

@@ -0,0 +1,53 @@
+ruby_source_path = @config['ruby-source-path']
+
+if ruby_source_path.nil? then
+
+  cached_dir = "ext/cached/ruby-#{RUBY_VERSION}"
+  if File.exist?(cached_dir) then
+    puts "Ruby source path not specified; using generated files from #{cached_dir}"
+  else
+    $stderr.puts "ERROR: Source code for the ruby interpreter could not be found (perhaps you forgot --ruby-source-path?)"
+    exit 1
+  end
+
+else
+
+  ruby_h = File.join(ruby_source_path, 'ruby.h')
+  if not File.exist?(ruby_source_path) or
+     not File.directory?(ruby_source_path) or
+     not File.exist?(ruby_h) then
+     $stderr.puts "ERROR: Could not find the ruby source code at #{ruby_source_path}"
+     exit 1
+  end
+
+  version_h = File.join(ruby_source_path, 'version.h')
+  if not File.exist?(ruby_source_path) or
+     not File.directory?(ruby_source_path) or
+     not File.exist?(ruby_h) then
+     $stderr.puts "ERROR: Could not find version.h at #{ruby_source_path}"
+     exit 1
+  end
+
+  File.open(version_h) do |vh|
+    found_version = false
+    vh.each_line do |line|
+      if line =~ /#define\s+RUBY_VERSION\s+\"(.*?)\"/
+        found_version = true
+        if RUBY_VERSION != $1 then
+          $stderr.puts "Wrong version for source; expected #{RUBY_VERSION} but got #{$1}"
+          exit 1
+        end
+      end
+    end
+    if not found_version then
+      $stderr.puts "ERROR: Could not determine ruby version from version.h"
+      exit 1
+    end
+  end
+
+end
+
+dive_into('ext') do
+  command('make clean')
+end
+

data/post-setup.rb

@@ -0,0 +1,9 @@
+require 'run_tests'
+require 'generate_rdoc'
+
+if @config['without-tests'] != 'yes' then
+  run_tests()
+end
+
+generate_rdoc()
+

data/pre-config.rb

@@ -0,0 +1 @@
+@options['config-opt'] << "--ruby-source-path=#{@config['ruby-source-path']}"

data/run_tests.rb

@@ -0,0 +1,48 @@
+def run_tests
+  begin
+    require 'test/unit'
+  rescue LoadError
+    puts "WARNING: Test::Unit not installed; skipping tests"
+    return
+  end
+
+  $:.unshift('ext')
+  $:.unshift('lib')
+  tests = Dir['test/test_*.rb']
+  tests.each do |test|
+    load test
+  end
+
+  verbose = nil
+  begin
+    verbose = Test::Unit::UI.const_get(:VERBOSE)
+  rescue NameError
+    verbose = Test::Unit::UI::Console::TestRunner.const_get(:VERBOSE)
+  end
+  
+  tests = []
+  ObjectSpace.each_object do |o|
+    if Class === o and o < Test::Unit::TestCase then
+      tests << o
+    end
+  end
+
+  suite = Test::Unit::TestSuite.new("Nodewrap")
+  tests.each do |test|
+    test.suite.tests.each do |testcase|
+      suite << testcase
+    end
+  end
+
+  return Test::Unit::UI::Console::TestRunner.run(
+      suite,
+      verbose)
+end
+
+if __FILE__ == $0 then
+  require 'timeout'
+  result = nil
+  timeout(600) { result = run_tests() }
+  exit(result.error_count + result.failure_count)
+end
+

data/test/expression_samples.rb

@@ -0,0 +1,158 @@
+require 'rbconfig'
+
+class TEST_CLASS
+  FOO = 10
+end
+
+EXPRESSION_SAMPLES = {
+  :lit                     => '42',
+  :vcall                   => 'foo',
+  :fcall                   => 'foo()',
+  :fcall_many              => 'foo(1, 2, 3)',
+  :fcall_many2             => 'foo 1, 2, 3',
+  :fcall_splat             => 'a = [2, 3]; foo(1, *a)',
+  :fcall_block             => 'foo() { nil }',
+  :fcall_block_with_args   => 'foo() { |x,y| [x, y] }',
+  :plus                    => '1+1',
+  :minus                   => '54-2',
+  :times                   => '12*6',
+  :div                     => '16/7',
+  :less                    => '8 < 5',
+  :less_eq                 => '8 <= 5',
+  :greater                 => '8 > 5',
+  :greater_eq              => '8 >= 5',
+  :equal                   => '8 == 5',
+  :threequal               => '8 === 5',
+  :spaceship               => "8 <=\> 5", # the \> is for Align.vim
+  :lshift                  => '8 << 5 ',
+  :rshift                  => '8 >> 5',
+  :bit_and                 => '8 & 5',
+  :bit_or                  => '8 | 5',
+  :bit_xor                 => '8 ^ 5',
+  :mod                     => '8 % 5',
+  :not_equal               => '8 != 5',
+  # TODO: :match           => ''foo' =~ /foo|bar/',
+  # TODO: :not_match       => ''foo' !~ /foo|bar/',
+  :call                    => 'self.foo',
+  # TODO: super
+  # TODO: zsuper
+  # TODO: redo
+  # TODO: retry
+  :sym_not                 => '!true',
+  :sym_and                 => 'true && false',
+  :sym_or                  => 'true || false',
+  :lit_not                 => 'not true',
+  :lit_and                 => 'true and false',
+  :lit_or                  => 'true or false',
+  :array                   => '[1, 2, 3]',
+  :zarray                  => '[]',
+  :array_splat             => '[1, 2, *[3, 4]]',
+  :array_splat_var         => 'a = [3, 4]; [1, 2, *a]',
+  # TODO: block
+  :hash                    => '{ 1 => 2, 2 => 3 }',
+  :zhash                   => '{}',
+  :ternary                 => 'true ? false : nil',
+  :if                      => 'if true then false; else nil; end',
+  :if2                     => '42 if true',
+  :true                    => 'true',
+  :false                   => 'false',
+  :nil                     => 'nil',
+  :self                    => 'self',
+  :dot2                    => '5..8',
+  :dot3                    => '5...8',
+  :gvar                    => '$stdout',
+  :ivar                    => '@foo',
+  :cvar                    => '@@foo',
+  :dvar                    => 'foo = 1; foo',
+  :nth_ref                 => '$1',
+  :back_ref                => '$`',
+  :dasgn_curr              => 'foo = 1',
+  # TODO: dasgn
+  :iasgn                   => '@foo = 6',
+  # TODO: lasgn
+  # TODO: masgn
+  :cdecl                   => 'remove_foo; FOO = 1',
+  :cvdecl                  => '@@foo = 1',
+  # TODO: cvasgn
+  :attrasgn                => 'h = {}; h.default = true; h',
+  :const                   => 'FOO',
+  :colon2                  => 'self::FOO',
+  :colon3                  => '::TEST_CLASS::FOO',
+  # TODO: lvar
+  # TODO: newline
+  :str                     => '"foo"',
+  :regx                    => '/foo/',
+  # TODO: :regx_cflag      => '/foo/i',
+  :regx_once               => '/foo/o',
+  # :regx_once_cflag       => '/foo/oi',
+  # TODO: xstr
+  :dstr                    => 'a = 1; b = 2; "#{a}#{b}"',
+  :dregx                   => 'a = 1; b = 2; /#{a}#{b}/',
+  # :dregx_cflag           => 'a = 1; b = 2; /#{a}#{b}/i',
+  :dregx_once              => 'a = 1; b = 2; /#{a}#{b}/',
+  # :dregx_once_cflag      => 'a = 1; b = 2; /#{a}#{b}/oi',
+  # TODO dregx with next set
+  # TODO: dxstr
+  # TODO: evstr
+  :iter                    => 'loop { break }',
+  :iter_x                  => 'loop { break 10 }',
+  :while_1                 => 'while true; break; end',
+  :while_1_x               => 'while true; break 7; end',
+  :while_1_do              => 'while true do; break; end',
+  :while_1_do_x            => 'while true do; break 7; end',
+  :while_0                 => 'begin; break; end while true',
+  :while_0_x               => 'begin; break 7; end while true',
+  :until_1                 => 'until false; break; end',
+  :until_1_x               => 'until false; break 7; end',
+  :until_1_do              => 'until false do; break; end',
+  :until_1_do_x            => 'until false do; break 7; end',
+  :until_0                 => 'begin; break; end until false',
+  :until_0_x               => 'begin; break 7; end until false',
+  :break                   => 'break',
+  :break_x                 => 'break 49',
+  :catch                   => 'catch(:foo) { throw :foo; 42 }',
+  # TODO: yield
+  :begin                   => 'begin; 42; end',
+  :begin_empty             => 'begin; end',
+  :begin_ensure            => 'begin; 7; ensure; 42; end',
+  :begin_ensure_empty_head => 'begin; ensure; 42; end',
+  :begin_ensure_empty_body => 'begin; ensure; end',
+  :rescue                  => 'raise "foo" rescue 7',
+  :rescue2                 => 'raise "foo"; 42 rescue 7',
+  :begin_rescue            => 'begin; raise "foo"; rescue; 42; end',
+  :begin_rescue_multi      => 'begin; raise "foo"; 6; rescue; 42; end',
+  :begin_rescue_empty_head => 'begin; rescue; end',
+  :begin_rescue_empty_resq => 'begin; 42; rescue; end',
+  :resbody                 => 'begin; raise "foo"; rescue; 42; end',
+  :case_when               => 'case 42; when TrueClass then 6; when Fixnum then 42; end',
+  :case_when_multi_arg     => 'case 42; when TrueClass, Fixnum then 42; end',
+  :case_when_empty_body    => 'case 42; when TrueClass; when Fixnum then 42; end',
+  # TODO: alias
+  # TODO: valias
+  # TODO: undef
+  # TODO: class
+  # TODO: sclass
+  # TODO: scope
+  # TODO: defn
+  # TODO: defs
+  :defined                 => 'defined?(NilClass)',
+  # TODO: match3
+}
+
+
+major = Config::CONFIG['MAJOR'].to_i
+minor = Config::CONFIG['MINOR'].to_i
+teeny = Config::CONFIG['TEENY'].to_i
+ruby_version_code = major * 100 + minor * 10 + teeny
+
+if ruby_version_code < 170 then
+  EXPRESSION_SAMPLES.delete(:break_x)
+  EXPRESSION_SAMPLES.delete(:iter_x)
+  EXPRESSION_SAMPLES.delete(:while_1_x)
+  EXPRESSION_SAMPLES.delete(:while_1_do_x)
+  EXPRESSION_SAMPLES.delete(:while_0_x)
+  EXPRESSION_SAMPLES.delete(:until_1_x)
+  EXPRESSION_SAMPLES.delete(:until_1_do_x)
+  EXPRESSION_SAMPLES.delete(:until_0_x)
+end
+