evilcap-ruby-vnc 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3c6cb5b602176bf4af4687a2771a19b5d24e902e6137be88b572b0f3f98ee960
+  data.tar.gz: f9d1482b9dfd3454ffaa01c3c9fb0c7aba39102d29ee449fe2e84eec09894e76
+SHA512:
+  metadata.gz: bc3bbf48ff15d28609e84b9a789fb5a767679a263bc74417e9836d4653fef1a7aebe4fe2a72b02ccc4a7f14fbe83233b6c3c3e1c698f9e4d85fb30f13f2a54be
+  data.tar.gz: b7d0d3538d01d2f93630d2ac158174e623c404cd0efb876a8650d5a2756e44df42266d3f20833c67935d1d87eea44cbbf5c430bc644ae9bd2bf6d9dd1b9111d8

data/COPYING

@@ -0,0 +1,20 @@
+Copyright (c) 2007-2010 Charles Lowe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/Changelog.rdoc

@@ -0,0 +1,19 @@
+== Unreleased:
+
+- Replaced DES-algorithm with Ruby's built-in OpenSSL wrapper instead
+- Parse framebuffer width/height and hostname from ServerInitialisation
+- Added a project Gemfile
+
+== 1.1.0 / 2012-06-03
+
+- Fixes to support ruby 1.9 (jedi4ever & codemonkeyjohn).
+
+== 1.0.1 / 2011-09-15
+
+- Split out gemspec into separate file and use for Rakefile.
+- Add homepage and rubyforge project to gemspec.
+
+== 1.0.0 / 2008-08-29
+
+- First public release
+

data/README.rdoc

