node-marshal 0.1.1 → 0.1.2

data/lib/node-marshal.rb

@@ -1,5 +1,26 @@
 require_relative '../ext/node-marshal/nodemarshal.so'
-require 'zlib'
+begin
+	require 'zlib'
+rescue LoadError
+	# If zlib library is absent in the system no support for
+	# compression will be provided in 
+end
+
+# Implementation of Array::to_h method for Ruby 1.9 (and probably 2.0)
+# Don't use for Ruby 2.2.x and Ruby 2.3.x
+if !defined?([].to_h)
+	class Array
+		def to_h
+			h = {}
+			a = self
+			a.each do |x|
+				raise "wrong array length" if x.length != 2
+				h[x[0]] = x[1];
+			end
+			return h
+		end
+	end
+end
 
 class NodeMarshal
 	# call-seq:
@@ -12,7 +33,7 @@ class NodeMarshal
 	#   with the command for nodemarshal.so inclusion (default is 
 	#   require_relative '../ext/node-marshal/nodemarshal.so')
 	def to_compiled_rb(outfile, *args)
-		compress = false
+		compress = true
 		so_path = "require_relative '../ext/node-marshal/nodemarshal.so'"
 		if args.length > 0
 			opts = args[0]
@@ -25,6 +46,9 @@ class NodeMarshal
 		end
 		# Compression
 		if compress
+			if !defined?(Zlib)
+				raise "Compression is not supported: Zlib is absent"
+			end
 			zlib_include = "require 'zlib'"
 			data_txt = NodeMarshal.base85r_encode(Zlib::deflate(self.to_bin))
 			data_bin = "Zlib::inflate(NodeMarshal.base85r_decode(data_txt))"
@@ -61,4 +85,135 @@ EOS
 		node.to_compiled_rb(outfile, *args)
 		return true
 	end
+
+	# call-seq:
+	#   obj.replace_symbols(syms_subs)
+	#
+	# Replaces some symbols inside parsed AST to user-defined aliases.
+	# It is designed to make code obfuscation easier. Be careful when using
+	# this ability: it is possible to break external libraries calls,
+	# operators overloading and some metaprogramming techniques.
+	# - +syms_subs+ -- Hash with the table of aliases. Keys are original names,
+	# values are aliases. Keys and values MUST BE strings (not symbols!).
+	def replace_symbols(syms_subs)
+		# Check input data
+		# a) type
+		if !(syms_subs.is_a?(Hash))
+			raise "symb_subs must be a hash"
+		end
+		# b) uniqueness of values inside the hash
+		values = syms_subs.values
+		if values.size != values.uniq.size
+			raise ArgumentError, "values (new names) must be unique"
+		end
+		# c) uniqueness of values after replacement
+		# TODO: MAKE IT!!!
+		# Use NodeMarshal C part to replace the symbols
+		self.to_hash # To initialize Hash with preparsed Ruby AST NODE
+		syms_subs.each do |key, value|
+			change_symbol(key, value)
+		end
+		self
+	end
+
+	# call-seq:
+	#   obj.get_safe_symbols
+	#
+	# Returns an array that contains strings with the names of symbols that are safe
+	# to change. It excludes symbols that are present in the table of literals (and their derivatives
+	# such as @x and x=). Such operation is useful for attr_readed, attr_writer and another similar
+	# metaprogramming techniques handling
+	#
+	# - +our_symbols+ symbols created during node creation (must be found manually by the user
+	#   by means of Symbol.all_symbols calling BEFORE and AFTER node creation.
+	def get_safe_symbols(our_symbols)
+		self.to_hash # To initialize Hash with preparsed Ruby AST NODE
+		symbolic_literals =  self.literals.select {|x| x.is_a?(Symbol)}.map {|x| x.to_s}
+		fixed_symbols = [] + symbolic_literals
+		fixed_symbols += symbolic_literals.map {|x| "@#{x}"}
+		fixed_symbols += symbolic_literals.map {|x| "#{x}="}
+		our_symbols = our_symbols.dup
+		our_symbols -= fixed_symbols
+	end
+
+	# call-seq:
+	#   obj.get_aliases_table(our_symbols)
+	# 
+	# Returns a hash that has {"old_sym_name"=>"new_sym_name",...} format.
+	# "new_sym_name" are generated automatically.
+	#
+	# - +our_symbols+ -- An array that contains the list of symbols (AS STRINGS,
+	# NOT AS SYMBOLS) that can be renamed.
+	def get_aliases_table(our_symbols)
+		symbols_ary = get_safe_symbols(our_symbols)
+		pos = 0;
+		aliases_ary = symbols_ary.map do |sym|
+			pos += 1
+			if sym.length > 1 && sym[0..1] == '@@'
+				"@@q#{pos}"
+			elsif sym[0] == '@'
+				"@q#{pos}"
+			elsif sym[0] =~ /[A-Z]/
+				"Q#{pos}"
+			elsif sym[0] =~ /[a-z]/
+				"q#{pos}"
+			end
+		end
+		[symbols_ary, aliases_ary].transpose.to_h		
+	end
+
+	# call-seq:
+	#   obj.rename_ivars
+	def rename_ivars(*args)
+		if args.size == 0
+			excl_names = []
+		else
+			excl_names = args[0]
+		end
+
+		to_hash
+		syms = @nodehash[:symbols].select {|x| (x =~ /@[^@]/) == 0}
+		pos = 1;
+		syms_new = syms.map do |x|
+			if excl_names.find_index(x[1..-1]) != nil
+				str = x
+			else
+				str = "@ivar#{pos}"
+			end
+			pos = pos + 1;
+			str
+		end
+		syms_subs =  [syms, syms_new].transpose.to_h
+		replace_symbols(syms_subs)
+		self
+	end
+
+	# call-seq:
+	#   obj.rebuld
+	#
+	# Rebuilds the node by converting it to the binary dump and further restoring
+	# of it from this dump. It doesn't change the original node and returns rebuilt
+	# node.
+	def rebuild
+		NodeMarshal.new(:binmemory, to_bin)
+	end
+end
+
+# Designed for the logging of symbols table changes. When an example of 
+# SymbolsLogger is created the current global table of symbols is saved 
+# inside it. The created example can be used for finding new symbols in
+# the global table. This is useful for code obfuscation.
+class SymbolsLogger
+	def initialize
+		@symtbl_old = Symbol.all_symbols
+	end
+
+	def new_symbols
+		symtbl_new = Symbol.all_symbols
+		symtbl_new - @symtbl_old
+	end
+
+	def update
+		@symtbl_old = Symbol.all_symbols
+	end
 end

