rallhook 0.7.0

data/AUTHORS

@@ -0,0 +1,3 @@
+rallhook de tario <rseminara@hotmail.com>
+
+

data/CHANGELOG

@@ -0,0 +1,82 @@
+0.7.0	Concurrency support, any thread can hook without affect the hook state of the other threads
+
+		Restrictions about overwrite instance methods disabled
+
+		Added class shadows to confine the behaviour added throught methods to hook state
+
+		Implemented UboundMethod#unchecked_bind to bind methods of different classes
+
+0.6.1	Fixed bug on binding of class methods in Object#specific_method
+
+0.6.0	Implemented method UboundMethod#body
+
+		Improved compatibility of test cases with ruby1.9 and ruby1.8 behaviour
+
+		Implemented Object#specific_method to lookup methods by klass and method_id
+
+		Delete overload of Object#method
+
+0.5.0	Security Improved: Restricted define of singleton methods over classes when hook is enabled
+
+		Added special check for Object#binding to avoid change the binding behaviour with method redirection
+
+		Security improved: Added hook of rb_add_method to avoid the overwriting of any method
+
+		Security improved: Fixed leaks of hooking methods by making all methods called over Hook illegal if hook state is enabled
+
+		More helpers to make easier to use. (see MethodHandler class)
+
+		Documented methods and classes to generate useful RDoc
+		
+		Internal refactoring to split the logic of rallhook, hooking, method_handle invoke, etc... and the modification of the ruby interpreter with hook calls, etc...
+
+0.4.1	Fixed bug in the hook module
+
+0.4.0	Fixed bug in the version numbering
+
+0.3.1	Added new method of intercept calls
+
+		Changed interface of handlling of methods (see README and examples) to avoid errors in the handling of yield functions in ruby1.8
+
+		New internal method of hook fixe many many bugs
+
+		Fixed fastcall convention calls in i386, hooks and detection of calling convention
+
+		Fixed compatibility issues with ruby1.8 and ruby1.9 in i386
+
+		Rakefile configured to build extensions automatically at gem install
+
+0.3.0:	Compatibility with ruby1.8 on i386 (tested with ruby 1.8.6 patchlevel 111 in ubuntu 8.04)		
+
+		Compatibility with ruby1.9 on i386 (tested with ruby 1.9.0 in ubuntu 8.04)		
+
+		Compatiblity with ruby1.8 on x86_64 (tested with ruby 1.8.7 patchlevel  72 in ubuntu 9.04)
+
+		Compatibility with ruby1.9 on x86_64 (tested with ruby 1.9.0 r17482 in ubuntu 9.04)
+		
+		New method introspection features (see README for examples)
+		
+
+0.2.1:	Fixed issue #3: corrupted block arguments in hooking ( http://github.com/tario/rallhook/issues/issue/3 )
+
+		Added testcase to test the issue #3
+
+		Added some automatic tests of integrity of the modified interpreter
+
+0.2.0:	Fixed RAII issues in RallHook::hook method
+
+		Changed version of package to 0.2.0 to avoid "malformed" version number
+
+0.2.0-rc1:	Added "TagContainer trick" to fix the issue #2: undesirable nest at super call with block  ( http://github.com/tario/rallhook/issues/issue/2 )
+
+		Added klass parameter to hooked_send, fixing the issue #1: undesirable nest at super call ( http://github.com/tario/rallhook/issues/issue/1 )
+
+		Added classes and methods to read method body info as the file and line where that method was defined
+			obj.method(:foo).body.file
+			obj.method(:foo).body.line
+		
+
+0.1.1:	Changed hooking and unhooking mechanism in the call of the handler of hooks
+to make it internal at rallhooking (calling of hook and unhook from the call method are unnecesary now)
+
+0.1.0:	implemented basic hooking as PoC of rallhook, basic example works fine

data/README