@@ -0,0 +1,33 @@
+= 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.
+
+= Running the tests
+
+* Boot up the two VNC servers with `docker-compose up`.
+
+* Run the test-suite with `bundle exec rake spec`.
+
+= Resources
+
+* {The Remote Framebuffer Protocol (RFC6143)}[https://tools.ietf.org/html/rfc6143]
+
+* https://github.com/rfbproto/rfbproto/blob/master/rfbproto.rst
+
+= 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.
+
+= P.S.
+
+This gem forked from [https://github.com/aquasync/ruby-vnc] for normally reads and additions. This is my frist gem publishing, so be patient.

data/Rakefile

@@ -0,0 +1,39 @@
+require "bundler/gem_tasks"
+require 'rake'
+
+task :default => :spec
+
+desc 'Run all specs'
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+end
+
+desc 'Run all specs and generate html spec document'
+namespace :spec do
+  RSpec::Core::RakeTask.new :html do |t|
+    t.rspec_opts = ['--format html --out spec.html']
+  end
+end
+
+require 'rdoc/task'
+
+Rake::RDocTask.new do |t|
+  t.rdoc_dir = 'doc'
+  t.rdoc_files.include 'lib/**/*.rb'
+  t.rdoc_files.include 'README'
+  t.title = 'evilcap-ruby-vnc documentation'
+  t.options += %w[--line-numbers --inline-source --tab-width 2]
+  t.main = 'README'
+end
+
+require 'rubygems/package_task'
+
+spec = eval File.read('evilcap-ruby-vnc.gemspec')
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.need_tar = false
+  pkg.need_zip = false
+  pkg.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/vncdes.rb

@@ -0,0 +1,55 @@
+require 'openssl'
+
+# MIT-licensed code by Andrew Dorofeyev
+# from https://github.com/d-theus/vncrec-ruby
+
+# The server sends a random 16-byte challenge:
+#
+#      +--------------+--------------+-------------+
+#      | No. of bytes | Type [Value] | Description |
+#      +--------------+--------------+-------------+
+#      | 16           | U8           | challenge   |
+#      +--------------+--------------+-------------+
+#
+# The client encrypts the challenge with DES (ECB), using a password supplied
+# by the user as the key.  To form the key, the password is truncated
+# to eight characters, or padded with null bytes on the right.
+# Actually, each byte is also reversed. Challenge string is split
+# in two chunks of 8 bytes, which are encrypted separately and clashed together
+# again. The client then sends the resulting 16-byte response:
+#
+#      +--------------+--------------+-------------+
+#      | No. of bytes | Type [Value] | Description |
+#      +--------------+--------------+-------------+
+#      | 16           | U8           | response    |
+#      +--------------+--------------+-------------+
+#
+# The protocol continues with the SecurityResult message.
+
+module Cipher
+  class VNCDES
+    attr_reader :key
+
+    def initialize(key)
+      @key = normalized(key[0..7])
+      self
+    end
+
+    def encrypt(challenge)
+      chunks = [challenge.slice(0, 8), challenge.slice(8, 8)]
+      cipher = OpenSSL::Cipher::DES.new(:ECB)
+      cipher.encrypt
+      cipher.key = self.key
+      chunks.reduce('') { |a, e| cipher.reset; a << cipher.update(e) }.force_encoding('UTF-8')
+    end
+
+    private
+
+    def normalized(key)
+      rev = ->(n) { (0...8).reduce(0) { |a, e| a + 2**e * n[7 - e] } }
+      inv = key.each_byte.map { |b| rev[b].chr }.join
+      inv.ljust(8, "\x00")
+    end
+  end
+end
+

data/lib/net/rfb/frame_buffer.rb

@@ -0,0 +1,175 @@
+require 'vncrec'
+require 'chunky_png'
+
+module Net::RFB
+
+  # Manage FrameBuffer pixel data for RFB protocol
+  # This is a little wrapper for the `Proxy` class in vncrec-ruby https://github.com/d-theus/vncrec-ruby
+  class FrameBuffer
+    class VNCRecAuthStub
+      def initialize(io, *options)
+      end
+    end
+
+    # @param io  [IO, #read, #sysread, #syswrite, #read_nonblock] string stream from VNC server.
+    # @param w   [Integer] width of the screen area
+    # @param h   [Integer] height of the screen area
+    # @param bpp [Symbol] bits per pixel (BGR8 or BGRA)
+    # @param encodings [Array<Symbol>] encoding (RAW or HEXTILE or ZRLE) default: RAW
+    def initialize(io, w, h, bpp, encodings=nil)
+      @cb_mutex = Monitor.new
+      @cb_cv = @cb_mutex.new_cond
+
+      @encodings = encodings
+
+      @vnc_rec_pix_fmt = convert_to_vnc_rec_pix_fmt bpp
+
+      @proxy = VNCRec::RFB::Proxy.new(io, nil, nil, nil, [VNCRecAuthStub, nil])
+      @proxy.prepare_framebuffer w, h, @vnc_rec_pix_fmt[:bpp]
+    end
+
+    def send_initial_data
+      # set encoding
+      unless self.set_encodings @encodings
+        raise 'Error while setting encoding'
+      end
+
+      # set pixel format
+      self.set_pixel_format @vnc_rec_pix_fmt
+
+      # request all pixel data
+      self.request_update_fb incremental: false
+    end
+
+    # raw pixel data of screen
+    def pixel_data
+      @proxy.data
+    end
+
+    # 32bit RGBA pixel data of screen
+    def rgba_pixel_data
+      px = self.pixel_data
+      raise 'Error in get raw pixel_data.' unless px
+      self.class.convert_raw_pixel_data_to_rgba px, @vnc_rec_pix_fmt[:string]
+    end
+
+    # convert raw pixel data to 32bit RGBA values according to VNC pixel format
+    # @param px      [String]  binary pixel data
+    # @param pix_fmt [String]  pixel format (bgra, bgr8)
+    # @return [Array<Integer>] array of 32bit pixel data
+    def self.convert_raw_pixel_data_to_rgba(px, pix_fmt)
+      # see https://github.com/d-theus/vncrec-ruby/blob/master/lib/vncrec/constants.rb
+      case pix_fmt.to_s
+      when 'bgra'
+        # convert 32bit BGRA -> 32bit RGBA
+        px = px.unpack("V*")
+        px.map! { |p| (p << 8) | 0xff }
+      when 'bgr8'
+        # convert 8bit BGR -> 32bit RGBA
+        px = px.unpack("C*")
+        px.map! do |p|
+          r = (p & 0b00000111)
+          g = (p & 0b00111000) >> 3
+          b = (p & 0b11000000) >> 6
+          ((r * 36) << 24) | ((g * 36) << 16) | ((b * 85) << 8) | 0xff
+        end
+      else
+        raise "unknown pixel format #{pix_fmt.inspect}"
+      end
+    end
+
+    # Set a way that server should use to represent pixel data
+    # @param [Symbol|String] pixel format:
+    #  * :BGR8
+    #  * :BGRA
+    def set_pixel_format(format)
+      @proxy.set_pixel_format convert_to_vnc_rec_pix_fmt(format)
+    end
+
+    # Set way of encoding video frames.
+    # @param encodings [Symbol|String] list of encoding of video data used to transfer.
+    #  * :RAW
+    #  * :HEXTILE
+    #  * :ZRLE
+    def set_encodings(*encodings)
+      @proxy.set_encodings [encodings].flatten.compact.map{|sym| VNCRec::const_get "ENC_#{sym}"}
+    end
+
+    # Send request for update framebuffer.
+    #  if block given, called it with pixel data after the response received.
+    # @param [Boolean] incremental incremental, request just difference
+    #  between previous and current framebuffer state.
+    # @param x [Integer]
+    # @param y [Integer]
+    # @param w [Integer]
+    # @param h [Integer]
+    # @param wait_for_response [Boolean] if true, wait for a FramebufferUpdate response
+    def request_update_fb(incremental: true, x: nil, y: nil, w: nil, h: nil, wait_for_response: false)
+      @cb_mutex.synchronize do
+        @proxy.fb_update_request incremental ? 1 : 0, x||0, y||0, w||@proxy.w, h||@proxy.h
+
+        if wait_for_response
+          @cb_cv.wait
+        end
+      end
+    end
+
+    def handle_response(t)
+      case t
+      when 0 # ----------------------------------------------- FramebufferUpdate
+        ret = handle_fb_update
+        @cb_mutex.synchronize do
+          @cb_cv.broadcast
+        end
+        return ret
+      when 1 # --------------------------------------------- SetColourMapEntries
+        return handle_set_colormap_entries
+      end
+    end
+
+    # save current screen pixel data as PNG image
+    # @param dest [String|IO|nil] destination file path, or IO-object, or nil
+    # @return [String] PNG binary data as string when dest is null
+    #         [true]   else case
+    def save_pixel_data_as_png(dest=nil)
+      self.request_update_fb(wait_for_response: true)
+
+      image = ChunkyPNG::Image.new(@proxy.w, @proxy.h, rgba_pixel_data)
+
+      if dest.is_a? IO
+        # write to IO-object
+        image.write dest
+      elsif dest.is_a?(String) || dest.is_a?(Pathname)
+        # write to file
+        image.save dest.to_s
+      elsif dest.nil?
+        # return binary data as string
+        return image.to_blob
+      else
+        raise ArgumentError, "Unsupported destination type #{dest.inspect}"
+      end
+      true
+    end
+
+    private
+
+    # convert pixel_format symbol to VNCRec::PIX_FMT_XXX symbol.
+    # @param pix_fmt [Symbol|String] bits per pixel (BGR8 or BGRA)
+    def convert_to_vnc_rec_pix_fmt(pix_fmt)
+      return pix_fmt if pix_fmt.is_a?(Hash)
+      pf = pix_fmt.to_s.prepend('PIX_FMT_').upcase.to_sym
+      raise ArgumentError, "Unsupported pixel_format '#{pix_fmt}', now supported values are: BGR8, BGRA" unless VNCRec.const_defined? pf
+      VNCRec.const_get(pf)
+    end
+
+    # Receives data and applies diffs(if incremental) to the @data
+    def handle_fb_update
+      @proxy.handle_fb_update
+    end
+
+    # @return [Array] palette
+    def handle_set_colormap_entries
+      @proxy.handle_colormap_update
+    end
+  end
+end

data/lib/net/vnc.rb

@@ -0,0 +1,371 @@
+require 'socket'
+require 'yaml'
+require 'thread'
+require 'cipher/vncdes'
+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
+  #
+  #   require 'net/vnc'
+  #   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.chr
+        packet[1] = button.chr
+        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,
+      :pix_fmt => :BGRA,
+      :encoding => :RAW
+    }
+
+    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, :desktop_name
+
+    def initialize display=':0', options={}
+      @server = 'localhost'
+      if display =~ /^(.*)(:\d+)$/
+        @server, display = $1, $2
+      end
+      @display = display[1..-1].to_i
+      @desktop_name = nil
+      @options = DEFAULT_OPTIONS.merge options
+      @clipboard = nil
+      @fb = 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::VNCDES.new(password).encrypt(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
+      @framebuffer_width  = socket.read(2).to_s.unpack('n')[0].to_i
+      @framebuffer_height = socket.read(2).to_s.unpack('n')[0].to_i
+
+      # TODO: parse this.
+      pixel_format = socket.read(16)
+
+      # read the name in byte chunks of 20
+      name_length = socket.read(4).to_s.unpack('N')[0]
+      @desktop_name = [].tap do |it|
+        while name_length > 0
+          len = [20, name_length].min
+          it << socket.read(len)
+          name_length -= len
+        end
+      end.join
+
+      _load_frame_buffer
+    end
+
+    # this types +text+ on the server
+    def type text, options={}
+      packet = 0.chr * 8
+      packet[0] = 4.chr
+      text.split(//).each do |char|
+        packet[7] = char[0]
+        packet[1] = 1.chr
+        socket.write packet
+        packet[1] = 0.chr
+        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)
+      case which
+      when String
+        if which.length != 1
+          raise ArgumentError, 'can only get key_code of single character strings'
+        end
+        which[0].ord
+      when Symbol
+        KEY_MAP[which]
+      when Integer
+        which
+      else
+        raise ArgumentError, "unsupported key value: #{which.inspect}"
+      end
+    end
+    private :get_key_code
+
+    def key_down which, options={}
+      packet = 0.chr * 8
+      packet[0] = 4.chr
+      key_code = get_key_code which
+      packet[4, 4] = [key_code].pack('N')
+      packet[1] = 1.chr
+      socket.write packet
+      wait options
+    end
+
+    def key_up which, options={}
+      packet = 0.chr * 8
+      packet[0] = 4.chr
+      key_code = get_key_code which
+      packet[4, 4] = [key_code].pack('N')
+      packet[1] = 0.chr
+      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
+
+    # take screenshot as PNG image
+    # @param dest [String|IO|nil] destination file path, or IO-object, or nil
+    # @return [String] PNG binary data as string when dest is null
+    #         [true]   else case
+    def take_screenshot(dest=nil)
+      fb = _load_frame_buffer  # on-demand loading
+      fb.save_pixel_data_as_png dest
+    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 reconnect
+      60.times do
+        if @packet_reading_state.nil?
+          connect
+          @packet_reading_thread = Thread.new { packet_reading_thread }
+          return true
+        end
+        sleep 0.5
+      end
+      warn 'reconnect failed because packet reading state had not been stopped for 30 seconds.'
+      false
+    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
+
+    def clipboard= text
+      text = text.to_s.gsub(/\R/, "\n") # eol of ClientCutText's text is LF
+      byte_size = text.to_s.bytes.size
+      packet = 0.chr * (8 + byte_size)
+      packet[0] = 6.chr # message-type: 6 (ClientCutText)
+      packet[4, 4] = [byte_size].pack('N') # length
+      packet[8, byte_size] = text
+      socket.write(packet)
+      @clipboard = text
+    end
+
+    private
+
+    def read_packet type
+      case type
+      when 0 # ----------------------------------------------- FramebufferUpdate
+        @fb.handle_response type if @fb
+      when 1 # --------------------------------------------- SetColourMapEntries
+        @fb.handle_response type if @fb
+      when 2 # ------------------------------------------------------------ Bell
+        nil  # not support
+      when 3 # --------------------------------------------------- ServerCutText
+        socket.read 3 # discard padding bytes
+        len = socket.read(4).unpack('N')[0]
+        @mutex.synchronize { @clipboard = socket.read len }
+      else
+        warn '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.ord
+        rescue
+          warn "exception in packet_reading_thread: #{$!.class}:#{$!}\n#{$!.backtrace}"
+          break
+        end
+      end
+      @packet_reading_state = nil
+    end
+
+    def _load_frame_buffer
+      unless @fb
+        require 'net/rfb/frame_buffer'
+
+        @fb = Net::RFB::FrameBuffer.new @socket, @framebuffer_width, @framebuffer_height, @options[:pix_fmt], @options[:encoding]
+        @fb.send_initial_data
+      end
+      @fb
+    end
+  end
+end

data/lib/net/vnc/version.rb

@@ -0,0 +1,6 @@
+module Net
+  class VNC
+    VERSION = '1.2.0'.freeze
+  end
+end
+

data/spec/cipher_vncdes_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'cipher/vncdes'
+
+RSpec.describe Cipher::VNCDES do
+  it 'should pad key with zeroes if key is shorter than 8 characters' do
+    key = Cipher::VNCDES.new('test').key
+
+    expect(key.size).to eq 8
+    expect(key[4..7]).to eq(0.chr * 4)
+  end
+
+  it 'should cut the key if the key is longer than 8 characters' do
+    expect(Cipher::VNCDES.new('iamdefinitelylongerthan8characters').key.size).to eq 8
+  end
+
+  it 'should correctly encrypt keys' do
+    encrypted_string = Cipher::VNCDES.new('matzisnicesowearenice').encrypt("\x9D\xBBU\n\x05b\x96L \b'&\x18\xCE(\xD8")
+    expect(encrypted_string.encoding.to_s).to eq 'UTF-8'
+    expect(encrypted_string.size).to eq 16
+    expect(encrypted_string).to eq "2\x95\xA7\xAE\xD4A\xF3\xDCt\x82d\e\xAE\x8A\xB9c"
+  end
+end

data/spec/net_vnc_spec.rb

@@ -0,0 +1,136 @@
+require '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
+

data/spec/real_net_vnc_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require 'net/vnc'
+
+RSpec.describe Net::VNC do
+  NO_AUTH_SERVER_DISPLAY   = ':1'
+  WITH_AUTH_SERVER_DISPLAY = ':2'
+
+  context 'no auth' do
+    it 'should connect with no password' do
+      Net::VNC.open(NO_AUTH_SERVER_DISPLAY) do |vnc|
+        vnc.pointer_move(10, 15)
+        expect(vnc.pointer.x).to eq 10
+        expect(vnc.pointer.y).to eq 15
+
+        vnc.pointer_move(20, 25)
+        expect(vnc.pointer.x).to eq 20
+        expect(vnc.pointer.y).to eq 25
+      end
+    end
+
+    it 'should connect with password even though it is not needed' do
+      Net::VNC.open(NO_AUTH_SERVER_DISPLAY, password: 'password') do |vnc|
+        vnc.pointer_move(10, 15)
+        expect(vnc.pointer.x).to eq 10
+      end
+    end
+  end
+
+  context 'with auth' do
+    it 'should connect with a password' do
+      Net::VNC.open(WITH_AUTH_SERVER_DISPLAY, password: 'matzisnicesowearenice') do |vnc|
+        vnc.pointer_move(10, 15)
+        expect(vnc.pointer.x).to eq 10
+        expect(vnc.pointer.y).to eq 15
+      end
+    end
+
+    it 'should give error with a wrong password' do
+      expect { Net::VNC.open(WITH_AUTH_SERVER_DISPLAY, password: 'wrongPasssword') }.to raise_error(RuntimeError, 'Unable to authenticate - 1')
+    end
+
+    it 'should give error with no password' do
+      expect { Net::VNC.open(WITH_AUTH_SERVER_DISPLAY) }.to raise_error(RuntimeError, 'Need to authenticate but no password given')
+    end
+  end
+
+  context 'screenshotting' do
+    def verify_screenshot(input)
+      image_size = ImageSize.path(input)
+      expect(image_size.format).to eq :png
+      expect(image_size.width).to eq 1366
+      expect(image_size.height).to eq 768
+    end
+
+    it 'should allow you to take a screenshot with a path' do
+      Tempfile.open('ruby-vnc-spec') do |screenshotfile|
+        Net::VNC.open(NO_AUTH_SERVER_DISPLAY) do |vnc|
+          vnc.pointer_move(10, 15)
+          vnc.take_screenshot(screenshotfile.path)
+        end
+        verify_screenshot(screenshotfile.path)
+      end
+    end
+
+    it 'should allow you to take a screenshot with a blob' do
+      Tempfile.open('ruby-vnc-spec-blob') do |screenshotfile|
+        vnc = Net::VNC.open(NO_AUTH_SERVER_DISPLAY)
+        begin
+          vnc.pointer_move(10, 15)
+          blob = vnc.take_screenshot(nil)
+          screenshotfile.write(blob)
+        ensure
+          vnc.close
+        end
+
+        verify_screenshot(screenshotfile.path)
+      end
+    end
+
+    it 'should allow you to take a screenshot with a IO-object' do
+      screenshotfile = File.new("out.png", "w")
+
+      begin
+        Net::VNC.open(NO_AUTH_SERVER_DISPLAY) do |vnc|
+          vnc.pointer_move(10, 15)
+          vnc.take_screenshot(screenshotfile)
+        end
+        verify_screenshot(screenshotfile)
+      ensure
+        screenshotfile.close
+        File.delete(screenshotfile)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: evilcap-ruby-vnc
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Charles Lowe
+- Egor Topolnyak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: vncrec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+- !ruby/object:Gem::Dependency
+  name: chunky_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: image_size
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A library which implements the client VNC protocol to control VNC servers.
+email: topolnyak012@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- Changelog.rdoc
+files:
+- COPYING
+- Changelog.rdoc
+- README.rdoc
+- Rakefile
+- data/keys.yaml
+- lib/cipher/vncdes.rb
+- lib/net/rfb/frame_buffer.rb
+- lib/net/vnc.rb
+- lib/net/vnc/version.rb
+- spec/cipher_vncdes_spec.rb
+- spec/net_vnc_spec.rb
+- spec/real_net_vnc_spec.rb
+homepage: https://github.com/evilcap/ruby-vnc
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.rdoc
+- "--title"
+- evilcap-ruby-vnc documentation
+- "--tab-width"
+- '2'
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: evilcap-ruby-vnc
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Evilcap Ruby VNC library.
+test_files: []