rallhook 0.7.0

data/ext/rallhook_base/rb_call_fake.c

@@ -0,0 +1,398 @@
+/*
+
+This file is part of the rallhook project, http://github.com/tario/rallhook
+
+Copyright (c) 2009-2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+rallhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+rallhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with rallhook.  if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include <ruby.h>
+
+#ifdef RUBY1_8
+#include <node.h>
+#include <env.h> // from ruby
+#endif
+
+#include <dlfcn.h>
+#include <stdarg.h>
+#include "ruby_symbols.h"
+#include "rb_call_fake.h"
+#include "ruby_redirect.h"
+
+void* rb_call_copy;
+
+extern REDIRECTHANDLER current_redirect_handler;
+
+#ifdef __i386__
+
+VALUE read_eax( ) {
+}
+
+VALUE read_edx( ) {
+__asm__("mov %edx, %eax");
+}
+
+VALUE read_ecx( ) {
+__asm__("mov %ecx, %eax");
+}
+
+int rb_call_write_eax(int value) {
+	return value;
+}
+
+int is_fastcall = 1;
+int is_calibrate = 0;
+int vm_is_fastcall = 1;
+int vm_is_calibrate = 0;
+VALUE calibrate_klass;
+VALUE calibrate_recv;
+ID calibrate_mid;
+
+#endif
+
+#ifdef RUBY1_9
+
+VMCALLMETHOD vm_call_method_copy;
+
+typedef void rb_vm_t_;
+#endif
+
+VALUE rb_call_copy_i(
+    VALUE klass, VALUE recv,
+    ID    mid,
+    int argc,			/* OK */
+    const VALUE *argv,		/* OK */
+    int scope,
+    VALUE self
+) {
+#ifdef __i386__
+	if (is_fastcall == 1) {
+
+		int array[7] = { (int)klass, (int)recv, mid, argc, (int)argv, scope, (int)self };
+		rb_call_write_eax(array);
+
+		__asm__("push %ebp\n");	// save all registers
+		__asm__("push %esi\n");
+		__asm__("push %edi\n");
+		__asm__("push %ebx\n");
+		__asm__("push %edx\n");
+		__asm__("push %ecx\n");
+		__asm__("mov 0x4(%eax), %edx\n");
+		__asm__("mov 0x8(%eax), %ecx\n");
+		__asm__("push 0x18(%eax)\n");
+		__asm__("push 0x14(%eax)\n");
+		__asm__("push 0x10(%eax)\n");
+		__asm__("push 0x0c(%eax)\n");
+		__asm__("mov (%eax), %eax\n");
+		__asm__("call *rb_call_copy\n");
+		__asm__("add $0x10, %esp\n");
+		__asm__("pop %ecx\n");
+		__asm__("pop %edx\n");
+		__asm__("pop %ebx\n");
+		__asm__("pop %edi\n");
+		__asm__("pop %esi\n");
+		__asm__("pop %ebp\n");
+		return read_eax();
+
+	} else if ( is_fastcall == 2) {
+		int array[7] = { (int)klass, (int)recv, mid, argc, (int)argv, scope, (int)self };
+		rb_call_write_eax(array);
+
+		__asm__("push %ebp\n");	// save all registers
+		__asm__("push %esi\n");
+		__asm__("push %edi\n");
+		__asm__("push %ebx\n");
+		__asm__("push %edx\n");
+		__asm__("push %ecx\n");
+		__asm__("mov 0x4(%eax), %edx\n");
+		__asm__("push 0x18(%eax)\n");
+		__asm__("push 0x14(%eax)\n");
+		__asm__("push 0x10(%eax)\n");
+		__asm__("push 0x0c(%eax)\n");
+		__asm__("push 0x08(%eax)\n");
+		__asm__("mov (%eax), %eax\n");
+		__asm__("call *rb_call_copy\n");
+		__asm__("add $0x14, %esp\n");
+		__asm__("pop %ecx\n");
+		__asm__("pop %edx\n");
+		__asm__("pop %ebx\n");
+		__asm__("pop %edi\n");
+		__asm__("pop %esi\n");
+		__asm__("pop %ebp\n");
+		return read_eax();
+
+	} else {
+#endif
+	return ((RBCALL)rb_call_copy)(klass,recv,mid,argc,argv,scope,self);
+#ifdef __i386__
+	}
+#endif
+
+}
+
+#ifdef RUBY1_9
+
+VALUE
+vm_call_method_i(rb_thread_t_ * const th, rb_control_frame_t_ * const cfp,
+	       const int num, rb_block_t_ * const blockptr, const VALUE flag,
+	       const ID id, void * mn, const VALUE recv_, VALUE klass)
+{
+
+#ifdef __i386__
+	if (vm_is_fastcall == 1) {
+
+		int array[9] = { (int)th, (int)cfp, num, (int)blockptr, (int)flag, (int)id, (int)mn, (int)recv_, (int)klass };
+		rb_call_write_eax(array);
+
+		__asm__("push %ebp\n");	// save all registers
+		__asm__("push %esi\n");
+		__asm__("push %edi\n");
+		__asm__("push %ebx\n");
+		__asm__("push %edx\n");
+		__asm__("push %ecx\n");
+		__asm__("mov 0x4(%eax), %edx\n");
+		__asm__("mov 0x8(%eax), %ecx\n");
+		__asm__("push 0x20(%eax)\n");
+		__asm__("push 0x1c(%eax)\n");
+		__asm__("push 0x18(%eax)\n");
+		__asm__("push 0x14(%eax)\n");
+		__asm__("push 0x10(%eax)\n");
+		__asm__("push 0x0c(%eax)\n");
+		__asm__("mov (%eax), %eax\n");
+		__asm__("call *vm_call_method_copy\n");
+		__asm__("add $0x18, %esp\n");
+		__asm__("pop %ecx\n");
+		__asm__("pop %edx\n");
+		__asm__("pop %ebx\n");
+		__asm__("pop %edi\n");
+		__asm__("pop %esi\n");
+		__asm__("pop %ebp\n");
+		return read_eax();
+
+	} else if ( vm_is_fastcall == 2) {
+		int array[9] = { (int)th, (int)cfp, num, (int)blockptr, (int)flag, (int)id, (int)mn, (int)recv_, (int)klass };
+		rb_call_write_eax(array);
+
+		__asm__("push %ebp\n");	// save all registers
+		__asm__("push %esi\n");
+		__asm__("push %edi\n");
+		__asm__("push %ebx\n");
+		__asm__("push %edx\n");
+		__asm__("push %ecx\n");
+		__asm__("mov 0x4(%eax), %edx\n");
+		__asm__("push 0x20(%eax)\n");
+		__asm__("push 0x1c(%eax)\n");
+		__asm__("push 0x18(%eax)\n");
+		__asm__("push 0x14(%eax)\n");
+		__asm__("push 0x10(%eax)\n");
+		__asm__("push 0x0c(%eax)\n");
+		__asm__("push 0x08(%eax)\n");
+		__asm__("mov (%eax), %eax\n");
+		__asm__("call *vm_call_method_copy\n");
+		__asm__("add $0x1c, %esp\n");
+		__asm__("pop %ecx\n");
+		__asm__("pop %edx\n");
+		__asm__("pop %ebx\n");
+		__asm__("pop %edi\n");
+		__asm__("pop %esi\n");
+		__asm__("pop %ebp\n");
+		return read_eax();
+
+	} else {
+#endif
+		return vm_call_method_copy(th,cfp,num,blockptr,flag,id,mn,recv_,klass);
+#ifdef __i386__
+	}
+#endif
+
+
+}
+
+VALUE
+vm_call_method_fake(rb_thread_t_ * const th, rb_control_frame_t_ * const cfp,
+	       const int num, rb_block_t_ * const blockptr, const VALUE flag,
+	       ID id, void * mn, VALUE recv, VALUE klass)
+{
+	VALUE klass_copy = klass;
+	VALUE recv_copy = recv;
+	ID id_copy = id;
+
+	current_redirect_handler(&klass, &recv, &id);
+
+	if (id_copy != id || klass_copy != klass || recv_copy != recv) {
+		mn = rb_get_method_body(klass, id, 0);
+	}
+
+	return vm_call_method_i(
+			th,
+			cfp,
+			num,
+			blockptr,
+			flag,
+			id,
+			mn,
+			recv,
+			klass);
+
+
+}
+
+#ifdef __i386__
+
+VALUE vm_call_method_fake_regs(
+	_WORD eax, _WORD edx, _WORD ecx, _WORD* esp
+) {
+
+	esp++;
+
+	if (vm_is_calibrate) {
+		if ((VALUE)esp[7] == calibrate_recv && (VALUE)esp[8] == calibrate_klass && (ID)esp[5] == calibrate_mid) {
+			vm_is_fastcall = 0;
+		} else if ( (VALUE)esp[5] == calibrate_recv ) {
+			vm_is_fastcall = 2;
+		} else {
+			vm_is_fastcall = 1;
+		}
+		vm_is_calibrate = 0;
+	}
+
+	if (vm_is_fastcall == 0) {
+		return vm_call_method_fake(
+			(rb_thread_t_*)esp[0],
+			(rb_control_frame_t_*)esp[1],
+			(int)esp[2],
+			(rb_block_t_*)esp[3],
+			(VALUE)esp[3],
+			(ID)esp[4],
+			(void*)esp[5],
+			(VALUE)esp[6],
+			(VALUE)esp[7]
+			);
+	} else if (vm_is_fastcall == 2 ) {
+		return vm_call_method_fake(
+			(rb_thread_t_*)eax,
+			(rb_control_frame_t_*)edx,
+			(int)esp[0],
+			(rb_block_t_*)esp[1],
+			(VALUE)esp[2],
+			(ID)esp[3],
+			(void*)esp[4],
+			(VALUE)esp[5],
+			(VALUE)esp[6]
+			);
+
+	} else {
+		return vm_call_method_fake(
+			(rb_thread_t_*)eax,
+			(rb_control_frame_t_*)edx,
+			(int)ecx,
+			(rb_block_t_*)esp[0],
+			(VALUE)esp[1],
+			(ID)esp[2],
+			(void*)esp[3],
+			(VALUE)esp[4],
+			(VALUE)esp[5]
+			);
+
+	}
+
+}
+
+#endif
+
+#endif
+
+
+VALUE
+rb_call_fake(
+    VALUE klass, VALUE recv,
+    ID    mid,
+    int argc,			/* OK */
+    const VALUE *argv,		/* OK */
+    int scope,
+    VALUE self
+) {
+
+	current_redirect_handler(&klass, &recv, &mid);
+	return rb_call_copy_i(klass,recv,mid,argc,argv,scope,self);
+
+}
+
+
+#ifdef __i386__
+
+VALUE
+rb_call_fake_regs(
+	_WORD eax, _WORD edx, _WORD ecx, _WORD* esp
+) {
+	VALUE klass;
+	VALUE recv;
+	ID    mid;
+	int argc;			/* OK */
+	const VALUE *argv;
+	int scope;
+	VALUE self;
+
+	esp++;
+
+
+	if (is_calibrate) {
+
+		if ((VALUE)edx == calibrate_recv && (VALUE)eax == calibrate_klass && (ID)ecx == calibrate_mid) {
+			is_fastcall = 1;
+		} else if ( (VALUE)edx == calibrate_recv && (VALUE)eax == calibrate_klass && (ID)esp[0] == calibrate_mid ) {
+			is_fastcall = 2;
+		} else {
+			is_fastcall = 0;
+		}
+		is_calibrate = 0;
+		return Qnil;
+	}
+
+	if (is_fastcall == 0) {
+		klass = (VALUE)esp[0];
+		recv = (VALUE)esp[1];
+		mid = (ID)esp[2];
+		argc = (int)esp[3];
+		argv = (VALUE*)esp[4];
+		scope = (int)esp[5];
+		self = (VALUE)esp[6];
+	} else if (is_fastcall == 2) {
+		klass = (VALUE)eax;
+		recv = (VALUE)edx;
+		mid = (VALUE)esp[0];
+		argc = (int)esp[1];
+		argv = (VALUE*)esp[2];
+		scope = (int)esp[3];
+		self = (VALUE)esp[4];
+	} else {
+		klass = (VALUE)eax;
+		recv = (VALUE)edx;
+		mid = (VALUE)ecx;
+		argc = (int)esp[0];
+		argv = (VALUE*)esp[1];
+		scope = (int)esp[2];
+		self = (VALUE)esp[3];
+	}
+	return rb_call_fake(klass,recv,mid,argc,argv,scope,self);
+}
+
+#endif
+
+void
+rb_call_fake_init() {
+
+}

