rbkb 0.6.10

data/lib/rbkb/cli/b64.rb

@@ -0,0 +1,35 @@
+require 'rbkb/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# b64 converts strings or raw data to base-64 encoding.
+class Rbkb::Cli::B64 < Rbkb::Cli::Executable
+  def make_parser
+    super()
+    arg = @oparse
+    arg.banner += " <data | blank for stdin>"
+
+    add_std_file_opt(:indat)
+
+    arg.on("-l", "--length LEN", Numeric, "Output LEN chars per line") do |l|
+        bail("length must be > 0") unless l > 0
+        @opts[:len] = l
+    end
+  end
+
+  def parse(*args)
+    super(*args)
+    parse_string_argument(:indat)
+    parse_file_argument(:indat)
+    parse_catchall()
+    @opts[:indat] ||= @stdin.read
+  end
+
+  def go(*args)
+    super(*args)
+    @stdout << @opts[:indat].b64(opts[:len]).chomp + "\n"
+    self.exit(0)
+  end
+end
+

data/lib/rbkb/cli/bgrep.rb

@@ -0,0 +1,86 @@
+require 'rbkb/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# searches for a binary string in input. string can be provided 'hexified'
+class Rbkb::Cli::Bgrep < Rbkb::Cli::Executable
+  def initialize(*args)
+    super(*args) do |this|
+      this.opts[:start_off] ||= 0
+      this.opts[:end_off] ||= -1
+      this.opts[:include_fname] ||= true
+    end
+  end
+
+  def make_parser
+    arg = super()
+    arg.banner += " <search> <file | blank for stdin>"
+
+    arg.on("-x", "--[no-]hex", "Search for hex (default: false)") do |x|
+      @opts[:hex] = x
+    end
+
+    arg.on("-r", "--[no-]regex", "Search for regex (default: false)") do |r|
+      @opts[:rx] = r
+    end
+
+    arg.on("-a", "--align=BYTES", Numeric, 
+           "Only match on alignment boundary") do |a|
+      @opts[:align] = a
+    end
+
+    arg.on("-n", "--[no-]filename", 
+           "Toggle filenames. (Default: #{@opts[:include_fname]})") do |n|
+      @opts[:include_fname] = n
+    end
+    return arg
+  end
+
+
+  def parse(*args)
+    super(*args)
+
+    bail "need search argument" unless @find = @argv.shift
+
+    if @opts[:hex] and @opts[:rx]
+      bail "-r and -x are mutually exclusive"
+    end
+
+    # ... filenames vs. stdin will be parsed in 'go'
+  end
+
+  def go(*args)
+    super(*args)
+
+    if @opts[:hex]
+      bail "you specified -x for hex and the subject isn't" unless @find.ishex?
+      @find = @find.unhexify
+    elsif @opts[:rx]
+      @find = Regexp.new(@find, Regexp::MULTILINE)
+    end
+
+    if fname = @argv.shift
+      dat = do_file_read(fname)
+      fname = nil unless @argv[0] # only print filenames for multiple files
+    else
+      dat = @stdin.read
+    end
+
+    loop do 
+      dat.bgrep(@find, @opts[:align]) do |hit_start, hit_end, match|
+        @stdout.write "#{fname}:" if fname and @opts[:include_fname]
+
+        @stdout.write(
+          "#{(hit_start).to_hex.rjust(8,"0")}:"+
+          "#{(hit_end).to_hex.rjust(8,"0")}:b:"+
+          "#{match.inspect}\n")
+      end
+
+      break unless fname=@argv.shift
+      dat = do_file_read(fname)
+    end
+    self.exit(0)
+  end
+end
+

data/lib/rbkb/cli/blit.rb

