node-marshal 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 37790a2feee8e4d9869f054217f7f5619b34f50a
+  data.tar.gz: 4c5d0348106b37071045ec5da275d6f66f9420d2
+SHA512:
+  metadata.gz: 34b5a2b79293e3ce4ee8be7999f8d41171147188b70e508193a153ab01bf193babdb63ed815ae5a187dd944b9faa0eccb58d3398061426140bb5d03ed915b4cb
+  data.tar.gz: 49d63f4879503ee1fd9b756044013c04792721a20dc66e8bb14c6f6af9b6c88512c43356eeb75a26bf5df5f58bdc72f4bfaccae5823816a5cdf2b65671c9b8d7

data/README.rdoc

@@ -0,0 +1,18 @@
+== node-marshal
+
+This gem is designed for transformation of Ruby source code (eiher in the form of files or strings) to the 
+Ruby nodes (syntax trees) used by Ruby MRI internals. Obtained nodes can be serialized to the platform-dependent
+binary or ASCII strings and restored and launched from serialized format. Such kind of transformation is
+irreversible and can be used for source code protection; the similar principle is used by RubyEncoder commercial
+software.
+
+The key features of node-marshal gem:
+- Irreversible conversion of a source code to the Ruby node (abstract syntax tree)
+- Ruby 1.9.3 and 2.2.x support (only MRI)
+- Active usage of Ruby internals (mainly AST) and Ruby standard library (Marshal and Zlib)
+- Set of tests for easy addition of new Ruby versions
+- Result of compilation depends on Ruby version and used platform (x86, x64 etc.)
+- 2-clause BSD license suitable for creation of custom source code protection system
+
+Changelog:
+- 04.MAY.2015 - 0.1.1 - first public version

data/bin/noderbc

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby
+require_relative '../lib/node-marshal.rb'
+
+help = <<-EOS
+Ruby source files compiler. It is based on NodeMarshal class.
+from NodeDump gem. Source code is transformed to the Ruby node
+(syntax tree) serialized into ASCII string. Such transformation
+is based on Ruby internal syntax tree, irreversible and can
+be used for code obfuscation.
+
+(C) 2015 Alexey Voskov. License: 2-clause BSD.
+
+Usage:
+  noderbc inpfile outfile
+  
+  inpfile -- Name of input Ruby script (with extension)
+  outfile -- Name of output Ruby (with extension)
+EOS
+
+if ARGV.length != 2
+	puts help
+else
+	inpfile = ARGV[0]
+	outfile = ARGV[1]
+	raise 'inpfile and outfile cannot be equal' if inpfile == outfile
+	NodeMarshal.compile_rb_file(outfile, inpfile)
+end

data/bin/noderbc.bat

@@ -0,0 +1 @@
+@ruby noderbc %*

data/ext/node-marshal/COPYING

@@ -0,0 +1,23 @@
+Copyright (C) 2015 Alexey Voskov. All rights reserved.
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/ext/node-marshal/base85r.c

