processwanker 0.0.7

data/lib/net/net_connection.rb

@@ -0,0 +1,167 @@
+############################################################################
+#
+# net_connection.rb
+#
+# handles the physical TCP/SSL connection between client(s) and daemon(s)
+#
+############################################################################
+
+require 'openssl'
+require 'config'
+require 'thread'
+require 'util'
+
+module ProcessWanker
+	
+  ############################################################################
+  #
+  #
+  #
+  ############################################################################
+
+	class NetConnection
+		include Log
+	
+		attr_accessor				:ssl_connection	
+		attr_accessor				:user
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def initialize(ssl_connection)
+			@write_mutex=Mutex.new
+			@ssl_connection=ssl_connection
+			@read_thread = Thread.new { read_proc }
+			@user = ssl_connection.peer_cert.subject.to_a.select { |x| x[0]=="CN" }.map { |x| x[1] }[0]
+		end
+
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def wait
+			@read_thread.join
+		end
+
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def send_msg(msg)
+
+			@write_mutex.synchronize do			
+				debug("sending message #{msg.inspect}")
+				begin
+					data=Marshal.dump(msg)
+					length=[data.length].pack("N")
+					@ssl_connection.write(length + data)
+				rescue Exception => e
+					on_close()
+				end
+			end
+			
+		end
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def close_rudely()
+			ProcessWanker::with_logged_rescue("close_rudely",Log::DEBUG) do
+				@ssl_connection.io.close()
+			end
+			disconnect()
+		end
+
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def disconnect()
+			on_close()
+			if(Thread.current != @read_thread)
+				@read_thread.join
+			end
+		end
+
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def read_proc
+			while(@ssl_connection)
+				read_connection()
+			end
+		end
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+		def read_connection()
+			begin
+				length=@ssl_connection.read(4)
+				raise "closed" if(length.length != 4)
+				length=length.unpack("N")[0]
+				data=@ssl_connection.read(length)
+				raise "closed" if(data.length != length)
+				msg=Marshal.load(data)
+				on_msg(msg)
+			rescue Exception => e
+				on_close()
+			end
+		end
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+		def on_close()
+			ProcessWanker::with_logged_rescue("on_close",Log::DEBUG) do
+				@ssl_connection.close if(@ssl_connection)
+			end
+			@ssl_connection=nil
+		end
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+		def on_msg(msg)
+#			puts msg.inspect
+		end
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+	end
+
+end

data/lib/net/net_server.rb