data/ext/rallhook_base/rb_call_fake.h

@@ -0,0 +1,138 @@
+/*
+
+This file is part of the rallhook project, http://github.com/tario/rallhook
+
+Copyright (c) 2009-2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+rallhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+rallhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with rallhook.  if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef __RB_CALL_FAKE_H
+#define __RB_CALL_FAKE_H
+
+#include <ruby.h>
+#include "ruby_version.h"
+
+#define FASTCALL
+
+void
+rb_call_fake_init();
+
+typedef VALUE (*RBCALL_FASTCALL) (
+    int argc,			/* OK */
+    const VALUE *argv,		/* OK */
+    int scope,
+    VALUE self
+) FASTCALL;
+
+typedef VALUE (*RBCALL) (
+    VALUE klass, VALUE recv,
+    ID    mid,
+    int argc,			/* OK */
+    const VALUE *argv,		/* OK */
+    int scope,
+    VALUE self
+);
+
+//typedef void rb_control_frame_t;
+
+
+#ifdef RUBY1_9
+
+typedef void rb_block_t_;
+typedef void rb_iseq_t_;
+typedef void rb_thread_t_;
+// from vm_core.h
+typedef struct {
+    VALUE *pc;
+    VALUE *sp;
+    VALUE *bp;
+    rb_iseq_t_ *iseq;
+    VALUE flag;
+    VALUE self;
+    VALUE *lfp;
+    VALUE *dfp;
+    rb_iseq_t_ *block_iseq;
+    VALUE proc;
+    ID method_id;
+    VALUE method_class;
+} rb_control_frame_t_;
+
+typedef VALUE (*VMCALLMETHOD) (
+	rb_thread_t_ * th, rb_control_frame_t_ *cfp,
+    const int num, rb_block_t_ * blockptr, const VALUE flag,
+    const ID id, void * mn, const VALUE recv, VALUE klass
+) ;
+#endif
+
+extern void* rb_call_copy;
+
+#ifdef RUBY1_9
+extern VMCALLMETHOD vm_call_method_copy;
+VALUE
+vm_call_method_fake(rb_thread_t_ * const th, rb_control_frame_t_ * const cfp,
+	       const int num, rb_block_t_ * const blockptr, const VALUE flag,
+	       const ID id, void * mn, const VALUE recv_, VALUE klass);
+#endif
+
+#ifdef __i386__
+#define _WORD int
+#else
+#define _WORD long int
+#endif
+
+
+VALUE
+rb_call_fake(
+    VALUE klass, VALUE recv,
+    ID    mid,
+    int argc,			/* OK */
+    const VALUE *argv,		/* OK */
+    int scope,
+    VALUE self
+);
+
+#ifdef __i386__
+
+#ifndef _WORD
+#define _WORD int
+#endif
+
+VALUE
+rb_call_fake_regs(
+	_WORD eax, _WORD edx, _WORD ecx, _WORD* esp
+);
+
+VALUE
+vm_call_method_fake_regs(
+	_WORD eax, _WORD edx, _WORD ecx, _WORD* esp
+);
+
+#endif
+
+
+extern void* rb_call_original;
+
+#ifdef __i386__
+extern int vm_is_calibrate;
+extern int is_calibrate;
+extern VALUE calibrate_klass;
+extern VALUE calibrate_recv;
+extern ID calibrate_mid;
+#endif
+
+
+
+#endif

