emonti-rbkb 0.6.1.3 → 0.6.2

data/lib/rbkb/cli/rstrings.rb

@@ -0,0 +1,102 @@
+require 'rbkb/cli'
+
+# rstrings is Unix "strings" in ruby... with some extra stuff
+class Rbkb::Cli::Rstrings < Rbkb::Cli::Executable
+  def initialize(*args)
+    super(*args)
+    {
+      :start_off => 0, 
+      :end_off => -1, 
+      :encoding => :both, 
+      :minimum => 6,
+      :align => nil,
+      :indat => Array.new,
+      :fnames => Array.new,
+    }.each {|k,v| @opts[k] ||= v }
+  end
+
+  def make_parser()
+    arg = super()
+    arg.banner += " <file ... || blank for stdin>"
+
+    arg.on("-s", "--start=OFFSET", "Start at offset") do |s|
+      unless m=/^(?:(\d+)|0x([A-Fa-f0-9]+))$/.match(s)
+        bail "invalid offset '#{s}'"
+      end
+      @opts[:start_off] = (m[2])? m[0].hex : m[0].to_i
+    end
+
+    arg.on("-e", "--end=OFFSET", "End at offset") do |e|
+      unless m=/^(?:(\d+)|0x([A-Fa-f0-9]+))$/.match(e)
+        bail "invalid offset '#{e}'"
+      end
+      @opts[:end_off] = (m[2])? m[0].hex : m[0].to_i
+    end
+
+    arg.on("-t", "--encoding-type=TYPE", 
+      "Encoding: ascii/unicode/both (default=#{@opts[:encoding]})") do |t|
+        @opts[:encoding] = t.to_sym
+    end
+
+    arg.on("-l", "--min-length=NUM", Numeric,
+      "Minimum length of strings (default=#{@opts[:minimum]})") do |l|
+        @opts[:minimum] = l
+    end
+
+    arg.on("-a", "--align=ALIGNMENT", Numeric, 
+      "Match only on alignment (default=none)") do |a|
+        (@opts[:align] = a) > 0 or bail "bad alignment '#{a}'"
+    end
+
+    return arg
+  end
+
+  def parse(*args)
+    super(*args)
+    if @opts[:indat].empty? and not @argv.empty?
+      while a=@argv.shift
+        @opts[:indat] << do_file_read(a)
+        @opts[:fnames] << a
+      end
+    end
+
+    parse_catchall()
+
+    if @opts[:indat].empty?
+      @opts[:indat] << @stdin.read() if @opts[:indat].empty?
+      @opts[:fnames] << "[STDIN]"
+    end
+  end
+
+  def go(*args)
+    super(*args)
+
+    start_off = @opts[:start_off]
+    end_off   = @opts[:end_off]
+    enc  = @opts[:encoding]
+    min  = @opts[:minimum]
+    align = @opts[:align]
+
+    @opts[:pr_fnames]=true if @opts[:fnames].size > 1
+
+    i=0
+    while buf=@opts[:indat].shift
+      buf[start_off..end_off].strings(
+        :encoding => enc,
+        :minimum => min,
+        :align => align
+      ) do |off, len, type, str|
+        if @opts[:pr_fnames]
+          @stdout << "#{@opts[:fnames][i]}:"
+        end
+        @stdout << "#{(off+start_off).to_hex.rjust(8,"0")}:"+
+                   "#{(len+start_off).to_hex.rjust(8,"0")}:"+
+                   "#{type.to_s[0,1]}:#{str.delete("\000").inspect}\n"
+      end
+      i+=1
+    end
+
+    self.exit(0)
+  end
+end
+

data/lib/rbkb/cli/slice.rb