@@ -0,0 +1,207 @@
+= rallhook - An ruby absolute method hooker
+
+This package contains rallhook, a ruby C extension to intercept ruby methods calls at interpreter level in a transparent way from ruby itself.
+
+== Installation
+
+=== Prerequisites
+
+* ruby-cymbol >= 0.1.0 (found at http://github.com/tario/ruby-cymbol)
+* ruby debug info ( apt-get install libruby1.8-dbg or libruby1.9-dbg on debian based systems)
+* ruby development package ( apt-get install ruby1.8-dev or ruby1.9-dev on debian based systems)
+* objdump
+* distorm ( found at https://code.google.com/p/distorm/ )
+
+
+=== Gem installation
+
+* Download the last version of the gem from http://github.com/tario/ruby-cpp/downloads
+* Install the gem with the following;
+
+gem install rallhook-X.X.X.gem
+
+== Usage
+
+=== Basic Example
+
+test.rb:
+
+	require "rubygems"
+	require "rallhook"
+
+	include RallHook
+
+	class MethodHandler < HookHandler
+
+		def handle_method (klass,self_,m, method_id)
+
+			# print to the standar output details about the method called
+			print "method call #{m}:#{method_id} over #{self_}:#{self_.class} \n"
+			nil # do nothing
+		end
+	end
+
+	MethodHandler.hook do
+	# all ruby calls in this block are intercepted by hook_recv::call
+
+		[1,2,3].each do |x|
+		print x,"\n"
+		end
+
+	end
+
+standard output:
+
+	method call each:4001 over 123:Array 
+	method call print:7697 over main:Object 
+	method call write:7649 over #<IO:0x7fb15e54fad0>:IO 
+	method call to_s:3137 over 1:Fixnum 
+	1method call write:7649 over #<IO:0x7fb15e54fad0>:IO 
+
+	method call print:7697 over main:Object 
+	method call write:7649 over #<IO:0x7fb15e54fad0>:IO 
+	method call to_s:3137 over 2:Fixnum 
+	2method call write:7649 over #<IO:0x7fb15e54fad0>:IO 
+
+	method call print:7697 over main:Object 
+	method call write:7649 over #<IO:0x7fb15e54fad0>:IO 
+	method call to_s:3137 over 3:Fixnum 
+	3method call write:7649 over #<IO:0x7fb15e54fad0>:IO 
+
+=== Redirecting calls
+
+	require "rubygems"
+	require "rallhook"
+
+	include RallHook
+
+	class MethodHandler < HookHandler
+		include RallHook::Helper
+
+		def handle_method (klass,recv,m,method_id)
+
+			if m == :foo
+				# redirects the calls of method foo to method bar on the same object
+				return redirect_call(klass,recv, :bar)
+			end
+
+			if m == :bar
+				# redirects the calls of method bar to method bar on the method_handler
+				return redirect_call(self.class,self, :bar)
+			end
+
+			nil # do nothing
+		end
+		
+		def bar
+			print "bar in MethodHandler\n"
+		end
+	end
+
+	class X
+		def foo
+			print "foo in X\n"
+		end
+		def bar
+			print "bar in X\n"
+		end
+	end
+
+	print "WITHOUT HOOK:\n"
+
+	x = X.new
+	x.foo
+	x.bar
+
+	print "WITH HOOK:\n"
+
+	MethodHandler.hook do
+		# all ruby calls in this block are intercepted by hook_recv::call
+		x = X.new
+		x.foo # redirected to X#bar
+		x.bar # redirected to MethodHandler#bar
+
+	end
+
+=== Wrap Calls
+	require "rubygems"
+	require "rallhook"
+
+	include RallHook
+
+	class MethodHandler < HookHandler
+		include RallHook::Helper
+		
+		class FooMethodWrapper < MethodWrapper
+			def call(*x)
+				# call with reyield if block_given
+				if block_given?
+					original_call(*x) do |*a|
+						yield(*a)
+					end
+					# add "�bar?"
+					yield("bar?")
+				else
+					original_call(*x)
+				end
+			end
+		end
+
+		def handle_method (klass,recv,m,method_id)
+			if m == :each
+				return FooMethodWrapper.redirect_handler(klass,recv,m,method_id)
+			end
+			nil # do nothing
+		end
+	end
+
+	print "calling Array#each without hook\n"
+	[1,2,3,4].each do |x|
+		print x.inspect, " "
+	end
+	print "\n"
+
+	print "calling Array#each WITH hook\n"
+	MethodHandler.hook do
+
+		# 1 2 3 4 "bar?"
+		[1,2,3,4].each do |x|
+			print x.inspect," "
+		end
+		print "\n"
+
+	end
+
+
+=== Method Instrospection new features example
+
+source1.rb
+
+	class X
+		def foo
+		end
+	end
+
+source2.rb
+
+	class Y < X
+		def foo
+		end
+	end
+
+main.rb
+
+	require "rallhook"
+	require "source1.rb"
+	require "source2.rb"
+
+	x = X.new
+	y = Y.new
+
+	print x.method(:foo).body.file,"\n" # source1.rb
+	print y.method(:foo).body.file,"\n" # source2.rb
+
+	print y.method(X,:foo).body.file,"\n" # source1.rb
+	print y.method(Y,:foo).body.file,"\n" # source2.rb
+
+

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'rallhook'
+  s.version = '0.7.0'
+  s.author = 'Dario Seminara'
+  s.email = 'robertodarioseminara@gmail.com'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Allow hooking of all method invocations transparently to control and / or monitor the behavior of a ruby program'
+  s.homepage = "http://github.com/tario/rallhook"
+  s.has_rdoc = true
+  s.add_dependency "ruby-cymbol", ">= 0.1.0"
+  s.extra_rdoc_files = [ 'README' ]
+  s.rdoc_options << '--main' << 'README'
+  s.extensions = FileList["ext/**/extconf.rb"].to_a
+  s.files = Dir.glob("{examples,lib,test}/**/*.rb") + Dir.glob("ext/**/*.c") + Dir.glob("ext/**/*.h") + Dir.glob("ext/**/extconf.rb") +
+    [ 'AUTHORS', 'CHANGELOG', 'README', 'Rakefile', 'TODO' ]
+end
+
+desc 'Run tests'
+task :default => [ :test ]
+
+Rake::TestTask.new('test') do |t|
+  t.libs << 'test'
+  t.pattern = '{test}/**/test_*.rb'
+  t.verbose = true
+end
+
+desc 'Generate RDoc'
+Rake::RDocTask.new :rdoc do |rd|
+  rd.rdoc_dir = 'doc'
+  rd.rdoc_files.add 'lib', 'ext', 'README'
+  rd.main = 'README'
+end
+
+desc 'Build Gem'
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+end
+
+desc 'Clean up'
+task :clean => [ :clobber_rdoc, :clobber_package ]
+
+desc 'Clean up'
+task :clobber => [ :clean ]

data/TODO

@@ -0,0 +1,8 @@
+* Threading support
+* Tests cases for 1.0.0 interface
+* More integrity testcases (with use of ruby core methods)
+* Security testcases (hook bypass checks,  security tests)
+* Win32 compatibility
+* Delete distorm dependency
+* Delete libruby debuginfo dependency
+* Make rallhook functionality transparent (backtraces, exceptions, etc ...)

data/examples/hook/example1.rb

@@ -0,0 +1,19 @@
+require "rubygems"
+require "rallhook"
+
+include RallHook
+
+class HookProc
+	def handle_method (klass,self_,m,method_id)
+
+		# print to the standard output details about the method called
+		print "method call #{m}:#{method_id} over #{self_}:#{self_.class}\n"
+		nil # do nothing
+	end
+end
+
+hook_proc = HookProc.new
+Hook.hook hook_proc do
+	print 2+2,"\n"
+	print [1,2,3].inject{|x,y| x+y},"\n"
+end

data/examples/hook/example2.rb

@@ -0,0 +1,30 @@
+require "rubygems"
+require "rallhook"
+
+include RallHook
+
+class HookProc
+	def handle_method (klass,self_,m,method_id)
+
+		# print to the standard output details about the method called
+		print "method call #{m}:#{method_id} over #{self_}:#{self_.class}\n"
+		nil # do nothing
+	end
+end
+
+class X
+	def foo
+	end
+end
+
+class Y <X
+	def foo
+		super
+	end
+end
+
+hook_proc = HookProc.new
+Hook.hook hook_proc do
+	y = Y.new
+	y.foo
+end

data/examples/hook/example3.rb

@@ -0,0 +1,24 @@
+require "rubygems"
+require "rallhook"
+
+include RallHook
+
+class MethodHandler
+	def handle_method (klass,self_,m,method_id)
+
+		# print to the standard output details about the method called
+		print "method call #{m}:#{method_id} over #{self_}:#{self_.class}\n"
+		nil # do nothing
+	end
+end
+
+mhandler = MethodHandler.new
+
+Hook.hook mhandler do
+# all ruby calls in this block are intercepted by hook_recv::call
+
+	[1,2,3].each do |x|
+	print x,"\n"
+	end
+
+end

data/examples/hook/example4.rb

@@ -0,0 +1,18 @@
+require "rubygems"
+require "rallhook"
+
+include RallHook
+
+class MethodHandler < RallHook::HookHandler
+	def handle_method (klass,self_,m,method_id)
+
+		# print to the standard output details about the method called
+		print "method call #{m}:#{method_id} over #{self_}:#{self_.class}\n"
+		nil # do nothing
+	end
+end
+
+MethodHandler.hook do
+	print 2+2,"\n"
+	print [1,2,3].inject{|x,y| x+y},"\n"
+end

data/examples/hook/intercept.rb

@@ -0,0 +1,41 @@
+require "rubygems"
+require "rallhook"
+
+include RallHook
+
+class MethodHandler
+	include RallHook::Helper
+	
+	class FooMethodWrapper < MethodWrapper
+		def call(a)
+			# replace the a parameter with a+5
+			original_call(a+5)
+		end
+	end
+
+	def handle_method (klass,recv,m, method_id)
+
+		if m == :foo
+			return FooMethodWrapper.redirect_handler(klass,recv,m,method_id)
+		end
+
+		nil # do nothing
+	end
+	
+end
+
+class X
+	def foo(a)
+		print "foo in X with a = #{a}\n"
+	end
+end
+x = X.new
+print "calling X#foo without hook\n"
+x.foo 4 # "foo in X with a = 4"
+
+print "calling X#foo WITH hook\n"
+mhandler = MethodHandler.new
+Hook.hook mhandler do
+x.foo 4 # "foo in X with a = 9" :)
+end
+

data/examples/hook/intercept2.rb

@@ -0,0 +1,49 @@
+require "rubygems"
+require "rallhook"
+
+include RallHook
+
+class MethodHandler
+	include RallHook::Helper
+	
+	class FooMethodWrapper < MethodWrapper
+		def call(*x)
+			# call with reyield if block_given
+			if block_given?
+				original_call(*x) do |*a|
+					yield(*a)
+				end
+				# add "�bar?"
+				yield("bar?")
+			else
+				original_call(*x)
+			end
+		end
+	end
+
+	def handle_method (klass,recv,m,method_id)
+		if m == :each
+			return FooMethodWrapper.redirect_handler(klass,recv,m,method_id)
+		end
+		nil # do nothing
+	end
+end
+
+print "calling Array#each without hook\n"
+[1,2,3,4].each do |x|
+	print x.inspect, " "
+end
+print "\n"
+
+print "calling Array#each WITH hook\n"
+mhandler = MethodHandler.new
+Hook.hook mhandler do
+
+# 1 2 3 4 "bar?"
+[1,2,3,4].each do |x|
+	print x.inspect," "
+end
+print "\n"
+
+end
+

data/examples/hook/redirect.rb

@@ -0,0 +1,55 @@
+require "rubygems"
+require "rallhook"
+
+include RallHook
+
+class MethodHandler
+	include RallHook::Helper
+
+	def handle_method (klass,recv,m,method_id)
+
+		if m == :foo
+			# redirects the calls of method foo to method bar on the same object
+			return redirect_call(klass,recv, :bar)
+		end
+
+		if m == :bar
+			# redirects the calls of method bar to method bar on the method_handler
+			return redirect_call(self.class,self, :bar)
+		end
+
+		nil # do nothing
+	end
+	
+	def bar
+		print "bar in MethodHandler\n"
+	end
+end
+
+class X
+	def foo
+		print "foo in X\n"
+	end
+	def bar
+		print "bar in X\n"
+	end
+end
+
+mhandler = MethodHandler.new
+
+print "WITHOUT HOOK:\n"
+
+x = X.new
+x.foo
+x.bar
+
+print "WITH HOOK:\n"
+
+Hook.hook mhandler do
+# all ruby calls in this block are intercepted by hook_recv::call
+x = X.new
+x.foo # redirected to X#bar
+x.bar # redirected to MethodHandler#bar
+
+end
+

data/examples/hook/redirect_inherited.rb

@@ -0,0 +1,28 @@
+require "rubygems"
+require "rallhook"
+
+include RallHook
+
+class MethodHandler
+	include RallHook::Helper
+
+	def handle_method (klass,recv,m,method_id)
+		
+		print "called method #{m} over #{recv}\n"
+		
+		if m == :inherited
+			return redirect_call(klass,recv,:ssss) 
+		end
+
+		nil # do nothing
+	end
+end
+
+mhandler = MethodHandler.new
+Hook.hook mhandler do
+# all ruby calls in this block are intercepted by hook_recv::call
+class N
+end
+
+end
+

data/examples/hook/shadow.rb

@@ -0,0 +1,44 @@
+require "rubygems"
+require "rallhook"
+
+include RallHook
+
+class MethodHandler < RallHook::HookHandler
+	def handle_method (klass,self_,m,method_id)
+		# print to the standard output details about the method called
+		print "method call #{m}:#{method_id} over #{self_}:#{self_.class}\n"
+		nil # do nothing
+	end
+end
+
+class X
+	def foo
+		print "outside of hook foo\n"
+	end
+end
+
+x = X.new
+
+x.foo
+
+MethodHandler.hook do
+	class X
+		def foo
+			print "inside of hook foo\n"
+		end
+		
+		def bar
+			print "inside of hook bar\n"
+		end
+	end
+	
+	x.foo
+	x.bar
+end
+
+x.foo
+begin
+x.bar # NoMethodError
+rescue NoMethodError
+print "there is no method bar in X outside the hook\n"
+end

data/examples/instrospection/main.rb

@@ -0,0 +1,13 @@
+require "rubygems"
+require "rallhook"
+require "source1.rb"
+require "source2.rb"
+
+x = X.new
+y = Y.new
+
+print "definition of method :foo in #{x}: ", x.method(:foo).body.file,"\n" # source1.rb
+print "definition of method :foo in #{y}: ", y.method(:foo).body.file,"\n" # source2.rb
+
+print "definition of method :foo of class X in object #{y}: ", y.method(X,:foo).body.file,"\n" # source1.rb
+print "definition of method :foo of class Y in object #{y}: ", y.method(Y,:foo).body.file,"\n" # source1.rb

data/examples/instrospection/source1.rb

@@ -0,0 +1,4 @@
+class X
+	def foo
+	end
+end

data/examples/instrospection/source2.rb

@@ -0,0 +1,4 @@
+class Y < X
+	def foo
+	end
+end