drbservice 1.0.4

data/examples/rubyversion.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'drbservice'
+require 'drbservice/passwordauth'
+
+# An example service that just returns the version of Ruby running on the
+# current machine.
+class RubyVersionService < DRbService
+	include DRbService::PasswordAuthentication
+
+	service_password '6d4bf8ac6490219f4f8807dad066d742f39a2d25501ae66d650cb647cd758979'
+
+	### Fetch the version of Ruby running this service as a vector of
+	### three network-byte-order shorts.
+	def ruby_version
+		return RUBY_VERSION.split( /\./, 3 ).map( &:to_i ).pack( 'n*' )
+	end
+
+end
+
+RubyVersionService.start( 
+	:ip       => '127.0.0.1',
+	:port     => 4848, 
+	:certfile => 'service.pem',
+	:keyfile  => 'service.pem' )
+

data/lib/drb/authsslprotocol.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require 'uri'
+
+require 'drb'
+require 'drb/ssl'
+
+module DRb
+
+	# A DRb protocol implementation that provides an authenticated, encrypted channel
+	# for DRb services.
+	class DRbAuthenticatedSSLSocket < DRbSSLSocket
+
+		# The scheme of URIs which specify this protocol
+		SCHEME = 'drbauthssl'
+
+
+		### Parse a drbauthssl:// URI. Accepts a String, a URI, or any object that responds to 
+		### #host, #port, and #query.
+		### Return the values from the URI as an Array of the form: [ host, port, optionhash ].
+		### Raises DRbBadScheme if the +uri+ is not a +drbauthssl+ URI.
+		### Raises DRbBadURI if the +uri+ is missing the port number.
+		def self::parse_uri( uri )
+			uri = URI( uri ) unless uri.respond_to?( :host )
+			raise DRbBadScheme, "not a #{SCHEME} URI: %p" % [ uri ] unless 
+				uri.scheme == SCHEME
+			raise DRbBadURI, "missing the port number" unless
+				uri.port && uri.port.to_i.nonzero?
+
+			return [ uri.host, uri.port.to_i, uri.query ]
+		end
+
+
+		### Open a client connection to the server at +uri+, using configuration 
+		### +config+.  Return a protocol instance for this connection.
+		def self::open( uri, config )
+			host, port, option = self.parse_uri( uri )
+			host.untaint
+			port.untaint
+			soc = TCPSocket.open( host, port )
+			ssl_conf = DRb::DRbSSLSocket::SSLConfig.new( config )
+			ssl_conf.setup_ssl_context
+			ssl = ssl_conf.connect( soc )
+			self.new( uri, ssl, ssl_conf, true )
+		end
+
+
+	end # class DRbAuthenticatedSSLSocket
+
+
+	DRbProtocol.add_protocol( DRbAuthenticatedSSLSocket )
+
+end # module DRb
+
+

data/lib/drbservice.rb

