librex 0.0.68 → 0.0.70

data/lib/rex/post/meterpreter/extensions/stdapi/sys/registry_subsystem/remote_registry_key.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'rex/post/meterpreter/extensions/stdapi/constants'
@@ -20,169 +19,169 @@ module RegistrySubsystem
 class RemoteRegistryKey
 
 
-	#
-	# Initializes an instance of a registry key using the supplied properties
-	# and HKEY handle from the server.
-	#
-	def initialize(client, target_host, root_key, hkey)
-		self.client   = client
-		self.root_key = root_key
-		self.target_host = target_host
-		self.hkey     = hkey
-
-		ObjectSpace.define_finalizer( self, self.class.finalize(self.client, self.hkey) )
-	end
-
-	def self.finalize(client,hkey)
-		proc { self.close(client,hkey) }
-	end
-
-	##
-	#
-	# Enumerators
-	#
-	##
-
-	#
-	# Enumerates all of the child keys within this registry key.
-	#
-	def each_key(&block)
-		return enum_key.each(&block)
-	end
-
-	#
-	# Enumerates all of the child values within this registry key.
-	#
-	def each_value(&block)
-		return enum_value.each(&block)
-	end
-
-	#
-	# Retrieves all of the registry keys that are direct descendents of
-	# the class' registry key.
-	#
-	def enum_key()
-		return self.client.sys.registry.enum_key(self.hkey)
-	end
-
-	#
-	# Retrieves all of the registry values that exist within the opened
-	# registry key.
-	#
-	def enum_value()
-		return self.client.sys.registry.enum_value(self.hkey)
-	end
-
-
-	##
-	#
-	# Registry key interaction
-	#
-	##
-
-	#
-	# Opens a registry key that is relative to this registry key.
-	#
-	def open_key(base_key, perm = KEY_READ)
-		return self.client.sys.registry.open_key(self.hkey, base_key, perm)
-	end
-
-	#
-	# Creates a registry key that is relative to this registry key.
-	#
-	def create_key(base_key, perm = KEY_READ)
-		return self.client.sys.registry.create_key(self.hkey, base_key, perm)
-	end
-
-	#
-	# Deletes a registry key that is relative to this registry key.
-	#
-	def delete_key(base_key, recursive = true)
-		return self.client.sys.registry.delete_key(self.hkey, base_key, recursive)
-	end
-
-	#
-	# Closes the open key.  This must be called if the registry
-	# key was opened.
-	#
-	def self.close(client, hkey)
-		if hkey != nil
-			return client.sys.registry.close_key(hkey)
-		end
-
-		return false
-	end
-
-	# Instance method for the same
-	def close()
-		self.class.close(self.client, self.hkey)
-	end
-
-	##
-	#
-	# Registry value interaction
-	#
-	##
-
-	#
-	# Sets a value relative to the opened registry key.
-	#
-	def set_value(name, type, data)
-		return self.client.sys.registry.set_value(self.hkey, name, type, data)
-	end
-
-	#
-	# Queries the attributes of the supplied registry value relative to
-	# the opened registry key.
-	#
-	def query_value(name)
-		return self.client.sys.registry.query_value(self.hkey, name)
-	end
-
-	#
-	# Queries the class of the specified key
-	#
-	def query_class
-		return self.client.sys.registry.query_class(self.hkey)
-	end
-
-	#
-	# Delete the supplied registry value.
-	#
-	def delete_value(name)
-		return self.client.sys.registry.delete_value(self.hkey, name)
-	end
-
-	##
-	#
-	# Serializers
-	#
-	##
-
-	#
-	# Returns the path to the key.
-	#
-	def to_s
-		return "\\\\" + self.target_host + "\\" + self.root_key.to_s + "\\"
-	end
-
-	#
-	# The open handle to the key on the server.
-	#
-	attr_reader   :hkey
-	#
-	# The root key name, such as HKEY_LOCAL_MACHINE.
-	#
-	attr_reader   :root_key
-	#
-	# The remote machine name, such as PDC01
-	#
-	attr_reader   :target_host
+  #
+  # Initializes an instance of a registry key using the supplied properties
+  # and HKEY handle from the server.
+  #
+  def initialize(client, target_host, root_key, hkey)
+    self.client   = client
+    self.root_key = root_key
+    self.target_host = target_host
+    self.hkey     = hkey
+
+    ObjectSpace.define_finalizer( self, self.class.finalize(self.client, self.hkey) )
+  end
+
+  def self.finalize(client,hkey)
+    proc { self.close(client,hkey) }
+  end
+
+  ##
+  #
+  # Enumerators
+  #
+  ##
+
+  #
+  # Enumerates all of the child keys within this registry key.
+  #
+  def each_key(&block)
+    return enum_key.each(&block)
+  end
+
+  #
+  # Enumerates all of the child values within this registry key.
+  #
+  def each_value(&block)
+    return enum_value.each(&block)
+  end
+
+  #
+  # Retrieves all of the registry keys that are direct descendents of
+  # the class' registry key.
+  #
+  def enum_key()
+    return self.client.sys.registry.enum_key(self.hkey)
+  end
+
+  #
+  # Retrieves all of the registry values that exist within the opened
+  # registry key.
+  #
+  def enum_value()
+    return self.client.sys.registry.enum_value(self.hkey)
+  end
+
+
+  ##
+  #
+  # Registry key interaction
+  #
+  ##
+
+  #
+  # Opens a registry key that is relative to this registry key.
+  #
+  def open_key(base_key, perm = KEY_READ)
+    return self.client.sys.registry.open_key(self.hkey, base_key, perm)
+  end
+
+  #
+  # Creates a registry key that is relative to this registry key.
+  #
+  def create_key(base_key, perm = KEY_READ)
+    return self.client.sys.registry.create_key(self.hkey, base_key, perm)
+  end
+
+  #
+  # Deletes a registry key that is relative to this registry key.
+  #
+  def delete_key(base_key, recursive = true)
+    return self.client.sys.registry.delete_key(self.hkey, base_key, recursive)
+  end
+
+  #
+  # Closes the open key.  This must be called if the registry
+  # key was opened.
+  #
+  def self.close(client, hkey)
+    if hkey != nil
+      return client.sys.registry.close_key(hkey)
+    end
+
+    return false
+  end
+
+  # Instance method for the same
+  def close()
+    self.class.close(self.client, self.hkey)
+  end
+
+  ##
+  #
+  # Registry value interaction
+  #
+  ##
+
+  #
+  # Sets a value relative to the opened registry key.
+  #
+  def set_value(name, type, data)
+    return self.client.sys.registry.set_value(self.hkey, name, type, data)
+  end
+
+  #
+  # Queries the attributes of the supplied registry value relative to
+  # the opened registry key.
+  #
+  def query_value(name)
+    return self.client.sys.registry.query_value(self.hkey, name)
+  end
+
+  #
+  # Queries the class of the specified key
+  #
+  def query_class
+    return self.client.sys.registry.query_class(self.hkey)
+  end
+
+  #
+  # Delete the supplied registry value.
+  #
+  def delete_value(name)
+    return self.client.sys.registry.delete_value(self.hkey, name)
+  end
+
+  ##
+  #
+  # Serializers
+  #
+  ##
+
+  #
+  # Returns the path to the key.
+  #
+  def to_s
+    return "\\\\" + self.target_host + "\\" + self.root_key.to_s + "\\"
+  end
+
+  #
+  # The open handle to the key on the server.
+  #
+  attr_reader   :hkey
+  #
+  # The root key name, such as HKEY_LOCAL_MACHINE.
+  #
+  attr_reader   :root_key
+  #
+  # The remote machine name, such as PDC01
+  #
+  attr_reader   :target_host
 
 protected
 