@@ -0,0 +1,43 @@
+require 'rbkb/cli'
+
+# Returns a slice from input. This is just a shell interface to a String.slice 
+# operation.
+class Rbkb::Cli::Slice < Rbkb::Cli::Executable
+
+  def initialize(*args)
+    super(*args)
+    @opts[:last] ||= -1
+  end
+
+  def make_parser()
+    super()
+    add_std_file_opt(:indat)
+    add_range_opts(:first, :last)
+    arg = @oparse
+
+    arg.banner += " start (no args when using -r or -x)"
+  end
+
+
+  def parse(*args)
+    super(*args)
+    @opts[:first] ||= @argv.shift
+
+    unless(Numeric === @opts[:first] or /^-?\d+$/.match(@opts[:first]) )
+      bail_args "invalid start length"
+    end
+
+    parse_catchall()
+
+    @opts[:first] = @opts[:first].to_i
+    @opts[:indat] ||= @stdin.read()
+  end
+
+
+  def go(*args)
+    super(*args)
+    @stdout << @opts[:indat][ @opts[:first] .. @opts[:last] ]
+  end
+
+end
+

data/lib/rbkb/cli/telson.rb

@@ -0,0 +1,116 @@
+require 'rbkb/cli'
+require 'rbkb/plug'
+require 'eventmachine'
+
+
+# This is an implementation of the original blackbag "telson" around 
+# ruby and eventmachine. 
+#
+# Telson can do the following things with minimum fuss: 
+#   - Run as a server or client using UDP or TCP
+#   - Debugging network protocols
+#   - Observe client/server behaviors using different messages at
+#     various phases of a conversation.
+#
+class Rbkb::Cli::Telson < Rbkb::Cli::Executable
+
+  def initialize(*args)
+    super(*args)
+    @b_addr = Plug::Blit::DEFAULT_IPADDR
+    @b_port = Plug::Blit::DEFAULT_PORT
+    @srced = @persist = false
+    @s_addr = "0.0.0.0"
+    @s_port = 0
+    @proto = :TCP
+
+    # XXX TODO Plug::UI obviously need fixing. It shouldn't be a module
+    # with constants for configuration
+    Plug::UI::LOGCFG[:verbose] = true
+    Plug::UI::LOGCFG[:dump] = :hex
+    Plug::UI::LOGCFG[:out] = @stderr
+  end
+
+
+  def make_parser()
+    arg = super()
+    arg.banner += " host:port"
+
+    arg.on("-u", "--udp", "UDP mode") do
+      @proto=:UDP
+    end
+
+    arg.on("-b", "--blit=ADDR:PORT", "Where to listen for blit") do |b|
+      unless m=/^(?:([\w\.]+):)?(\d+)$/.match(b)
+        bail("Invalid blit address/port")
+      end
+      @b_port = m[2].to_i
+      @b_addr = m[1] if m[1]
+    end
+
+    arg.on("-o", "--output=FILE", "Output to file instead of screen") do |f|
+      Plug::UI::LOGCFG[:out] = File.open(f, "w") # XXX
+    end
+
+    arg.on("-q", "--quiet", "Turn off verbose logging") do
+      Plug::UI::LOGCFG[:verbose] = false # XXX
+    end
+
+    arg.on("-r", "--reconnect", "Attempt to reconnect endlessly.") do
+      @persist=true
+    end
+
+    arg.on("-s", "--source=(ADDR:?)PORT", "Bind on port (and addr?)") do |p|
+      if m=/^(?:([\w\.]+):)?(\d+)$/.match(p)
+        @s_addr = $1 if $1
+        @s_port = $2.to_i
+        @srced = true
+      else
+        bail("Invalid listen argument: #{p.inspect}")
+      end
+    end
+  end
+
+
+  def parse(*args)
+    super(*args)
+
+    # Get target argument
+    unless (m = /^([\w\.]+):(\d+)$/.match(@argv.shift)) and @argv.shift.nil?
+      bail "Invalid target #{arg}"
+    end
+
+    @t_addr = m[1]
+    @t_port = m[2].to_i
+  end
+
+
+  def go(*args)
+    super(*args)
+
+    loop do
+      EventMachine.run {
+        if @proto == :TCP
+          bail("Sorry: --source only works with UDP.") if @srced
+
+          c=EventMachine.connect(@t_addr, @t_port, Plug::Telson, @proto)
+
+        elsif @proto == :UDP
+          c=EventMachine.open_datagram_socket(
+            @s_addr, @s_port, Plug::Telson, @proto
+          )
+          c.peers.add_peer_manually(@t_addr, @t_port)
+
+        ### someday maybe raw or others?
+        else
+          raise "bad protocol"
+        end
+
+        EventMachine.start_server(@b_addr, @b_port, Plug::Blit, :TCP, c)
+        Plug::UI::verbose("** BLITSRV-#{@b_addr}:#{@b_port}(TCP) Started") # XXX
+      }
+      break unless @persist
+      Plug::UI::verbose("** RECONNECTING") # XXX
+    end
+  end
+end
+

