keyhole 0.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 buffpojken
+
+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/README.rdoc

@@ -0,0 +1,17 @@
+= keyhole
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 buffpojken. See LICENSE for details.

data/bin/keyhole

@@ -0,0 +1 @@
+load File.dirname(__FILE__) + '/../lib/keyhole.rb'

data/lib/em-websocket/connection.rb

@@ -0,0 +1,191 @@
+require 'addressable/uri'
+
+module EventMachine
+  module WebSocket
+    class Connection < EventMachine::Connection
+      include Debugger
+
+      attr_reader :state, :request
+
+      # Set the max frame lenth to very high value (10MB) until there is a
+      # limit specified in the spec to protect against malicious attacks
+      MAXIMUM_FRAME_LENGTH = 10 * 1024 * 1024
+
+      # define WebSocket callbacks
+      def onopen(&blk);     @onopen = blk;    end
+      def onclose(&blk);    @onclose = blk;   end
+      def onerror(&blk);    @onerror = blk;   end
+      def onmessage(&blk);  @onmessage = blk; end
+
+      def initialize(options)
+        @options = options
+        @debug = options[:debug] || false
+        @secure = options[:secure] || false
+        @tls_options = options[:tls_options] || {}
+        @state = :handshake
+        @request = {}
+        @data = ''
+
+        debug [:initialize]
+      end
+
+      def post_init
+        start_tls(@tls_options) if @secure
+      end
+
+      def receive_data(data)
+        debug [:receive_data, data]
+
+        @data << data
+        dispatch
+      end
+
+      def unbind
+        debug [:unbind, :connection]
+
+        @state = :closed
+        @onclose.call if @onclose
+      end
+
+      def dispatch
+        case @state
+          when :handshake
+            handshake
+          when :connected
+            process_message
+          else raise WebSocketError, "invalid state: #{@state}"
+        end
+      end
+
+      def handshake
+        if @data.match(/<policy-file-request\s*\/>/)
+          send_flash_cross_domain_file
+          return false
+        else
+          debug [:inbound_headers, @data]
+          begin
+            @handler = HandlerFactory.build(@data, @secure, @debug)
+            @data = ''
+            send_data @handler.handshake
+
+            @request = @handler.request
+            @state = :connected
+            @onopen.call if @onopen
+            return true
+          rescue => e
+            debug [:error, e]
+            process_bad_request(e)
+            return false
+          end
+        end
+      end
+
+      def process_bad_request(reason)
+        @onerror.call(reason) if @onerror
+        send_data "HTTP/1.1 400 Bad request\r\n\r\n"
+        close_connection_after_writing
+      end
+
+      def send_flash_cross_domain_file
+        file =  '<?xml version="1.0"?><cross-domain-policy><allow-access-from domain="*" to-ports="*"/></cross-domain-policy>'
+        debug [:cross_domain, file]
+        send_data file
+
+        # handle the cross-domain request transparently
+        # no need to notify the user about this connection
+        @onclose = nil
+        close_connection_after_writing
+      end
+
+      def process_message
+        debug [:message, @data]
+
+        # This algorithm comes straight from the spec
+        # http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76#section-4.2
+
+        error = false
+
+        while !error
+          pointer = 0
+          frame_type = @data[pointer].to_i
+          pointer += 1
+
+          if (frame_type & 0x80) == 0x80
+            # If the high-order bit of the /frame type/ byte is set
+            length = 0
+
+            loop do
+              b = @data[pointer].to_i
+              return false unless b
+              pointer += 1
+              b_v = b & 0x7F
+              length = length * 128 + b_v
+              break unless (b & 0x80) == 0x80
+            end
+
+            # Addition to the spec to protect against malicious requests
+            if length > MAXIMUM_FRAME_LENGTH
+              close_with_error(DataError.new("Frame length too long (#{length} bytes)"))
+              return false
+            end
+
+            if @data[pointer+length-1] == nil
+              debug [:buffer_incomplete, @data.inspect]
+              # Incomplete data - leave @data to accumulate
+              error = true
+            else
+              # Straight from spec - I'm sure this isn't crazy...
+              # 6. Read /length/ bytes.
+              # 7. Discard the read bytes.
+              @data = @data[(pointer+length)..-1]
+
+              # If the /frame type/ is 0xFF and the /length/ was 0, then close
+              if length == 0
+                send_data("\xff\x00")
+                @state = :closing
+                close_connection_after_writing
+              else
+                error = true
+              end
+            end
+          else
+            # If the high-order bit of the /frame type/ byte is _not_ set
+            msg = @data.slice!(/^\x00([^\xff]*)\xff/)
+            if msg
+              msg.gsub!(/\A\x00|\xff\z/, '')
+              if @state == :closing
+                debug [:ignored_message, msg]
+              else
+                msg.force_encoding('UTF-8') if msg.respond_to?(:force_encoding)
+                @onmessage.call(msg) if @onmessage
+              end
+            else
+              error = true
+            end
+          end
+        end
+
+        false
+      end
+
+      # should only be invoked after handshake, otherwise it
+      # will inject data into the header exchange
+      #
+      # frames need to start with 0x00-0x7f byte and end with
+      # an 0xFF byte. Per spec, we can also set the first
+      # byte to a value betweent 0x80 and 0xFF, followed by
+      # a leading length indicator
+      def send(data)
+        debug [:send, data]
+        ary = ["\x00", data, "\xff"]
+        ary.collect{ |s| s.force_encoding('UTF-8') if s.respond_to?(:force_encoding) }
+        send_data(ary.join)
+      end
+
+      def close_with_error(message)
+        @onerror.call(message) if @onerror
+        close_connection_after_writing
+      end
+    end
+  end
+end