@@ -0,0 +1,89 @@
+require 'rbkb/cli'
+require 'rbkb/plug'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# blit is for use with any of the "plug" tools such as telson, feed, blitplug.
+# It is used to send data over a socket via their OOB blit listener.
+class Rbkb::Cli::Blit < Rbkb::Cli::Executable
+  attr_accessor :blit_msg
+
+  def initialize(*args)
+    super(*args)
+    {
+      :b_addr => Plug::Blit::DEFAULT_IPADDR,
+      :b_port => Plug::Blit::DEFAULT_PORT,
+      :bp_proto => :TCP,
+      :b_peeridx => 0,
+    }.each {|k, v| @opts[k] ||= v}
+  end
+
+  def make_parser()
+    super()
+    add_std_file_opt(:indat)
+    arg = @oparse
+
+    arg.banner += " <data | blank for stdin>"
+
+    arg.on("-t", "--trans-protocol=PROTO", 
+                 "Blit transport protocol TCP/UDP") do |t|
+      @opts[:b_proto] = t.upcase.to_sym
+    end
+
+    arg.on("-b", "--blitsrv=ADDR:PORT", 
+           "Where to send blit messages") do |b|
+
+      unless(m=/^(?:([\w\.]+):)?(\d+)$/.match(b))
+        bail "invalid blit address/port"
+      end
+      @opts[:b_port] = m[2].to_i
+      @opts[:b_port] = m[1] if m[1]
+    end
+
+    arg.on("-i", "--peer-index=IDX", Numeric, 
+           "Index for remote peer to receive") do |i|
+      @opts[:b_peeridx] = i
+    end
+
+    arg.on("-l", "--list-peers", "Lists the peer array for the target") do
+      @blit_msg = Plug::Blit.make_list_peers
+    end
+
+    arg.on("-k", "--kill", "Stops the remote event loop.") do
+      @blit_msg = Plug::Blit.make_kill
+    end
+
+    return arg
+  end
+
+  def parse(*args)
+    super(*args)
+
+    unless @blit_msg
+      if @opts[:indat].nil?
+        @opts[:indat] = (@argv.length > 0)?  @argv.join(" ") : @stdin.read()
+      end
+      @blit_msg = Plug::Blit.make_sendmsg(@opts[:b_peeridx], @opts[:indat]) 
+    end
+  end
+
+  def go(*args)
+    super(*args)
+
+    begin
+      Plug::Blit.blit_init(
+        :addr => @opts[:b_addr],
+        :port => @opts[:b_port],
+        :protocol => @opts[:b_proto]
+      )
+
+      Plug::Blit.blit_raw(@blit_msg)
+    rescue
+      bail($!)
+    end
+
+    self.exit(0)
+  end
+
+end

data/lib/rbkb/cli/chars.rb

@@ -0,0 +1,24 @@
+require 'rbkb/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# Repeats an argument N times
+class Rbkb::Cli::Chars < Rbkb::Cli::Executable
+  def make_parser
+    super()
+    @oparse.banner += " 100 A; # print 100 A's"
+  end
+
+  def parse(*args)
+    super(*args)
+    bail_args @argv.join(' ') unless @argv.size == 2
+  end
+
+  def go(*args)
+    super(*args)
+    @stdout << @argv[1] * @argv[0].to_i
+    self.exit(0)
+  end
+end
+

data/lib/rbkb/cli/crc32.rb

@@ -0,0 +1,35 @@
+require 'rbkb/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# crc32 returns a crc32 checksum in hex from stdin or a file
+class Rbkb::Cli::Crc32 < Rbkb::Cli::Executable
+  def initialize(*args)
+    super(*args)
+    @opts[:first] ||= 0
+    @opts[:last]  ||= -1
+  end
+
+  def make_parser()
+    arg = super()
+    arg.banner += " [filename]"
+    add_std_file_opt(:indat)
+    add_range_opts(:first, :last)
+  end
+
+  def parse(*args)
+    super(*args)
+    parse_file_argument(:indat)
+    parse_catchall()
+  end
+
+  def go(*args)
+    super(*args)
+    @opts[:indat] ||= @stdin.read()
+    @stdout.puts @opts[:indat][ @opts[:first] .. @opts[:last] ].crc32.to_hex
+    self.exit(0)
+  end
+end
+
+

data/lib/rbkb/cli/d64.rb

@@ -0,0 +1,28 @@
+require 'rbkb/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# d64 converts a base-64 encoded string back to its orginal form.
+class Rbkb::Cli::D64 < Rbkb::Cli::Executable
+  def make_parser
+    super()
+    @oparse.banner += " <data | blank for stdin>"
+    add_std_file_opt(:indat)
+  end
+
+  def parse(*args)
+    super(*args)
+    parse_string_argument(:indat)
+    parse_file_argument(:indat)
+    parse_catchall()
+    @opts[:indat] ||= @stdin.read
+  end
+
+  def go(*args)
+    super(*args)
+    @stdout << @opts[:indat].d64
+    self.exit(0)
+  end
+end
+

data/lib/rbkb/cli/dedump.rb