@@ -0,0 +1,208 @@
+#!/usr/bin/env ruby
+
+require 'drb'
+require 'drb/ssl'
+
+
+# A base class for DRb-based services. Concrete subclasses must define the service API by 
+# declaring public methods. By default, any public methods are hidden until the client 
+# authenticates. You can optionally declare a subset of its API that is # accessible before 
+# authentication by wrapping them in an 'unguarded' block. # See DRbService::unguarded for 
+# more details. 
+class DRbService
+	require 'drbservice/utils'
+	include DRbUndumped,
+	        DRbService::Logging
+
+	# Library version
+	VERSION = '1.0.4'
+
+	# Version-control revision
+	REVISION = %$Revision: 59c8e5acd8bb $
+
+	# The default IP address to listen on
+	DEFAULT_IP = '127.0.0.1'
+
+	# The default port to listen on
+	DEFAULT_PORT = 4848
+
+	# The default path to the service cert, relative to the current directory
+	DEFAULT_CERTNAME = 'service-cert.pem'
+
+	# The default path to the service key, relative to the current directory
+	DEFAULT_KEYNAME = 'service-key.pem'
+
+	# The default values for the drbservice config hash
+	DEFAULT_CONFIG = {
+		:ip       => DEFAULT_IP,
+		:port     => DEFAULT_PORT,
+		:certfile => DEFAULT_CERTNAME,
+		:keyfile  => DEFAULT_KEYNAME,
+	}
+
+	# The container for obscured methods
+	class << self
+		attr_reader :real_methods
+	end
+
+
+	#################################################################
+	###	C L A S S   M E T H O D S
+	#################################################################
+
+	### Start the DRbService, using the ip, port, and cert information from the given +config+ 
+	### hash.
+	###
+	### [:ip]       the ip to bind to
+	### [:port]     the port to listen on
+	### [:certfile] the name of the server's SSL certificate file
+	### [:keyfile]  the name of the server's SSL key file
+	### 
+	def self::start( config={} )
+		config = DEFAULT_CONFIG.merge( config )
+
+		frontobj = self.new( config )
+		uri = "drbssl://%s:%d" % config.values_at( :ip, :port )
+
+		cert = OpenSSL::X509::Certificate.new( File.read(config[:certfile]) )
+		key  = OpenSSL::PKey::RSA.new( File.read(config[:keyfile]) )
+
+		config = {
+			:safe_level     => 1,
+			:verbose        => true,
+	        :SSLCertificate => cert,
+	        :SSLPrivateKey  => key,
+		}
+
+		DRbService.log.info "Starting %p as a DRbService at %s" % [ self, uri ]
+		server = DRb::DRbServer.new( uri, frontobj, config )
+		DRbService.log.debug "  started. Joining the DRb thread."
+		$0 = "%s %s" % [ self.name, uri ]
+		server.thread.join
+	end
+
+
+	### Method-addition callback: Obscure the method +meth+ unless unguarded mode is enabled.
+	def self::method_added( meth )
+		super
+
+		unless self == ::DRbService || meth.to_sym == :initialize
+			if !self.public_instance_methods.collect( &:to_sym ).include?( meth )
+				DRbService.log.debug "Not obsuring %p#%s: not a public method" % [ self, meth ]
+			elsif self.unguarded_mode
+				DRbService.log.debug "Not obscuring %p#%s: unguarded mode." % [ self, meth ]
+			else
+				DRbService.log.debug "Obscuring %p#%s." % [ self, meth ]
+				@real_methods ||= {}
+				@real_methods[ meth.to_sym ] = self.instance_method( meth )
+				remove_method( meth )
+			end
+		end
+	end
+
+
+	### Inheritance callback: Add a per-class 'unguarded mode' flag to subclasses.
+	def self::inherited( subclass )
+		self.log.debug "Setting @unguarded_mode in %p" % [ subclass ]
+		subclass.instance_variable_set( :@unguarded_mode, false )
+		super
+	end
+
+
+	### Declare some service methods that can be called without authentication in
+	### the provided block.
+	def self::unguarded
+		self.unguarded_mode = true
+		yield
+	ensure
+		self.unguarded_mode = false
+	end
+
+
+	### Return the library's version string
+	def self::version_string( include_buildnum=false )
+		vstring = "%s %s" % [ self.name, VERSION ]
+		vstring << " (build %s)" % [ REVISION[/.*: ([[:xdigit:]]+)/, 1] || '0' ] if include_buildnum
+		return vstring
+	end
+
+
+	### Class accessors
+	class << self
+
+		# The unguarded mode flag -- instance methods defined while this flag is set
+		# will not be hidden
+		attr_accessor :unguarded_mode
+
+	end
+
+
+	#################################################################
+	###	I N S T A N C E   M E T H O D S
+	#################################################################
+
+	### Create a new instance of the service.
+	### Raises a ScriptError if DRbService is instantiated directly.
+	def initialize( config={} )
+		raise ScriptError,
+			"can't instantiate #{self.class} directly: please subclass it instead" if
+			self.class == DRbService
+		@authenticated = false
+	end
+
+
+	######
+	public
+	######
+
+	### Return a human-readable representation of the object.
+	def inspect
+		return "#<%s:0x%0x>" % [ self.class, self.__id__ * 2 ]
+	end
+
+
+	### Returns +true+ if the client has successfully authenticated.
+	def authenticated?
+		return @authenticated ? true : false
+	end
+
+
+	### Returns +true+ if the client has successfully authenticated and is authorized 
+	### to use the service. By default, authentication is sufficient for authorization;
+	### to specify otherwise, override this method in your service's subclass or 
+	### include an auth mixin that provides one.
+	def authorized?
+		return self.authenticated?
+	end
+
+
+	### Default authentication implementation -- always fails. You'll need to include
+	### one of the authentication modules or provide your own #authenticate method in
+	### your subclass.
+	def authenticate( *args )
+		self.log.error "authentication failure (fallback method)"
+		raise SecurityError, "authentication failure"
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Handle calls to guarded methods by requiring the authentication flag be
+	### set if there is a password set.
+	def method_missing( sym, *args )
+		return super unless body = self.class.real_methods[ sym ]
+
+		if self.authorized?
+			return body.clone.bind( self ).call( *args )
+		else
+			self.log.error "Guarded method %p called without authentication!" % [ sym ]
+			raise SecurityError, "not authenticated"
+		end
+	end
+
+
+end # class DRbService
+
+

data/lib/drbservice/ldapauth.rb