data/lib/em-websocket/debugger.rb

@@ -0,0 +1,17 @@
+module EventMachine
+  module WebSocket
+    module Debugger
+
+      private
+
+      def debug(*data)
+        if @debug
+          require 'pp'
+          pp data
+          puts
+        end
+      end
+
+    end
+  end
+end

data/lib/em-websocket/handler.rb

@@ -0,0 +1,19 @@
+module EventMachine
+  module WebSocket
+    class Handler
+      include Debugger
+
+      attr_reader :request
+
+      def initialize(request, response, debug = false)
+        @request = request
+        @response = response
+        @debug = debug
+      end
+
+      def handshake
+        # Implemented in subclass
+      end
+    end
+  end
+end

data/lib/em-websocket/handler75.rb

@@ -0,0 +1,21 @@
+module EventMachine
+  module WebSocket
+    class Handler75 < Handler
+      def handshake
+        location  = "#{@request['Host'].scheme}://#{@request['Host'].host}"
+        location << ":#{@request['Host'].port}" if @request['Host'].port
+        location << @request['Path']
+
+        upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
+        upgrade << "Upgrade: WebSocket\r\n"
+        upgrade << "Connection: Upgrade\r\n"
+        upgrade << "WebSocket-Origin: #{@request['Origin']}\r\n"
+        upgrade << "WebSocket-Location: #{location}\r\n\r\n"
+
+        debug [:upgrade_headers, upgrade]
+
+        return upgrade
+      end
+    end
+  end
+end

data/lib/em-websocket/handler76.rb

