librex 0.0.20 → 0.0.21

data/lib/rex/post/meterpreter/extensions/stdapi/fs/dir.rb

@@ -0,0 +1,282 @@
+#!/usr/bin/env ruby
+
+require 'rex/post/dir'
+require 'rex/post/meterpreter/extensions/stdapi/stdapi'
+
+module Rex
+module Post
+module Meterpreter
+module Extensions
+module Stdapi
+module Fs
+
+###
+#
+# This class implements directory operations against the remote endpoint.  It
+# implements the Rex::Post::Dir interface.
+#
+###
+class Dir < Rex::Post::Dir
+
+	class << self
+		attr_accessor :client
+	end
+
+	##
+	#
+	# Constructor
+	#
+	##
+
+	#
+	# Initializes the directory instance.
+	#
+	def initialize(path)
+		self.path   = path
+		self.client = self.class.client
+	end
+
+	##
+	#
+	# Enumeration
+	#
+	##
+
+	#
+	# Enumerates all of the contents of the directory.
+	#
+	def each(&block)
+		client.fs.dir.foreach(self.path, &block)
+	end
+
+	#
+	# Enumerates all of the files/folders in a given directory.
+	#
+	def Dir.entries(name = getwd)
+		request = Packet.create_request('stdapi_fs_ls')
+		files   = []
+
+		request.add_tlv(TLV_TYPE_DIRECTORY_PATH, name)
+
+		response = client.send_request(request)
+
+		response.each(TLV_TYPE_FILE_NAME) { |file_name|
+			files << file_name.value
+		}
+		
+		return files
+	end
+
+	#
+	# Enumerates files with a bit more information than the default entries.
+	#
+	def Dir.entries_with_info(name = getwd)
+		request = Packet.create_request('stdapi_fs_ls')
+		files   = []
+
+		request.add_tlv(TLV_TYPE_DIRECTORY_PATH, name)
+
+		response = client.send_request(request)
+
+		fname = response.get_tlvs(TLV_TYPE_FILE_NAME)
+		fpath = response.get_tlvs(TLV_TYPE_FILE_PATH)
+		sbuf  = response.get_tlvs(TLV_TYPE_STAT_BUF)
+
+		if (!fname or !sbuf)
+			return []
+		end
+
+		fname.each_with_index { |file_name, idx|
+			st = nil
+			
+			if (sbuf[idx])
+				st = ::Rex::Post::FileStat.new
+				st.update(sbuf[idx].value)
+			end
+
+			files <<
+				{
+					'FileName' => file_name.value, 
+					'FilePath' => fpath[idx].value,
+					'StatBuf'  => st,
+				}
+		}
+		
+		return files
+	end
+
+	##
+	#
+	# General directory operations
+	#
+	##
+
+	#
+	# Changes the working directory of the remote process.
+	#
+	def Dir.chdir(path)
+		request = Packet.create_request('stdapi_fs_chdir')
+
+		request.add_tlv(TLV_TYPE_DIRECTORY_PATH, path)
+
+		response = client.send_request(request)
+
+		return 0
+	end
+	
+	#
+	# Creates a directory.
+	#
+	def Dir.mkdir(path)
+		request = Packet.create_request('stdapi_fs_mkdir')
+
+		request.add_tlv(TLV_TYPE_DIRECTORY_PATH, path)
+
+		response = client.send_request(request)
+
+		return 0
+	end
+
+	#
+	# Returns the current working directory of the remote process.
+	#
+	def Dir.pwd
+		request = Packet.create_request('stdapi_fs_getwd')
+
+		response = client.send_request(request)
+
+		return response.get_tlv(TLV_TYPE_DIRECTORY_PATH).value
+	end
+
+	#
+	# Synonym for pwd.
+	#
+	def Dir.getwd
+		pwd
+	end
+
+	#
+	# Removes the supplied directory if it's empty.
+	#
+	def Dir.delete(path)
+		request = Packet.create_request('stdapi_fs_delete_dir')
+
+		request.add_tlv(TLV_TYPE_DIRECTORY_PATH, path)
+
+		response = client.send_request(request)
+
+		return 0
+	end
+
+	#
+	# Synonyms for delete.
+	#
+	def Dir.rmdir(path)
+		delete(path)
+	end
+
+	#
+	# Synonyms for delete.
+	#
+	def Dir.unlink(path)
+		delete(path)
+	end
+
+	##
+	#
+	# Directory mirroring
+	#
+	##
+
+	#
+	# Downloads the contents of a remote directory a 
+	# local directory, optionally in a recursive fashion.
+	#
+	def Dir.download(dst, src, recursive = false, force = true, &stat)
+		self.entries(src).each { |src_sub|
+			dst_item = dst + ::File::SEPARATOR + src_sub
+			src_item = src + File::SEPARATOR + src_sub
+
+			if (src_sub == '.' or src_sub == '..')
+				next
+			end
+
+			src_stat = client.fs.filestat.new(src_item)
+
+			if (src_stat.file?)
+				stat.call('downloading', src_item, dst_item) if (stat)
+				begin 
+					client.fs.file.download(dst_item, src_item)
+					stat.call('downloaded', src_item, dst_item) if (stat)
+				rescue ::Rex::Post::Meterpreter::RequestError => e
+					if force
+						stat.call('failed', src_item, dst_item) if (stat)
+					else
+						raise e
+					end
+				end
+				
+			elsif (src_stat.directory?)
+				if (recursive == false)
+					next
+				end
+
+				begin
+					::Dir.mkdir(dst_item)
+				rescue
+				end
+
+				stat.call('mirroring', src_item, dst_item) if (stat)
+				download(dst_item, src_item, recursive, force, &stat)
+				stat.call('mirrored', src_item, dst_item) if (stat)
+			end
+		}
+	end
+
+	#
+	# Uploads the contents of a local directory to a remote 
+	# directory, optionally in a recursive fashion.
+	#
+	def Dir.upload(dst, src, recursive = false, &stat)
+		::Dir.entries(src).each { |src_sub|
+			dst_item = dst + File::SEPARATOR + src_sub
+			src_item = src + ::File::SEPARATOR + src_sub
+
+			if (src_sub == '.' or src_sub == '..')
+				next
+			end
+
+			src_stat = ::File.stat(src_item)
+
+			if (src_stat.file?)
+				stat.call('uploading', src_item, dst_item) if (stat)
+				client.fs.file.upload(dst_item, src_item)
+				stat.call('uploaded', src_item, dst_item) if (stat)
+			elsif (src_stat.directory?)
+				if (recursive == false)
+					next
+				end
+
+				begin
+					self.mkdir(dst_item)
+				rescue
+				end
+
+				stat.call('mirroring', src_item, dst_item) if (stat)
+				upload(dst_item, src_item, recursive, &stat)
+				stat.call('mirrored', src_item, dst_item) if (stat)
+			end
+		}
+	end
+
+	#
+	# The path of the directory that was opened.
+	#
+	attr_reader   :path 
+protected
+	attr_accessor :client # :nodoc:
+	attr_writer   :path # :nodoc:
+
+end
+
+end; end; end; end; end; end