data/lib/rbkb/cli/unhexify.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'rbkb/cli'
+
+# unhexify converts a string of hex bytes back to raw data. Input can be 
+# supplied via stdin, a hex-string argument, or a file containing hex (use -f).
+class Rbkb::Cli::Unhexify < Rbkb::Cli::Executable
+  def make_parser
+    super()
+    add_std_file_opt(:indat)
+    arg = @oparse
+
+    #----------------------------------------------------------------------
+    # Add local options
+    arg.banner += " <data | blank for stdin>"
+
+    arg.on("-d", "--delim DELIMITER", 
+           "DELIMITER regex between hex chunks") do |d|
+        @opts[:delim] = Regexp.new(d.gsub('\\\\', '\\'))
+    end
+  end
+
+  def parse(*args)
+    super(*args)
+
+    # default string arg
+    if @opts[:indat].nil? and a=@argv.shift
+      @opts[:indat] = a.dup 
+    end
+
+    # catchall
+    bail_args @argv.join(' ') if ARGV.length != 0 
+  end
+
+  def go(*args)
+    super(*args)
+
+    # Default to standard input
+    @opts[:indat] ||= @stdin.read() 
+
+    @opts[:indat].delete!("\r\n")
+    @opts[:delim] ||= /\s*/
+
+    unless out = @opts[:indat].unhexify(@opts[:delim])
+      bail "Error: Failed parsing as hex"
+    end
+
+    @stdout << out
+
+    self.exit(0)
+  end
+end
+

data/lib/rbkb/cli/urldec.rb

@@ -0,0 +1,31 @@
+require 'rbkb/cli'
+
+# urldec converts a url percent-encoded string back to its raw form.
+# Input can be supplied via stdin, a string argument, or a file (with -f).
+# (url percent-encoding is just fancy hex encoding)
+class Rbkb::Cli::Urldec < Rbkb::Cli::Executable
+  def make_parser()
+    super()
+    add_std_file_opt(:indat)
+    arg = @oparse
+    arg.banner += " <data | blank for stdin>"
+
+    arg.on("-p", "--[no-]plus", "Convert '+' to space (default: true)") do |p|
+      @opts[:noplus] = (not p)
+    end
+  end
+
+  def parse(*args)
+    super(*args)
+    parse_string_argument(:indat)
+    parse_catchall()
+  end
+
+  def go(*args)
+    super(*args)
+    # Default to standard input
+    @opts[:indat] ||= @stdin.read()
+    @stdout << @opts[:indat].urldec(:noplus => @opts[:noplus])
+  end
+end
+

data/lib/rbkb/cli/urlenc.rb

@@ -0,0 +1,31 @@
+require 'rbkb/cli'
+
+# urlenc converts a string or raw data to a url percent-encoded string 
+# Input can be supplied via stdin, a string argument, or a file (with -f).
+# (url percent-encoding is just fancy hex encoding)
+class Rbkb::Cli::Urlenc < Rbkb::Cli::Executable
+  def make_parser()
+    super()
+    add_std_file_opt(:indat)
+    arg = @oparse
+    arg.banner += " <data | blank for stdin>"
+
+    arg.on("-p", "--[no-]plus", 
+           "Convert spaces to '+' (default: false)") do |p|
+      @opts[:plus] = p
+    end
+  end
+
+  def parse(*args)
+    super(*args)
+    parse_string_argument(:indat)
+    parse_catchall()
+  end
+
+  def go(*args)
+    super(*args)
+    # Default to standard input
+    @opts[:indat] ||= @stdin.read()
+    @stdout << @opts[:indat].urlenc(:plus => @opts[:plus]) + "\n"
+  end
+end