@@ -0,0 +1,52 @@
+require 'rbkb/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# Reverses a hexdump back to raw data. Designed to work with hexdumps created 
+# by Unix utilities like 'xxd' as well as 'hexdump -C'.
+class Rbkb::Cli::Dedump < Rbkb::Cli::Executable
+  def initialize(*args)
+    super(*args) {|this|
+      this.opts[:len] ||= 16
+      yield this if block_given?
+    }
+  end
+
+  def make_parser()
+    arg = super()
+    arg.banner += " <input-file | blank for stdin>"
+
+    arg.on("-l", "--length LEN", Numeric, 
+      "Bytes per line in hexdump (Default: #{@opts[:len]})") do |l|
+        bail("Length must be greater than zero") unless (@opts[:len] = l) > 0
+    end
+    return arg
+  end
+
+  def parse(*args)
+    super(*args)
+    parse_file_argument(:indat)
+    parse_catchall()
+  end
+
+  def go(*args)
+    super(*args)
+
+    # Default to standard input
+    @opts[:indat] ||= @stdin.read() 
+
+    self.exit(1) unless((@opts[:len] ||= @opts[:indat].length) > 0)
+
+    begin
+      @opts[:indat].dehexdump( :len => @opts[:len], :out => @stdout)
+    rescue
+      bail "Error: #{$!}"
+    end
+
+    self.exit(0)
+  end
+end
+
+
+

data/lib/rbkb/cli/feed.rb

