ruby-vnc 1.0.0

data/ChangeLog

@@ -0,0 +1,4 @@
+== 1.0.0 / 2008-08-29
+
+- First public release
+

data/README

@@ -0,0 +1,26 @@
+= Introduction
+
+The ruby-vnc library provides for simple rfb-protocol based control of a
+VNC server. This can be used, eg, to automate applications (sometimes there
+is no better way), or script some sort of interaction.
+
+Being VNC based gives it the advantage of being able to be run against
+servers on any platform.
+
+The primary documentation is for the Net::VNC class.
+
+= Thanks
+
+Code borrows a lot from Tim Waugh's excellent rfbplaymacro. So far all it
+really offers on top of that is access to the host clipboard, and the ease
+with which it can be scripted, ie taking conditional actions based on the
+contents thereof.
+
+= TODO
+
+* Having the ability to take and analyse screen dumps would be useful.
+
+* Finish the specs.
+
+* Fix issues with the way we use a background thread to handle the clipboard
+  etc chatter from the server.

data/Rakefile

@@ -0,0 +1,83 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+require 'spec/rake/verify_rcov'
+
+require File.dirname(__FILE__) + '/lib/net/vnc/version'
+
+PKG_NAME = 'ruby-vnc'
+PKG_VERSION = Net::VNC::VERSION
+
+task :default => :spec
+
+desc 'Run all specs'
+Spec::Rake::SpecTask.new :spec do |t|
+	t.spec_opts = ['--format specdoc --colour']
+end
+
+desc 'Run all specs and generate html spec document'
+namespace :spec do
+	Spec::Rake::SpecTask.new :html do |t|
+		t.spec_opts = ['--format html:spec.html']
+	end
+end
+
+desc 'Run all specs and generate coverage'
+Spec::Rake::SpecTask.new :rcov do |t|
+	t.rcov = true
+	t.rcov_opts = ['--exclude', 'spec']
+	t.rcov_opts << '--xrefs'
+	t.rcov_opts << '--text-report'
+end
+
+namespace :rcov do
+	RCov::VerifyTask.new :verify => :rcov do |t|
+		t.threshold = 100.0
+		t.index_html = 'coverage/index.html'
+	end
+end
+
+Rake::RDocTask.new do |t|
+	t.rdoc_dir = 'doc'
+	t.rdoc_files.include 'lib/**/*.rb'
+	t.rdoc_files.include 'README'
+	t.title = "#{PKG_NAME} documentation"
+	t.options += %w[--line-numbers --inline-source --tab-width 2]
+	t.main = 'README'
+end
+
+spec = Gem::Specification.new do |s|
+	s.name = PKG_NAME
+	s.version = PKG_VERSION
+	s.summary = %q{Ruby VNC library.}
+	s.description = %q{A library which implements the client VNC protocol to control VNC servers.}
+	s.authors = ['Charles Lowe']
+	s.email = %q{aquasync@gmail.com}
+	# not yet registered
+	#s.homepage = %q{http://code.google.com/p/ruby-vnc}
+	#s.rubyforge_project = %q{ruby-vnc}
+
+	# none yet
+	#s.executables = ['oletool']
+	s.files  = ['Rakefile', 'README', 'ChangeLog', 'data/keys.yaml']
+	s.files += FileList['lib/**/*.rb']
+	s.files += FileList['spec/*_spec.rb']
+	# is there an rspec equivalent?
+	#s.test_files = FileList['test/test_*.rb']
+
+	s.has_rdoc = true
+	s.rdoc_options += [
+		'--main', 'README',
+		'--title', "#{PKG_NAME} documentation",
+		'--tab-width', '2'
+	]
+end
+
+Rake::GemPackageTask.new(spec) do |t|
+	t.gem_spec = spec
+	t.need_tar = false
+	t.need_zip = false
+	t.package_dir = 'build'
+end
+

data/data/keys.yaml

@@ -0,0 +1,128 @@
+backspace:      0xff08
+tab:            0xff09
+linefeed:       0xff0a
+clear:          0xff0b
+return:         0xff0d
+pause:          0xff13
+scroll_lock:    0xff14
+sys_req:        0xff15
+escape:         0xff1b
+delete:         0xffff
+home:           0xff50
+left:           0xff51
+up:             0xff52
+right:          0xff53
+down:           0xff54
+prior:          0xff55
+page_up:        0xff55
+next:           0xff56
+page_down:      0xff56
+end:            0xff57
+begin:          0xff58
+select:         0xff60
+print:          0xff61
+execute:        0xff62
+insert:         0xff63
+undo:           0xff65
+redo:           0xff66
+menu:           0xff67
+find:           0xff68
+cancel:         0xff69
+help:           0xff6a
+break:          0xff6b
+mode_switch:    0xff7e
+script_switch:  0xff7e
+num_lock:       0xff7f
+kp_space:       0xff80
+kp_tab:         0xff89
+kp_enter:       0xff8d
+kp_f1:          0xff91
+kp_f2:          0xff92
+kp_f3:          0xff93
+kp_f4:          0xff94
+kp_home:        0xff95
+kp_left:        0xff96
+kp_up:          0xff97
+kp_right:       0xff98
+kp_down:        0xff99
+kp_prior:       0xff9a
+kp_page_up:     0xff9a
+kp_next:        0xff9b
+kp_page_down:   0xff9b
+kp_end:         0xff9c
+kp_begin:       0xff9d
+kp_insert:      0xff9e
+kp_delete:      0xff9f
+kp_equal:       0xffbd
+kp_multiply:    0xffaa
+kp_add:         0xffab
+kp_separator:   0xffac
+kp_subtract:    0xffad
+kp_decimal:     0xffae
+kp_divide:      0xffaf
+kp_0:           0xffb0
+kp_1:           0xffb1
+kp_2:           0xffb2
+kp_3:           0xffb3
+kp_4:           0xffb4
+kp_5:           0xffb5
+kp_6:           0xffb6
+kp_7:           0xffb7
+kp_8:           0xffb8
+kp_9:           0xffb9
+f1:             0xffbe
+f2:             0xffbf
+f3:             0xffc0
+f4:             0xffc1
+f5:             0xffc2
+f6:             0xffc3
+f7:             0xffc4
+f8:             0xffc5
+f9:             0xffc6
+f10:            0xffc7
+f11:            0xffc8
+f12:            0xffc9
+f13:            0xffca
+f14:            0xffcb
+f15:            0xffcc
+f16:            0xffcd
+f17:            0xffce
+f18:            0xffcf
+f19:            0xffd0
+f20:            0xffd1
+f21:            0xffd2
+f22:            0xffd3
+f23:            0xffd4
+f24:            0xffd5
+f25:            0xffd6
+f26:            0xffd7
+f27:            0xffd8
+f28:            0xffd9
+f29:            0xffda
+f30:            0xffdb
+f31:            0xffdc
+f32:            0xffdd
+f33:            0xffde
+f34:            0xffdf
+f35:            0xffe0
+left_shift:     0xffe1
+right_shift:    0xffe2
+left_control:   0xffe3
+right_control:  0xffe4
+caps_lock:      0xffe5
+shift_lock:     0xffe6
+left_meta:      0xffe7
+right_meta:     0xffe8
+left_alt:       0xffe9
+right_alt:      0xffea
+left_super:     0xffeb
+right_super:    0xffec
+left_hyper:     0xffed
+right_hyper:    0xffee
+# some convenience aliases
+shift:          0xffe1
+control:        0xffe3
+meta:           0xffe7
+alt:            0xffe9
+super:          0xffeb
+hyper:          0xffed