@@ -0,0 +1,200 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+require 'treequel'
+require 'drbservice'
+
+# An authentication strategy for DRbService -- set a password via a 
+# class method.
+module DRbService::LDAPAuthentication
+
+	### Methods added to including classes when LDAPAuthentication is
+	### mixed in.
+	module ClassMethods
+
+		# The default attributes of a search
+		DEFAULT_SEARCH = {
+			:filter => 'uid=%s',
+			:base   => nil,
+			:scope  => :sub,
+		}.freeze
+
+
+		### Extension callback -- add the necessary class instance variables
+		### to extended modules.
+		def self::extended( mod )
+			super
+			mod.instance_variable_set( :@ldap_uri, nil )
+			mod.instance_variable_set( :@ldap_dn, nil )
+			mod.instance_variable_set( :@ldap_dn_search, DEFAULT_SEARCH.dup )
+			mod.instance_variable_set( :@ldap_authz_callback, nil )
+		end
+
+
+		### Set the URI of the LDAP server to bind to for authentication
+		def ldap_uri( uri=nil )
+			@ldap_uri = uri if uri
+			return @ldap_uri
+		end
+
+
+		### Set the pattern to use when creating the DN to use when binding.
+		def ldap_dn( pattern=nil )
+			@ldap_dn = pattern if pattern
+			return @ldap_dn
+		end
+
+
+		### Set a filter that is used when searching for an account to bind
+		### as.
+		def ldap_dn_search( filter=nil, options={} )
+			if filter
+				@ldap_dn_search ||= {}
+				@ldap_dn_search[:filter] = filter
+				@ldap_dn_search[:base] = options[:base] if options[:base]
+				@ldap_dn_search[:scope] = options[:scope] if options[:scope]
+			end
+
+			return @ldap_dn_search
+		end
+
+
+		### Register a function to call when the user successfully binds to the
+		### directory to check for authorization. It will be called with the 
+		### Treequel::Branch of the bound user and the Treequel::Directory they
+		### are bound to. Returning +true+ from this function will cause 
+		### authorization to succeed, while returning a false value causes it to 
+		### fail.
+		def ldap_authz_callback( callable=nil, &block )
+			if callable
+				@ldap_authz_callback = callable
+			elsif block
+				@ldap_authz_callback = block
+			end
+
+			return @ldap_authz_callback
+		end
+
+	end # module ClassMethods
+
+
+	### Overridden mixin callback -- add the ClassMethods to the including class 
+	def self::included( klass )
+		super
+		klass.extend( ClassMethods )
+	end
+
+
+	### Set up some instance variables used by the mixin.
+	def initialize( *args )
+		super
+		@authenticated	 = false
+		@authuser		 = nil
+		@authuser_branch = nil
+	end
+
+
+	# the username of the authenticated user
+	attr_reader :authuser
+
+	# the Treequel::Branch of the authenticated user
+	attr_reader :authuser_branch
+
+
+ 	### Authenticate using the specified +password+, calling the provided block if 
+	### authentication succeeds. Raises a SecurityError if authentication fails. If
+	### no password is set, the block is called regardless of what the +password+ is.
+	def authenticate( user, password )
+		uri = self.class.ldap_uri
+		self.log.debug "Connecting to %p for authentication" % [ uri ]
+		directory = Treequel.directory( uri )
+		self.log.debug "  finding LDAP record for: %p" % [ user ]
+		user_branch = self.find_auth_user( directory, user ) or
+			return super
+
+		self.log.debug "  binding as %p (%p)" % [ user, user_branch ]
+		directory.bind_as( user_branch, password )
+		self.log.debug "  bound successfully..."
+
+		@authenticated = true
+
+		if cb = self.class.ldap_authz_callback
+			self.log.debug "  calling authorization callback..."
+
+			unless self.call_authz_callback( cb, user_branch, directory )
+				msg = "  authorization failed for: %s" % [ user_branch ]
+				self.log.debug( msg )
+				raise SecurityError, msg
+			end
+
+			self.log.debug "  authorization succeeded."
+		end
+
+		@authuser = user
+		@authuser_branch = user
+		yield
+
+	rescue LDAP::ResultError => err
+		self.log.error "  authentication failed for %p" % [ user_branch || user ]
+		raise SecurityError, "authentication failure"
+
+	ensure
+		@authuser = nil
+		@authuser_branch = nil
+		@authenticated = false
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Find the specified +username+ entry in the given +directory+, which should be a 
+	### Treequel::Directory. Returns the Treequel::Branch for the first found user, if one 
+	### was found, or +nil+ if no such user was found.
+	def find_auth_user( directory, username )
+		self.log.debug "Finding the user to bind as."
+
+		if dnpattern = self.class.ldap_dn
+			self.log.debug "  using DN pattern %p" % [ dnpattern ]
+			dn = dnpattern % [ username ]
+			user = Treequel::Branch.new( directory, dn )
+			return user.exists? ? user : nil
+
+		else
+			dnsearch = self.class.ldap_dn_search
+			usersearch = dnsearch[:base] ?
+				Treequel::Branch.new( directory, dnsearch[:base] ) :
+				directory.base
+			usersearch = usersearch.scope( dnsearch[:scope] ) if dnsearch[:scope]
+			usersearch = usersearch.filter( dnsearch[:filter] % [username] )
+
+			self.log.debug "  using filter: %s" % [ usersearch ]
+			if user = usersearch.first
+				self.log.debug "    search found: %s" % [ user ]
+				return user
+			else
+				self.log.error "    search returned no entries" % [ usersearch ]
+				return nil
+			end
+		end
+
+	end
+
+
+	### Call the authorization callback with the given +user+ and +directory+ and
+	### return true if it indicates authorization was successful. 
+	def call_authz_callback( callback, user, directory )
+
+		if callback.respond_to?( :call )
+			return true if callback.call( user, directory )
+
+		else callback = self.method( callback )
+			return true if callback.call( user, directory )
+		end
+
+	end
+
+end # DRbService::LDAPAuthentication
+
+