data/test/test_base.rb

@@ -125,7 +125,6 @@ a, b = XYPoint.new(0.0, 0.0), XYPoint.new(3.0, 4.0)
 c, d = PolarPoint.new(1.0, 0.0), PolarPoint.new(2.0, 90.0)
 [a.distance(b), c.distance(d)]
 EOS
-
 		assert_node_compiler(program)
 	end
 
@@ -148,6 +147,45 @@ EOS
 		end
 	end
 
+	# Test regular expressions (NODE_MATCH3 node issue)
+	def test_node_match3
+		program = <<-EOS
+a = "  d--abc"
+a =~ Regexp.new("abc")
+EOS
+		assert_node_compiler(program)
+	end
+
+	def test_node_block_pass
+		program = <<-EOS
+[1, 2, 3, "A"].map(&:class)
+EOS
+		assert_node_compiler(program)
+	end
+
+	# Check the reaction on the parsing errors during the node creation
+	# In the case of syntax error ArgumentError exception should be generated
+	def test_syntax_error
+		program = "a = 1; a++" # Contains syntax error
+		# a) from memory (string)
+		test_passed = false
+		begin
+			node = NodeMarshal.new(:srcmemory, program)
+		rescue ArgumentError
+			test_passed = true
+		end
+		assert_equal(test_passed, true);
+		# b) from file
+		File.open("_tmp.rb", "w") {|fp| fp << program }
+		test_passed = false
+		begin
+			node = NodeMarshal.new(:srcfile, "_tmp.rb")
+		rescue ArgumentError
+			test_passed = true
+		end
+		assert_equal(test_passed, true);	
+	end
+
 	# Part of the tests: compare result of direct usage of eval
 	# for the source code and its
 	def assert_node_compiler(program)

data/test/test_lifegame.rb

@@ -58,11 +58,11 @@ EOS
 		File.open('lifegame_bin.rb', 'w') {|fp| fp << txt }
 		`ruby lifegame_bin.rb`
 		res_file = File.read('life.res')
-		`rm life.res`	
+		`rm life.res`
 		# Run the life game without compilation to the file
 		load('lifegame.rb')
 		res_load = run_game
 		Object.send(:remove_const, :LifeGame)