@@ -0,0 +1,229 @@
+require 'rbkb/cli'
+require 'rbkb/plug'
+require 'rbkb/plug/feed_import'
+require 'eventmachine'
+
+# Copyright 2009 emonti at moatasano dot com
+# See README.rdoc for license information
+#
+# This is a plug-board message feeder from static data sources.
+# The "feed" handles messages opaquely and just plays them in the given 
+# sequence.
+#
+# Feed can do the following things with minimum fuss: 
+#   - Import messages from files, yaml, or pcap
+#   - Inject custom/modified messages with "blit"
+#   - Run as a server or client using UDP or TCP
+#   - Bootstrap protocols without a lot of work up front
+#   - Skip uninteresting messages and focus attention on the fun ones.
+#   - Replay conversations for relatively unfamiliar protocols.
+#   - Observe client/server behaviors using different messages at
+#     various phases of a conversation.
+#
+# To-dos / Ideas:
+#  - Unix Domain Socket support?
+#  - more import options?
+#  - dynamic feed elements?
+#  - add/control feed elements while 'stepping'?
+#
+
+class Rbkb::Cli::Feed < Rbkb::Cli::Executable
+  def initialize(*args)
+    @local_addr = "0.0.0.0"
+    @local_port = nil
+    @listen = false
+    @persist = false
+    @transport = :TCP
+    @svr_method = :start_server
+    @cli_method = :bind_connect
+    @blit_addr = Plug::Blit::DEFAULT_IPADDR
+    @blit_port = Plug::Blit::DEFAULT_PORT
+
+
+    ## Default options sent to the Feed handler
+    @feed_opts = { 
+      :close_at_end => false,
+      :step => false,
+      :go_first => false
+    }
+
+    super(*args)
+
+    # TODO Plug::UI obviously need fixing. 
+    # TODO It shouldn't be driven by 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("-o", "--output=FILE", "Output to file") do |o|
+      Plug::UI::LOGCFG[:out] = File.open(o, "w")
+    end
+
+    arg.on("-l", "--listen=(ADDR:?)PORT", "Server - on port (and addr?)") do |p|
+      if m=/^(?:([\w\._-]+):)?(\d+)$/.match(p)
+        @local_addr = $1 if $1
+        @local_port = $2.to_i
+        @listen = true
+      else
+        raise "Invalid listen argument: #{p.inspect}"
+      end
+    end
+
+    arg.on("-s", "--source=(ADDR:?)PORT", "Bind client on port and addr") do |p|
+      if m=/^(?:([\w\.]+):)?(\d+)$/.match(p)
+        @local_addr = $1 if $1
+        @local_port = $2.to_i
+      else
+        bail("Invalid source argument: #{p.inspect}")
+      end
+    end
+
+    arg.on("-b", "--blit=(ADDR:)?PORT", "Where to listen for blit") do |b|
+      puts b
+      unless(m=/^(?:([\w\._-]+):)?(\d+)$/.match(b))
+        raise "Invalid blit argument: #{b.inspect}"
+      end
+      @blit_port = m[2].to_i
+      @blit_addr = m[1] if m[1]
+    end
+
+    arg.on("-i", "--[no-]initiate", "Send the first message on connect") do |i|
+      @feed_opts[:go_first] = i
+    end
+
+    arg.on("-e", "--[no-]end", "End connection when feed is exhausted") do |c|
+      @feed_opts[:close_at_end] = c
+    end
+     
+    arg.on("--[no-]step", "'Continue' prompt between messages") do |s|
+      @feed_opts[:step] = s
+    end
+
+    arg.on("-u", "--udp", "Use UDP instead of TCP" ) do
+      @transport = :UDP
+    end
+
+    arg.on("-r", "--reconnect", "Attempt to reconnect endlessly.") do
+      @persist=true
+    end
+
+    arg.on("-q", "--quiet", "Suppress verbose messages/dumps") do
+      Plug::UI::LOGCFG[:verbose] = false
+    end
+
+    arg.on("-Q", "--squelch-exhausted", "Squelch 'FEED EXHAUSTED' messages") do |s|
+      @feed_opts[:squelch_exhausted] = true
+    end
+
+    arg.separator  "  Sources: (can be combined)"
+
+    arg.on("-f", "--from-files=GLOB", "Import messages from raw files") do |f|
+      @feed_opts[:feed] ||= []
+      @feed_opts[:feed] += FeedImport.import_rawfiles(f)
+    end
+
+    arg.on("-x", "--from-hex=FILE", "Import messages from hexdumps") do |x|
+      @feed_opts[:feed] ||= []
+      @feed_opts[:feed] += FeedImport.import_dump(x)
+    end
+
+    arg.on("-y", "--from-yaml=FILE", "Import messages from yaml") do |y|
+      @feed_opts[:feed] ||= []
+      @feed_opts[:feed] += FeedImport.import_yaml(y)
+    end
+
+    arg.on("-p", "--from-pcap=FILE[:FILTER]", "Import messages from pcap") do |p|
+      if /^([^:]+):(.+)$/.match(p)
+        file = $1
+        filter = $2
+      else
+        file = p
+        filter = nil
+      end
+
+      @feed_opts[:feed] ||= []
+      @feed_opts[:feed] += FeedImport.import_pcap(file, filter)
+    end
+  end
+
+  def parse(*args)
+    super(*args)
+
+    if @transport == :UDP
+      @svr_method = @cli_method = :open_datagram_socket
+    end
+
+    @local_port ||= 0
+    # Prepare EventMachine arguments based on whether we are a client or server
+    if @listen # server
+      @meth = @svr_method
+      addr_args = [@local_addr, @local_port]
+      @feed_opts[:kind] = :server
+      @feed_opts[:no_stop_on_unbind] = true
+    else # client
+
+      ## Get target/listen argument for client mode
+      unless (m = /^([\w\.]+):(\d+)$/.match(tgt=@argv.shift))
+        bail_args tgt
+      end
+
+      @target_addr = m[1]
+      @target_port = m[2].to_i
+
+      if @transport == :UDP
+        addr_args = [@local_addr, @local_port]
+      else
+        addr_args = [@local_addr, @local_port, @target_addr, @target_port]
+      end
+
+      @meth = @cli_method
+      @feed_opts[:kind] = :client
+    end
+
+    @feed_opts[:feed] ||= []
+
+    @em_args=[ 
+      @meth, 
+      addr_args,
+      Plug::ArrayFeeder, 
+      @transport, 
+      @feed_opts
+    ].flatten
+
+    parse_catchall()
+  end
+
+
+  def go(*args)
+    super(*args)
+
+    Plug::UI.verbose "** FEED CONTAINS #{@feed_opts[:feed].size} MESSAGES"
+
+    ## Start the eventmachine
+    loop do
+      EventMachine::run do
+        EventMachine.send(*@em_args) do |c|
+          EventMachine.start_server(@blit_addr, @blit_port, Plug::Blit, :TCP, c)
+          Plug::UI::verbose("** BLITSRV-#{@blit_addr}:#{@blit_port}(TCP) Started")
+
+          # if this is a UDP client, we will always send the first message
+          if [:UDP, :client] == [@transport, c.kind]
+            peer = c.peers.add_peer_manually(@target_addr, @target_port)
+            c.feed_data(peer)
+            c.go_first = false
+          end
+        end
+      end
+
+      break unless @persist
+      Plug::UI::verbose("** RECONNECTING")
+    end
+
+  end
+end
+