node-marshal 0.1.1 → 0.1.2

data/ext/node-marshal/nodedump.c

@@ -18,10 +18,43 @@
 static VALUE cNodeObjAddresses, cNodeInfo;
 
 /*
- * Part 1. "Citations" from Ruby 2.2.1 internal include files
+ * Part 1. .H files: nodedump functions + parts of Ruby internals
  */
 #include "nodedump.h"
 
+#ifdef WITH_CUSTOM_RB_GLOBAL_ENTRY
+/* Custom (and slow) implementation of rb_global_entry internal API for Ruby 2.3
+   (original rb_global_entry API was opened before Ruby 2.3)
+   It uses a hack with the node creation. The main idea of the hack is 
+   to create a node from the expression containing only a name of the global variable
+   and extract global entry address from NODE_GVAR u3 "leaf" */
+static struct rb_global_entry *rb_global_entry(ID id)
+{
+	NODE *node, *gvar_node;
+	struct rb_global_entry *gentry;
+	/* a) Step 1: create node from the expression consisting only from
+	   our global variable */
+	node = rb_compile_string("<compiled>", rb_id2str(id), NUM2INT(1));
+	if (nd_type(node) != NODE_SCOPE)
+	{
+		return NULL;
+	}
+	/* b) Trace the node to the NODE_GVAR */
+	gvar_node = node->u2.node;
+	if (nd_type(gvar_node) == NODE_PRELUDE) /* Present only in 2.3 */
+	{
+		gvar_node = gvar_node->u2.node;
+	}
+	if (nd_type(gvar_node) != NODE_GVAR) /* Error: no GVAR found */
+	{
+		return NULL;
+	}
+	/* c) Get the global entry address and return its address */
+	gentry = gvar_node->u3.entry;
+	return gentry;
+}
+#endif
+
 
 /*
  * Part 2. Information about the nodes
@@ -703,7 +736,8 @@ int count_num_of_nodes(NODE *node, NODE *parent, NODEInfo *info)
 		}
 		else if (ut[2] != NT_LONG && ut[2] != NT_NULL)
 		{
-			rb_raise(rb_eArgError, "Invalid child node 3: %d", ut[2]);
+			rb_raise(rb_eArgError, "Invalid child node 3 of node %s: TYPE %d, VALUE %"PRIxPTR,
+				ruby_node_name(nd_type(node)), ut[2], (uintptr_t) (node->u3.value));
 		}
 
 		return num;
@@ -861,6 +895,13 @@ void print_node(VALUE str, NODE *node, int tab)
 			PRINT_NODE_TAB; rbstr_printf(str, "  ");
 			rbstr_printf(str, ">| IDTABLE\n");
 		}
+		else if (ut[i] == NT_ENTRY)
+		{
+			struct rb_global_entry *gentry;
+			gentry = (struct rb_global_entry *) uref[i];
+			PRINT_NODE_TAB; rbstr_printf(str, "  ");
+			rbstr_printf(str, ">| [GLOBAL ENTRY PTR=0x%"PRIxPTR" ID=%X]\n", (uintptr_t) gentry->var, gentry->id);
+		}
 		else
 		{
 			PRINT_NODE_TAB; rbstr_printf(str, "  ");
@@ -1172,8 +1213,8 @@ static VALUE get_hash_strfield(VALUE hash, const char *idtxt)
 static VALUE check_hash_magic(VALUE data)
 {
 	VALUE val, refval;
-	// MAGIC signature must be valid	
-	val = get_hash_strfield(data, "MAGIC");	
+	// MAGIC signature must be valid
+	val = get_hash_strfield(data, "MAGIC");
 	if (strcmp("NODEMARSHAL10", RSTRING_PTR(val)))
 		rb_raise(rb_eArgError, "Bad value of MAGIC signature");
 	// RUBY_PLATFORM signature must match the current platform
@@ -1221,7 +1262,7 @@ static VALUE m_nodedump_from_memory(VALUE self, VALUE dump)
 		rb_raise(rb_eArgError, "num_of_nodes not found");
 	}
 	else
-	{		
+	{
 		num_of_nodes = FIX2INT(val);
 	}
 	/* Check "magic" signature and platform identifiers */