@@ -0,0 +1,232 @@
+############################################################################
+#
+# net_server.rb
+#
+# accept incoming TLS connections, parse and dispatch requests
+#
+############################################################################
+
+require 'openssl'
+require 'config'
+require 'net_util'
+require 'socket'
+require 'net_server_client'
+require 'thread'
+require 'config_daemon'
+
+module ProcessWanker
+	
+  ############################################################################
+  #
+  #
+  #
+  ############################################################################
+
+	class TCPFilteredServer < TCPServer
+		
+		include Log
+		
+		def initialize(hostname,port,auth)
+			@auth=auth
+			super(hostname,port)
+		end
+		
+		def accept()
+			while(true)
+				con=super()
+        debug("got TCP connection from #{con.peeraddr.inspect}")
+				return(con) if(validate_auth(con))
+				ProcessWanker::with_logged_rescue("accept - reject remote addr") do
+					con.close()
+				end
+			end
+		end
+		
+		def validate_auth(con)
+
+			remote_addr=con.peeraddr[3]
+			remote_addr=IPAddr.new(remote_addr)
+			
+			if(!@auth.allow_ip(remote_addr))
+				info("reject ip #{remote_addr.inspect}")
+				return(false)
+			end
+			
+			true
+		end
+		
+	end
+
+  ############################################################################
+  #
+  #
+  #
+  ############################################################################
+
+	class NetServer
+	
+		include Log
+	
+		@@instance=nil	
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def initialize(cfg)
+			
+			@@instance=self
+			@mutex=Mutex.new
+			@clients=[]
+			
+			daemon=cfg.daemon
+			auth=daemon.get_auth
+			@auth=auth
+
+			# check that we're not using default certs and listening anything other than
+			# localhost.
+			if(@auth.is_default)
+				if(daemon.listen_hostname != ConfigDaemon::DEFAULT_LISTEN_HOSTNAME)
+					
+					error "***"
+					error "*** For security reasons, I will only listen on #{ConfigDaemon::DEFAULT_LISTEN_HOSTNAME} while using"
+					error "*** the default built-in SSL certificates. You must generate real"
+					error "*** certificates if you wish to control this daemon remotely."
+					error "***"
+					
+					daemon.listen_hostname=ConfigDaemon::DEFAULT_LISTEN_HOSTNAME
+					
+				end
+			end
+			
+			@ca_cert=auth.ca_cert
+			@context=OpenSSL::SSL::SSLContext.new
+			@context.cert=auth.my_cert
+			@context.key=auth.my_key
+			@context.verify_mode=OpenSSL::SSL::VERIFY_PEER
+			@context.verify_callback=proc do |preverify_ok,ssl_context|
+				verify_peer(preverify_ok,ssl_context)
+			end
+
+#			@tcp_server=TCPServer.new(daemon.listen_hostname,daemon.listen_port)
+			@tcp_server=TCPFilteredServer.new(daemon.listen_hostname,daemon.listen_port,auth)
+			@ssl_server=OpenSSL::SSL::SSLServer.new(@tcp_server,@context)
+			
+			@server_thread=Thread.new { server_proc }
+			
+		end
+
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def stop_server()
+			@ssl_server.close
+			@server_thread.join
+			c=@clients.clone
+			c.each do |c|
+				c.disconnect()
+			end
+		end
+
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def verify_peer(preverify_ok,ssl_context)
+			if(!ssl_context.current_cert.verify(@ca_cert.public_key))
+				info("client certificate rejected")
+				return(false)
+			end
+			peer_name=ssl_context.current_cert.subject.to_a.select { |x| x[0]=="CN" }.map { |x| x[1] }[0]
+			info("verified identity of #{peer_name}")
+
+			if(@auth.accept_peers && !@auth.accept_peers[peer_name])
+				info("failed to accept peer #{peer_name}")
+				return(false)
+			end
+			if(@auth.reject_peers && @auth.reject_peers[peer_name])
+				info("rejected peer #{peer_name}")
+				return(false)
+			end
+			
+			true
+		end
+
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def server_proc
+			
+			while(true)
+				begin
+					ssl_connection=@ssl_server.accept
+				rescue OpenSSL::SSL::SSLError => e
+					next
+				rescue Errno::EBADF
+					break
+				end
+				
+				@mutex.synchronize do
+					nc=NetServerClient.new(ssl_connection,self)
+					info("new connection from #{nc.user}")
+					@clients << nc
+				end
+			end
+			info("server stopped")
+			
+		end
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def client_closed(client)
+			@mutex.synchronize do
+				@clients.delete(client)
+			end
+		end
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+		def post_fork()
+			c=nil
+			@mutex.synchronize do
+				c=@clients.clone
+			end
+			c.each do |client|
+				client.close_rudely()
+			end
+			ProcessWanker::with_logged_rescue("post_fork - stop_server") do
+				stop_server()
+			end
+		end	
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+		def self.instance
+			@@instance
+		end	
+	
+	end
+
+end

data/lib/net/net_server_client.rb

@@ -0,0 +1,84 @@
+############################################################################
+#
+# net_server_client.rb
+#
+# server's view of a client connection
+#
+############################################################################
+
+require 'openssl'
+require 'config'
+require 'net_util'
+require 'socket'
+require 'net_connection'
+require 'thread'
+
+module ProcessWanker
+	
+  ############################################################################
+  #
+  #
+  #
+  ############################################################################
+
+	class NetServerClient < NetConnection
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def initialize(ssl_connection,server)
+			@server=server
+			super(ssl_connection)
+		end
+
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+		def on_msg(msg)
+			super(msg)
+			ProcessWanker::with_logged_rescue("NetServerClient::on_msg") do
+				resp=NetApi::execute(msg,self)
+				if(resp)
+					debug("send resp #{resp.inspect}")
+					resp[:done]=true
+					send_msg(resp)
+				end			
+			end
+		end
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+		def inform(msg)
+			send_msg( { :info => msg } )
+		end
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+		def on_close()
+			super()
+			@server.client_closed(self)
+		end
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+	end
+
+end

data/lib/net/net_util.rb