data/ext/rallhook_base/restrict_def.c

@@ -0,0 +1,176 @@
+/*
+
+This file is part of the rallhook project, http://github.com/tario/rallhook
+
+Copyright (c) 2009-2010 Roberto Dario Seminara <robertodarioseminara@gmail.com>
+
+rallhook is free software: you can redistribute it and/or modify
+it under the terms of the gnu general public license as published by
+the free software foundation, either version 3 of the license, or
+(at your option) any later version.
+
+rallhook is distributed in the hope that it will be useful,
+but without any warranty; without even the implied warranty of
+merchantability or fitness for a particular purpose.  see the
+gnu general public license for more details.
+
+you should have received a copy of the gnu general public license
+along with rallhook.  if not, see <http://www.gnu.org/licenses/>.
+
+*/
+#include "ruby.h"
+#include "restrict_def.h"
+#include "ruby_symbols.h"
+#include "hook.h"
+
+#ifndef __USE_GNU
+#define __USE_GNU
+#endif
+
+#include <dlfcn.h>
+
+ID __shadow___id;
+ID __unshadow___id;
+ID shadow_id;
+ID id_restrict_def;
+
+typedef void NODE_;
+
+typedef void (*RBADDMETHOD) (
+    VALUE klass,
+    ID id,
+    NODE_* node,
+    int noex
+);
+
+RBADDMETHOD rb_add_method_copy;
+
+typedef struct AttachedThreadInfo_ {
+	int hook_enabled;
+	int hook_enable_left;
+	VALUE hook_proc;
+	int handle_method_arity;
+} AttachedThreadInfo;
+
+AttachedThreadInfo* tinfo_from_thread(VALUE thread);
+
+int overwrite_enabled(VALUE current_thread) {
+	return tinfo_from_thread(current_thread)->hook_enabled ;
+}
+
+VALUE shadow_or_create(VALUE klass);
+
+VALUE create_shadow(VALUE klass) {
+	if (FL_TEST(klass, FL_SINGLETON)) {
+		VALUE obj = rb_iv_get(klass, "__attached__");
+		VALUE obj_klass = rb_obj_class(obj);
+		VALUE shadow_of_klass = shadow_or_create(obj_klass);
+
+		VALUE retvalue = rb_class_boot(shadow_of_klass);
+		FL_SET(retvalue, FL_SINGLETON);
+
+		// define as __attached__ of the new singleton class the same object
+		rb_iv_set(retvalue, "__attached__", obj);
+		return retvalue;
+	} else {
+		return rb_class_new(klass);
+	}
+}
+
+VALUE shadow_or_create(VALUE klass) {
+
+	VALUE shadow_klass = rb_ivar_get(klass, __shadow___id);
+	if ( shadow_klass == Qnil ) {
+		shadow_klass = create_shadow(klass);
+		rb_ivar_set(klass, __shadow___id, shadow_klass );
+		rb_ivar_set(shadow_klass, __unshadow___id, klass );
+	}
+	return shadow_klass;
+}
+
+VALUE shadow_or_original(VALUE klass) {
+
+	VALUE shadow_klass = rb_ivar_get(klass, __shadow___id);
+	if ( shadow_klass == Qnil ) {
+		return klass;
+	}
+	return shadow_klass;
+
+}
+
+VALUE unshadow(VALUE klass) {
+	VALUE unshadow_klass = rb_ivar_get(klass, __unshadow___id);
+	if (unshadow_klass == Qnil) {
+		return klass;
+	} else {
+		return unshadow_klass;
+	}
+
+}
+
+void rb_add_method_fake(
+    VALUE klass,
+    ID id,
+    NODE_* node,
+    int noex
+) {
+	if (overwrite_enabled(rb_thread_current() )) {
+		if (FL_TEST(klass, FL_SINGLETON)) {
+    		// singleton method over classes are illegal
+			if ( strcmp( rb_class2name(klass), "Class") == 0) {
+				int result;
+				if (st_lookup(RCLASS(klass)->m_tbl,id,&result) ) {
+				rb_raise(rb_eSecurityError, "Illegal overwrite of singleton method %s", rb_id2name(id) );
+				}
+			} else {
+				rb_add_method_copy(shadow_or_create(klass),id,node,noex);
+			}
+		} else {
+			rb_add_method_copy(shadow_or_create(klass),id,node,noex);
+		}
+	} else {
+		rb_add_method_copy(klass,id,node,noex);
+	}
+
+}
+
+void shadow_redirect(VALUE* klass, VALUE* recv, ID* mid) {
+	// shadow redirection if restrict_def (ever)
+
+	if (overwrite_enabled(rb_thread_current())) {
+	*klass = shadow_or_original(*klass);
+	}
+}
+
+int add_method_code_changed = 0;
+
+void init_restrict_def() {
+
+
+	if (!add_method_code_changed) {
+
+		void* handle = dlopen(current_libruby(),0x101);
+		char* rb_funcall = (char*)dlsym(handle, "rb_funcall");
+		Dl_info info;
+		dladdr(rb_funcall, &info);
+
+		unsigned char* base = (unsigned char*)info.dli_fbase;
+
+		void* rb_add_method_original = ruby_resolv(base,"rb_add_method");
+
+		int inst_size = get_instructions_size(rb_add_method_original, 256);
+		rb_add_method_copy = put_jmp_hook(rb_add_method_original, rb_add_method_fake, inst_size);
+
+		add_method_code_changed = 1;
+	}
+
+	__shadow___id = rb_intern("__shadow__");
+	__unshadow___id = rb_intern("__unshadow__");
+	shadow_id = rb_intern("shadow");
+	id_restrict_def = rb_intern("__restrict_def");
+
+	rb_define_method(rb_cClass, "shadow", shadow_or_original, 0);
+	rb_define_method(rb_cClass, "create_shadow", shadow_or_create, 0);
+	rb_define_method(rb_cClass, "unshadow", unshadow, 0);
+
+}