@@ -1301,6 +1342,46 @@ static VALUE m_nodedump_symbols(VALUE self)
 	rb_raise(rb_eArgError, "Symbol information not initialized. Run to_hash before reading.");
 }
 
+/*
+ * Replace one symbol by another
+ * (to be used for code obfuscation)
+ */
+static VALUE m_nodedump_change_symbol(VALUE self, VALUE old_sym, VALUE new_sym)
+{
+	VALUE val_nodehash = rb_iv_get(self, "@nodehash");
+	VALUE syms, key;
+	// Check if node is position-independent
+	// (i.e. with initialized NODEInfo structure that contains
+	// relocations for symbols)
+	if (val_nodehash == Qnil)
+		rb_raise(rb_eArgError, "This node is not preparsed into Hash");
+	// Check data types of the input array
+	if (TYPE(old_sym) != T_STRING)
+	{
+		rb_raise(rb_eArgError, "old_sym argument must be a string");
+	}
+	if (TYPE(new_sym) != T_STRING)
+	{
+		rb_raise(rb_eArgError, "new_sym argument must be a string");
+	}
+	// Get the symbol table from the Hash
+	syms = rb_hash_aref(val_nodehash, ID2SYM(rb_intern("symbols")));
+	if (syms == Qnil)
+		rb_raise(rb_eArgError, "Preparsed hash has no :symbols field");
+	// Check if new_sym is present in the symbol table
+	key = rb_funcall(syms, rb_intern("find_index"), 1, new_sym);
+	if (key != Qnil)
+	{
+		rb_raise(rb_eArgError, "new_sym value must be absent in table of symbols");
+	}
+	// Change the symbol in the preparsed Hash
+	key = rb_funcall(syms, rb_intern("find_index"), 1, old_sym);
+	if (key == Qnil)
+		return Qnil;
+	RARRAY_PTR(syms)[FIX2INT(key)] = new_sym;
+	return self;
+}
+
 /*
  * Return array with the list of literals
  */
@@ -1308,7 +1389,8 @@ static VALUE m_nodedump_literals(VALUE self)
 {
 	int i;
 	VALUE val_relocs, val_nodeinfo, lits;
-	// Variant 1: node loaded from file
+	// Variant 1: node loaded from file. It uses NODEObjAddresses struct
+	// with the results of Ruby NODE structure parsing.
 	val_relocs = rb_iv_get(self, "@obj_addresses");
 	if (val_relocs != Qnil)
 	{
@@ -1317,10 +1399,17 @@ static VALUE m_nodedump_literals(VALUE self)
 		Data_Get_Struct(val_relocs, NODEObjAddresses, relocs);
 		lits = rb_ary_new();
 		for (i = 0; i < relocs->lits_len; i++)
-			rb_ary_push(lits, rb_funcall(relocs->lits_adr[i], rb_intern("dup"), 0));
+		{
+			VALUE val = relocs->lits_adr[i];
+			int t = TYPE(val);
+			if (t != T_SYMBOL && t != T_FLOAT && t != T_FIXNUM)
+				val = rb_funcall(val, rb_intern("dup"), 0);
+			rb_ary_push(lits, val);
+		}
 		return lits;
 	}
-	// Variant 2: node saved to file (parsed from memory)
+	// Variant 2: node saved to file (parsed from memory). It uses
+	// NODEInfo struct that is initialized during node dump parsing.
 	val_nodeinfo = rb_iv_get(self, "@nodeinfo");
 	if (val_nodeinfo != Qnil)
 	{
@@ -1337,9 +1426,19 @@ static VALUE m_nodedump_literals(VALUE self)
 		}
 		return lits;
 	}
-	rb_raise(rb_eArgError, "Literals information not initialized. Run to_hash before reading.");	
+	rb_raise(rb_eArgError, "Literals information not initialized. Run to_hash before reading.");
 }
 