data/lib/cipher/des.rb

@@ -0,0 +1,439 @@
+module Cipher
+	#
+	# = Brief
+	#
+	# The Cipher::DES class allows for encryption and decryption of plain
+	# text using the "Data Encryption Standard". This version is the modified
+	# version which is part of the VNC authentication scheme.
+	#
+	# Usage is pretty straight forward:
+	#
+	#   des = Cipher::DES.new 'mysecretkey', :encrypt
+	#   str = des.update 'plain text'
+	#   str << des.update 'more plain text'
+	#   str << final
+	#
+	# Or just use the shortcut class methods:
+	#
+	#   str = Cipher::DES.encrypt 'mysecretkey', 'plain text'
+	#
+	# = About
+	#
+	# This code was ported from the file "d3des.c", for portability reasons.
+	# It is not expected to be quick, but is only being used currently for the
+	# VNC authentication handshake. If you wanted to cipher a lot of text, you
+	# should probably compile the original C as an extension.
+	#
+	# I've included the following copyright info from the C source verbatim:
+	#
+	#   This is D3DES (V5.09) by Richard Outerbridge with the double and
+	#   triple-length support removed for use in VNC.  Also the bytebit[] array
+	#   has been reversed so that the most significant bit in each byte of the
+	#   key is ignored, not the least significant.
+	#   
+	#   These changes are:
+	#   Copyright (C) 1999 AT&T Laboratories Cambridge.  All Rights Reserved.
+	#   
+	#   This software is distributed in the hope that it will be useful,
+	#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+	#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+	#   
+	#   D3DES (V5.09)
+	#   
+	#   A portable, public domain, version of the Data Encryption Standard.
+	#   
+	#   Written with Symantec's THINK (Lightspeed) C by Richard Outerbridge.
+	#   Thanks to: Dan Hoey for his excellent Initial and Inverse permutation
+	#   code;  Jim Gillogly & Phil Karn for the DES key schedule code; Dennis
+	#   Ferguson, Eric Young and Dana How for comparing notes; and Ray Lau,
+	#   for humouring me on.
+	# 
+	#   Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge.
+	#   (GEnie : OUTER; CIS : [71755,204]) Graven Imagery, 1992.
+	#
+	class DES
+		BLOCK_SIZE = 8
+
+		attr_reader :key, :mode
+
+		# Create a des cipher object. +key+ should be cipher key to use, and +mode+ should
+		# be either <tt>:encrypt</tt> or <tt>:decrypt</tt>.
+		#
+		# It will expand +key+ to be 8 bytes by padding with null bytes. If it is longer than
+		# 8 bytes, the additional data is discarded.
+		def initialize key, mode
+			unless [:encrypt, :decrypt].include? mode
+				raise ArgumentError, 'invalid mode argument - %s' % mode
+			end
+			@mode = mode
+
+			# ensure key is 8 bytes. pad with nulls as needed
+			key = key[0, BLOCK_SIZE]
+			key << 0.chr * (BLOCK_SIZE - key.length)
+			@key = key
+
+			# now expand the key schedule
+			@keys = self.class.send :prepare_key_stage2, self.class.send(:prepare_key_stage1, key, mode)
+
+			# this internal buffer is used because we must process data in chunks of 8 bytes
+			@buf = ''
+		end
+
+		# This updates the cipher with +data+, returning any available ciphered output. The +data+ is
+		# processed in blocks of 8 bytes, so any residual is added to an internal buffer.
+		def update data
+			result = ''
+			data = @buf + data unless @buf.empty?
+			num_blocks, residual = data.length.divmod BLOCK_SIZE
+			num_blocks.times do |i|
+				block = data[i * BLOCK_SIZE, BLOCK_SIZE].unpack('N2')
+				result << self.class.send(:desfunc, block, @keys).pack('N2')
+			end
+			@buf = residual == 0 ? '' : data[-residual..-1]
+			result
+		end
+
+		# This flushes the internal buffer by padding it out with null bytes, and doing a final
+		# DES round. Note that this means the ciphered text is always padded out to a multiple of
+		# 8 bytes.
+		def final
+			if @buf.empty?
+				''
+			else
+				update 0.chr * (BLOCK_SIZE - @buf.length)
+			end
+		end
+
+		# A shortcut method to create a cipher object using +key+, and fully encrypt +data+
+		def self.encrypt key, data
+			des = new key, :encrypt
+			des.update(data) << des.final
+		end
+
+		# A shortcut method to create a cipher object using +key+, and fully decrypt +data+
+		def self.decrypt key, data
+			des = new key, :decrypt
+			des.update(data) << des.final
+		end
+
+		class << self #:nodoc: all
+			BYTEBIT	= [
+				01, 02, 04, 010, 020, 040, 0100, 0200
+			]
+
+			BIGBYTE = [
+				0x800000, 0x400000, 0x200000, 0x100000,
+				0x080000, 0x040000, 0x020000, 0x010000,
+				0x008000, 0x004000, 0x002000, 0x001000,
+				0x000800, 0x000400, 0x000200, 0x000100,
+				0x000080, 0x000040, 0x000020, 0x000010,
+				0x000008, 0x000004, 0x000002, 0x000001
+			]
+
+			# Use the key schedule specified in the Standard (ANSI X3.92-1981).
+
+			PC1 = [
+				56, 48, 40, 32, 24, 16,  8,	 0, 57, 49, 41, 33, 25, 17,
+				 9,  1, 58, 50, 42, 34, 26,	18, 10,  2, 59, 51, 43, 35,
+				62, 54, 46, 38, 30, 22, 14,	 6, 61, 53, 45, 37, 29, 21,
+				13,  5, 60, 52, 44, 36, 28,	20, 12,  4, 27, 19, 11,  3 
+			]
+
+			TOTROT = [
+				1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28
+			]
+
+			PC2 = [
+				13, 16, 10, 23,  0,  4,  2, 27, 14,  5, 20,  9,
+				22, 18, 11,  3, 25,  7, 15,  6, 26, 19, 12,  1,
+				40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47,
+				43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31
+			]
+
+		private
+
+			#
+			# Prepares +key+ to be used
+			#
+			# +key+:: String
+			# +mode+:: :encrypt or :decrypt
+			#
+			# Thanks to James Gillogly & Phil Karn!
+			#
+			# corresponds to "deskey"
+			#
+			def prepare_key_stage1 key, mode
+				pcr = [nil] * 56
+				kn = [nil] * 32
+
+				pc1m = (0...56).map do |j|
+					l = PC1[j]
+					m = l & 07
+					(key[l >> 3] & BYTEBIT[m]) != 0 ? 1 : 0;
+				end
+
+				16.times do |i|
+					m = mode == :encrypt ? i << 1 : (15 - i) << 1
+					n = m + 1
+					kn[m] = kn[n] = 0
+					28.times do |j|
+						l = (j + TOTROT[i]) % 28
+						pcr[j] = pc1m[l]
+						pcr[j + 28] = pc1m[l + 28]
+					end
+					24.times do |j|
+						kn[m] |= BIGBYTE[j] if pcr[PC2[j]] != 0
+						kn[n] |= BIGBYTE[j] if pcr[PC2[j+24]] != 0
+					end
+				end
+
+				kn
+			end
+
+			# corresponds to "cookey"
+			def prepare_key_stage2(raw1)
+				cook = []
+
+				16.times do |i|
+					a = raw1[i * 2 + 0]
+					b = raw1[i * 2 + 1]
+					x  = (a & 0x00fc0000) << 6
+					x |= (a & 0x00000fc0) << 10
+					x |= (b & 0x00fc0000) >> 10
+					x |= (b & 0x00000fc0) >> 6
+					cook << x
+					x  = (a & 0x0003f000) << 12
+					x	|= (a & 0x0000003f) << 16
+					x	|= (b & 0x0003f000) >> 4
+					x |= (b & 0x0000003f)
+					cook << x
+				end
+
+				cook
+			end
+
+			SP1 = [
+				0x01010400, 0x00000000, 0x00010000, 0x01010404,
+				0x01010004, 0x00010404, 0x00000004, 0x00010000,
+				0x00000400, 0x01010400, 0x01010404, 0x00000400,
+				0x01000404, 0x01010004, 0x01000000, 0x00000004,
+				0x00000404, 0x01000400, 0x01000400, 0x00010400,
+				0x00010400, 0x01010000, 0x01010000, 0x01000404,
+				0x00010004, 0x01000004, 0x01000004, 0x00010004,
+				0x00000000, 0x00000404, 0x00010404, 0x01000000,
+				0x00010000, 0x01010404, 0x00000004, 0x01010000,
+				0x01010400, 0x01000000, 0x01000000, 0x00000400,
+				0x01010004, 0x00010000, 0x00010400, 0x01000004,
+				0x00000400, 0x00000004, 0x01000404, 0x00010404,
+				0x01010404, 0x00010004, 0x01010000, 0x01000404,
+				0x01000004, 0x00000404, 0x00010404, 0x01010400,
+				0x00000404, 0x01000400, 0x01000400, 0x00000000,
+				0x00010004, 0x00010400, 0x00000000, 0x01010004
+			]
+
+			SP2 = [
+				0x80108020, 0x80008000, 0x00008000, 0x00108020,
+				0x00100000, 0x00000020, 0x80100020, 0x80008020,
+				0x80000020, 0x80108020, 0x80108000, 0x80000000,
+				0x80008000, 0x00100000, 0x00000020, 0x80100020,
+				0x00108000, 0x00100020, 0x80008020, 0x00000000,
+				0x80000000, 0x00008000, 0x00108020, 0x80100000,
+				0x00100020, 0x80000020, 0x00000000, 0x00108000,
+				0x00008020, 0x80108000, 0x80100000, 0x00008020,
+				0x00000000, 0x00108020, 0x80100020, 0x00100000,
+				0x80008020, 0x80100000, 0x80108000, 0x00008000,
+				0x80100000, 0x80008000, 0x00000020, 0x80108020,
+				0x00108020, 0x00000020, 0x00008000, 0x80000000,
+				0x00008020, 0x80108000, 0x00100000, 0x80000020,
+				0x00100020, 0x80008020, 0x80000020, 0x00100020,
+				0x00108000, 0x00000000, 0x80008000, 0x00008020,
+				0x80000000, 0x80100020, 0x80108020, 0x00108000
+			]
+
+			SP3 = [
+				0x00000208, 0x08020200, 0x00000000, 0x08020008,
+				0x08000200, 0x00000000, 0x00020208, 0x08000200,
+				0x00020008, 0x08000008, 0x08000008, 0x00020000,
+				0x08020208, 0x00020008, 0x08020000, 0x00000208,
+				0x08000000, 0x00000008, 0x08020200, 0x00000200,
+				0x00020200, 0x08020000, 0x08020008, 0x00020208,
+				0x08000208, 0x00020200, 0x00020000, 0x08000208,
+				0x00000008, 0x08020208, 0x00000200, 0x08000000,
+				0x08020200, 0x08000000, 0x00020008, 0x00000208,
+				0x00020000, 0x08020200, 0x08000200, 0x00000000,
+				0x00000200, 0x00020008, 0x08020208, 0x08000200,
+				0x08000008, 0x00000200, 0x00000000, 0x08020008,
+				0x08000208, 0x00020000, 0x08000000, 0x08020208,
+				0x00000008, 0x00020208, 0x00020200, 0x08000008,
+				0x08020000, 0x08000208, 0x00000208, 0x08020000,
+				0x00020208, 0x00000008, 0x08020008, 0x00020200
+			]
+
+			SP4 = [
+				0x00802001, 0x00002081, 0x00002081, 0x00000080,
+				0x00802080, 0x00800081, 0x00800001, 0x00002001,
+				0x00000000, 0x00802000, 0x00802000, 0x00802081,
+				0x00000081, 0x00000000, 0x00800080, 0x00800001,
+				0x00000001, 0x00002000, 0x00800000, 0x00802001,
+				0x00000080, 0x00800000, 0x00002001, 0x00002080,
+				0x00800081, 0x00000001, 0x00002080, 0x00800080,
+				0x00002000, 0x00802080, 0x00802081, 0x00000081,
+				0x00800080, 0x00800001, 0x00802000, 0x00802081,
+				0x00000081, 0x00000000, 0x00000000, 0x00802000,
+				0x00002080, 0x00800080, 0x00800081, 0x00000001,
+				0x00802001, 0x00002081, 0x00002081, 0x00000080,
+				0x00802081, 0x00000081, 0x00000001, 0x00002000,
+				0x00800001, 0x00002001, 0x00802080, 0x00800081,
+				0x00002001, 0x00002080, 0x00800000, 0x00802001,
+				0x00000080, 0x00800000, 0x00002000, 0x00802080
+			]
+
+			SP5 = [
+				0x00000100, 0x02080100, 0x02080000, 0x42000100,
+				0x00080000, 0x00000100, 0x40000000, 0x02080000,
+				0x40080100, 0x00080000, 0x02000100, 0x40080100,
+				0x42000100, 0x42080000, 0x00080100, 0x40000000,
+				0x02000000, 0x40080000, 0x40080000, 0x00000000,
+				0x40000100, 0x42080100, 0x42080100, 0x02000100,
+				0x42080000, 0x40000100, 0x00000000, 0x42000000,
+				0x02080100, 0x02000000, 0x42000000, 0x00080100,
+				0x00080000, 0x42000100, 0x00000100, 0x02000000,
+				0x40000000, 0x02080000, 0x42000100, 0x40080100,
+				0x02000100, 0x40000000, 0x42080000, 0x02080100,
+				0x40080100, 0x00000100, 0x02000000, 0x42080000,
+				0x42080100, 0x00080100, 0x42000000, 0x42080100,
+				0x02080000, 0x00000000, 0x40080000, 0x42000000,
+				0x00080100, 0x02000100, 0x40000100, 0x00080000,
+				0x00000000, 0x40080000, 0x02080100, 0x40000100
+			]
+
+			SP6 = [
+				0x20000010, 0x20400000, 0x00004000, 0x20404010,
+				0x20400000, 0x00000010, 0x20404010, 0x00400000,
+				0x20004000, 0x00404010, 0x00400000, 0x20000010,
+				0x00400010, 0x20004000, 0x20000000, 0x00004010,
+				0x00000000, 0x00400010, 0x20004010, 0x00004000,
+				0x00404000, 0x20004010, 0x00000010, 0x20400010,
+				0x20400010, 0x00000000, 0x00404010, 0x20404000,
+				0x00004010, 0x00404000, 0x20404000, 0x20000000,
+				0x20004000, 0x00000010, 0x20400010, 0x00404000,
+				0x20404010, 0x00400000, 0x00004010, 0x20000010,
+				0x00400000, 0x20004000, 0x20000000, 0x00004010,
+				0x20000010, 0x20404010, 0x00404000, 0x20400000,
+				0x00404010, 0x20404000, 0x00000000, 0x20400010,
+				0x00000010, 0x00004000, 0x20400000, 0x00404010,
+				0x00004000, 0x00400010, 0x20004010, 0x00000000,
+				0x20404000, 0x20000000, 0x00400010, 0x20004010
+			]
+
+			SP7 = [
+				0x00200000, 0x04200002, 0x04000802, 0x00000000,
+				0x00000800, 0x04000802, 0x00200802, 0x04200800,
+				0x04200802, 0x00200000, 0x00000000, 0x04000002,
+				0x00000002, 0x04000000, 0x04200002, 0x00000802,
+				0x04000800, 0x00200802, 0x00200002, 0x04000800,
+				0x04000002, 0x04200000, 0x04200800, 0x00200002,
+				0x04200000, 0x00000800, 0x00000802, 0x04200802,
+				0x00200800, 0x00000002, 0x04000000, 0x00200800,
+				0x04000000, 0x00200800, 0x00200000, 0x04000802,
+				0x04000802, 0x04200002, 0x04200002, 0x00000002,
+				0x00200002, 0x04000000, 0x04000800, 0x00200000,
+				0x04200800, 0x00000802, 0x00200802, 0x04200800,
+				0x00000802, 0x04000002, 0x04200802, 0x04200000,
+				0x00200800, 0x00000000, 0x00000002, 0x04200802,
+				0x00000000, 0x00200802, 0x04200000, 0x00000800,
+				0x04000002, 0x04000800, 0x00000800, 0x00200002
+			]
+
+			SP8 = [
+				0x10001040, 0x00001000, 0x00040000, 0x10041040,
+				0x10000000, 0x10001040, 0x00000040, 0x10000000,
+				0x00040040, 0x10040000, 0x10041040, 0x00041000,
+				0x10041000, 0x00041040, 0x00001000, 0x00000040,
+				0x10040000, 0x10000040, 0x10001000, 0x00001040,
+				0x00041000, 0x00040040, 0x10040040, 0x10041000,
+				0x00001040, 0x00000000, 0x00000000, 0x10040040,
+				0x10000040, 0x10001000, 0x00041040, 0x00040000,
+				0x00041040, 0x00040000, 0x10041000, 0x00001000,
+				0x00000040, 0x10040040, 0x00001000, 0x00041040,
+				0x10001000, 0x00000040, 0x10000040, 0x10040000,
+				0x10040040, 0x10000000, 0x00040000, 0x10001040,
+				0x00000000, 0x10041040, 0x00040040, 0x10000040,
+				0x10040000, 0x10001000, 0x10001040, 0x00000000,
+				0x10041040, 0x00041000, 0x00041000, 0x00001040,
+				0x00001040, 0x00040040, 0x10000000, 0x10041000
+			]
+
+			def desfunc block, keys
+				leftt = block[0]
+				right = block[1]
+
+				work = ((leftt >> 4) ^ right) & 0x0f0f0f0f
+				right ^= work
+				leftt ^= (work << 4)
+				work = ((leftt >> 16) ^ right) & 0x0000ffff
+				right ^= work
+				leftt ^= (work << 16)
+				work = ((right >> 2) ^ leftt) & 0x33333333
+				leftt ^= work
+				right ^= (work << 2)
+				work = ((right >> 8) ^ leftt) & 0x00ff00ff
+				leftt ^= work
+				right ^= (work << 8)
+				right = ((right << 1) | ((right >> 31) & 1)) & 0xffffffff
+				work = (leftt ^ right) & 0xaaaaaaaa
+				leftt ^= work
+				right ^= work
+				leftt = ((leftt << 1) | ((leftt >> 31) & 1)) & 0xffffffff
+
+				8.times do |i|
+					work  = (right << 28) | (right >> 4)
+					work ^= keys[i * 4 + 0]
+					fval  = SP7[ work		 & 0x3f]
+					fval |= SP5[(work >>  8) & 0x3f]
+					fval |= SP3[(work >> 16) & 0x3f]
+					fval |= SP1[(work >> 24) & 0x3f]
+					work  = right ^ keys[i * 4 + 1]
+					fval |= SP8[ work		 & 0x3f]
+					fval |= SP6[(work >>  8) & 0x3f]
+					fval |= SP4[(work >> 16) & 0x3f]
+					fval |= SP2[(work >> 24) & 0x3f]
+					leftt ^= fval
+					work  = (leftt << 28) | (leftt >> 4)
+					work ^= keys[i * 4 + 2]
+					fval  = SP7[ work		 & 0x3f]
+					fval |= SP5[(work >>  8) & 0x3f]
+					fval |= SP3[(work >> 16) & 0x3f]
+					fval |= SP1[(work >> 24) & 0x3f]
+					work  = leftt ^ keys[i * 4 + 3]
+					fval |= SP8[ work		 & 0x3f]
+					fval |= SP6[(work >>  8) & 0x3f]
+					fval |= SP4[(work >> 16) & 0x3f]
+					fval |= SP2[(work >> 24) & 0x3f]
+					right ^= fval
+				end
+
+				right = ((right << 31) | (right >> 1)) & 0xffffffff
+				work = (leftt ^ right) & 0xaaaaaaaa
+				leftt ^= work
+				right ^= work
+				leftt = ((leftt << 31) | (leftt >> 1)) & 0xffffffff
+				work = ((leftt >> 8) ^ right) & 0x00ff00ff
+				right ^= work
+				leftt ^= (work << 8)
+				work = ((leftt >> 2) ^ right) & 0x33333333
+				right ^= work
+				leftt ^= (work << 2)
+				work = ((right >> 16) ^ leftt) & 0x0000ffff
+				leftt ^= work
+				right ^= (work << 16)
+				work = ((right >> 4) ^ leftt) & 0x0f0f0f0f
+				leftt ^= work
+				right ^= (work << 4)
+
+				[right, leftt]
+			end
+		end
+	end
+end
+