-		assert_equal(res_file, res_load)		
+		assert_equal(res_file, res_load)
 	end
 end

data/test/test_obfuscator.rb

@@ -0,0 +1,36 @@
+require_relative '../lib/node-marshal.rb'
+require 'test/unit'
+
+# Test node-marshal obfuscator abilities
+class TestObfuscator < Test::Unit::TestCase
+	def test_sym_replace
+		# Create the node and find all new symbols
+		symlog = SymbolsLogger.new
+		node = NodeMarshal.new(:srcfile, 'lifegame.rb')
+		our_symbols = symlog.new_symbols.map(&:to_s)
+		node.to_hash
+		# Try to exclude symbols used in attr_reader and attr_writer constructions
+		our_symbols = node.get_safe_symbols(our_symbols)
+		# Prepare hash table for replacement
+		reptbl = node.get_aliases_table(our_symbols)
+		life_game_name = reptbl["LifeGame"]
+		grid_name = reptbl["Grid"]
+		make_step_name = reptbl["make_step!"].to_sym
+		cfg_glider_gun_name = reptbl["cfg_glider_gun!"].to_sym
+		# Replace symbols
+		puts "----- Symbols replacement table"
+		puts reptbl.to_s
+		puts "-------------------------------"
+		node.replace_symbols(reptbl)
+		# Rebuild node, save it to the file and reload it
+		node = node.rebuild
+		File.open('life.bin', 'wb') {|fp| fp << node.to_bin};
+		node.compile.eval
+		# Execute the node
+		grid_class = Object.const_get(life_game_name).const_get(grid_name)
+		g = grid_class.new(25, 80)
+		g.send(cfg_glider_gun_name)
+		75.times {g.send(make_step_name)}
+		puts g.to_ascii
+	end
+end

data/test/test_qcall.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+require_relative '../lib/node-marshal.rb'
+require 'test/unit'
+
+
+# This unit tests Ruby 2.3 &. safe navigation operator
+class TestQCALL < Test::Unit::TestCase
+	def test_qcall
+		qcall_program = %q{
+class Account
+	def initialize(owner_name, owner_address)
+		@owner_name = owner_name
+		@owner_info = (owner_address.nil?) ? nil : OwnerInfo.new(owner_address);
+	end
+	def owner_name
+		@owner_name
+	end
+	def owner_info
+		@owner_info
+	end
+end
+class OwnerInfo
+	def initialize(address)
+		@address = address
+	end
+	def address
+		@address
+	end
+end
+a = Account.new("Owner", "Moscow");
+puts "'#{a&.owner_name}'"
+puts "'#{a&.owner_info&.address}'"
+b = Account.new("Owner", nil);
+puts "'#{b&.owner_name}'"
+puts "'#{b&.owner_info&.address}'"
+[a&.owner_name, a&.owner_info&.address, b&.owner_name, b&.owner_info&.address]
+}
+
+		node = NodeMarshal.new(:srcmemory, qcall_program)
+		bindump =  node.to_bin
+		node = NodeMarshal.new(:binmemory, bindump)
+		res_node = node.compile.eval
+		res_text = eval(qcall_program)
+		assert_equal(res_text, res_node)
+	end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: node-marshal
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Alexey Voskov
@@ -9,7 +9,7 @@ autorequire:
 bindir:
 - bin
 cert_chain: []
-date: 2015-05-04 00:00:00.000000000 Z
+date: 2015-12-24 00:00:00.000000000 Z
 dependencies: []
 description: "This gem is designed for transformation of Ruby source code (eiher in
   the form of files or strings) to the \nRuby nodes (syntax trees) used by Ruby MRI
@@ -34,6 +34,7 @@ files:
 - ext/node-marshal/libobj/readme.txt
 - ext/node-marshal/node193.h
 - ext/node-marshal/node220.h
+- ext/node-marshal/node230.h
 - ext/node-marshal/nodedump.c
 - ext/node-marshal/nodedump.h
 - ext/node-marshal/nodeinfo.c
@@ -42,6 +43,8 @@ files:
 - test/test_base.rb
 - test/test_complex.rb
 - test/test_lifegame.rb
+- test/test_obfuscator.rb
+- test/test_qcall.rb
 - test/tinytet.rb
 homepage: 
 licenses:
@@ -65,7 +68,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Transforms Ruby sources to binary nodes (trees) that can be saved and loaded