binproxy 1.0.0

data/lib/binproxy/proxy_event.rb

@@ -0,0 +1,57 @@
+module BinProxy
+  class ProxyBaseItem
+    include BinProxy::Logger
+    attr_accessor :session, :disposition, :id
+    attr_reader :src, :dest, :time
+    def src=(s)
+      @src = s
+      @dest = opposite_peer(s)
+    end
+    def dest=(d)
+      @dest = d
+      @src = opposite_peer(d)
+    end
+
+    def initialize
+      @time = Time.now
+    end
+
+    def headers
+      {
+        message_id: @id,
+        session_id: @session && @session.id,
+        src: @src,
+        dest: @dest,
+        time: @time.to_i,
+        disposition: @disposition,
+      }
+    end
+
+    def to_hash
+      { head: headers }
+    end
+    private
+
+    def opposite_peer(p)
+      case p
+      when :client; :server
+      when :server; :client
+      else raise "invalid peer: #{p}"
+      end
+    end
+
+  end
+  class ProxyEvent < ProxyBaseItem
+    def initialize(summary)
+      super()
+      @summary = summary
+      @disposition = 'Info'
+    end
+
+    def headers
+      super.merge({
+        summary: @summary
+      })
+    end
+  end
+end

data/lib/binproxy/proxy_message.rb

@@ -0,0 +1,191 @@
+require 'rbkb'
+require 'bindata'
+require_relative 'bindata'
+require_relative 'logger'
+require_relative 'proxy_event'
+require 'base64'
+
+######################################################################
+# monkey patch bindata classes to add annotated_snapshot
+#
+# Annotated snapshots should be hashes which convert cleanly to JSON and
+# have the following properties:  (Note that this is somewhat different
+# from the format of builtin BinData snapshots.)
+#
+#   name: string or null
+#   objclass: string
+#   display: string or null
+#
+#   [either]
+#     contents: array of annotated_snapshots
+#   [or]
+#     value: primitive type
+#     repr: 'raw' or 'base64'
+#
+######################################################################
+
+class BinData::Base
+  # Not called directly, but return value is merged by subclasses
+  def annotated_snapshot
+    {
+      name: nil, #things generally don't know their own name, so compound types will overwrite this.
+      objclass: self.class.to_s,
+      display: eval_parameter(:display_as)
+    }
+  end
+  def annotate_value(v)
+    if v.respond_to? :annotated_snapshot
+      return v.annotated_snapshot
+    end
+    v = Base64.encode64(v) if v.is_a? String
+    return { value: v }
+  end
+end
+
+class BinData::BasePrimitive
+  def annotated_snapshot
+    super.merge annotate_value(snapshot)
+  end
+end
+
+#XXX should we pass along which choice, include what the options were?
+class BinData::Choice
+  def annotated_snapshot
+    super.merge contents: [ current_choice.annotated_snapshot ], contents_type: :hash
+  end
+end
+
+class BinData::Array
+  def annotated_snapshot
+    super.merge contents: elements.map { |el| el.annotated_snapshot }, contents_type: :array
+  end
+end
+
+class BinData::Struct
+  def annotated_snapshot
+    super.merge( contents: field_names.map do |name|
+      o = find_obj_for_name(name)
+      o.annotated_snapshot.merge name: name if include_obj?(o)
+    end.find_all { |x| x }, contents_type: :hash )
+  end
+end
+
+class BinData::Primitive
+  def annotated_snapshot
+    super.merge annotate_value(snapshot)
+  end
+end
+
+module BinProxy
+  # This class represents a message being proxied, including the
+  # raw bits, the BinData parsed representation, and metadata such
+  # as the asssociated session, which direction it's going, and whether
+  # it's been forwarded. [some of the above still TODO!]
+  class ProxyMessage < BinProxy::ProxyBaseItem
+    attr_accessor :message, :message_class, :force_reserialize
+    attr_reader :modified
+
+
+    def initialize(raw_bytes, parsed_message)
+      super()
+      @raw = raw_bytes
+      @message = parsed_message
+      @message_class = @message.class
+      @modified = false
+      @force_reserialize # XXX ???
+
+      if @raw != @message.to_binary_s
+        log.warn "WARNING, inconsistent binary representation:\n[[ORIGINAL]]\n#{@raw.hexdump}\n[[RESERIALIZED]]\n#{@message.to_binary_s.hexdump}"
+        log.warn "... @raw encoding is #{@raw.encoding}; to_binary_s is #{@message.to_binary_s.encoding}"
+      end
+    end
+
+    # The next two methods are the last stop before JSON encoding, so all strings
+    # in the returned hash must be UTF-8 compatible.
+
+    def headers
+      super.merge({
+        size: @raw.length,
+        # HACK - this will prevent errors, but will mangle anything that isn't
+        # actually utf8. We should try to handle this upstream where we might
+        # know what the actual encoding is.
+        summary: @message.summary.force_encoding('UTF-8').scrub,
+        message_class: @message_class.to_s,
+      })
+    end
+
+    def to_hash
+      {
+        head: headers,
+        body: {
+          snapshot: @message.annotated_snapshot,
+          raw: Base64.encode64(@raw)
+        }
+      }
+    end
+
+    def to_binary_s
+      if @modified or @force_reserialize
+        @message.to_binary_s
+      else
+        @raw
+      end
+    end
+
+    def update!(snapshot)
+      @modified = true
+      @message.assign( deannotate_snapshot(snapshot) )
+    end
+
+    def forward!(reason)
+      @session.send_message(self)
+      self.disposition = "Sent #{reason}"
+    end
+
+    def drop!(reason)
+      self.disposition = "Dropped #{reason}"
+    end
+
+    def inspect #standard inspect pulls in junk from sesssion
+      "#<#{self.class.to_s} #{self.to_hash}>"
+    end
+
+    private
+    #turns the output of #annotated_snapshot into the format used by
+    # #snapshot and #assign  XXX not fully tested w/ compound elements, esp arrays
+    def deannotate_snapshot(s, out=nil)
+      val = if s.has_key? :value
+        if s[:value].is_a? String
+          Base64.decode64(s[:value])
+        else
+          s[:value]
+        end
+      elsif s.has_key? :contents
+        if s[:contents_type].to_s == 'hash'
+          s[:contents].reduce({}) {|h, c| deannotate_snapshot(c, h) }
+        elsif s[:contents_type].to_s == 'array'
+          s[:contents].reduce([]) {|a, c| deannotate_snapshot(c, a) }
+        else
+          raise "Expected hash or array for contents_type, got #{s[:contents_type]}"
+        end
+      else
+        raise "Snapshot has neither :value nor :contents key"
+      end
+
+      if out.nil? # top level item
+        val
+      elsif out.is_a? Hash
+        raise "Expected :name for snapshot item within a hash" unless s.has_key? :name
+        out[s[:name].to_sym] = val
+        out
+      elsif out.is_a? Array
+        out << val
+      else
+        raise "Ooops!  out param s/b hash or array, but it was #{out.class}"
+      end
+    end
+
+
+
+  end
+end