data/lib/net/vnc.rb

@@ -0,0 +1,306 @@
+require 'socket'
+require 'yaml'
+require 'thread'
+require 'cipher/des'
+require 'net/vnc/version'
+
+module Net
+	#
+	# The VNC class provides for simple rfb-protocol based control of
+	# a VNC server. This can be used, eg, to automate applications.
+	#
+	# Sample usage:
+	#
+	#	  # launch xclock on localhost. note that there is an xterm in the top-left
+	#   Net::VNC.open 'localhost:0', :shared => true, :password => 'mypass' do |vnc|
+	#     vnc.pointer_move 10, 10
+	#     vnc.type 'xclock'
+	#     vnc.key_press :return
+	#   end
+	#
+	# = TODO
+	#
+	# * The server read loop seems a bit iffy. Not sure how best to do it.
+	# * Should probably be changed to be more of a lower-level protocol wrapping thing, with the
+	#   actual VNCClient sitting on top of that. all it should do is read/write the packets over
+	#   the socket.
+	#
+	class VNC
+		class PointerState
+			attr_reader :x, :y, :button
+
+			def initialize vnc
+				@x = @y = @button = 0
+				@vnc = vnc
+			end
+
+			# could have the same for x=, and y=
+			def button= button
+				@button = button
+				refresh
+			end
+
+			def update x, y, button=@button
+				@x, @y, @button = x, y, button
+				refresh
+			end
+
+			def refresh
+				packet = 0.chr * 6
+				packet[0] = 5
+				packet[1] = button
+				packet[2, 2] = [x].pack 'n'
+				packet[4, 2] = [y].pack 'n'
+				@vnc.socket.write packet
+			end
+		end
+
+		BASE_PORT = 5900
+		CHALLENGE_SIZE = 16
+		DEFAULT_OPTIONS = {
+			:shared => false,
+			:wait => 0.1
+		}
+
+		keys_file = File.dirname(__FILE__) + '/../../data/keys.yaml'
+		KEY_MAP = YAML.load_file(keys_file).inject({}) { |h, (k, v)| h.update k.to_sym => v }
+		def KEY_MAP.[] key
+			super or raise ArgumentError.new('Invalid key name - %s' % key)
+		end
+
+		attr_reader :server, :display, :options, :socket, :pointer
+
+		def initialize display=':0', options={}
+			@server = 'localhost'
+			if display =~ /^(.*)(:\d+)$/
+				@server, display = $1, $2
+			end
+			@display = display[1..-1].to_i
+			@options = DEFAULT_OPTIONS.merge options
+			@clipboard = nil
+			@pointer = PointerState.new self
+			@mutex = Mutex.new
+			connect
+			@packet_reading_state = nil
+			@packet_reading_thread = Thread.new { packet_reading_thread }
+		end
+
+		def self.open display=':0', options={}
+			vnc = new display, options
+			if block_given?
+				begin
+					yield vnc
+				ensure
+					vnc.close
+				end
+			else
+				vnc
+			end
+		end
+
+		def port
+			BASE_PORT + @display
+		end
+
+		def connect
+			@socket = TCPSocket.open server, port
+			unless socket.read(12) =~ /^RFB (\d{3}.\d{3})\n$/
+				raise 'invalid server response'
+			end
+			@server_version = $1
+			socket.write "RFB 003.003\n"
+			data = socket.read(4)
+			auth = data.to_s.unpack('N')[0]
+			case auth
+			when 0, nil
+				raise 'connection failed'
+			when 1
+				# ok...
+			when 2
+				password = @options[:password] or raise 'Need to authenticate but no password given'
+				challenge = socket.read CHALLENGE_SIZE
+				response = Cipher::DES.encrypt password, challenge
+				socket.write response
+				ok = socket.read(4).to_s.unpack('N')[0]
+				raise 'Unable to authenticate - %p' % ok unless ok == 0
+			else
+				raise 'Unknown authentication scheme - %d' % auth
+			end
+
+			# ClientInitialisation
+			socket.write((options[:shared] ? 1 : 0).chr)
+
+			# ServerInitialisation
+			# TODO: parse this.
+			socket.read(20)
+			data = socket.read(4)
+			# read this many bytes in chunks of 20
+			size = data.to_s.unpack('N')[0]
+			while size > 0
+				len = [20, size].min
+				# this is the hostname, and other stuff i think...
+				socket.read(len)
+				size -= len
+			end
+		end
+
+		# this types +text+ on the server
+		def type text, options={}
+			packet = 0.chr * 8
+			packet[0] = 4
+			text.split(//).each do |char|
+				packet[7] = char[0]
+				packet[1] = 1
+				socket.write packet
+				packet[1] = 0
+				socket.write packet
+			end
+			wait options
+		end
+
+		# this takes an array of keys, and successively holds each down then lifts them up in
+		# reverse order.
+		# FIXME: should wait. can't recurse in that case.
+		def key_press(*args)
+			options = Hash === args.last ? args.pop : {}
+			keys = args
+			raise ArgumentError, 'Must have at least one key argument' if keys.empty?
+			begin
+				key_down keys.first
+				if keys.length == 1
+					yield if block_given?
+				else
+					key_press(*(keys[1..-1] + [options]))
+				end
+			ensure
+				key_up keys.first
+			end
+		end
+
+		def get_key_code which
+			if String === which
+				if which.length != 1
+					raise ArgumentError, 'can only get key_code of single character strings'
+				end
+				which[0]
+			else
+				KEY_MAP[which]
+			end
+		end
+		private :get_key_code
+
+		def key_down which, options={}
+			packet = 0.chr * 8
+			packet[0] = 4
+			key_code = get_key_code which
+			packet[4, 4] = [key_code].pack('N')
+			packet[1] = 1
+			socket.write packet
+			wait options
+		end
+
+		def key_up which, options={}
+			packet = 0.chr * 8
+			packet[0] = 4
+			key_code = get_key_code which
+			packet[4, 4] = [key_code].pack('N')
+			packet[1] = 0
+			socket.write packet
+			wait options
+		end
+
+		def pointer_move x, y, options={}
+			# options[:relative]
+			pointer.update x, y
+			wait options
+		end
+
+		BUTTON_MAP = {
+			:left => 0
+		}
+
+		def button_press button=:left, options={}
+			begin
+				button_down button, options
+				yield if block_given?
+			ensure
+				button_up button, options
+			end
+		end
+
+		def button_down which=:left, options={}
+			button = BUTTON_MAP[which] || which
+			raise ArgumentError, 'Invalid button - %p' % which unless (0..2) === button
+			pointer.button |= 1 << button
+			wait options
+		end
+
+		def button_up which=:left, options={}
+			button = BUTTON_MAP[which] || which
+			raise ArgumentError, 'Invalid button - %p' % which unless (0..2) === button
+			pointer.button &= ~(1 << button)
+			wait options
+		end
+
+		def wait options={}
+			sleep options[:wait] || @options[:wait]
+		end
+
+		def close
+			# destroy packet reading thread
+			if @packet_reading_state == :loop
+				@packet_reading_state = :stop
+				while @packet_reading_state
+					# do nothing
+				end
+			end
+			socket.close
+		end
+
+		def clipboard
+			if block_given?
+				@clipboard = nil
+				yield
+				60.times do
+					clipboard = @mutex.synchronize { @clipboard }
+					return clipboard if clipboard
+					sleep 0.5
+				end
+				warn 'clipboard still empty after 30s'
+				nil
+			else
+				@mutex.synchronize { @clipboard }
+			end
+		end
+
+		private
+
+		def read_packet type
+			case type
+			when 3 # ServerCutText
+				socket.read 3 # discard padding bytes
+				len = socket.read(4).unpack('N')[0]
+				@mutex.synchronize { @clipboard = socket.read len }
+			else
+				raise NotImplementedError, 'unhandled server packet type - %d' % type
+			end
+		end
+
+		def packet_reading_thread
+			@packet_reading_state = :loop
+			loop do
+				begin
+					break if @packet_reading_state != :loop
+					next unless IO.select [socket], nil, nil, 2
+					type = socket.read(1)[0]
+					read_packet type
+				rescue
+					warn "exception in packet_reading_thread: #{$!.class}:#{$!}"
+					break
+				end
+			end
+			@packet_reading_state = nil
+		end
+	end
+end
+

data/lib/net/vnc/version.rb

@@ -0,0 +1,6 @@
+module Net
+	class VNC
+		VERSION = '1.0.0'
+	end
+end
+

data/spec/cipher_des_spec.rb

@@ -0,0 +1,142 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'cipher/des'
+
+describe 'Cipher::DES' do
+	DES = Cipher::DES
+
+	DATA = [
+		['0xcafecafecafecafe', :encrypt, [
+			11571950, 6765055, 15777490, 16705475, 7667282, 16705355, 6747478, 16709450, 7259479,
+			16578410, 7323963, 16580202, 11502011, 16580218, 12520091, 12451450, 3759051, 13328317,
+			3242445, 14375869, 1142229, 13851581, 5598645, 13843389, 14132645, 15940541, 14386855,
+			7551935, 16356014, 7813567, 14794410, 12511175
+		], [
+			738924839, 154022719, 1010515743, 185740803, 490290973, 252849675, 420822813, 789982986,
+			454377245, 739708714, 453263161, 1010503466, 721829689, 943394618, 791293753, 807083834,
+			237974078, 353056061, 203896366, 386741565, 70726702, 370488637, 355873838, 372585277,
+			890649646, 975516477, 907680814, 942093119, 1040850214, 422458175, 943337247, 455749127
+		], [276147755, 314564801]],
+		['0xcafecafecafecafe', :decrypt, [
+			14794410, 12511175, 16356014, 7813567, 14386855, 7551935, 14132645, 15940541, 5598645,
+			13843389, 1142229, 13851581, 3242445, 14375869, 3759051, 13328317, 12520091, 12451450,
+			11502011, 16580218, 7323963, 16580202, 7259479, 16578410, 6747478, 16709450, 7667282,
+			16705355, 15777490, 16705475, 11571950, 6765055
+		], [
+			943337247, 455749127, 1040850214, 422458175, 907680814, 942093119, 890649646, 975516477,
+			355873838, 372585277, 70726702, 370488637, 203896366, 386741565, 237974078, 353056061,
+			791293753, 807083834, 721829689, 943394618, 453263161, 1010503466, 454377245, 739708714,
+			420822813, 789982986, 490290973, 252849675, 1010515743, 185740803, 738924839, 154022719
+		], [3868695016, 412139341]],
+		['0xdeadbeefdeadbeef', :encrypt, [
+			7466991, 16631125, 16695036, 16227052, 14614126, 5292027, 15400830, 4176957, 15531887,
+			7044594, 14942075, 3008831, 15597555, 15162582, 16252891, 13468671, 11426815, 16115512,
+			12548989, 7945806, 9404409, 16576702, 14647293, 2457327, 14680009, 12499187, 6029295,
+			10997623, 16383439, 2076626, 14630590, 13906815
+		], [
+			473906965, 506403861, 1060846891, 725367084, 926487615, 791546683, 977080112, 792607549,
+			993860151, 254752562, 943524644, 1060838975, 993999155, 523449622, 1027552015, 1058740287,
+			724516124, 624893496, 791486009, 926749454, 591347458, 926486334, 926878011, 926750511,
+			926887715, 1057565491, 373238077, 1060060215, 1043793727, 521091602, 926561549, 859702079
+		], [1755543026, 929731926]],
+		['0xdeadbeefdeadbeef', :decrypt, [
+			14630590, 13906815, 16383439, 2076626, 6029295, 10997623, 14680009, 12499187, 14647293,
+			2457327, 9404409, 16576702, 12548989, 7945806, 11426815, 16115512, 16252891, 13468671,
+			15597555, 15162582, 14942075, 3008831, 15531887, 7044594, 15400830, 4176957, 14614126,
+			5292027, 16695036, 16227052, 7466991, 16631125
+		], [
+			926561549, 859702079, 1043793727, 521091602, 373238077, 1060060215, 926887715, 1057565491,
+			926878011, 926750511, 591347458, 926486334, 791486009, 926749454, 724516124, 624893496,
+			1027552015, 1058740287, 993999155, 523449622, 943524644, 1060838975, 993860151, 254752562,
+			977080112, 792607549, 926487615, 791546683, 1060846891, 725367084, 473906965, 506403861
+		], [2531611598, 527835150]]
+	]
+
+	describe '(private class methods)' do
+		it 'can prepare keys for encryption and decryption' do
+			DATA.each do |hex_key, mode, stage1, stage2, expect|
+				key = [hex_key[2..-1]].pack('H*')
+				DES.send(:prepare_key_stage1, key, mode).should == stage1
+				DES.send(:prepare_key_stage2, stage1).should == stage2
+			end
+		end
+
+		it 'can prepare perform a DES round on a block of data' do
+			DATA.each do |hex_key, mode, stage1, stage2, expect|
+				DES.send(:desfunc, [0, 0], stage2).should == expect
+			end
+		end
+	end
+
+	describe '#initialize' do
+		it 'can create a DES object from a key and a mode' do
+			hex_key, mode, stage1, stage2, expect = DATA[0]
+			key = [hex_key[2..-1]].pack('H*')
+			des = DES.new key, mode
+			des.key.should == key
+			des.mode.should == mode
+			des.instance_variable_get(:@buf).should == ''
+			des.instance_variable_get(:@keys).should == stage2
+		end
+
+		it 'will reject invalid modes' do
+			lambda { DES.new 'key', :encryptify }.should raise_error(ArgumentError)
+		end
+
+		it 'expands or truncates the key to 8 bytes' do
+			DES.new('my-really-long-key', :encrypt).key.should == 'my-reall'
+			DES.new('key', :encrypt).key.should == "key\000\000\000\000\000"
+		end
+	end
+
+	describe '#update' do
+		before :each do
+			hex_key, mode, stage1, stage2, @expect = DATA[0]
+			key = [hex_key[2..-1]].pack('H*')
+			@des = DES.new key, mode
+		end
+
+		it 'will return the data in ciphered form' do
+			@des.update([0, 0].pack('N2')).should == @expect.pack('N2')
+		end
+
+		it 'will store the residual in buffer' do
+			@des.update([0].pack('N')).should == ''
+			@des.instance_variable_get(:@buf).should == [0].pack('N')
+			@des.update([0].pack('N')).should == @expect.pack('N2')
+			@des.instance_variable_get(:@buf).should == ''
+		end
+	end
+
+	describe '#final' do
+		before :each do
+			hex_key, mode, stage1, stage2, @expect = DATA[0]
+			key = [hex_key[2..-1]].pack('H*')
+			@des = DES.new key, mode
+		end
+
+		it 'will flush the buffer by padding with null bytes' do
+			@des.final.should == ''
+			@des.update([0].pack('N')).should == ''
+			@des.final.should == @expect.pack('N2')
+		end
+	end
+
+	describe '.encrypt' do
+		it 'is a shortcut class method for DES encryption' do
+			hex_key, mode, stage1, stage2, expect = DATA[0]
+			key = [hex_key[2..-1]].pack('H*')
+			mode.should == :encrypt
+			DES.encrypt(key, [0].pack('N')).should == expect.pack('N2')
+		end
+	end
+
+	describe '.decrypt' do
+		it 'is a shortcut class method for DES decryption' do
+			hex_key, mode, stage1, stage2, expect = DATA[1]
+			key = [hex_key[2..-1]].pack('H*')
+			mode.should == :decrypt
+			DES.decrypt(key, [0].pack('N')).should == expect.pack('N2')
+		end
+	end
+end
+

data/spec/net_vnc_spec.rb

@@ -0,0 +1,136 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'net/vnc'
+
+=begin
+class SocketMock
+	class MockIOError < IOError
+	end
+
+	def initialize
+		# this can be used to make detailed assertions
+		@trace = []
+		@read_buf  = ''
+		@write_buf = ''
+	end
+
+	def read len
+		@trace << [:read, len]
+		if @read_buf.length < len
+			msg = 'bad socket read sequence - read(%d) but only %d byte(s) available' % [len, @read_buf.length]
+			raise MockIOError, msg
+		end
+		@read_buf.slice! 0, len
+	end
+
+	def write data
+		@trace << [:write, data]
+		@write_buf << data
+	end
+end
+
+class VNCServerSocketMock < SocketMock
+	TICK_TIME = 0.1
+
+	def initialize(&block)
+		super
+
+		@pending_read = nil
+		obj = self
+		@t = Thread.new { block.call obj; @pending_read = nil }
+		100.times do |i|
+			break if @pending_read
+			if i == 99
+				msg = 'blah'
+				raise MockIOError, msg
+			end
+			sleep TICK_TIME
+		end
+	end
+
+	def run
+		yield
+		100.times do |i|
+			break unless @pending_read
+			if i == 99
+				msg = 'missing socket write sequence'
+				raise MockIOError, msg
+			end
+			sleep TICK_TIME
+		end
+		raise 'wrote to much' if @write_buf.length != 0
+		raise 'did not read enough' if @read_buf.length != 0
+	end
+
+	def read len
+		@trace << [:read, len]
+		100.times do |i|
+			break if @read_buf.length >= len
+			if i == 99
+				msg = 'timeout during socket read sequence - read(%d) but only %d byte(s) available' % [len, @read_buf.length]
+				raise MockIOError, msg
+			end
+			sleep TICK_TIME
+		end
+		@read_buf.slice! 0, len
+	end
+
+	def write data
+		unless @read_buf.empty?
+			raise MockIOError, 'tried to write with non empty read buffer - (%p, %p)' % [@read_buf, data]
+		end
+		super
+		if !@pending_read
+			raise MockIOError, "wrote to socket but server is not expecting it"
+		end
+		if @write_buf.length >= @pending_read
+			@pending_read = @write_buf.slice!(0, @pending_read)
+			sleep TICK_TIME while @pending_read.is_a? String
+		end
+	end
+
+	def provide_data data
+		@read_buf << data
+	end
+
+	def expect_data len
+		@pending_read = len
+		sleep TICK_TIME while @pending_read.is_a? Fixnum
+		@pending_read
+	end
+end
+
+describe 'Net::VNC' do
+	VNC = Net::VNC
+	
+	it 'should do something' do
+=begin
+		socket_mock.should_receive(:read).once.ordered.with(12).and_return("RFB 003.003\n")
+		socket_mock.should_receive(:write).once.ordered.with(/^RFB (\d{3}.\d{3})\n$/)
+		socket_mock.should_receive(:read).once.ordered.with(4).and_return([1].pack('N'))
+		socket_mock.should_receive(:write).once.ordered.with("\000")
+		socket_mock.should_receive(:read).once.ordered.with(20).and_return('')
+		socket_mock.should_receive(:read).once.ordered.with(4).and_return([0].pack('N'))
+		#m = mock('my mock')
+		#m.should_receive(:test1).ordered.once.with('argument').and_return(1)
+		#m.should_receive(:test2).ordered.once.with('argument').and_return(2)
+		#p m.test1('argument')
+		#p m.test2('argument')
+		vnc = VNC.open('192.168.0.1:0')
+#=end
+
+		server = VNCServerSocketMock.new do |s|
+			s.provide_data "RFB 003.003\n"
+			p :read => s.expect_data(12)
+			s.provide_data [1].pack('N')
+			p :read => s.expect_data(1)
+			s.provide_data ' ' * 20
+			s.provide_data [0].pack('N')
+		end
+		server.run do
+			TCPSocket.should_receive(:open).with('192.168.0.1', 5900).and_return(server)
+			vnc = VNC.open('192.168.0.1:0')
+		end
+	end
+end
+=end
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-vnc
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Charles Lowe
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-29 00:00:00 +10:00
+default_executable: 
+dependencies: []
+
+description: A library which implements the client VNC protocol to control VNC servers.
+email: aquasync@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README
+- ChangeLog
+- data/keys.yaml
+- lib/cipher/des.rb
+- lib/net/vnc/version.rb
+- lib/net/vnc.rb
+- spec/cipher_des_spec.rb
+- spec/net_vnc_spec.rb
+has_rdoc: true
+homepage: 
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+- --title
+- ruby-vnc documentation
+- --tab-width
+- "2"
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Ruby VNC library.
+test_files: []
+