librex 0.0.19 → 0.0.20

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

@@ -1,369 +0,0 @@
-require 'rex/socket'
-require 'rex/proto/http'
-require 'rex/proto/http/handler'
-
-module Rex
-module Proto
-module Http
-
-###
-#
-# Runtime extension of the HTTP clients that connect to the server.
-#
-###
-module ServerClient
-
-	#
-	# Initialize a new request instance.
-	#
-	def init_cli(server)
-		self.request   = Request.new
-		self.server    = server
-		self.keepalive = false
-	end
-
-	#
-	# Resets the parsing state.
-	#
-	def reset_cli
-		self.request.reset
-	end
-
-	#
-	# Transmits a response and adds the appropriate headers.
-	#
-	def send_response(response)
-		# Set the connection to close or keep-alive depending on what the client
-		# can support.
-		response['Connection'] = (keepalive) ? 'Keep-Alive' : 'close'
-
-		# Add any other standard response headers.
-		server.add_response_headers(response)
-
-		# Send it off.
-		put(response.to_s)
-	end
-
-	#
-	# The current request context.
-	#
-	attr_accessor :request
-	#
-	# Boolean that indicates whether or not the connection supports keep-alive.
-	#
-	attr_accessor :keepalive
-	#
-	# A reference to the server the client is associated with.
-	#
-	attr_accessor :server
-
-end
-
-###
-#
-# Acts as an HTTP server, processing requests and dispatching them to
-# registered procs.  Some of this server was modeled after webrick.
-#
-###
-class Server
-
-	include Proto
-
-	#
-	# A hash that associated a file extension with a mime type for use as the
-	# content type of responses.
-	#
-	ExtensionMimeTypes =
-		{
-			"rhtml" => "text/html",
-			"html"  => "text/html",
-			"htm"   => "text/htm",
-			"jpg"   => "image/jpeg",
-			"jpeg"  => "image/jpeg",
-			"jpeg"  => "image/jpeg",
-			"gif"   => "image/gif",
-			"png"   => "image/png",
-			"bmp"   => "image/bmp",
-			"txt"   => "text/plain",
-			"css"   => "text/css",
-			"ico"   => "image/x-icon",
-		}
-
-	#
-	# The default server name that will be returned in the Server attribute of
-	# a response.
-	#
-	DefaultServer = "Rex"
-
-	#
-	# Initializes an HTTP server as listening on the provided port and
-	# hostname.
-	#
-	def initialize(port = 80, listen_host = '0.0.0.0', ssl = false, context = {}, comm = nil)
-		self.listen_host = listen_host
-		self.listen_port = port
-		self.context     = context
-		self.listener    = nil
-		self.resources   = {}
-		self.server_name = DefaultServer
-		self.ssl         = ssl
-		self.comm        = comm
-	end
-
-	#
-	# Returns the hardcore alias for the HTTP service
-	#
-	def self.hardcore_alias(*args)
-		"#{(args[0] || '')}#{(args[1] || '')}"
-	end
-
-	#
-	# HTTP server.
-	#
-	def alias
-		super || "HTTP Server"
-	end
-
-	#
-	# Listens on the defined port and host and starts monitoring for clients.
-	#
-	def start
-
-		self.listener = Rex::Socket::TcpServer.create(
-			'LocalHost' => self.listen_host,
-			'LocalPort' => self.listen_port,
-			'Context'   => self.context,
-			'SSL'		=> self.ssl,
-			'Comm'      => self.comm
-		)
-
-		# Register callbacks
-		self.listener.on_client_connect_proc = Proc.new { |cli|
-			on_client_connect(cli)
-		}
-		self.listener.on_client_data_proc = Proc.new { |cli|
-			on_client_data(cli)
-		}
-
-		self.listener.start
-	end
-
-	#
-	# Terminates the monitor thread and turns off the listener.
-	#
-	def stop
-		self.listener.stop
-		self.listener.close
-	end
-
-
-	#
-	# Waits for the HTTP service to terminate
-	#
-	def wait
-		self.listener.wait if self.listener
-	end
-
-	#
-	# Closes the supplied client, if valid.
-	#
-	def close_client(cli)
-		listener.close_client(cli)
-	end
-
-	#
-	# Mounts a directory or resource as being serviced by the supplied handler.
-	#
-	def mount(root, handler, long_call = false, *args)
-		resources[root] = [ handler, long_call, args ]
-	end
-
-	#
-	# Remove the mount point.
-	#
-	def unmount(root)
-		resources.delete(root)
-	end
-
-	#
-	# Adds a resource handler, such as one for /, which will be called whenever
-	# the resource is requested.  The ``opts'' parameter can have any of the
-	# following:
-	#
-	# Proc      (proc) - The procedure to call when a request comes in for this resource.
-	# LongCall  (bool) - Hints to the server that this resource may have long
-	#                    request processing times.
-	#
-	def add_resource(name, opts)
-		if (resources[name])
-			raise RuntimeError,
-				"The supplied resource '#{name}' is already added.", caller
-		end
-
-		# If a procedure was passed, mount the resource with it.
-		if (opts['Proc'])
-			mount(name, Handler::Proc, false, opts['Proc'], opts['VirtualDirectory'])
-		else
-			raise ArgumentError, "You must specify a procedure."
-		end
-	end
-
-	#
-	# Removes the supplied resource handler.
-	#
-	def remove_resource(name)
-		self.resources.delete(name)
-	end
-
-	#
-	# Adds Server headers and stuff.
-	#
-	def add_response_headers(resp)
-		resp['Server'] = self.server_name
-	end
-
-	#
-	# Returns the mime type associated with the supplied file.  Right now the
-	# set of mime types is fairly limited.
-	#
-	def mime_type(file)
-		type = nil
-
-		if (file =~ /\.(.+?)$/)
-			type = ExtensionMimeTypes[$1.downcase]
-		end
-
-		type || "text/plain"
-	end
-
-	#
-	# Sends a 404 error to the client for a given request.
-	#
-	def send_e404(cli, request)
-		resp = Response::E404.new
-
-		resp['Content-Type'] = 'text/html'
-
-		resp.body =
-			"<html><head>" +
-			"<title>404 Not Found</title>" +
-			"</head><body>" +
-			"<h1>Not found</h1>" +
-			"The requested URL #{html_escape(request.resource)} was not found on this server.<p><hr>" +
-			"</body></html>"
-
-		# Send the response to the client like what
-		cli.send_response(resp)
-	end
-
-	attr_accessor :listen_port, :listen_host, :server_name, :context, :ssl, :comm
-	attr_accessor :listener, :resources
-
-protected
-
-	#
-	# Extends new clients with the ServerClient module and initializes them.
-	#
-	def on_client_connect(cli)
-		cli.extend(ServerClient)
-
-		cli.init_cli(self)
-	end
-
-	#
-	# Processes data coming in from a client.
-	#
-	def on_client_data(cli)
-		begin
-			#
-			# XXX: Handle ParseCode::Partial
-			#
-			data = cli.get
-
-			raise ::EOFError if not data
-			raise ::EOFError if data.empty?
-
-			case cli.request.parse(data)
-				when Packet::ParseCode::Completed
-					dispatch_request(cli, cli.request)
-
-					cli.reset_cli
-				when Packet::ParseCode::Error
-					close_client(cli)
-			end
-		rescue EOFError
-			if (cli.request.completed?)
-				dispatch_request(cli, cli.request)
-
-				cli.reset_cli
-			end
-
-			close_client(cli)
-		end
-	end
-
-	#
-	# Dispatches the supplied request for a given connection.
-	#
-	def dispatch_request(cli, request)
-		# Is the client requesting keep-alive?
-		if ((request['Connection']) and
-		   (request['Connection'].downcase == 'Keep-Alive'.downcase))
-			cli.keepalive = true
-		end
-
-		# Search for the resource handler for the requested URL.  This is pretty
-		# inefficient right now, but we can spruce it up later.
-		p    = nil
-		len  = 0
-		root = nil
-
-		resources.each_pair { |k, val|
-			if (request.resource =~ /^#{k}/ and k.length > len)
-				p    = val
-				len  = k.length
-				root = k
-			end
-		}
-
-		if (p)
-			# Create an instance of the handler for this resource
-			handler = p[0].new(self, *p[2])
-
-			# If the handler class requires a relative resource...
-			if (handler.relative_resource_required?)
-				# Substituted the mount point root in the request to make things
-				# relative to the mount point.
-				request.relative_resource = request.resource.gsub(/^#{root}/, '')
-				request.relative_resource = '/' + request.relative_resource if (request.relative_resource !~ /^\//)
-			end
-
-
-			# If we found the resource handler for this resource, call its
-			# procedure.
-			if (p[1] == true)
-				Rex::ThreadFactory.spawn("HTTPServerRequestHandler", false) {
-					handler.on_request(cli, request)
-				}
-			else
-				handler.on_request(cli, request)
-			end
-		else
-			elog("Failed to find handler for resource: #{request.resource}",
-				LogSource)
-
-			send_e404(cli, request)
-		end
-
-		# If keep-alive isn't enabled for this client, close the connection
-		if (cli.keepalive == false)
-			close_client(cli)
-		end
-	end
-
-end
-
-end
-end
-end
-

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

@@ -1,79 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift(File.join(File.dirname(__FILE__), '..', '..', '..'))
-
-require 'test/unit'
-require 'rex/proto/http'
-
-class Rex::Proto::Http::Server::UnitTest < Test::Unit::TestCase
-
-	ListenPort = 8090
-	ListenHost = '127.0.0.1'
-
-	SrvKlass = Rex::Proto::Http::Server
-	CliKlass = Rex::Proto::Http::Client
-
-	def test_server
-		begin
-			s   = start_srv
-			c   = CliKlass.new(ListenHost, ListenPort)
-
-			1.upto(10) { 
-				req = c.request_raw('uri' => '/')
-				res = c.send_recv(req)
-				assert_not_nil(res)
-				assert_equal(404, res.code)
-			}
-		ensure
-			stop_srv
-		end
-	end
-
-	def test_resource
-		begin
-			s   = start_srv
-			c   = CliKlass.new(ListenHost, ListenPort)
-
-			s.add_resource('/foo', 
-				'Proc' => Proc.new { |cli, req|
-					resp = Rex::Proto::Http::Response::OK.new
-
-					resp.body = "Chickens everywhere"
-				
-					cli.send_response(resp)
-				})
-
-			1.upto(10) { 
-				req = c.request_raw('uri' => '/foo')
-				res = c.send_recv(req)
-				assert_not_nil(res)
-				assert_equal(200, res.code)
-				assert_equal("Chickens everywhere", res.body)
-			}
-
-			s.remove_resource('/foo')
-
-			req = c.request_raw('uri' => '/foo')
-			res = c.send_recv(req)
-			assert_not_nil(res)
-			assert_equal(404, res.code)
-		ensure
-			stop_srv
-		end
-	end
-
-protected
-
-	def start_srv
-		self.srv = SrvKlass.new(ListenPort, ListenHost)
-		self.srv.start
-		self.srv
-	end
-
-	def stop_srv
-		self.srv.stop if (self.srv)
-	end
-
-attr_accessor :srv
-
-end

data/lib/rex/proto/ntlm.rb

@@ -1,7 +0,0 @@
-require 'rex/proto/ntlm/constants'
-require 'rex/proto/ntlm/exceptions'
-require 'rex/proto/ntlm/crypt'
-require 'rex/proto/ntlm/utils'
-require 'rex/proto/ntlm/base'
-require 'rex/proto/ntlm/message'
-