data/lib/rbkb/cli/xor.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require 'rbkb/cli'
+
+# Repeating string xor. Takes input from a string, stdin, or a file (-f).
+class Rbkb::Cli::Xor < Rbkb::Cli::Executable
+  def make_parser()
+    super()
+    add_std_file_opt(:indat)
+    arg = @oparse
+    arg.banner += " -k|-s <key> <data | stdin>"
+
+    arg.separator "  Key options (you must specify one of the following):"
+    arg.on("-s", "--strkey STRING", "xor against STRING")  do |s|
+        bail "only one key option can be specified with -s or -x" if @opts[:key]
+        @opts[:key] = s
+    end
+
+    arg.on("-x", "--hexkey HEXSTR", "xor against binary HEXSTR") do |x|
+        bail "only one key option can be specified with -s or -x" if @opts[:key]
+        x.sub!(/^0[xX]/, '')
+        bail "Unable to parse hex string" unless @opts[:key] = x.unhexify
+    end
+    return arg
+  end
+
+  def parse(*args)
+    super(*args)
+    bail("You must specify a key with -s or -x\n#{@oparse}") unless @opts[:key]
+    parse_string_argument(:indat)
+    parse_catchall()
+  end
+
+  def go(*args)
+    super(*args)
+    @opts[:indat] ||= @stdin.read
+    @stdout << @opts[:indat].xor(@opts[:key])
+    self.exit(0)
+  end
+end
+

data/lib/rbkb/cli.rb