+/*
+ * Update the array with the list of literals
+ * (to be used for code obfuscation)
+ * Warning! This function is a stub!
+ */
+static VALUE m_nodedump_change_literal(VALUE self, VALUE old_lit, VALUE new_lit)
+{
+    /* TO BE IMPLEMENTED */
+    return self;
+}
 
 
 /*
@@ -1354,7 +1453,13 @@ static VALUE m_nodedump_compile(VALUE self)
 	VALUE nodename = rb_iv_get(self, "@nodename");
 	VALUE filename = rb_iv_get(self, "@filename");
 	VALUE filepath = rb_iv_get(self, "@filepath");
+#ifndef WITH_RB_ISEQW_NEW
+	/* For Pre-2.3 */
 	return rb_iseq_new_top(node, nodename, filename, filepath, Qfalse);
+#else
+	/* For Ruby 2.3 */
+	return rb_iseqw_new(rb_iseq_new_top(node, nodename, filename, filepath, Qfalse));
+#endif
 }
 
 /*
@@ -1365,6 +1470,7 @@ static VALUE m_nodedump_from_source(VALUE self, VALUE file)
 	VALUE line = INT2FIX(1), f, node, filepath;
 	const char *fname;
 
+	rb_gc_disable();
 	rb_secure(1);
 	FilePathValue(file);
 	fname = StringValueCStr(file);
@@ -1376,7 +1482,12 @@ static VALUE m_nodedump_from_source(VALUE self, VALUE file)
 	/* Create node from the source */
 	f = rb_file_open_str(file, "r");
 	node = (VALUE) rb_compile_file(fname, f, NUM2INT(line));
+	rb_gc_enable();
 	rb_iv_set(self, "@node", node);
+	if ((void *) node == NULL)
+	{
+		rb_raise(rb_eArgError, "Error during string parsing");
+	}
 	return self;
 }
 
@@ -1387,7 +1498,7 @@ static VALUE m_nodedump_from_string(VALUE self, VALUE str)
 {
 	VALUE line = INT2FIX(1), node;
 	const char *fname = "STRING";
-	Check_Type(str, T_STRING);	
+	Check_Type(str, T_STRING);
 	rb_secure(1);
 	/* Create empty information about the file */
 	rb_iv_set(self, "@nodename", rb_str_new2("<main>"));
@@ -1407,6 +1518,10 @@ static VALUE m_nodedump_from_string(VALUE self, VALUE str)
 	rb_iv_set(self, "@node", node);
 	rb_gc_enable();
 	rb_gc_start();
+	if ((void *) node == NULL)
+	{
+		rb_raise(rb_eArgError, "Error during string parsing");
+	}
 	return self;
 }
 
@@ -1492,9 +1607,9 @@ static VALUE m_nodedump_dump_tree_short(VALUE self)
  * - <tt>MAGIC</tt> -- NODEMARSHAL10
  * - <tt>RUBY_PLATFORM</tt> -- saved <tt>RUBY_PLATFORM</tt> constant value
  * - <tt>RUBY_VERSION</tt>  -- saved <tt>RUBY_VERSION</tt> constant value
- * 
+ *
  * <i>Part 2: Program loadable elements.</i>
- * 
+ *
  * All loadable elements are arrays. Index of the array element means
  * its identifier that is used in the node tree.
  *
@@ -1507,6 +1622,10 @@ static VALUE m_nodedump_dump_tree_short(VALUE self)
  * <i>Part 3: Nodes information</i>
  * - <tt>nodes</tt> -- string that contains binary encoded information
  *   about the nodes
