librex 0.0.20 → 0.0.21

data/lib/rex/proto/http/header.rb.ut.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..'))
+
+require 'test/unit'
+require 'rex/proto/http'
+
+class Rex::Proto::Http::Packet::Header::UnitTest < Test::Unit::TestCase
+
+	Klass = Rex::Proto::Http::Packet::Header
+
+	def test_to_s
+		h = Klass.new
+
+		h['Foo']     = 'Fishing'
+		h['Chicken'] = 47
+
+		assert_equal(
+			"Foo: Fishing\r\n" +
+			"Chicken: 47\r\n\r\n", h.to_s)
+	end
+
+	def test_from_s
+		h = Klass.new
+
+		h.from_s(
+			"POST /foo HTTP/1.0\r\n" +
+			"Lucifer: Beast\r\n" +
+			"HoHo: Satan\r\n" +
+			"Eat: Babies\r\n" +
+			"\r\n")
+
+		assert_equal('Babies', h['Eat'], 'header')
+		assert_equal('Satan', h['HoHo'], 'header')
+		assert_equal('Satan', h['hOhO'], 'header')
+
+		assert_equal("POST /foo HTTP/1.0\r\n", h.cmd_string, 'cmd_string')
+	end
+
+	def test_just_cmdstring
+		h = Klass.new
+
+		h.from_s("POST /foo HTTP/1.0")
+		assert_equal("POST /foo HTTP/1.0\r\n", h.cmd_string, 'just cmd_string')
+	end
+end

data/lib/rex/proto/http/packet.rb

