librex 0.0.16 → 0.0.17

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

@@ -0,0 +1,214 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..'))
+
+require 'test/unit'
+require 'rex/proto/http'
+
+class Rex::Proto::Http::Request::UnitTest < Test::Unit::TestCase
+
+	Klass = Rex::Proto::Http::Request
+
+	def test_to_s
+		h = Klass.new
+
+		h.headers['Foo']     = 'Fishing'
+		h.headers['Chicken'] = 47
+		h.auto_cl = true
+
+		assert_equal(
+			"GET / HTTP/1.1\r\n" +
+			"Foo: Fishing\r\n" +
+			"Content-Length: 0\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('POST', h.method, 'method')
+		assert_equal('/foo', h.uri, 'uri')
+		assert_equal('1.0', h.proto, 'proto')
+		assert_equal('Babies', h['Eat'], 'header')
+
+		assert_equal("POST /foo HTTP/1.0\r\n", h.cmd_string, 'cmd_string')
+
+		h.method = 'GET'
+		assert_equal("GET /foo HTTP/1.0\r\n", h.cmd_string, 'set method')
+
+		h.uri = '/bar'
+		assert_equal("GET /bar HTTP/1.0\r\n", h.cmd_string, 'set uri')
+
+		h.proto = '1.2'
+		assert_equal("GET /bar HTTP/1.2\r\n", h.cmd_string, 'set proto')
+	end
+
+	def junk_request
+		h = Klass.new
+		h.from_s("GET /foo/bar.html HTTP/1.0\r\n" + "Foo: Bar\r\n\r\n")
+		return h
+	end
+
+	def test_junk_slashes
+		srand(0)
+
+		h = junk_request
+		assert_equal('GET', h.method, 'method')
+		assert_equal('1.0', h.proto, 'proto')
+		assert_equal('Bar', h['Foo'], 'header')
+		assert_equal('/foo/bar.html', h.uri, 'uri')
+
+		h = junk_request
+		h.junk_directories = 1
+		assert_equal('/D/../DnJT/../kXG/../Y/../BmnXu/../foo/lZ/../J/../zQzFP/../S/../Yxzd/../bar.html', h.uri, 'junk directories')
+
+		h = junk_request
+		h.junk_slashes = 1
+		assert_equal('/foo//bar.html', h.uri, 'junk slashes')
+
+		h = junk_request
+		h.junk_self_referring_directories = 1
+		assert_equal('/././foo/././bar.html', h.uri, 'junk referring directories')
+
+		h = junk_request
+		h.junk_param_start = 1
+		assert_equal('/%3fgf=XjLyc/../foo/bar.html', h.uri, 'junk start of params')
+		
+		h = junk_request
+		h.junk_end_of_uri = 1
+		assert_equal('/%20HTTP/1.0%0d%0a/../../foo/bar.html', h.uri, 'junk end of URI')
+	end
+
+	def test_params
+		srand(0)
+
+		h = junk_request
+		assert_equal('/foo/bar.html', h.uri, 'uri')
+
+		h.uri_parts['QueryString']['B'] = 'a'
+		assert_equal('/foo/bar.html?B=a', h.uri, 'uri with param')
+		
+		h.uri_parts['QueryString']['B'] = ['a','b']
+		assert_equal('/foo/bar.html?B=a&B=b', h.uri, 'uri with a param with multiple values')
+		
+		h.uri_parts['QueryString']['B'] = '='
+		assert_equal('/foo/bar.html?B=%3d', h.uri, 'uri with a param that requires escaping')
+	
+		assert_equal(
+    		"GET /foo/bar.html?B=%3d HTTP/1.0\r\n" +
+    		"Foo: Bar\r\n" +
+    		"Content-Length: 0\r\n" +
+			"\r\n", h.to_s, 'GET to_s'
+		)
+		
+		h.method = 'POST'
+		assert_equal(
+    		"POST /foo/bar.html HTTP/1.0\r\n" +
+    		"Foo: Bar\r\n" +
+    		"Content-Length: 5\r\n" +
+			"\r\n" +
+			'B=%3d',
+			h.to_s, 'POST to_s'
+		)
+
+		h.body = 'FOO'
+		assert_equal(
+    		"POST /foo/bar.html HTTP/1.0\r\n" +
+    		"Foo: Bar\r\n" +
+    		"Content-Length: 3\r\n" +
+			"\r\n" +
+			'FOO',
+			h.to_s, 'POST to_s, with hardcoded body'
+		)
+
+	end
+
+	def test_junk_params
+		srand(0)
+		h = junk_request
+		
+		h.junk_params = 1
+		h.uri_parts['QueryString']['a'] = 'b'
+		h.uri_parts['QueryString']['c'] = 'd'
+
+		assert_equal("GET /foo/bar.html?eZUhlXbdhzzW=HpxJATk&UwDqBU=EQwvK&oebrfUGJbvjTMSxKih=MkBx&nYkjF=DiohcEa&tzJFh=eIUHDVbs&a=b&UHTfAFbreJT=VlcIruAo&mZKziXgT=z&hsytpEdbRjC=tPkpE&yNetXi=JaaW&PiazmuQvoAKLNHeGt=ePpmrS&c=d&BpCycOlbkfdyudyhMgpQCIzKwabBAFYiP=ulrTYGUG&zGCccmlFtJkNVfRjtzIZVtlWQZulBFGMa=OIHtFvqDKybZDOS&ERFeYDFokx=YhShOxHruwhRdMugizXZuyrpuAMJSEHDwMltwtSzxHaxudDKUqBUQqycaXwC&JCspZkaEpKM=hlnghajZyYSUecISZYnqcYSDsTtAKDGbjGTiyymUrAktp&hMPhXMF=BKGGmmLyVyyzCMdJzIFrBrPMvMVSZNecspVGkwoaeFP HTTP/1.0\r\nFoo: Bar\r\nContent-Length: 0\r\n\r\n", h.to_s, 'junk params (GET)')
+
+		h.method = 'POST'
+		assert_equal("POST /foo/bar.html HTTP/1.0\r\nFoo: Bar\r\nContent-Length: 591\r\n\r\nxfgwQgKMdA=WTFkTkFc&axTMmHQdAXPKDDQwJ=lwRJs&PmOhEQkHXbuHWieQbvv=LXO&eaiRjHtwlENl=rIgR&kBdFQmoWeT=UqKDW&a=b&dpoRzoqedheulYQ=ndBX&AXlvaZZGYPlpR=w&uFTvWtLLhHawHvgk=XVC&KFmmkBkFFmjYx=yJExY&CTDNLNkRaGviVUqRlZV=kEviLihu&c=d&LhZhftGZYtmzQXaDaudCF=HPOjnHzmzdxLDNYEzWdmLOSZsDlHdOLJLQnBScAVYJISLczRPDqYVcVOvBMLZn&atiBQBQhhsmoINqT=gXEfWAlfPTPzMtKpQGVeDQABygrSSWPPcHbYYMNSOOUHsrbsPXLNdfu&EcBxxXQpawCvRUmAGsWPKio=VigqsjpnbwKERDleXdmeLCdHzJXAwRozVeaPwRKRDnJ&DHQiEakGgRlbzOWfIdcfiRcvQIsHMgUrLd=AUtcNlvnyEuMlwEpkQSleujwAxJyhwxMGzkjmkeyTmsjO&zRDdbDhzbkVnqKdxdYyQAkiNBCCTMenVNx=zMxABkKqgcCcBNTvRkHGJPSdqSCdRjT",h.to_s, 'junk params (POST)')
+
+		h.method = 'SEARCH'
+		assert_equal("SEARCH /foo/bar.html HTTP/1.0\r\nFoo: Bar\r\nContent-Length: 522\r\n\r\nMjtCUDRsmqKl=vbEzWljeH&YvPKTNnlnSHYg=ovkqQaoQ&geUXPsTibtiRXbNwXeF=nhxicBEVIy&jwjZFB=HBBH&kNsybgrTitkQwq=rDITuAUgir&a=b&YCHsLzcfBQ=SOV&vFhqCboTPHsdjhwxQYFz=RtgW&mJFMqQ=EZ&tRdGcKFkkUyyWKreOzw=BoHFPpgXO&dzZEAaU=YREgxR&c=d&kfeJswjgOXgcrh=usIlCRPDVwydlWSHxaEtZazvTOSgbkmUsDSNzxfhSMvbniHetQBYQtb&yYwMEwzuoO=KbOmNEWPdOqZLfbWurUCZAfuGSWuZNMlTfcTooZvdcqKURAnmiBwWt&xWncBVCgyGmjkXzSmZuPxbVBJzRLADk=TvFUEpQQFgWDIcpKmcfsLibxH&mFJYMohOtPEW=CHtIFnPPpZWZZTdJLjanSIBjyxuKKYfrbNOFXqnxlmLrYRVeSZdlxoxqf&LOgBBkZMIyMY=DKHcOIujjRXMtHvuneTqtyBr", h.to_s, 'junk params (SEARCH)')
+	end
+
+	def test_junk_pipelining
+		srand(0)
+
+		h = Klass.new
+		h.from_s("GET /foo HTTP/1.0\r\n" + "Foo: Bar\r\n\r\n")
+		h.junk_pipeline = 1
+		assert_equal("GET / HTTP/1.1\r\nConnection: Keep-Alive\r\n\r\nGET /foo HTTP/1.0\r\nFoo: Bar\r\nContent-Length: 0\r\nConnection: Closed\r\n\r\n", h.to_s, 'pipeline')
+	end
+
+	def test_junk_all
+        srand(0)
+
+        h = junk_request
+        h.junk_slashes = 1
+        h.junk_directories = 1
+        h.junk_self_referring_directories = 1
+		h.junk_end_of_uri = 1
+		h.junk_param_start = 1
+
+        seen = {}
+		expect = [
+			{"//"=>145, "/./"=>35, "param"=>1, "http"=>1, "/w/../"=>3},
+			{"//"=>149, "/./"=>35, "param"=>1, "http"=>1, "/w/../"=>3},
+			{"//"=>130, "/./"=>30, "param"=>1, "http"=>1, "/w/../"=>2},
+			{"//"=>165, "/./"=>40, "param"=>1, "http"=>1, "/w/../"=>4},
+			{"//"=>145, "/./"=>35, "param"=>1, "http"=>1, "/w/../"=>3},
+		]
+		i = 0
+        5.times {
+            str = h.uri.dup
+            assert_not_equal('/foo/bar.html', str, 'all the junk')
+            assert_nil(seen[str], 'all the junk, not a dup rand')
+            seen[str] = 1
+
+			seen = { '/./' => 0, '//' => 0, '/w/../' => 0, 'http' => 0, 'param' => 0}
+			matched = 1
+			while matched == 1
+				# p str
+				if str.sub!(/\/%20HTTP\/1.0%0d%0a\/\.\.\/\.\.\//, '/')
+					seen['http'] += 1;
+				elsif str.sub!(/\/%3f\w+=\w+\/\.\.\//i, '/')
+					seen['param'] += 1;
+				elsif str.sub!(/\/\w+\/\.\.\//, '/')
+					seen['/./'] += 1;
+				elsif str.sub!(/\/\//, '/')
+					seen['//'] += 1;
+				elsif str.sub!(/\/.\//, '/')
+					seen['/w/../'] += 1;
+				else
+					matched = 0
+				end
+			end
+
+			assert_equal('/foo/bar.html', str, 'normalized')
+			assert_equal(expect[i], seen, 'expected counts')
+			i += 1
+        }
+    end
+
+	def test_normalize
+		h = junk_request
+		h.uri = '/foo/..////./././asdf/././//../bar.html'
+		assert_equal('/bar.html', h.uri, 'normalize on set')
+	end
+end

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

@@ -0,0 +1,90 @@
+require 'rex/proto/http'
+
+module Rex
+module Proto
+module Http
+
+###
+#
+# HTTP response class.
+#
+###
+class Response < Packet
+
+	##
+	#
+	# Builtin response class wrappers.
+	#
+	## 
+
+	#
+	# HTTP 200/OK response class wrapper.
+	#
+	class OK < Response
+		def initialize(message = 'OK', proto = DefaultProtocol)
+			super(200, message, proto)
+		end
+	end
+
+	#
+	# HTTP 404/File not found response class wrapper.
+	#
+	class E404 < Response
+		def initialize(message = 'File not found', proto = DefaultProtocol)
+			super(404, message, proto)
+		end
+	end
+
+	#
+	# Constructage of the HTTP response with the supplied code, message, and
+	# protocol.
+	#
+	def initialize(code = 200, message = 'OK', proto = DefaultProtocol)
+		super()
+
+		self.code    = code.to_i
+		self.message = message
+		self.proto   = proto
+
+		# Default responses to auto content length on
+		self.auto_cl = true
+
+		# default chunk sizes (if chunked is used)
+		self.chunk_min_size = 1
+		self.chunk_max_size = 10
+	end
+
+	#
+	# Updates the various parts of the HTTP response command string.
+	#
+	def update_cmd_parts(str)
+		if (md = str.match(/HTTP\/(.+?)\s+(\d+)\s?(.+?)\r?\n?$/))
+			self.message = md[3].gsub(/\r/, '')
+			self.code    = md[2].to_i
+			self.proto   = md[1]
+		else
+			raise RuntimeError, "Invalid response command string", caller
+		end
+	end
+
+	#
+	# Returns the response based command string.
+	#
+	def cmd_string
+		"HTTP\/#{proto} #{code}#{(message and message.length > 0) ? ' ' + message : ''}\r\n"
+	end
+
+	#
+	# Used to store a copy of the original request
+	#
+	attr_accessor :request 
+	
+	
+	attr_accessor :code 
+	attr_accessor :message
+	attr_accessor :proto
+end
+
+end
+end
+end

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

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..'))
+
+require 'test/unit'
+require 'rex/proto/http'
+
+class Rex::Proto::Http::Response::UnitTest < Test::Unit::TestCase
+
+	Klass = Rex::Proto::Http::Response
+
+	def test_deflate
+		h = Klass.new
+		h.body = 'hi mom'
+		h.compress = 'deflate'
+		assert_equal(
+			"HTTP/1.1 200 OK\r\n" +
+			"Content-Length: 14\r\n" +
+			"Content-Encoding: deflate\r\n\r\n" +
+			"x\234\313\310T\310\315\317\005\000\a\225\002;", 
+			h.to_s, 'deflate'
+			)
+	end
+
+	def test_gzip
+		h = Klass.new
+		h.body = 'hi mom'
+		h.compress = 'gzip'
+		srand(0)
+
+		response = h.to_s
+
+		http_header = response.slice!(0,63)
+
+		assert_equal(
+			"HTTP/1.1 200 OK\r\n" +
+			"Content-Length: 26\r\n"+			
+			"Content-Encoding: gzip\r\n\r\n",
+			http_header, 'http headers'
+			)
+
+		assert_equal("\x1f\x8b\x08\x00", response.slice!(0,4), 'gzip headers')
+
+		# skip the next 6 bytes as it is host & time specific (zlib's example gun does, so why not us too?)
+		response.slice!(0,6)
+
+		assert_equal("\xcb\xc8\x54\xc8\xcd\xcf\x05\x00\x68\xa4\x1c\xf0\x06\x00\x00\x00", response, 'gzip data')
+	end
+
+
+	def test_to_s
+		h = Klass.new
+
+		h.headers['Foo']     = 'Fishing'
+		h.headers['Chicken'] = 47
+
+		assert_equal(
+			"HTTP/1.1 200 OK\r\n" +
+			"Content-Length: 0\r\n" +
+			"Foo: Fishing\r\n" +
+			"Chicken: 47\r\n\r\n", h.to_s, 'to_s w/o body')
+
+		h.body = 'hi mom'
+		assert_equal(
+			"HTTP/1.1 200 OK\r\n" +
+			"Content-Length: 6\r\n" +
+			"Foo: Fishing\r\n" +			
+			"Chicken: 47\r\n\r\nhi mom", h.to_s, 'to_s w/ body')
+	end
+
+
+	def test_chunked
+		h = Klass.new
+
+		h.headers['Foo']     = 'Fishing'
+		h.headers['Chicken'] = 47
+		h.auto_cl = false
+		h.transfer_chunked = true
+
+
+		assert_equal(
+			"HTTP/1.1 200 OK\r\n" +
+			"Transfer-Encoding: chunked\r\n" +
+			"Foo: Fishing\r\n" +
+			"Chicken: 47\r\n\r\n0\r\n\r\n", h.to_s, 'chunked w/o body'
+			)
+		
+		srand(0)
+		h.body = Rex::Text.rand_text_alphanumeric(100)
+		assert_equal(
+			"HTTP/1.1 200 OK\r\n" +
+			"Transfer-Encoding: chunked\r\n" +
+			"Foo: Fishing\r\n" +
+			"Chicken: 47\r\n\r\n" +
+			"5\r\nsv1AD\r\n7\r\n7DnJTVy\r\n5\r\nkXGYY\r\n5\r\nM6Bmn\r\n4\r\nXuYR\r\n5\r\nlZNIJ\r\n5\r\nUzQzF\r\n9\r\nPvASjYxzd\r\n5\r\nTTOng\r\n4\r\nBJ5g\r\n8\r\nfK0XjLy3\r\n6\r\nciAAk1\r\n6\r\nFmo0RP\r\n1\r\nE\r\n2\r\npq\r\n6\r\n6f4BBn\r\n4\r\np5jm\r\n1\r\n3\r\n6\r\nLuSbAO\r\n1\r\nj\r\n2\r\n1M\r\n3\r\n5qU\r\n0\r\n\r\n",
+			h.to_s, 'random chunk sizes'
+			)
+
+		h.chunk_max_size = 1
+		h.body = 'hi mom'
+		assert_equal(
+			"HTTP/1.1 200 OK\r\n" +
+			"Transfer-Encoding: chunked\r\n" +
+			"Foo: Fishing\r\n" +
+			"Chicken: 47\r\n\r\n" +
+			"1\r\nh\r\n1\r\ni\r\n1\r\n \r\n1\r\nm\r\n1\r\no\r\n1\r\nm\r\n0\r\n\r\n", 
+			h.to_s, '1 byte chunks'
+			)
+		
+		h.chunk_min_size = 2
+		assert_equal(
+			"HTTP/1.1 200 OK\r\n" +
+			"Transfer-Encoding: chunked\r\n" +
+			"Foo: Fishing\r\n" +
+			"Chicken: 47\r\n\r\n" +
+			"2\r\nhi\r\n2\r\n m\r\n2\r\nom\r\n0\r\n\r\n",
+			h.to_s, '2 byte chunks'
+			)
+
+		h = Klass.new(200, 'OK', '1.0')
+		h.body = 'hi mom'
+		h.auto_cl = false
+		h.transfer_chunked = true
+		assert_raise(Rex::RuntimeError, 'chunked encoding via 1.0') {
+			h.to_s
+		}
+
+	end
+
+	def test_from_s
+		h = Klass.new
+
+		h.from_s(
+			"HTTP/1.0 404 File not found\r\n" +
+			"Lucifer: Beast\r\n" +
+			"HoHo: Satan\r\n" +
+			"Eat: Babies\r\n" +
+			"\r\n")
+
+		assert_equal(404, h.code)
+		assert_equal('File not found', h.message)
+		assert_equal('1.0', h.proto)
+		assert_equal("HTTP/1.0 404 File not found\r\n", h.cmd_string)
+		h.code = 470
+		assert_equal("HTTP/1.0 470 File not found\r\n", h.cmd_string)
+		assert_equal('Babies', h['Eat'])
+	end
+
+end