ruby-vnc 1.1.0 → 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9b9252091b18c38896b7f1e8ee618dc77c1848c471c6f4eec36c9a2831b70640
+  data.tar.gz: d8599868187fa9f97649b68ded844306534609a9a9606bf022a629ab2174df1d
+SHA512:
+  metadata.gz: e671beb2f0319145b5c1f930c02245026adef5ef81accaf2530b42c25e5cca5bc996c4c67445d3c308a8b012c579bd49f4899633f0e42093921d4396aa594c54
+  data.tar.gz: eae517b3eb5295687fad89289ca0c3ca9067d12e3264c91057a9430ebc782d1a6f1b72ae8fdf94adac5e94e2f4abc786c14a4ce3483d2f2e08cb84e0207a95b8

data/{ChangeLog → Changelog.rdoc}

@@ -1,3 +1,12 @@
+== Unreleased:
+
+== 1.2.0 / 2021-09-21
+
+- Replaced DES-algorithm with Ruby's built-in OpenSSL wrapper instead
+- Parse framebuffer width/height and hostname from ServerInitialisation
+- Added a project Gemfile
+- Add a required ruby version (higher than Ruby 2.5)
+
 == 1.1.0 / 2012-06-03
 
 - Fixes to support ruby 1.9 (jedi4ever & codemonkeyjohn).

data/{README → README.rdoc}

@@ -9,6 +9,18 @@ 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

data/Rakefile

@@ -1,53 +1,38 @@
+require 'bundler/gem_tasks'
 require 'rake'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'spec/rake/spectask'
-require 'spec/rake/verify_rcov'
 
-spec = eval File.read('ruby-vnc.gemspec')
-
-task :default => :spec
+task default: :spec
 
 desc 'Run all specs'
-Spec::Rake::SpecTask.new :spec do |t|
-	t.spec_opts = ['--format specdoc --colour']
+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
-	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'
+  RSpec::Core::RakeTask.new :html do |t|
+    t.rspec_opts = ['--format html --out spec.html']
+  end
 end
 
-namespace :rcov do
-	RCov::VerifyTask.new :verify => :rcov do |t|
-		t.threshold = 100.0
-		t.index_html = 'coverage/index.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 = "#{PKG_NAME} documentation"
-	t.options += %w[--line-numbers --inline-source --tab-width 2]
-	t.main = 'README'
+  t.rdoc_dir = 'doc'
+  t.rdoc_files.include 'lib/**/*.rb'
+  t.rdoc_files.include 'README'
+  t.title = 'ruby-vnc documentation'
+  t.options += %w[--line-numbers --inline-source --tab-width 2]
+  t.main = 'README'
 end
 
-Rake::GemPackageTask.new(spec) do |t|
-	t.gem_spec = spec
-	t.need_tar = false
-	t.need_zip = false
-	t.package_dir = 'build'
-end
+require 'rubygems/package_task'
 
+spec = eval File.read('ruby-vnc.gemspec')
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.need_tar = false
+  pkg.need_zip = false
+  pkg.package_dir = 'build'
+end

data/lib/cipher/vncdes.rb

@@ -0,0 +1,54 @@
+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 = 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
+      raise 'Error while setting encoding' unless set_encodings @encodings
+
+      # set pixel format
+      set_pixel_format @vnc_rec_pix_fmt
+
+      # request all pixel data
+      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 = 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
+
+        @cb_cv.wait if wait_for_response
+      end
+    end
+
+    def handle_response(t)
+      case t
+      when 0 # ----------------------------------------------- FramebufferUpdate
+        ret = handle_fb_update
+        @cb_mutex.synchronize do
+          @cb_cv.broadcast
+        end
+        ret
+      when 1 # --------------------------------------------- SetColourMapEntries
+        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)
+      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
+      unless VNCRec.const_defined? pf
+        raise ArgumentError,
+              "Unsupported pixel_format '#{pix_fmt}', now supported values are: BGR8, BGRA"
+      end
+
+      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/version.rb

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