+ * - <tt>num_of_nodes</tt> -- number of nodes in the <tt>nodes</tt> field
+ * - <tt>nodename</tt> -- name of the node (usually "<main>")
+ * - <tt>filename</tt> -- name (without path) of .rb file used for the node generation
+ * - <tt>filepath</tt> -- name (with full path) of .rb file used for the node generation
  */
 static VALUE m_nodedump_to_hash(VALUE self)
 {
@@ -1515,18 +1634,29 @@ static VALUE m_nodedump_to_hash(VALUE self)
 	VALUE ans, num, val_info;
 	// DISABLE GARBAGE COLLECTOR (important for dumping)
 	rb_gc_disable();
-	// Allocate memory for the information about node
-	val_info = Data_Make_Struct(cNodeInfo, NODEInfo,
-		NODEInfo_mark, NODEInfo_free, info); // This data envelope cannot exist without NODE
-	NODEInfo_init(info);
-	rb_iv_set(self, "@nodeinfo", val_info);
-	// Convert node to NODEInfo structure
-	num = INT2FIX(count_num_of_nodes(node, node, info));
-	ans = NODEInfo_toHash(info);
-	rb_hash_aset(ans, ID2SYM(rb_intern("num_of_nodes")), num);
-	rb_hash_aset(ans, ID2SYM(rb_intern("nodename")), rb_iv_get(self, "@nodename"));
-	rb_hash_aset(ans, ID2SYM(rb_intern("filename")), rb_iv_get(self, "@filename"));
-	rb_hash_aset(ans, ID2SYM(rb_intern("filepath")), rb_iv_get(self, "@filepath"));
+	// Convert the node to the form with relocs (i.e. the information about node)
+	// if such form is not present
+	val_info = rb_iv_get(self, "@nodeinfo");
+	if (val_info == Qnil)
+	{
+		val_info = Data_Make_Struct(cNodeInfo, NODEInfo,
+			NODEInfo_mark, NODEInfo_free, info); // This data envelope cannot exist without NODE
+		NODEInfo_init(info);
+		rb_iv_set(self, "@nodeinfo", val_info);
+		num = INT2FIX(count_num_of_nodes(node, node, info));
+		rb_iv_set(self, "@nodeinfo_num_of_nodes", num);
+		// Convert node to NODEInfo structure
+		ans = NODEInfo_toHash(info);
+		rb_hash_aset(ans, ID2SYM(rb_intern("num_of_nodes")), num);
+		rb_hash_aset(ans, ID2SYM(rb_intern("nodename")), rb_iv_get(self, "@nodename"));
+		rb_hash_aset(ans, ID2SYM(rb_intern("filename")), rb_iv_get(self, "@filename"));
+		rb_hash_aset(ans, ID2SYM(rb_intern("filepath")), rb_iv_get(self, "@filepath"));
+		rb_iv_set(self, "@nodehash", ans);
+	}
+	else
+	{
+		ans = rb_iv_get(self, "@nodehash");
+	}
 	// ENABLE GARBAGE COLLECTOR (important for dumping)
 	rb_gc_enable();
 	return ans;
@@ -1565,7 +1695,7 @@ static VALUE m_nodedump_inspect(VALUE self)
 	sprintf(str,
 		"----- NodeMarshal:0x%"PRIxPTR"\n"
 		"    num_of_nodes: %d\n    nodename: %s\n    filepath: %s\n    filename: %s\n",
-		self,
+		(uintptr_t) (self),
 		(num_of_nodes == Qnil) ? -1 : FIX2INT(num_of_nodes),
 		(nodename == Qnil) ? "nil" : RSTRING_PTR(nodename),
 		(filepath == Qnil) ? "nil" : RSTRING_PTR(filepath),
@@ -1767,15 +1897,16 @@ static VALUE m_nodedump_node(VALUE self)
  * - Irreversible transformation of Ruby source code to the syntax tree
  * - Representation of syntax tree in binary form dependent from the platform and Ruby version
  * - Simple options for node inspection
- * - Ruby 1.9.3 and 2.2.1 support
+ * - Ruby 1.9.3, 2.2.x and 2.3.x support
+ * - Subroutines for custom code obfuscation
  */
 void Init_nodemarshal()
 {
 	static VALUE cNodeMarshal;
 	init_nodes_table(nodes_ctbl, NODES_CTBL_SIZE);
 	base85r_init_tables();
-	
-	cNodeMarshal = rb_define_class("NodeMarshal", rb_cObject);	
+
+	cNodeMarshal = rb_define_class("NodeMarshal", rb_cObject);
 	rb_define_singleton_method(cNodeMarshal, "base85r_encode", RUBY_METHOD_FUNC(m_base85r_encode), 1);
 	rb_define_singleton_method(cNodeMarshal, "base85r_decode", RUBY_METHOD_FUNC(m_base85r_decode), 1);
 
@@ -1789,7 +1920,9 @@ void Init_nodemarshal()
 	// Methods for working with the information about the node
 	// a) literals, symbols, generic information
 	rb_define_method(cNodeMarshal, "symbols", RUBY_METHOD_FUNC(m_nodedump_symbols), 0);
+	rb_define_method(cNodeMarshal, "change_symbol", RUBY_METHOD_FUNC(m_nodedump_change_symbol), 2);
 	rb_define_method(cNodeMarshal, "literals", RUBY_METHOD_FUNC(m_nodedump_literals), 0);
+	rb_define_method(cNodeMarshal, "change_literal", RUBY_METHOD_FUNC(m_nodedump_change_literal), 2);
 	rb_define_method(cNodeMarshal, "inspect", RUBY_METHOD_FUNC(m_nodedump_inspect), 0);
 	rb_define_method(cNodeMarshal, "node", RUBY_METHOD_FUNC(m_nodedump_node), 0);
 	// b) node and file names

data/ext/node-marshal/nodedump.h

@@ -46,7 +46,9 @@ void check_nodes_child_info(int pos);
 void init_nodes_table(int *nodes_ctbl, int num_of_entries);
 
 /* Parts of node.h from Ruby source code */
-#if (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 2)
+#if (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 3)
+#include "node230.h"
+#elif (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 2)
 #include "node220.h"
 #elif (RUBY_API_VERSION_MAJOR == 1) && (RUBY_API_VERSION_MINOR == 9)
 #include "node193.h"
@@ -54,14 +56,3 @@ void init_nodes_table(int *nodes_ctbl, int num_of_entries);
 #include "node220.h"
 #error Unsupported version of Ruby
 #endif
-
-/* Some Ruby internals */
-#if defined(__cplusplus)
-	extern "C" {
-#endif
-extern char *ruby_node_name(int type);
-extern VALUE rb_iseq_new_top(NODE *node, VALUE name, VALUE path, VALUE absolute_path, VALUE parent);
-extern VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict);
-#if defined(__cplusplus)
-	}
-#endif

data/ext/node-marshal/nodeinfo.c

@@ -3,6 +3,7 @@
  * Supported Ruby versions:
  * - Ruby 1.9.3
  * - Ruby 2.2.1
+ * - Ruby 2.3.0
  *
  * Fragments from Ruby source code are used here
  * (mainly from node.c, gc.c)
@@ -70,6 +71,9 @@ static int nodes_child_info[][4] =
 	{NODE_CALL, NT_NODE, NT_ID, NT_NODE},
 	{NODE_FCALL, NT_NULL, NT_ID, NT_NODE},
 	{NODE_VCALL, NT_NULL, NT_ID, NT_NULL},
+#ifdef NODE_QCALL
+	{NODE_QCALL, NT_NODE, NT_ID, NT_NODE}, /* &. operator from Ruby 2.3 */
+#endif	
 
 	{NODE_SUPER, NT_NULL, NT_NULL, NT_NODE},
 	{NODE_ZSUPER, NT_NULL, NT_NULL, NT_NULL},
@@ -93,6 +97,7 @@ static int nodes_child_info[][4] =
 
 	{NODE_MATCH,  NT_VALUE, NT_NULL, NT_NULL},
 	{NODE_MATCH2, NT_NODE, NT_NODE, NT_NULL},
+	{NODE_MATCH3, NT_NODE, NT_NODE, NT_NULL},
 
 	{NODE_LIT,    NT_VALUE, NT_NULL, NT_NULL},
 	{NODE_STR,    NT_VALUE, NT_NULL, NT_NULL},
@@ -109,7 +114,7 @@ static int nodes_child_info[][4] =
 	{NODE_ARGSCAT, NT_NODE, NT_NODE, NT_NULL},
 	{NODE_ARGSPUSH, NT_NODE, NT_NODE, NT_NULL},
 	{NODE_SPLAT, NT_NODE, NT_NULL, NT_NULL},
-	{NODE_BLOCK_PASS, NT_NODE, NT_NODE, NT_VALUE}, // ???
+	{NODE_BLOCK_PASS, NT_NODE, NT_NODE, NT_NODE}, // ???
 
 	{NODE_DEFN, NT_NULL, NT_ID,   NT_NODE},
 	{NODE_DEFS, NT_NODE, NT_ID, NT_NODE},
@@ -298,7 +303,7 @@ void check_nodes_child_info(int pos)
 	default:
 		return;
 	}
-#elif RUBY_API_VERSION_MAJOR == 2
+#elif (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 2)
 	/* RUBY 2.2.1 VARIANT */    
 	switch (type)
 	{
@@ -426,6 +431,124 @@ void check_nodes_child_info(int pos)
 		//	ruby_node_name(nodes_child_info[pos][0]));
 		return;
 	}
+#elif (RUBY_API_VERSION_MAJOR == 2) && (RUBY_API_VERSION_MINOR == 3)
+	switch (type)
+	{
+	case NODE_IF:		/* 1,2,3 */
+	case NODE_FOR:
+	case NODE_ITER:
+	case NODE_WHEN:
+	case NODE_MASGN:
+	case NODE_RESCUE:
+	case NODE_RESBODY:
+	case NODE_CLASS:
+	case NODE_BLOCK_PASS:
+		isval[1] = 1;
+	/* fall through */
+	case NODE_BLOCK:	/* 1,3 */
+	case NODE_ARRAY:
+	case NODE_DSTR:
+	case NODE_DXSTR:
+	case NODE_DREGX:
+	case NODE_DREGX_ONCE:
+	case NODE_ENSURE:
+	case NODE_CALL:
+	case NODE_DEFS:
+	case NODE_OP_ASGN1:
+		isval[0] = 1;
+	/* fall through */
+	case NODE_SUPER:	/* 3 */
+	case NODE_FCALL:
+	case NODE_DEFN:
+	case NODE_ARGS_AUX:
+		isval[2] = 1;
+		break;
+
+	case NODE_WHILE:	/* 1,2 */
+	case NODE_UNTIL:
+	case NODE_AND:
+	case NODE_OR:
+	case NODE_CASE:
+	case NODE_SCLASS:
+	case NODE_DOT2:
+	case NODE_DOT3:
+	case NODE_FLIP2:
+	case NODE_FLIP3:
+	case NODE_MATCH2:
+	case NODE_MATCH3:
+	case NODE_OP_ASGN_OR:
+	case NODE_OP_ASGN_AND:
+	case NODE_MODULE:
+	case NODE_ALIAS:
+	//case NODE_VALIAS:
+	case NODE_ARGSCAT:
+		isval[0] = 1;
+	/* fall through */
+	case NODE_GASGN:	/* 2 */
+	case NODE_LASGN:
+	case NODE_DASGN:
+	case NODE_DASGN_CURR:
+	case NODE_IASGN:
+	case NODE_IASGN2:
+	case NODE_CVASGN:
+	//case NODE_COLON3:
+	case NODE_OPT_N:
+	case NODE_EVSTR:
+	case NODE_UNDEF:
+	case NODE_POSTEXE:
+		isval[1] = 1;
+		break;
+
+	case NODE_HASH:	/* 1 */
+	case NODE_LIT:
+	case NODE_STR:
+	case NODE_XSTR:
+	case NODE_DEFINED:
+	case NODE_MATCH:
+	case NODE_RETURN:
+	case NODE_BREAK:
+	case NODE_NEXT:
+	case NODE_YIELD:
+	case NODE_COLON2:
+	case NODE_SPLAT:
+	case NODE_TO_ARY:
+		isval[0] = 1;
+		break;
+
+	case NODE_SCOPE:	/* 2,3 */
+	case NODE_CDECL:
+	case NODE_OPT_ARG:
+		isval[1] = 1;
+		isval[2] = 1;
+		break;
+
+	case NODE_ARGS:	/* custom */
+		isval[1] = 1;
+		break;
+
+	case NODE_ZARRAY:	/* - */
+	case NODE_ZSUPER:
+	case NODE_VCALL:
+	case NODE_GVAR:
+	case NODE_LVAR:
+	case NODE_DVAR:
+	case NODE_IVAR:
+	case NODE_CVAR:
+	case NODE_NTH_REF:
+	case NODE_BACK_REF:
+	case NODE_REDO:
+	case NODE_RETRY:
+	case NODE_SELF:
+	case NODE_NIL:
+	case NODE_TRUE:
+	case NODE_FALSE:
+	case NODE_ERRINFO:
+	case NODE_BLOCK_ARG:
+		break;
+	/* NODE_ALLOCA EXCLUDED */
+	default:		/* unlisted NODE */
+		return;
+	}
 #endif
 		
 	for (i = 0; i < 3; i++)