@@ -0,0 +1,64 @@
+require 'digest/md5'
+
+module EventMachine
+  module WebSocket
+    class Handler76 < Handler
+      # "\377\000" is octet version and "\xff\x00" is hex version
+      TERMINATE_STRING = "\xff\x00"
+
+      def handshake
+        challenge_response = solve_challenge(
+          @request['Sec-WebSocket-Key1'],
+          @request['Sec-WebSocket-Key2'],
+          @request['Third-Key']
+        )
+
+        location  = "#{@request['Host'].scheme}://#{@request['Host'].host}"
+        location << ":#{@request['Host'].port}" if @request['Host'].port
+        location << @request['Path']
+
+        upgrade =  "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
+        upgrade << "Upgrade: WebSocket\r\n"
+        upgrade << "Connection: Upgrade\r\n"
+        upgrade << "Sec-WebSocket-Location: #{location}\r\n"
+        upgrade << "Sec-WebSocket-Origin: #{@request['Origin']}\r\n"
+        if protocol = @request['Sec-WebSocket-Protocol']
+          validate_protocol!(protocol)
+          upgrade << "Sec-WebSocket-Protocol: #{protocol}\r\n"
+        end
+        upgrade << "\r\n"
+        upgrade << challenge_response
+
+        debug [:upgrade_headers, upgrade]
+
+        return upgrade
+      end
+
+      private
+
+      def solve_challenge(first, second, third)
+        # Refer to 5.2 4-9 of the draft 76
+        sum = [(extract_nums(first) / count_spaces(first))].pack("N*") +
+          [(extract_nums(second) / count_spaces(second))].pack("N*") +
+          third
+        Digest::MD5.digest(sum)
+      end
+
+      def extract_nums(string)
+        string.scan(/[0-9]/).join.to_i
+      end
+
+      def count_spaces(string)
+        spaces = string.scan(/ /).size
+        # As per 5.2.5, abort the connection if spaces are zero.
+        raise HandshakeError, "Websocket Key1 or Key2 does not contain spaces - this is a symptom of a cross-protocol attack" if spaces == 0
+        return spaces
+      end
+
+      def validate_protocol!(protocol)
+        raise HandshakeError, "Invalid WebSocket-Protocol: empty" if protocol.empty?
+        # TODO: Validate characters
+      end
+    end
+  end
+end

data/lib/em-websocket/handler_factory.rb

@@ -0,0 +1,53 @@
+module EventMachine
+  module WebSocket
+    class HandlerFactory
+      PATH   = /^(\w+) (\/[^\s]*) HTTP\/1\.1$/
+      HEADER = /^([^:]+):\s*(.+)$/
+
+      def self.build(data, secure = false, debug = false)
+        request = {}
+        response = nil
+
+        lines = data.split("\r\n")
+
+        # extract request path
+        first_line = lines.shift.match(PATH)
+        raise HandshakeError, "Invalid HTTP header" unless first_line
+        request['Method'] = first_line[1].strip
+        request['Path'] = first_line[2].strip
+
+        unless request["Method"] == "GET"
+          raise HandshakeError, "Must be GET request"
+        end
+
+        # extract query string values
+        request['Query'] = Addressable::URI.parse(request['Path']).query_values ||= {}
+        # extract remaining headers
+        lines.each do |line|
+          h = HEADER.match(line)
+          request[h[1].strip] = h[2].strip if h
+        end
+        request['Third-Key'] = lines.last
+
+        unless request['Connection'] == 'Upgrade' and request['Upgrade'] == 'WebSocket'
+          raise HandshakeError, "Connection and Upgrade headers required"
+        end
+
+        # transform headers
+        protocol = (secure ? "wss" : "ws")
+        request['Host'] = Addressable::URI.parse("#{protocol}://"+request['Host'])
+
+        version = request['Sec-WebSocket-Key1'] ? 76 : 75
+
+        case version
+        when 75
+          Handler75.new(request, response, debug)
+        when 76
+          Handler76.new(request, response, debug)
+        else
+          raise WebSocketError, "Must not happen"
+        end
+      end
+    end
+  end
+end

data/lib/em-websocket/websocket.rb