@@ -0,0 +1,407 @@
+require 'rex/proto/http'
+
+module Rex
+module Proto
+module Http
+
+DefaultProtocol = '1.1'
+
+###
+#
+# This class represents an HTTP packet.
+#
+###
+class Packet
+
+	#
+	# Parser processing codes
+	#
+	module ParseCode
+		Completed = 1
+		Partial   = 2
+		Error     = 3
+	end
+
+	#
+	# Parser states
+	#
+	module ParseState
+		ProcessingHeader = 1
+		ProcessingBody   = 2
+		Completed        = 3
+	end
+
+	require 'rex/proto/http/header'
+
+	#
+	# Initializes an instance of an HTTP packet.
+	#
+	def initialize()
+		self.headers = Header.new
+		self.auto_cl = true
+
+		reset
+	end
+
+	#
+	# Return the associated header value, if any.
+	#
+	def [](key)
+		if (self.headers.include?(key))
+			return self.headers[key]
+		end
+
+		self.headers.each_pair do |k,v|
+			if (k.downcase == key.downcase)
+				return v
+			end
+		end
+
+		return nil
+	end
+
+	#
+	# Set the associated header value.
+	#
+	def []=(key, value)
+		self.headers[key] = value
+	end
+
+	#
+	# Parses the supplied buffer.  Returns one of the two parser processing
+	# codes (Completed, Partial, or Error).
+	#
+	def parse(buf)
+
+		# Append the incoming buffer to the buffer queue.
+		self.bufq += buf.to_s
+
+		begin
+
+			# Process the header
+			if(self.state == ParseState::ProcessingHeader)
+				parse_header
+			end
+
+			# Continue on to the body if the header was processed
+			if(self.state == ParseState::ProcessingBody)
+				# Chunked encoding sets the parsing state on its own
+				if (self.body_bytes_left == 0 and not self.transfer_chunked)
+					self.state = ParseState::Completed
+				else
+					parse_body
+				end
+			end
+		rescue
+			# XXX: BUG: This rescue might be a problem because it will swallow TimeoutError
+			self.error = $!
+			return ParseCode::Error
+		end
+
+		# Return completed or partial to the parsing status to the caller
+		(self.state == ParseState::Completed) ? ParseCode::Completed : ParseCode::Partial
+	end
+
+	#
+	# Reset the parsing state and buffers.
+	#
+	def reset
+		self.state = ParseState::ProcessingHeader
+		self.transfer_chunked = false
+		self.inside_chunk     = false
+		self.headers.reset
+		self.bufq  = ''
+		self.body  = ''
+	end
+
+	#
+	# Reset the parsing state but leave the buffers.
+	#
+	def reset_except_queue
+		self.state = ParseState::ProcessingHeader
+		self.transfer_chunked = false
+		self.inside_chunk     = false
+		self.headers.reset
+		self.body  = ''
+	end
+
+	#
+	# Returns whether or not parsing has completed.
+	#
+	def completed?
+
+		return true if self.state == ParseState::Completed
+
+		# If the parser state is processing the body and there are an
+		# undetermined number of bytes left to read, we just need to say that
+		# things are completed as it's hard to tell whether or not they really
+		# are.
+		if (self.state == ParseState::ProcessingBody and self.body_bytes_left < 0)
+			return true
+		end
+
+		false
+	end
+
+	#
+	# Build a 'Transfer-Encoding: chunked' payload with random chunk sizes
+	#
+	def chunk(str, min_size = 1, max_size = 1000)
+		chunked = ''
+
+		# min chunk size is 1 byte
+		if (min_size < 1); min_size = 1; end
+
+		# don't be dumb
+		if (max_size < min_size); max_size = min_size; end
+
+		while (str.size > 0)
+			chunk = str.slice!(0, rand(max_size - min_size) + min_size)
+			chunked += sprintf("%x", chunk.size) + "\r\n" + chunk + "\r\n"
+		end
+		chunked += "0\r\n\r\n"
+	end
+
+	#
+	# Converts the packet to a string.
+	#
+	def to_s
+		content = self.body.dup
+
+		# Update the content length field in the header with the body length.
+		if (content)
+			if !self.compress.nil?
+				case self.compress
+					when 'gzip'
+						self.headers['Content-Encoding'] = 'gzip'
+						content = Rex::Text.gzip(content)
+					when 'deflate'
+						self.headers['Content-Encoding'] = 'deflate'
+						content = Rex::Text.zlib_deflate(content)
+					when 'none'
+					# this one is fine...
+					# when 'compress'
+					else
+						raise RuntimeError, 'Invalid Content-Encoding'
+				end
+			end
+
+			if (self.auto_cl == true && self.transfer_chunked == true)
+				raise RuntimeError, "'Content-Length' and 'Transfer-Encoding: chunked' are incompatible"
+			elsif self.auto_cl == true
+				self.headers['Content-Length'] = content.length
+			elsif self.transfer_chunked == true
+				if self.proto != '1.1'
+					raise RuntimeError, 'Chunked encoding is only available via 1.1'
+				end
+				self.headers['Transfer-Encoding'] = 'chunked'
+				content = self.chunk(content, self.chunk_min_size, self.chunk_max_size)
+			end
+		end
+
+		str  = self.headers.to_s(cmd_string)
+		str += content || ''
+	end
+
+	#
+	# Converts the packet from a string.
+	#
+	def from_s(str)
+		reset
+		parse(str)
+	end
+
+	#
+	# Returns the command string, such as:
+	#
+	# HTTP/1.0 200 OK for a response
+	#
+	# or
+	#
+	# GET /foo HTTP/1.0 for a request
+	#
+	def cmd_string
+		self.headers.cmd_string
+	end
+
+	attr_accessor :headers
+	attr_accessor :error
+	attr_accessor :state
+	attr_accessor :bufq
+	attr_accessor :body
+	attr_accessor :auto_cl
+	attr_accessor :max_data
+	attr_accessor :transfer_chunked
+	attr_accessor :compress
+	attr_reader   :incomplete
+
+	attr_accessor :chunk_min_size
+	attr_accessor :chunk_max_size
+
+protected
+
+	attr_writer   :incomplete
+	attr_accessor :body_bytes_left
+	attr_accessor :inside_chunk
+	attr_accessor :keepalive
+
+	##
+	#
+	# Overridable methods
+	#
+	##
+
+	#
+	# Allows derived classes to split apart the command string.
+	#
+	def update_cmd_parts(str)
+	end
+
+	##
+	#
+	# Parsing
+	#
+	##
+
+	def parse_header
+
+		head,data = self.bufq.split(/\r?\n\r?\n/, 2)
+
+		return if not data
+
+		self.headers.from_s(head)
+		self.bufq = data || ""
+
+		# Set the content-length to -1 as a placeholder (read until EOF)
+		self.body_bytes_left = -1
+
+		# Extract the content length if it was specified
+		if (self.headers['Content-Length'])
+			self.body_bytes_left = self.headers['Content-Length'].to_i
+		end
+
+		# Look for a chunked transfer header
+		if (self.headers['Transfer-Encoding'].to_s.downcase == 'chunked')
+			self.transfer_chunked = true
+			self.auto_cl = false
+		end
+
+		# Determine how to handle data when there is no length header
+		if (self.body_bytes_left == -1)
+			if (not self.transfer_chunked)
+				if (self.headers['Connection'].to_s.downcase.include?('keep-alive'))
+					# If we are using keep-alive, but have no content-length and
+					# no chunked transfer header, pretend this is the entire
+					# buffer and call it done
+					self.body_bytes_left = self.bufq.length
+				elsif (not self.headers['Content-Length'] and self.class == Rex::Proto::Http::Request)
+					# RFC 2616 says: "The presence of a message-body in a request
+					# is signaled by the inclusion of a Content-Length or
+					# Transfer-Encoding header field in the request's
+					# message-headers."
+					#
+					# So if we haven't seen either a Content-Length or a
+					# Transfer-Encoding header, there shouldn't be a message body.
+					self.body_bytes_left = 0
+				#else
+				# Otherwise we need to keep reading until EOF
+				end
+			end
+		end
+
+		# Throw an error if we didnt parse the header properly
+		if !self.headers.cmd_string
+			raise RuntimeError, "Invalid command string", caller
+		end
+
+		# Move the state into body processing
+		self.state = ParseState::ProcessingBody
+
+		# Allow derived classes to update the parts of the command string
+		self.update_cmd_parts(self.headers.cmd_string)
+	end
+
+	#
+	# Parses the body portion of the request.
+	#
+	def parse_body
+		# Just return if the buffer is empty
+		if (self.bufq.length == 0)
+			return
+		end
+
+		# Handle chunked transfer-encoding responses
+		if (self.transfer_chunked and self.inside_chunk != 1 and self.bufq.length)
+
+			# Remove any leading newlines or spaces
+			self.bufq.lstrip!
+
+			# If we didn't get a newline, then this might not be the full
+			# length, go back and get more.
+			# e.g.
+			#  first packet: "200"
+			#  second packet: "0\r\n\r\n<html>..."
+			if not bufq.index("\n")
+				return
+			end
+
+			# Extract the actual hexadecimal length value
+			clen = self.bufq.slice!(/^[a-fA-F0-9]+\r?\n/)
+
+			clen.rstrip! if (clen)
+
+			# if we happen to fall upon the end of the buffer for the next chunk len and have no data left, go get some more...
+			if clen.nil? and self.bufq.length == 0
+				return
+			end
+
+			# Invalid chunk length, exit out early
+			if clen.nil?
+				self.state = ParseState::Completed
+				return
+			end
+
+			self.body_bytes_left = clen.to_i(16)
+
+			if (self.body_bytes_left == 0)
+				self.bufq.sub!(/^\r?\n/s,'')
+				self.state = ParseState::Completed
+				return
+			end
+
+			self.inside_chunk = 1
+		end
+
+		# If there are bytes remaining, slice as many as we can and append them
+		# to our body state.
+		if (self.body_bytes_left > 0)
+			part = self.bufq.slice!(0, self.body_bytes_left)
+			self.body += part
+			self.body_bytes_left -= part.length
+		# Otherwise, just read it all.
+		else
+			self.body += self.bufq
+			self.bufq  = ''
+		end
+
+		# Finish this chunk and move on to the next one
+		if (self.transfer_chunked and self.body_bytes_left == 0)
+			self.inside_chunk = 0
+			self.parse_body
+			return
+		end
+
+		# If there are no more bytes left, then parsing has completed and we're
+		# ready to go.
+		if (not self.transfer_chunked and self.body_bytes_left == 0)
+			self.state = ParseState::Completed
+			return
+		end
+	end
+
+end
+
+end
+end
+end
+