@@ -0,0 +1,190 @@
+/*
+ * Implementation of own version of BASE85 binary data encoding
+ * adapted for the usage inside Ruby source code (i.e. without
+ * such symbols as \ " # { } '
+ *
+ * Format of the output stream:
+ * 1) First byte: number of bytes in the last chunk: from 0 to 3
+ *    (0 means that the last chunk contains 4 bytes, i.e. everything
+ *     is aligned). See val_to_char array for the used alphabet
+ * 2) big-endian 5-byte numbers (base 85)
+ * 3) empty string: arbitrary two bytes
+ *
+ * (C) 2015 Alexey Voskov
+ * License: 2-clause BSD
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <ruby.h>
+#include <ruby/version.h>
+
+#define BASE85R_STR_WIDTH 14 // Number of 5-byte groups in the string (12 for 60-byte string)
+
+#define D0_VAL 1 // 85**0
+#define D1_VAL 85 // 85**1
+#define D2_VAL 7225 // 85**2
+#define D3_VAL 614125 // 85**3
+#define D4_VAL 52200625 // 85**4
+
+static int di_val[5] = {D4_VAL, D3_VAL, D2_VAL, D1_VAL, D0_VAL};
+
+
+/* Modified BASE85 digits */
+static const char val_to_char[86] = // ASCIIZ string
+"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+"abcdefghijklmnopqrstuvwxyz"
+"0123456789"
+"!$%&()*-./"
+":;<=>?@[]^"
+",_|";
+
+static int char_to_val[128];
+
+
+/* Initializes internal tables that are required
+   for recoding */
+void base85r_init_tables()
+{
+	int i;
+	for (i = 0; i < 128; i++)
+		char_to_val[i] = -1;
+
+
+	for (i = 0; i < 85; i++)
+	{
+		if (char_to_val[(int) val_to_char[i]] != -1)
+			rb_raise(rb_eArgError, "Internal error");
+		char_to_val[(int) val_to_char[i]] = i;
+	}
+
+	for (i = 0; i < 85; i++)
+		if (char_to_val[(int) val_to_char[i]] != i)
+			rb_raise(rb_eArgError, "Internal error");
+}
+
+
+/* Calculate length of buffer for base85 encoding */
+static int base85_encode_buf_len(int len)
+{
+	// Calculate aligned (32-bit alignment) size of the buffer
+	int buf_len = ((len >> 2) << 2);
+	if (len % 4) buf_len += 4;
+	// Calculate size of the output buffer
+	buf_len = (buf_len * 5) / 4;
+	buf_len = (buf_len * 105) / 100;
+	buf_len += 32;
+	// Return buffer size
+	return buf_len;
+}
+
+/* Encode string to modified BASE85 ASCII.
+   Call base85_init_tables before using of this function */
+VALUE base85r_encode(VALUE input)
+{
+	VALUE output;
+	int inp_len, out_len, out_buf_len;
+	int pos, outpos;
+	unsigned int val;
+	unsigned char *outptr, *inptr;
+	int i;
+	// Check input data type and allocate string
+	if (TYPE(input) != T_STRING)
+		rb_raise(rb_eArgError, "base85r_encode: input must be a string");
+	inp_len = RSTRING_LEN(input);
+	out_buf_len = base85_encode_buf_len(inp_len);
+	output = rb_str_new(NULL, out_buf_len);
+	// Begin conversion
+	outpos = 0;
+	outptr = (unsigned char *) RSTRING_PTR(output);
+	inptr = (unsigned char *) RSTRING_PTR(input);
+	outptr[outpos++] = 32;
+	outptr[outpos++] = val_to_char[inp_len % 4];
+	out_len = 2;
+	for (pos = 0; pos < inp_len; )
+	{
+		// Get four bytes
+		val = 0;
+		for (i = 24; i >= 0; i -= 8)
+			if (pos < inp_len) val |= inptr[pos++] << i;
+		// And transform them to five bytes
+		for (i = 0; i < 5; i++)
+		{
+			int digit = (val / di_val[i]) % 85;
+			char sym = val_to_char[digit];
+			outptr[outpos++] = sym;
+		}
+		out_len += 5;
+		// Newline addition
+		if (pos % (4 * BASE85R_STR_WIDTH) == 0)
+		{
+			out_len += 2;
+			outptr[outpos++] = 10;
+			outptr[outpos++]= 32;
+		}
+	}
+	// Check the state of memory
+	if (outpos >= out_buf_len)
+		rb_raise(rb_eArgError, "base85r_encode: internal memory error");
+	// Truncate the empty "tail" of the buffer and return the string 
+	return rb_str_resize(output, out_len);
+}
+
+
+/* Decode string in modified BASE85 ASCII format.
+   Call base85_init_tables before using of this function */
+VALUE base85r_decode(VALUE input)
+{
+	int inp_len, out_len, pos, shift;
+	unsigned int val = 0;
+	VALUE output;
+	unsigned char *inptr, *outptr;
+	int tail_len, i;
+	// Check input data type and allocate string
+	if (TYPE(input) != T_STRING)
+		rb_raise(rb_eArgError, "base85r_decode: input must be a string");
+	inp_len = RSTRING_LEN(input);
+	if (inp_len < 6 && inp_len != 2)
+	{	// String with 1 or more symbols
+		rb_raise(rb_eArgError, "base85r_decode: input string is too short");
+	}
+	output = rb_str_new(NULL, inp_len);
+	// Begin conversion
+	inptr = (unsigned char *) RSTRING_PTR(input);
+	outptr = (unsigned char *) RSTRING_PTR(output);
+	out_len = 0;
+	tail_len = -1;
+	shift = 0;
+	val = 0;
+	for (pos = 0; pos < inp_len; pos++)
+	{
+		int digit = char_to_val[(int) inptr[pos]];
+		if (digit != -1)
+		{
+			if (tail_len == -1)
+			{
+				tail_len = digit;
+				if (tail_len > 4)
+					rb_raise(rb_eArgError, "base85r_decode: input string is corrupted");
+				continue;
+			}
+			val +=  digit * di_val[shift++]; 
+			if (shift == 5)
+			{
+				for (i = 24; i >= 0; i -= 8)
+					*outptr++ = (val >> i) & 0xFF;
+				shift = 0; val = 0;
+				out_len += 4;
+			}
+		}
+	}
+	// Check if the byte sequence was valid
+	if (shift != 0)
+		rb_raise(rb_eArgError, "base85r_decode: input string is corrupted");
+	// Take into account unaligned "tail"
+	if (tail_len != 0)
+	{
+		out_len -= (4 - tail_len);
+	}
+	return rb_str_resize(output, out_len);
+}