data/lib/binproxy/session.rb

@@ -0,0 +1,47 @@
+module BinProxy
+  # This class represents a pair of TCP connections (client <-> proxy and proxy
+  # <-> server), through which a number of messages may be sent.
+  class Session
+    include Observable
+    attr_reader :id, :endpoints, :open_time, :close_time
+
+    def initialize(id, client, server, parser_class)
+      @open_time = Time.now
+      @id = id
+      @endpoints = { client: client, server: server }
+      p = parser_class.new
+      @endpoints.each_pair do |peer, conn|
+        conn.parser = p
+        conn.add_observer(self, :send)
+      end
+    end
+
+    # should receive a ProxyMessage from Connection
+    def message_received(pm)
+      pm.session = self
+      changed
+      notify_observers(:message_received, pm)
+    end
+
+    def send_message(message)
+      endpoints[message.dest].send_message(message)
+    end
+
+    def connection_completed(conn)
+      # this is only called for the upstream connection, as the downstream connection is already completed
+      # by the time that the session is created
+      log.warn 'unexpected connection_completed on downstream' if conn.peer != :server
+      endpoints[:client].upstream_connected(conn)
+    end
+
+    def connection_lost(peer, reason)
+      @close_time = Time.now
+      # XXX Shutdown the endpoints
+      #  - but not until we've finished passing through* any existing messages
+      #  (this needs to be handled up a level at the proxy)
+      #  * or dropping??
+      changed
+      notify_observers(:session_closed, self, peer, reason)
+    end
+  end
+end

data/lib/binproxy/web_console.rb