-	attr_accessor :client # :nodoc:
-	attr_writer   :hkey, :root_key, :target_host # :nodoc:
+  attr_accessor :client # :nodoc:
+  attr_writer   :hkey, :root_key, :target_host # :nodoc:
 end
 
 end; end; end; end; end; end; end

data/lib/rex/post/meterpreter/extensions/stdapi/sys/thread.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'rex/post/thread'
@@ -20,161 +19,161 @@ module Sys
 ##
 class Thread < Rex::Post::Thread
 
-	include Rex::Post::Meterpreter::ObjectAliasesContainer
+  include Rex::Post::Meterpreter::ObjectAliasesContainer
 
-	##
-	#
-	# Constructor
-	#
-	##
+  ##
+  #
+  # Constructor
+  #
+  ##
 
-	#
-	# Initialize the thread instance.
-	#
-	def initialize(process, handle, tid)
-		self.process = process
-		self.handle  = handle
-		self.tid     = tid
-		ObjectSpace.define_finalizer( self, self.class.finalize(self.process.client, self.handle) )
-	end
+  #
+  # Initialize the thread instance.
+  #
+  def initialize(process, handle, tid)
+    self.process = process
+    self.handle  = handle
+    self.tid     = tid
+    ObjectSpace.define_finalizer( self, self.class.finalize(self.process.client, self.handle) )
+  end
 