data/ext/node-marshal/extconf.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/ruby
+require 'mkmf'
+create_makefile('nodemarshal')

data/ext/node-marshal/libobj/readme.txt

@@ -0,0 +1 @@
+Directory for the object files for static library assembling.

data/ext/node-marshal/node193.h

@@ -0,0 +1,312 @@
+/*
+ * Simpilfied node.h file from Ruby 1.9.3 source code
+ * Copyright (C) 1993-2007 Yukihiro Matsumoto
+ */
+
+#ifndef RUBY_NODE_H
+#define RUBY_NODE_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+enum node_type {
+    NODE_SCOPE,
+#define NODE_SCOPE       NODE_SCOPE
+    NODE_BLOCK,
+#define NODE_BLOCK       NODE_BLOCK
+    NODE_IF,
+#define NODE_IF          NODE_IF
+    NODE_CASE,
+#define NODE_CASE        NODE_CASE
+    NODE_WHEN,
+#define NODE_WHEN        NODE_WHEN
+    NODE_OPT_N,
+#define NODE_OPT_N       NODE_OPT_N
+    NODE_WHILE,
+#define NODE_WHILE       NODE_WHILE
+    NODE_UNTIL,
+#define NODE_UNTIL       NODE_UNTIL
+    NODE_ITER,
+#define NODE_ITER        NODE_ITER
+    NODE_FOR,
+#define NODE_FOR         NODE_FOR
+    NODE_BREAK,
+#define NODE_BREAK       NODE_BREAK
+    NODE_NEXT,
+#define NODE_NEXT        NODE_NEXT
+    NODE_REDO,
+#define NODE_REDO        NODE_REDO
+    NODE_RETRY,
+#define NODE_RETRY       NODE_RETRY
+    NODE_BEGIN,
+#define NODE_BEGIN       NODE_BEGIN
+    NODE_RESCUE,
+#define NODE_RESCUE      NODE_RESCUE
+    NODE_RESBODY,
+#define NODE_RESBODY     NODE_RESBODY
+    NODE_ENSURE,
+#define NODE_ENSURE      NODE_ENSURE
+    NODE_AND,
+#define NODE_AND         NODE_AND
+    NODE_OR,
+#define NODE_OR          NODE_OR
+    NODE_MASGN,
+#define NODE_MASGN       NODE_MASGN
+    NODE_LASGN,
+#define NODE_LASGN       NODE_LASGN
+    NODE_DASGN,
+#define NODE_DASGN       NODE_DASGN
+    NODE_DASGN_CURR,
+#define NODE_DASGN_CURR  NODE_DASGN_CURR
+    NODE_GASGN,
+#define NODE_GASGN       NODE_GASGN
+    NODE_IASGN,
+#define NODE_IASGN       NODE_IASGN
+    NODE_IASGN2,
+#define NODE_IASGN2      NODE_IASGN2
+    NODE_CDECL,
+#define NODE_CDECL       NODE_CDECL
+    NODE_CVASGN,
+#define NODE_CVASGN      NODE_CVASGN
+    NODE_CVDECL,
+#define NODE_CVDECL      NODE_CVDECL
+    NODE_OP_ASGN1,
+#define NODE_OP_ASGN1    NODE_OP_ASGN1
+    NODE_OP_ASGN2,
+#define NODE_OP_ASGN2    NODE_OP_ASGN2
+    NODE_OP_ASGN_AND,
+#define NODE_OP_ASGN_AND NODE_OP_ASGN_AND
+    NODE_OP_ASGN_OR,
+#define NODE_OP_ASGN_OR  NODE_OP_ASGN_OR
+    NODE_CALL,
+#define NODE_CALL        NODE_CALL
+    NODE_FCALL,
+#define NODE_FCALL       NODE_FCALL
+    NODE_VCALL,
+#define NODE_VCALL       NODE_VCALL
+    NODE_SUPER,
+#define NODE_SUPER       NODE_SUPER
+    NODE_ZSUPER,
+#define NODE_ZSUPER      NODE_ZSUPER
+    NODE_ARRAY,
+#define NODE_ARRAY       NODE_ARRAY
+    NODE_ZARRAY,
+#define NODE_ZARRAY      NODE_ZARRAY
+    NODE_VALUES,
+#define NODE_VALUES      NODE_VALUES
+    NODE_HASH,
+#define NODE_HASH        NODE_HASH
+    NODE_RETURN,
+#define NODE_RETURN      NODE_RETURN
+    NODE_YIELD,
+#define NODE_YIELD       NODE_YIELD
+    NODE_LVAR,
+#define NODE_LVAR        NODE_LVAR
+    NODE_DVAR,
+#define NODE_DVAR        NODE_DVAR
+    NODE_GVAR,
+#define NODE_GVAR        NODE_GVAR
+    NODE_IVAR,
+#define NODE_IVAR        NODE_IVAR
+    NODE_CONST,
+#define NODE_CONST       NODE_CONST
+    NODE_CVAR,
+#define NODE_CVAR        NODE_CVAR
+    NODE_NTH_REF,
+#define NODE_NTH_REF     NODE_NTH_REF
+    NODE_BACK_REF,
+#define NODE_BACK_REF    NODE_BACK_REF
+    NODE_MATCH,
+#define NODE_MATCH       NODE_MATCH
+    NODE_MATCH2,
+#define NODE_MATCH2      NODE_MATCH2
+    NODE_MATCH3,
+#define NODE_MATCH3      NODE_MATCH3
+    NODE_LIT,
+#define NODE_LIT         NODE_LIT
+    NODE_STR,
+#define NODE_STR         NODE_STR
+    NODE_DSTR,
+#define NODE_DSTR        NODE_DSTR
+    NODE_XSTR,
+#define NODE_XSTR        NODE_XSTR
+    NODE_DXSTR,
+#define NODE_DXSTR       NODE_DXSTR
+    NODE_EVSTR,
+#define NODE_EVSTR       NODE_EVSTR
+    NODE_DREGX,
+#define NODE_DREGX       NODE_DREGX
+    NODE_DREGX_ONCE,
+#define NODE_DREGX_ONCE  NODE_DREGX_ONCE
+    NODE_ARGS,
+#define NODE_ARGS        NODE_ARGS
+    NODE_ARGS_AUX,
+#define NODE_ARGS_AUX    NODE_ARGS_AUX
+    NODE_OPT_ARG,
+#define NODE_OPT_ARG     NODE_OPT_ARG
+    NODE_POSTARG,
+#define NODE_POSTARG     NODE_POSTARG
+    NODE_ARGSCAT,
+#define NODE_ARGSCAT     NODE_ARGSCAT
+    NODE_ARGSPUSH,
+#define NODE_ARGSPUSH    NODE_ARGSPUSH
+    NODE_SPLAT,
+#define NODE_SPLAT       NODE_SPLAT
+    NODE_TO_ARY,
+#define NODE_TO_ARY      NODE_TO_ARY
+    NODE_BLOCK_ARG,
+#define NODE_BLOCK_ARG   NODE_BLOCK_ARG
+    NODE_BLOCK_PASS,
+#define NODE_BLOCK_PASS  NODE_BLOCK_PASS
+    NODE_DEFN,
+#define NODE_DEFN        NODE_DEFN
+    NODE_DEFS,
+#define NODE_DEFS        NODE_DEFS
+    NODE_ALIAS,
+#define NODE_ALIAS       NODE_ALIAS
+    NODE_VALIAS,
+#define NODE_VALIAS      NODE_VALIAS
+    NODE_UNDEF,
+#define NODE_UNDEF       NODE_UNDEF
+    NODE_CLASS,
+#define NODE_CLASS       NODE_CLASS
+    NODE_MODULE,
+#define NODE_MODULE      NODE_MODULE
+    NODE_SCLASS,
+#define NODE_SCLASS      NODE_SCLASS
+    NODE_COLON2,
+#define NODE_COLON2      NODE_COLON2
+    NODE_COLON3,
+#define NODE_COLON3      NODE_COLON3
+    NODE_DOT2,
+#define NODE_DOT2        NODE_DOT2
+    NODE_DOT3,
+#define NODE_DOT3        NODE_DOT3
+    NODE_FLIP2,
+#define NODE_FLIP2       NODE_FLIP2
+    NODE_FLIP3,
+#define NODE_FLIP3       NODE_FLIP3
+    NODE_SELF,
+#define NODE_SELF        NODE_SELF
+    NODE_NIL,
+#define NODE_NIL         NODE_NIL
+    NODE_TRUE,
+#define NODE_TRUE        NODE_TRUE
+    NODE_FALSE,
+#define NODE_FALSE       NODE_FALSE
+    NODE_ERRINFO,
+#define NODE_ERRINFO     NODE_ERRINFO
+    NODE_DEFINED,
+#define NODE_DEFINED     NODE_DEFINED
+    NODE_POSTEXE,
+#define NODE_POSTEXE     NODE_POSTEXE
+    NODE_ALLOCA,
+#define NODE_ALLOCA      NODE_ALLOCA
+    NODE_BMETHOD,
+#define NODE_BMETHOD     NODE_BMETHOD
+    NODE_MEMO,
+#define NODE_MEMO        NODE_MEMO
+    NODE_IFUNC,
+#define NODE_IFUNC       NODE_IFUNC
+    NODE_DSYM,
+#define NODE_DSYM        NODE_DSYM
+    NODE_ATTRASGN,
+#define NODE_ATTRASGN    NODE_ATTRASGN
+    NODE_PRELUDE,
+#define NODE_PRELUDE     NODE_PRELUDE
+    NODE_LAMBDA,
+#define NODE_LAMBDA      NODE_LAMBDA
+    NODE_OPTBLOCK,
+#define NODE_OPTBLOCK    NODE_OPTBLOCK
+    NODE_LAST
+#define NODE_LAST        NODE_LAST
+};
+
+typedef struct RNode {
+    VALUE flags;
+    VALUE nd_reserved;		/* ex nd_file */
+    union {
+	struct RNode *node;
+	ID id;
+	VALUE value;
+	VALUE (*cfunc)(ANYARGS);
+	ID *tbl;
+    } u1;
+    union {
+	struct RNode *node;
+	ID id;
+	long argc;
+	VALUE value;
+    } u2;
+    union {
+	struct RNode *node;
+	ID id;
+	long state;
+	struct rb_global_entry *entry;
+	long cnt;
+	VALUE value;
+    } u3;
+} NODE;
+
+#define RNODE(obj)  (R_CAST(RNode)(obj))
+
+/* 0..4:T_TYPES, 5:FL_MARK, 6:reserved, 7:NODE_FL_NEWLINE */
+#define NODE_FL_NEWLINE (((VALUE)1)<<7)
+#define NODE_FL_CREF_PUSHED_BY_EVAL NODE_FL_NEWLINE
+
+#define NODE_TYPESHIFT 8
+#define NODE_TYPEMASK  (((VALUE)0x7f)<<NODE_TYPESHIFT)
+
+#define nd_type(n) ((int) (((RNODE(n))->flags & NODE_TYPEMASK)>>NODE_TYPESHIFT))
+#define nd_set_type(n,t) \
+    RNODE(n)->flags=((RNODE(n)->flags&~NODE_TYPEMASK)|((((unsigned long)(t))<<NODE_TYPESHIFT)&NODE_TYPEMASK))
+
+#define NODE_LSHIFT (NODE_TYPESHIFT+7)
+#define NODE_LMASK  (((SIGNED_VALUE)1<<(sizeof(VALUE)*CHAR_BIT-NODE_LSHIFT))-1)
+#define nd_line(n) (int)(RNODE(n)->flags>>NODE_LSHIFT)
+#define nd_set_line(n,l) \
+    RNODE(n)->flags=((RNODE(n)->flags&~(-1<<NODE_LSHIFT))|(((l)&NODE_LMASK)<<NODE_LSHIFT))
+
+#define NEW_NODE(t,a0,a1,a2) rb_node_newnode((t),(VALUE)(a0),(VALUE)(a1),(VALUE)(a2))
+
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+VALUE rb_parser_dump_tree(NODE *node, int comment);
+
+NODE *rb_compile_cstr(const char*, const char*, int, int);
+NODE *rb_compile_string(const char*, VALUE, int);
+NODE *rb_compile_file(const char*, VALUE, int);
+
+NODE *rb_node_newnode(enum node_type,VALUE,VALUE,VALUE);
+NODE *rb_node_newnode_longlife(enum node_type,VALUE,VALUE,VALUE);
+
+struct rb_global_entry {
+    struct rb_global_variable *var;
+    ID id;
+};
+
+struct rb_global_entry *rb_global_entry(ID);
+VALUE rb_gvar_get(struct rb_global_entry *);
+VALUE rb_gvar_set(struct rb_global_entry *, VALUE);
+VALUE rb_gvar_defined(struct rb_global_entry *);
+const struct kwtable *rb_reserved_word(const char *, unsigned int);
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_NODE_H */