@@ -0,0 +1,194 @@
+require 'sinatra/base'
+require 'sinatra-websocket'
+require 'clipboard'
+
+# Currently, the caller passes a block to .new which configures the Sinatra
+# app.  this config applies to the whole class, so technically we should
+# probably use some sort of get_instance class method which builds a subclass
+# for each invocation, but YAGNI.
+
+class BinProxy::WebConsole < Sinatra::Base
+  include BinProxy::Logger
+
+  def self.new_instance(&blk)
+    c = Class.new(self)
+    c.configure &blk
+    c.new
+  end
+
+  #def initialize
+  #  raise RuntimeError.new "Use WebConsole.build(&blk) instead of .new" if self.class == BinProxy::WebConsole
+  #  super
+  #end
+
+  set sockets: []
+  set haml: { escape_html: true }
+
+  get '/' do
+    if request.websocket?
+      request.websocket {|s| WebSocketHandler.new(settings.proxy, s) }
+    elsif settings.proxy.status != 'running'
+      redirect '/config'
+    else
+      haml :index, locals: {need_config: settings.proxy.nil?}
+    end
+  end
+
+  get '/config' do
+    haml :config, locals: { opt_vals: settings.opts }
+  end
+
+  post '/config' do
+    params.symbolize_keys!
+    new_opts = settings.opts.merge params
+    begin
+      settings.opts = new_opts
+      settings.proxy.configure(new_opts)
+      redirect '/'
+    rescue Exception => e
+      log.err_trace(e, 'updating configuration')
+      haml :config, locals: { opt_vals: new_opts, err_msg: e.message }
+    end
+  end
+
+  post '/reload' do
+    content_type :json
+    begin
+      settings.proxy.configure(settings.opts) #XXX this relies on configure to always trigger reload
+      { success: true }.to_json
+    rescue Exception => e
+      { success: false, message: e.message, detail: e.backtrace.join("\n") }.to_json
+    end
+  end
+
+  put '/clipboard' do
+    content_type :json
+    begin
+      if Clipboard.implementation == Clipboard::File
+        return { success: false, message: "Clipboard not available.  Install xclip?" }.to_json
+      end
+      log.info "Copying #{request.content_length} bytes to clipboard"
+      text = request.body.read
+      log.debug "CB Data: #{text}"
+      Clipboard.copy text
+      { success: true }.to_json
+    rescue Exception => e
+      log.error e.message + ": " + e.backtrace.join("\n")
+      { success: false, message: e.message, detail: e.backtrace.join("\n") }.to_json
+    end
+  end
+
+  get '/:name.css' do
+    begin
+      scss params[:name].to_sym, style: :expanded
+    rescue Sass::SyntaxError => e
+      log.err_trace(e, 'processing SCSS stylesheet')
+      content_type :css
+      "body::before { color: red; content: 'SASS Error: #{e.message} : #{e.backtrace[0]}' }"
+    end
+  end
+
+  get '/m/:id' do
+    content_type :json
+    settings.proxy.buffer[params[:id].to_i].to_hash.to_json rescue 404
+  end
+
+  class WebSocketHandler
+    include BinProxy::Logger
+
+    def initialize(proxy, socket)
+      @proxy = proxy
+      @socket = socket
+      @pending_messages = []
+
+      socket.onopen { self.onopen }
+      socket.onmessage {|m| self.onmessage(m) }
+      socket.onclose { self.onclose }
+    end
+
+    def socket_send(type, data)
+      @socket.send( JSON.generate({
+        type: type,
+        data: data
+      }, max_nesting: 99)) #XXX
+    end
+
+    def onopen
+      @proxy.add_observer(self, :send)
+      socket_send :message_count, @proxy.history_size
+    end
+
+    def onmessage(raw_ws_message)
+      log.debug "websocket message received: #{raw_ws_message}"
+      ws_message = JSON.parse(raw_ws_message, symbolize_names: true)
+      case ws_message[:action]
+      when 'ping'
+        socket_send :pong, status: @proxy.status
+      when 'forward'
+        message = @proxy.update_message_from_hash(ws_message[:message])
+        @proxy.send_message(message, :manual)
+        socket_send :update, message.to_hash #XXX send all of this, or just update?
+      when 'drop'
+        #XXX just doing this to get the message object
+        message = @proxy.update_message_from_hash(ws_message[:message])
+        @proxy.drop_message(message, :manual)
+        socket_send :update, message.to_hash #XXX same as above
+      when 'setIntercept'
+        log.debug "setIntercept: #{ws_message[:value]}"
+        @proxy.hold = ws_message[:value]
+      when 'load'
+        log.debug "load: #{ws_message[:value]}"
+        socket_send_message @proxy.buffer[ws_message[:value]]
+      when 'getHistory'
+        log.error 'unexpected getHistory'
+      #  log.debug "getHistory"
+      #  @proxy.buffer.each do |message|
+      #    socket_send_message message
+      #  end
+      when 'reloadParser'
+        log.debug 'reloadParser'
+        begin
+          @proxy.configure #XXX this relies on configure to always trigger reload, which is considered a bug
+          socket_send :info, message: 'Parser Reloaded'
+        rescue Exception => e
+          socket_send :error, message: "Parser Reload Failed: #{e.message}", detail: e.backtrace
+          log.err_trace(e, 'Reloading Parser')
+        end
+      else
+        log.error 'Unexpected WS message: ' + ws_message.inspect
+      end
+      log.debug 'Finished processing WS message'
+    #rescue Exception => e
+    #  puts "caught #{e}", e.backtrace
+    end
+
+    def onclose
+      @proxy.delete_observer(self)
+    #rescue Exception => e
+    #  puts "caught #{e}", e.backtrace
+    end
+
+    def message_received(message)
+      log.debug "sending WS message to front-end for message #{message.id}"
+      socket_send_message message
+    end
+
+    def session_event(event)
+      log.debug "session event #{event}"
+      socket_send :event, event.to_hash
+      #TODO delete observer if event is connection close
+    end
+
+    def bindata_error(operation, err)
+      socket_send :error, {
+        message: "Internal Error in #{operation}: #{err.class}: #{err.message}",
+        detail: err.backtrace.join("\n")
+      }
+    end
+
+    private
+    def socket_send_message(message)
+      socket_send :message, message.to_hash
+    end
+  end
+end