@@ -0,0 +1,212 @@
+require 'rbkb'
+require 'optparse'
+
+module Rbkb::Cli
+  # Rbkb::Cli::Executable is an abstract class for creating command line
+  # executables using the Ruby Black Bag framework.
+  class Executable
+
+    def self.run(param={})
+      new(param).go
+    end
+
+    attr_accessor :stdout, :stderr, :stdin, :argv, :opts, :oparse
+
+    # Instantiates a new Executable object.
+    #
+    # The 'param' argument is a named value hash. The following keys are
+    # significant:
+    #
+    #  :argv   - An array of cli arguments (default ARGV)
+    #  :opts    - executable/function options for use when running 'go'
+    #  :stdout, - IO redirection (mostly for unit tests)
+    #  :stderr,   
+    #  :stdin
+    #
+    #
+    # The above keys are deleted from the 'param' hash and stored as instance
+    # variables with attr_accessors.  All other parameters are ignored.
+    def initialize(param={})
+      @argv   ||= param.delete(:argv) || ARGV
+      @stdout ||= param.delete(:stdout) || STDOUT
+      @stderr ||= param.delete(:stderr) || STDERR
+      @stdin  ||= param.delete(:stdin) || STDIN
+      @opts   ||= param.delete(:opts) || {}
+      make_parser()
+      yield self if block_given?
+    end
+
+
+    # Wrapper for Kernel.exit() so we can unit test cli tools
+    def exit(ret)
+      if defined? Rbkb::Cli::TESTING
+        raise("Exited with return code: #{ret}") if ret != 0
+      else
+        Kernel.exit(ret)
+      end
+    end
+
+
+    # This method exits with a message on stderr
+    def bail(msg)
+      @stderr.puts msg if msg
+      self.exit(1)
+    end
+
+
+    # This method wraps a 'bail' with a basic argument error mesage and hint
+    # for the '-h or --help' flag
+    # The 'arg_err'  parameter is a string with the erroneous arguments
+    def bail_args(arg_err)
+      bail "Error: bad arguments - #{arg_err}\n  Hint: Use -h or --help"
+    end
+
+
+    # Prepares an OptionsParser object with blackbag standard options
+    # This is called from within initialize() and should be overridden in
+    # inherited classes to add additional OptionParser-based parsers.
+    #
+    # See parse for actual parsing.
+    def make_parser
+      @oparse ||= OptionParser.new 
+      @oparse.banner = "Usage: #{File.basename $0} [options]"
+
+      @oparse.on("-h", "--help", "Show this message") do
+        bail(@oparse)
+      end
+
+      @oparse.on("-v", "--version", "Show version and exit") do
+        bail("Ruby BlackBag version #{Rbkb::VERSION}")
+      end
+
+      return @oparse
+    end
+
+
+    # Abstract argument parser. Override this method with super() from 
+    # inherited executables. The base method just calls OptionParser.parse!
+    # on the internal @oparse object.
+    def parse
+      # parse flag arguments
+      @oparse.parse!(@argv) rescue(bail_args($!))
+      @parsed=true
+
+      # the overriding class may implement additional arguments from here
+    end
+    
+
+    # Abstract 'runner'. Override this method with super() from inherited
+    # executables. The base method just slurps in an optional argv and
+    # runs 'parse' if it hasn't already
+    def go(argv=nil)
+      if argv 
+        @argv = argv
+      end
+
+      parse
+
+      # the overriding class implements actual functionality beyond here
+    end
+
+
+    private
+
+    # Wraps a file read with a standard bail error message
+    def do_file_read(f)
+      File.read(f) rescue(bail "File Read Error: #{$!}")
+    end
+
+
+    # Implements a basic input file argument. File reading is handled
+    # by do_file_read().
+    #
+    # Takes one argument, which is the @opts hash keyname to store
+    # the file data into.
+    # (Used commonly throughout several executables)
+    def add_std_file_opt(inkey)
+      @oparse.on("-f", "--file FILENAME", "Input from FILENAME") do |f|
+        @opts[inkey] = do_file_read(f)
+      end
+      return @oparse
+    end
+
+
+    # Implements numeric and hex range options via '-r' and '-x'
+    #
+    # Takes two arguments which are the @opts hash key names for
+    # first and last parameters.
+    #
+    # (Used commonly throughout several executables)
+    def add_range_opts(fkey, lkey)
+      @oparse.on("-r", "--range=START[:END]", 
+                 "Start and optional end range") do |r|
+
+        raise "-x and -r are mutually exclusive" if @parser_got_range
+        @parser_got_range=true
+
+        unless m=/^(-?[0-9]+)(?::(-?[0-9]+))?$/.match(r)
+          raise "invalid range #{r.inspect}"
+        end
+
+        @opts[fkey] = $1.to_i
+        @opts[lkey] = $2.to_i if $2
+      end
+
+      @oparse.on("-x", "--hexrange=START[:END]", 
+                 "Start and optional end range in hex") do |r|
+
+        raise "-x and -r are mutually exclusive" if @parser_got_range
+        @parser_got_range=true
+
+        unless m=/^(-?[0-9a-f]+)(?::(-?[0-9a-f]+))?$/i.match(r)
+          raise "invalid range #{r.inspect}"
+        end
+
+        @opts[fkey] = 
+          if ($1[0,1] == '-')
+            ($1[1..-1]).hex_to_num * -1
+          else
+            $1.hex_to_num
+          end
+
+        if $2
+          @opts[lkey] = 
+            if($2[0,1] == '-')
+              $2[1..-1].hex_to_num * -1
+             else
+              $2.hex_to_num
+             end
+        end
+      end
+    end
+
+
+    # Conditionally parses a string argument. Uses 'key' to first check for 
+    # then store it in @opts hash if it is not yet there.
+    # (Used commonly throughout several executables)
+    def parse_string_argument(key)
+      if @opts[key].nil? and s=@argv.shift
+        @opts[key] = s.dup 
+      end
+    end
+
+
+    # Conditionally parses a file argument. Uses 'key' to first check for 
+    # then store it in @opts hash if it is not yet there.
+    # (Used commonly throughout several executables)
+    def parse_file_argument(key)
+      if @opts[key].nil? and f=@argv.shift
+        @opts[key] = do_file_read(f)
+      end
+    end
+
+    # For use at the end of a parser - calls bail_args with remaining
+    # arguments if there are extra arguments.
+    # (Used commonly throughout several executables)
+    def parse_catchall
+      bail_args(@argv.join(' ')) if(@argv.length != 0)
+    end
+
+  end
+end
+