@@ -0,0 +1,205 @@
+############################################################################
+#
+# net_util.rb
+#
+# handles the physical TCP/SSL connection between client(s) and daemon(s)
+#
+############################################################################
+
+require 'openssl'
+require 'fileutils'
+
+module ProcessWanker
+	
+  ############################################################################
+  #
+  #
+  #
+  ############################################################################
+
+	module NetUtil
+	
+		DEFAULT_PORT			=			45231
+
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+
+		def make_filename(prefix,type)
+			ext={ :key => "key", :cert => "crt" }[type]
+			"#{prefix}.#{ext}"
+		end
+		module_function				:make_filename
+	
+	  ############################################################################
+	  #
+	  # generate_ca
+	 	#
+	 	# create a new CA certificate and private key
+	  #
+	  ############################################################################
+
+		def generate_ca(prefix,passphrase=nil)
+
+			outdir=File.expand_path(File.dirname("#{prefix}a.b"))
+			FileUtils.mkdir_p(outdir)
+
+			#
+			# write key file
+			#
+			
+			puts "generating CA key..."
+			key = OpenSSL::PKey::RSA.new(2048)
+			cipher = OpenSSL::Cipher::Cipher.new('AES-128-CBC')
+			exp = passphrase ? key.export(cipher,passphrase) : key.export
+			puts "saving CA key..."
+			File.open(make_filename(prefix,:key),"w") do |f|
+				f.write(exp)
+			end
+			
+			#
+			# generate certificate
+			#
+			
+			puts "generating CA cert..."
+			ca_name = OpenSSL::X509::Name.parse('CN=ca')
+			ca_cert = OpenSSL::X509::Certificate.new
+			ca_cert.serial = 0
+			ca_cert.version = 2
+			ca_cert.not_before = Time.at(0)
+			ca_cert.not_after = Time.at(0x7fffffff)
+			ca_cert.public_key = key.public_key
+			ca_cert.subject = ca_name
+			ca_cert.issuer = ca_name
+
+			extension_factory = OpenSSL::X509::ExtensionFactory.new
+			extension_factory.subject_certificate = ca_cert
+			extension_factory.issuer_certificate = ca_cert
+
+			extension_factory.create_extension 'subjectKeyIdentifier', 'hash'
+			extension_factory.create_extension 'basicConstraints', 'CA:TRUE', true
+			extension_factory.create_extension 'keyUsage', 'cRLSign,keyCertSign', true
+
+			puts "signing CA cert..."
+			ca_cert.sign(key, OpenSSL::Digest::SHA1.new)
+
+			puts "saving CA cert..."
+			File.open(make_filename(prefix,:cert),"w") do |f|
+				f.write(ca_cert.to_pem)
+			end			
+			
+			puts "wrote #{make_filename(prefix,:key)} and #{make_filename(prefix,:cert)}"
+			
+		end
+
+		module_function			:generate_ca
+
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+		def generate_cert(ca_prefix,cert_prefix,name,passphrase=nil)
+			
+			outdir=File.expand_path(File.dirname("#{cert_prefix}a.b"))
+			FileUtils.mkdir_p(outdir)
+			
+			#
+			# load ca key and cert
+			#
+			
+			puts "loading CA key and cert..."
+			ca_key=OpenSSL::PKey::RSA.new( File.read(make_filename(ca_prefix,:key)) )
+			ca_cert=OpenSSL::X509::Certificate.new( File.read(make_filename(ca_prefix,:cert)) )
+			
+			#
+			# write key file
+			#
+			
+			puts "generating key for #{name}..."
+			key = OpenSSL::PKey::RSA.new(2048)
+			cipher = OpenSSL::Cipher::Cipher.new('AES-128-CBC')
+			exp = passphrase ? key.export(cipher,passphrase) : key.export
+			puts "saving key for #{name}..."
+			File.open(make_filename(cert_prefix,:key),"w") do |f|
+				f.write(exp)
+			end
+			
+			#
+			# generate CSR
+			#
+			
+			puts "generating CSR for #{name}..."
+			csr = OpenSSL::X509::Request.new
+			csr.version = 0
+			csr.subject = OpenSSL::X509::Name.parse("CN=#{name}")
+			csr.public_key = key.public_key
+			csr.sign(key,OpenSSL::Digest::SHA1.new)
+			
+			#
+			# create certificate
+			#
+			
+			puts "creating cert for #{name}..."
+			csr_cert = OpenSSL::X509::Certificate.new
+			csr_cert.serial = 0
+			csr_cert.version = 2
+			csr_cert.not_before = Time.at(0)
+			csr_cert.not_after = Time.at(0x7fffffff)
+
+			csr_cert.subject = csr.subject
+			csr_cert.public_key = csr.public_key
+			csr_cert.issuer = ca_cert.subject
+
+			extension_factory = OpenSSL::X509::ExtensionFactory.new
+			extension_factory.subject_certificate = csr_cert
+			extension_factory.issuer_certificate = ca_cert
+
+			extension_factory.create_extension 'basicConstraints', 'CA:FALSE'
+			extension_factory.create_extension 'keyUsage','keyEncipherment,dataEncipherment,digitalSignature'
+			extension_factory.create_extension 'subjectKeyIdentifier', 'hash'
+
+			puts "signing cert for #{name}..."
+			csr_cert.sign(ca_key,OpenSSL::Digest::SHA1.new)
+			
+			#
+			# save it
+			#
+			
+			puts "saving cert for #{name}..."
+			File.open(make_filename(cert_prefix,:cert),"w") do |f|
+				f.write(csr_cert.to_pem)
+			end			
+			
+			puts "wrote #{make_filename(cert_prefix,:key)} and #{make_filename(cert_prefix,:cert)}"
+			
+		end
+		module_function			:generate_cert
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+		def post_fork()
+
+			if(NetServer.instance())
+				NetServer.instance().post_fork()
+			end		
+		
+		end
+		module_function			:post_fork	
+	
+	  ############################################################################
+	  #
+	  #
+	  #
+	  ############################################################################
+	
+	end
+
+end