binproxy 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 44001220659cdaf6bbfc717584005b4f23942966
+  data.tar.gz: 9dd5864e6a3f35b5cdec8d87d8bf13d85a8572d3
+SHA512:
+  metadata.gz: 87561464e03a4db14d7fa9814d2e46ca0236cedf449f74aafa0a58eeb5121dfbcbe9c872f93d1b66980ffb46a84f0d44588c59a45392309ffe0887112fdcc9ed
+  data.tar.gz: c0e2f7a2fdf416ca685702028f435ff7f75307c0bcc6261219501ab8f5fc9fc72909006c1d9b4a3de7e22daf06fa74ee7a852fa4b8635f714951a8f1d5877dce

data/bin/binproxy

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+
+if RUBY_VERSION < "2.3"
+  throw "This program requires ruby 2.3 or later, but RUBY_VERSION is #{RUBY_VERSION}"
+end
+Encoding.default_external = 'BINARY'
+
+require 'binproxy'
+require 'binproxy/logger'
+require 'binproxy/web_console'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/object/blank'
+require 'json'
+require 'trollop'
+require 'haml'
+require 'sass'
+require 'colorize'
+require 'tempfile'
+
+opts = Trollop::options do
+  banner <<END
+Usage: #{$0} [opts] [listen-host listen-port dest-host dest-port]
+  If listen-host is omitted, it is assumed to be localhost.
+  In --socks mode, dest-host and dest-port are optional and ignored.
+
+  [opts] are:
+END
+  opt :class_name, "parser class", default: "RawMessage", short: 'c'
+  opt :class_file, "class file (default: guess from class name)", type: String, short: 'C'
+
+  opt :tls, "Unwrap TLS/SSL"
+  opt :tls_cert, "TLS/SSL certificate file (PEM format)", type: String, short: 'e'
+  opt :tls_key, "TLS/SSL private key file (PEM format)", type: String, short: 'k'
+
+  opt :http_host, "Run web server on this addr", default: 'localhost', short: 'o'
+  opt :http_port, "Run web server on this port", default: 4567, short: 'p'
+
+  opt :debug, "print debugging data to stdout", default: false, short: 'd'
+  opt :debug_extra, "as above, but extra verbose", default: false, short: 'D'
+
+  opt :socks_proxy, 'act as a SOCKSv4 proxy', default: false, short: 'S'
+  opt :http_proxy, 'act as an HTTP proxy (CONNECT only)', default: false, short: 'H'
+  #XXX the above two probably should be mutually exclusive
+end
+
+
+binproxy_root = File.absolute_path(File.join(File.dirname(__FILE__),'..'))
+
+log = BinProxy::Logger::log
+log.progname = 'BinProxy'
+formatter = Logger::Formatter.new
+log.formatter = lambda do |sev,date,prog,msg|
+  colors = {
+    DEBUG: :default,
+    INFO:  :light_white,
+    WARN:  :light_yellow,
+    ERROR: :red,
+    FATAL: :red,
+  }
+  #formatter.call(sev,date,prog,msg).colorize(colors[sev.to_sym] ||:light_blue)
+  line = caller.find {|l| !l.match /logger\.rb/ }
+  cm = line.match(%r|^.*/([^/]+):(\d+):in `(.*)'$|) or raise "Couldn't parse caller() line"
+  msg = msg.gsub /\r?\n/, ("\n" + " " * 25)
+  sprintf( "%-18s %-5s %s\n",
+           "#{cm[1]}:#{cm[2]}", sev, msg
+  ).colorize(colors[sev.to_sym] ||:light_blue)
+end
+log.level = case
+            when opts[:debug_extra] then Logger::DEBUG
+            when opts[:debug]       then Logger::INFO
+            else                         Logger::WARN
+            end
+
+if opts[:tls]
+  if opts[:tls_cert] or opts[:tls_key]
+    Trollop::die :tls_cert, "is required when :tls_key is given" unless opts[:tls_cert]
+    Trollop::die :tls_key, "is required when :tls_cert is given" unless opts[:tls_key]
+    Trollop::die :tls_cert, "must be an existing file" unless File.exists?(opts[:tls_cert])
+    Trollop::die :tls_key, "must be an existing file" unless File.exists?(opts[:tls_key])
+  else
+    log.info("generating a self-signed TLS/SSL cert")
+    #EM currently only supports files, not in-memory strings for cert/key
+    #XXX confirm this no longer leaks files
+    opts[:tls_cert] = Tempfile.create('cert').path
+    opts[:tls_key] = Tempfile.create('key').path
+    out = "yes '' | openssl req -x509 -nodes -days 365 -newkey rsa:1024 -keyout '#{opts[:ssl_key]}' -out '#{opts[:ssl_cert]}' >/dev/null"
+    log << out if log.debug?
+    system(out) #XXX
+  end
+end
+
+if [1,3].include? ARGV.length
+  log.debug 'assuming listen host is localhost'
+  ARGV.unshift 'localhost'
+end
+
+if ARGV.empty?
+  log.warn "No hosts/ports specified; please configure via the web interface."
+elsif (opts[:socks_proxy] or opts[:http_proxy]) and ARGV.length == 2
+  opts.merge! Hash[([ :lhost, :lport ].zip(ARGV))]
+  log.info "Proxying from #{opts[:lhost]}:#{opts[:lport]} to dynamic destination"
+elsif ARGV.length == 4
+  opts.merge! Hash[([ :lhost, :lport, :dhost, :dport ].zip(ARGV))]
+  log.info "Proxying from #{opts[:lhost]}:#{opts[:lport]} to #{opts[:dhost]}:#{opts[:dport]}"
+else
+  Trollop::die "Unexpected number of host/port arguments"
+end
+
+log.info "Constructing Proxy..."
+proxy = BinProxy::Proxy.new(binproxy_root, opts)
+
+log.info "Constructing Web Console..."
+web_console = Sinatra.new(BinProxy::WebConsole) do
+  set opts: opts
+  set proxy: proxy
+  set root: binproxy_root
+  set logging: nil unless opts[:debug_extra]
+end
+
+EventMachine.error_handler do |e|
+  log.err_trace e
+end
+
+log.info "Starting Server..."
+EventMachine.run do
+  Rack::Server.start({
+    app: web_console,
+    server: 'thin',
+    Host: opts[:http_host],
+    Port: opts[:http_port],
+  })
+  Signal.trap('INT') { EM.stop_event_loop }
+  EM.next_tick { log.info "BinProxy is ready" }
+end

data/lib/binproxy.rb

@@ -0,0 +1,2 @@
+require_relative 'binproxy/proxy'
+require_relative 'binproxy/class_loader'

data/lib/binproxy/bd_util.rb

@@ -0,0 +1,267 @@
+require 'bindata'
+
+=begin
+ class BinData::Base
+   def real_inspect
+     "#<#{self.class}:#{self.object_id} #{self.instance_variables.map do |v|
+       "#{v}=#{
+         tmp = self.instance_variable_get v
+         if tmp.respond_to? :real_inspect
+           tmp.real_inspect
+         else
+           tmp.inspect
+         end
+       }"
+     end.join ' '}>"
+   end
+ end
+=end
+
+class BinData::Line < BinData::BasePrimitive
+  default_parameter line_end: "\n"
+
+  def sensible_default; ""; end
+
+  #XXX not sure if this does the right thing wrt non-ascii input
+  # can you slip CR or LF in via other encodings?
+  def value_to_binary_string(v)
+    v.to_s.chomp.dup.force_encoding('BINARY').chomp + eval_parameter(:line_end)
+  end
+
+  def read_and_return_value(io)
+    ch = nil
+    str = ''
+    loop do
+      ch = io.readbytes(1)
+      if ch == "\n"
+        break
+      elsif ch == "\r"
+        ch = io.readbytes(1)
+        io.raw_io.ungetbyte(ch) unless ch == "\n"
+        break
+      end
+      str << ch
+    end
+    str
+  end
+end
+
+module BinData
+  class ArgProcessorWrapper
+    def initialize(original_processor, &blk)
+      @original = original_processor
+      @block = blk
+    end
+
+    def sanitize_parameters!(obj_class, obj_params)
+      @original.sanitize_parameters!(obj_class, obj_params)
+      @block.call(obj_class, obj_params)
+    end
+
+    def method_missing(sym, *args)
+      @original.send(sym, *args)
+    end
+  end      
+
+  module ClassParametersPlugin
+    module ClassMethods
+      def class_parameter(sym)
+        ( @class_params ||= [] ) << sym
+      end
+      
+    end
+    def self.included(obj_class)
+      # Wrap the obj_class's existing arg_processor
+      old_arg_processor = obj_class.arg_processor
+      new_arg_processor = ArgProcessorWrapper.new(old_arg_processor) do |obj_class,params|
+        class_params = obj_class.class_eval {@class_params} || []
+        class_params.each do |type|
+          if params.needs_sanitizing?(type)
+            t,p = params[type]
+            params[type] = params.create_sanitized_object_prototype(t,p)
+          end
+        end
+      end
+      obj_class.class_eval do 
+        @arg_processor = new_arg_processor
+      end
+
+      # add class_parameter(:foo) to our class methods / DSL
+      obj_class.extend ClassMethods
+    end
+
+
+  end
+end
+
+=begin
+I'm not sure there's a good way to make this work without a LOT of hackery...
+
+# This class basically exists so we can have type params in DSL-based classes.
+# See PascalString for an example
+class BinData::Variant < BinData::BasePrimitive
+  extend HasClassParameters
+  mandatory_parameter :type
+  class_parameter :type
+
+  def initialize_instance
+    @obj = get_parameter(:type).instantiate(nil,self)
+    @default = @obj.snapshot #should test if reference types need dup here TODO
+  end
+
+  def value_to_binary_string(v)
+    @obj.assign(v)
+    @obj.to_binary_s
+  end
+
+  def read_and_return_value(io)
+    @obj.read(io)
+    @obj.snapshot
+  end
+
+  def sensible_default
+    @default
+  end
+end
+
+=end
+
+# Like the Pascal String class shown in the docs, but with a variable type of
+# length specifier.
+class BinData::PascalString < BinData::BasePrimitive
+  include ::BinData::ClassParametersPlugin
+  default_parameter size_type: :uint8
+  class_parameter :size_type
+
+  def initialize_instance
+    @len_obj = get_parameter(:size_type).instantiate(nil,self)
+  end
+
+  # override this instead of using value_to_binary_string, so that
+  # we don't have to start out byte aligned (the string portion
+  # will still be aligned, though).
+  def do_write(io)
+    @len_obj.assign(_value.bytes.count)
+    @len_obj.write(io)
+    io.writebytes(_value)
+  end
+
+  # again, override for proper bit handling
+  def do_num_bytes
+    @len_obj.num_bytes + _value.bytes.count
+  end
+
+  # only called by do_write and do_num_bytes, which we've overridden, so
+  # shouldn't ever be called.
+  def value_to_binary_string(v)
+    raise RuntimeError.new "this should never be called"
+  end
+
+  def read_and_return_value(io)
+    @len_obj.read(io)
+    s = BinData::String.new(read_length: @len_obj).read(io)
+    s.snapshot
+  end
+
+  def sensible_default
+    ""
+  end
+end
+
+class BinData::Peek < BinData::BasePrimitive
+  include BinData::ClassParametersPlugin
+  default_parameter type: :uint8
+  class_parameter :type
+
+  def initialize_instance
+    @proto = get_parameter :type
+  end
+
+  def value_to_binary_string(val)
+    ''
+  end
+
+  def read_and_return_value(io)
+    #TODO - make this work rather than punting on it
+    if io.instance_eval {@rnbits} > 0
+      raise "cannot peek when not byte aligned!"
+    end
+
+    obj = get_parameter(:type).instantiate(nil,self)
+
+
+    io = io.raw_io
+    pos = io.pos
+    begin
+      obj.read(io)
+    ensure
+      io.pos = pos
+    end
+
+    obj
+  end
+
+  def sensible_default
+    0
+  end
+end
+
+#Need this for positioning underlying IO, which
+#we use to avoid altering BD::IO state (i.e. bits read)
+#TODO find a less hacky way to do all this
+module BinData::IO::Read::SeekableStream
+  attr_reader :initial_pos
+  public :raw_io
+end
+
+class BinData::Pointer < BinData::BasePrimitive
+  include BinData::ClassParametersPlugin
+  mandatory_parameter :ptr_type
+  class_parameter :ptr_type
+
+  #TODO - support seek from current pos?
+  #default_parameter ptr_from: :start
+
+  mandatory_parameter :val_type
+  class_parameter :val_type
+
+  default_parameter seek_from: :start #one of :start, :raw_start, or :current
+  default_parameter seek_offset: 0 #TODO possibly what I want is to name a specific parent object to count from
+
+  attr_reader :ptr, :val
+
+  def read_and_return_value(io)
+    ptr_obj = get_parameter(:ptr_type).instantiate(nil,self)
+    val_obj = get_parameter(:val_type).instantiate(nil,self)
+    ptr = ptr_obj.read(io)
+
+    rio = io.raw_io
+    pos = rio.pos
+
+    base = case get_parameter(:seek_from)
+        when :raw_start  then 0
+        when :start      then io.initial_pos
+        when :current    then pos + ptr
+        else raise "Invalid seek_from parameter"
+        end
+
+    rio.seek base + get_parameter(:seek_offset) + ptr
+    val_obj.read(rio)
+    rio.seek pos
+
+    #{p: ptr_obj, v: val_obj}
+    val_obj
+  end
+
+  #XXX hacky below, handles reading only
+
+  def value_to_binary_string(v)
+    v.to_binary_s
+  end
+
+  def sensible_default
+    #{p: 0, v: nil}
+    get_parameter(:val_type).instantiate(nil,self)
+  end
+
+end

data/lib/binproxy/bindata.rb

@@ -0,0 +1,44 @@
+require 'bindata'
+#This file collects various monkey-patches
+
+# Monkey-patch no-ops for state handling; user can override if needed.  Note:
+# can't use nil as parameter value, so use empty string as placeholder.
+class BinData::Base
+  def self.initial_state; ''; end
+  def current_state; eval_parameter(:protocol_state) || @parent && @parent.current_state ; end
+  def update_state; current_state; end
+  def summary
+    "#{self.class}: #{num_bytes} bytes of data"
+  end
+end
+class BinData::Choice
+  def summary
+    current_choice.summary
+  end
+end
+
+=begin
+class BinData::LazyEvaluator
+  #This is similar to a simplified lazy_eval, but starts w/ @obj, not @obj.parent
+  def lazy_eval_self(val)
+    if val.is_a? Symbol
+      @obj.send(val)
+    elsif val.respond_to? :arity
+      @obj.instance_exec(&val) #??
+    else
+      val
+    end
+  end
+end
+
+class BinData::DSLMixin::DSLParser
+  def summary(arg=nil, &b)
+    raise "expected one arg or block" unless arg.nil? ^ b.nil?
+    @the_class.class_exec do
+      define_method(:summary) do
+        lazy_evaluator.lazy_eval_self(arg || b)
+      end
+    end
+  end
+end
+=end