@@ -0,0 +1,26 @@
+module EventMachine
+  module WebSocket
+    class WebSocketError < RuntimeError; end
+    class HandshakeError < WebSocketError; end
+    class DataError < WebSocketError; end
+
+    def self.start(options, &blk)
+      EM.epoll
+      EM.run do
+
+        trap("TERM") { stop }
+        trap("INT")  { stop }
+
+        EventMachine::start_server(options[:host], options[:port],
+          EventMachine::WebSocket::Connection, options) do |c|
+          blk.call(c)
+        end
+      end
+    end
+
+    def self.stop
+      puts "Terminating WebSocket Server"
+      EventMachine.stop
+    end
+  end
+end

data/lib/em-websocket.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+#require "rubygems"
+require "eventmachine"
+
+%w[ debugger websocket connection handler_factory handler handler75 handler76 ].each do |file|
+  require "em-websocket/#{file}"
+end

data/lib/keyhole.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'eventmachine'
+require File.dirname(__FILE__) + '/sat_parser'
+require File.dirname(__FILE__) + '/query_server'
+require 'em-websocket'
+require 'sinatra/base'
+require 'thin'
+
+
+EventMachine.run{
+  
+  # This can implement the AJAX-based query-server, without any need
+  # of multiple servers. Or, it can just be an http-based reporting tool.
+  class Querier < Sinatra::Base    
+    get "/" do 
+      return "This is Keyhole, with #{$clients.length} clients connected"
+    end    
+  end
+  
+  
+  $channel = EM::Channel.new
+  $clients = {}
+    
+  EventMachine::start_server "127.0.0.1", 5000, SatParser
+  EventMachine::start_server "127.0.0.1", 5500, QueryServer
+  
+  # TODO - Make sure this reads config from a config-file instead of this weird thing!
+  EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8080, :debug => true) do |ws|
+    ws.onopen{
+      sid = $channel.subscribe { |msg| ws.send msg }      
+      $clients[sid] = true
+      ws.onmessage{|msg| $channel.push "Ninja!" }
+      ws.onclose{
+        $channel.unsubscribe(sid)
+        $clients.delete(sid)
+      }      
+    }    
+  end
+  
+  Querier.run!({:port => 3000})
+  
+}

data/lib/query_server.rb

@@ -0,0 +1,14 @@
+# QueryServer responds to telnet-calls on its designated port, and responds
+# with things...
+class QueryServer < EventMachine::Connection
+  
+  def post_init
+    send_data "#{$clients.length} clients connected"
+  end
+  
+  def receive_data(data)
+    send_data "#{$clients.length} clients connected"
+    close_connection if data =~ /quit/i
+  end
+  
+end

data/lib/sat_parser.rb

@@ -0,0 +1,17 @@
+class SatParser < EventMachine::Connection
+    
+  def post_init
+    puts "GSAT connected"
+  end
+  
+  def receive_data(data)
+    puts "Data received..."
+    puts data.inspect
+    $channel << data
+  end
+  
+  def unbind
+    $channel << "GSAT closed connection"
+  end
+  
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'keyhole'
+
+class Test::Unit::TestCase
+end

data/test/test_keyhole.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestKeyhole < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: keyhole
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- buffpojken
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-05 00:00:00 +02:00
+default_executable: keyhole
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: longer description of your gem
+email: daniel@sykewarrior.com
+executables: 
+- keyhole
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- lib/em-websocket.rb
+- lib/em-websocket/connection.rb
+- lib/em-websocket/debugger.rb
+- lib/em-websocket/handler.rb
+- lib/em-websocket/handler75.rb
+- lib/em-websocket/handler76.rb
+- lib/em-websocket/handler_factory.rb
+- lib/em-websocket/websocket.rb
+- lib/keyhole.rb
+- lib/query_server.rb
+- lib/sat_parser.rb
+- LICENSE
+- README.rdoc
+- test/helper.rb
+- test/test_keyhole.rb
+- bin/keyhole
+has_rdoc: true
+homepage: http://github.com/buffpojken/keyhole
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: one-line summary of your gem
+test_files: 
+- test/helper.rb
+- test/test_keyhole.rb