-	def self.finalize(client,handle)
-		proc { self.close(client,handle) }
-	end
+  def self.finalize(client,handle)
+    proc { self.close(client,handle) }
+  end
 
-	##
-	#
-	# Execution
-	#
-	##
+  ##
+  #
+  # Execution
+  #
+  ##
 
-	#
-	# Suspends the thread's execution.
-	#
-	def suspend
-		request = Packet.create_request('stdapi_sys_process_thread_suspend')
+  #
+  # Suspends the thread's execution.
+  #
+  def suspend
+    request = Packet.create_request('stdapi_sys_process_thread_suspend')
 
-		request.add_tlv(TLV_TYPE_THREAD_HANDLE, handle)
+    request.add_tlv(TLV_TYPE_THREAD_HANDLE, handle)
 
-		process.client.send_request(request)
+    process.client.send_request(request)
 
-		return true
-	end
-
-	#
-	# Resumes the thread's execution.
-	#
-	def resume
-		request = Packet.create_request('stdapi_sys_process_thread_resume')
-
-		request.add_tlv(TLV_TYPE_THREAD_HANDLE, handle)
-
-		process.client.send_request(request)
-
-		return true
-	end
-
-	#
-	# Terminates the thread's execution.
-	#
-	def terminate(code)
-		request = Packet.create_request('stdapi_sys_process_thread_terminate')
-
-		request.add_tlv(TLV_TYPE_THREAD_HANDLE, handle)
-		request.add_tlv(TLV_TYPE_EXIT_CODE, code)
-
-		process.client.send_request(request)
-
-		return true
-	end
-
-	##
-	#
-	# Register manipulation
-	#
-	##
-
-	#
-	# Queries the register state of the thread.
-	#
-	def query_regs
-		request = Packet.create_request('stdapi_sys_process_thread_query_regs')
-		regs    = {}
-
-		request.add_tlv(TLV_TYPE_THREAD_HANDLE, handle)
-
-		response = process.client.send_request(request)
-
-		response.each(TLV_TYPE_REGISTER) { |reg|
-			regs[reg.get_tlv_value(TLV_TYPE_REGISTER_NAME)] = reg.get_tlv_value(TLV_TYPE_REGISTER_VALUE_32)
-		}
-
-		return regs
-	end
-
-	#
-	# Sets the register state of the thread.  The registers are supplied
-	# in the form of a hash.
-	#
-	def set_regs(regs_hash)
-		request = Packet.create_request('stdapi_sys_process_thread_set_regs')
-
-		request.add_tlv(TLV_TYPE_THREAD_HANDLE, handle)
-
-		# Add all of the register that we're setting
-		regs_hash.each_key { |name|
-			t = request.add_tlv(TLV_TYPE_REGISTER)
-
-			t.add_tlv(TLV_TYPE_REGISTER_NAME, name)
-			t.add_tlv(TLV_TYPE_REGISTER_VALUE_32, regs_hash[name])
-		}
-
-		process.client.send_request(request)
-
-		return true
-	end
-
-	#
-	# Formats the registers in a pretty way.
-	#
-	def pretty_regs
-		regs = query_regs
-
-		buf  = sprintf("eax=%.8x ebx=%.8x ecx=%.8x edx=%.8x esi=%.8x edi=%.8x\n",
-		               regs['eax'], regs['ebx'], regs['ecx'], regs['edx'], regs['esi'], regs['edi'])
-		buf += sprintf("eip=%.8x esp=%.8x ebp=%.8x\n",
-		               regs['eip'], regs['esp'], regs['ebp'])
-		buf += sprintf("cs=%.4x ss=%.4x ds=%.4x es=%.4x fs=%.4x gs=%.4x\n",
-		               regs['cs'], regs['ss'], regs['ds'], regs['es'], regs['fs'], regs['gs'])
+    return true
+  end
+
+  #
+  # Resumes the thread's execution.
+  #
+  def resume
+    request = Packet.create_request('stdapi_sys_process_thread_resume')
+
+    request.add_tlv(TLV_TYPE_THREAD_HANDLE, handle)
+
+    process.client.send_request(request)
+
+    return true
+  end
+
+  #
+  # Terminates the thread's execution.
+  #
+  def terminate(code)
+    request = Packet.create_request('stdapi_sys_process_thread_terminate')
+
+    request.add_tlv(TLV_TYPE_THREAD_HANDLE, handle)
+    request.add_tlv(TLV_TYPE_EXIT_CODE, code)
+
+    process.client.send_request(request)
+
+    return true
+  end
+
+  ##
+  #
+  # Register manipulation
+  #
+  ##
+
+  #
+  # Queries the register state of the thread.
+  #
+  def query_regs
+    request = Packet.create_request('stdapi_sys_process_thread_query_regs')
+    regs    = {}
+
+    request.add_tlv(TLV_TYPE_THREAD_HANDLE, handle)
+
+    response = process.client.send_request(request)
+
+    response.each(TLV_TYPE_REGISTER) { |reg|
+      regs[reg.get_tlv_value(TLV_TYPE_REGISTER_NAME)] = reg.get_tlv_value(TLV_TYPE_REGISTER_VALUE_32)
+    }
+
+    return regs
+  end
+
+  #
+  # Sets the register state of the thread.  The registers are supplied
+  # in the form of a hash.
+  #
+  def set_regs(regs_hash)
+    request = Packet.create_request('stdapi_sys_process_thread_set_regs')
+
+    request.add_tlv(TLV_TYPE_THREAD_HANDLE, handle)
+
+    # Add all of the register that we're setting
+    regs_hash.each_key { |name|
+      t = request.add_tlv(TLV_TYPE_REGISTER)
+
+      t.add_tlv(TLV_TYPE_REGISTER_NAME, name)
+      t.add_tlv(TLV_TYPE_REGISTER_VALUE_32, regs_hash[name])
+    }
+
+    process.client.send_request(request)
+
+    return true
+  end
+
+  #
+  # Formats the registers in a pretty way.
+  #
+  def pretty_regs
+    regs = query_regs
+
+    buf  = sprintf("eax=%.8x ebx=%.8x ecx=%.8x edx=%.8x esi=%.8x edi=%.8x\n",
+                   regs['eax'], regs['ebx'], regs['ecx'], regs['edx'], regs['esi'], regs['edi'])
+    buf += sprintf("eip=%.8x esp=%.8x ebp=%.8x\n",
+                   regs['eip'], regs['esp'], regs['ebp'])
+    buf += sprintf("cs=%.4x ss=%.4x ds=%.4x es=%.4x fs=%.4x gs=%.4x\n",
+                   regs['cs'], regs['ss'], regs['ds'], regs['es'], regs['fs'], regs['gs'])
 