data/lib/rex/post/meterpreter/extensions/stdapi/fs/file.rb

@@ -0,0 +1,266 @@
+#!/usr/bin/env ruby
+
+require 'rex/post/file'
+require 'rex/post/meterpreter/channel'
+require 'rex/post/meterpreter/channels/pools/file'
+require 'rex/post/meterpreter/extensions/stdapi/stdapi'
+require 'rex/post/meterpreter/extensions/stdapi/fs/io'
+require 'rex/post/meterpreter/extensions/stdapi/fs/file_stat'
+require 'fileutils'
+
+module Rex
+module Post
+module Meterpreter
+module Extensions
+module Stdapi
+module Fs
+
+###
+#
+# This class implements the Rex::Post::File interface and wraps interaction
+# with files on the remote machine.
+#
+###
+class File < Rex::Post::Meterpreter::Extensions::Stdapi::Fs::IO
+
+SEPARATOR = "\\"
+Separator = "\\"
+
+	include Rex::Post::File
+	
+	class << self
+		attr_accessor :client
+	end
+	
+	#
+	# Search for files.
+	#
+	def File.search( root=nil, glob="*.*", recurse=true, timeout=-1 )
+		
+		files = ::Array.new
+		
+		request = Packet.create_request( 'stdapi_fs_search' )
+
+		root = root.chomp( '\\' ) if root
+		
+		request.add_tlv( TLV_TYPE_SEARCH_ROOT, root )
+		request.add_tlv( TLV_TYPE_SEARCH_GLOB, glob )
+		request.add_tlv( TLV_TYPE_SEARCH_RECURSE, recurse )
+
+		# we set the response timeout to -1 to wait indefinatly as a 
+		# search could take an indeterminate ammount of time to complete.
+		response = client.send_request( request, timeout )
+		if( response.result == 0 )
+			response.each( TLV_TYPE_SEARCH_RESULTS ) do | results |
+				files << {
+					'path' => results.get_tlv_value( TLV_TYPE_FILE_PATH ).chomp( '\\' ),
+					'name' => results.get_tlv_value( TLV_TYPE_FILE_NAME ),
+					'size' => results.get_tlv_value( TLV_TYPE_FILE_SIZE )
+				}
+			end
+		end
+		
+		return files
+	end
+	
+	#
+	# Returns the base name of the supplied file path to the caller.
+	#
+	def File.basename(*a)
+		path = a[0]
+		sep  = "\\" + File::SEPARATOR
+
+		# I suck at regex.
+		path =~ /(.*)#{sep}(.*)$/
+
+		Rex::FileUtils.clean_path($2 || path)
+	end
+
+	#
+	# Expands a file path, substituting all environment variables, such as
+	# %TEMP%.
+	#
+	def File.expand_path(path)
+		request = Packet.create_request('stdapi_fs_file_expand_path')
+
+		request.add_tlv(TLV_TYPE_FILE_PATH, path)
+
+		response = client.send_request(request)
+		
+		return response.get_tlv_value(TLV_TYPE_FILE_PATH)
+	end
+
+	#
+	# Performs a stat on a file and returns a FileStat instance.
+	#
+	def File.stat(name)
+		return client.fs.filestat.new(name)
+	end
+	
+	#
+	# Performs a delete on the specified file.
+	#
+	def File.rm(name)		
+		request = Packet.create_request('stdapi_fs_delete_file')
+
+		request.add_tlv(TLV_TYPE_FILE_PATH,name)
+
+		response = client.send_request(request)
+		
+		return response
+	end
+	
+	#
+	# Performs a delete on the specified file.
+	#
+	def File.unlink(name)
+		return File.rm(name)
+	end	
+	
+	#
+	# Upload one or more files to the remote computer the remote
+	# directory supplied in destination.
+	#
+	def File.upload(destination, *src_files, &stat)
+		src_files.each { |src|
+			dest = destination
+
+			stat.call('uploading', src, dest) if (stat)
+			if (File.basename(destination) != ::File.basename(src))
+				dest += File::SEPARATOR + ::File.basename(src)
+			end
+
+			upload_file(dest, src)
+			stat.call('uploaded', src, dest) if (stat)
+		}
+	end
+
+	#
+	# Upload a single file.
+	#
+	def File.upload_file(dest_file, src_file)
+		# Open the file on the remote side for writing and read
+		# all of the contents of the local file
+		dest_fd = client.fs.file.new(dest_file, "wb")
+		src_buf = ''
+		
+		::File.open(src_file, 'rb') { |f|
+			src_buf = f.read(f.stat.size)
+		}
+
+		begin
+			dest_fd.write(src_buf)
+		ensure
+			dest_fd.close
+		end
+	end
+
+	#
+	# Download one or more files from the remote computer to the local 
+	# directory supplied in destination.
+	#
+	def File.download(destination, *src_files, &stat)
+		src_files.each { |src|
+			dest = destination
+
+			stat.call('downloading', src, dest) if (stat)
+
+			if (::File.basename(destination) != File.basename(src))
+				dest += ::File::SEPARATOR + File.basename(src)
+			end
+
+			download_file(dest, src)
+			
+			stat.call('downloaded', src, dest) if (stat)
+		}
+	end
+
+	#
+	# Download a single file.
+	#
+	def File.download_file(dest_file, src_file)
+		src_fd = client.fs.file.new(src_file, "rb")
+		::FileUtils.mkdir_p(::File.dirname(dest_file))
+		dst_fd = ::File.new(dest_file, "wb")
+
+		# Keep transferring until EOF is reached...
+		begin
+			while ((data = src_fd.read) != nil)
+				dst_fd.write(data)
+			end
+		rescue EOFError
+		ensure
+			src_fd.close
+			dst_fd.close
+		end
+	end
+
+	##
+	#
+	# Constructor
+	#
+	##
+
+	#
+	# Initializes and opens the specified file with the specified permissions.
+	#
+	def initialize(name, mode = "r", perms = 0)
+		self.client = self.class.client
+		self.filed  = _open(name, mode, perms)
+	end
+
+	##
+	#
+	# IO implementators
+	#
+	##
+
+	#
+	# Returns whether or not the file has reach EOF.
+	#
+	def eof
+		return self.filed.eof
+	end
+
+	#
+	# Returns the current position of the file pointer.
+	#
+	def pos
+		return self.filed.tell
+	end
+
+	#
+	# Synonym for sysseek.
+	#
+	def seek(offset, whence = SEEK_SET)
+		return self.sysseek(offset, whence)
+	end
+
+	#
+	# Seeks to the supplied offset based on the supplied relativity.
+	#
+	def sysseek(offset, whence = SEEK_SET)
+		return self.filed.seek(offset, whence)
+	end
+
+protected
+
+	##
+	#
+	# Internal methods
+	#
+	##
+
+	#
+	# Creates a File channel using the supplied information.
+	#
+	def _open(name, mode = "r", perms = 0)
+		return Rex::Post::Meterpreter::Channels::Pools::File.open(
+				self.client, name, mode, perms)
+	end
+
+	attr_accessor :client # :nodoc:
+
+end
+
+end; end; end; end; end; end