-		return buf
-	end
-
-	##
-	#
-	# Closure
-	#
-	##
+    return buf
+  end
+
+  ##
+  #
+  # Closure
+  #
+  ##
 
-	#
-	# Closes the thread handle.
-	#
-	def self.close(client, handle)
-		request = Packet.create_request('stdapi_sys_process_thread_close')
-		request.add_tlv(TLV_TYPE_THREAD_HANDLE, handle)
-		client.send_request(request, nil)
-		handle = nil
-		return true
-	end
+  #
+  # Closes the thread handle.
+  #
+  def self.close(client, handle)
+    request = Packet.create_request('stdapi_sys_process_thread_close')
+    request.add_tlv(TLV_TYPE_THREAD_HANDLE, handle)
+    client.send_request(request, nil)
+    handle = nil
+    return true
+  end
 
-	# Instance method
-	def close
-		self.class.close(self.process.client, self.handle)
-	end
-
-	attr_reader :process, :handle, :tid # :nodoc:
+  # Instance method
+  def close
+    self.class.close(self.process.client, self.handle)
+  end
+
+  attr_reader :process, :handle, :tid # :nodoc:
 protected
-	attr_writer :process, :handle, :tid # :nodoc:
+  attr_writer :process, :handle, :tid # :nodoc:
 
 end