rbkb 0.6.10

data/lib/rbkb/cli/hexify.rb

@@ -0,0 +1,65 @@
+require 'rbkb/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# The hexify command converts a string or raw data to hex characters. 
+# Input can be supplied via stdin, a string argument, or a file (with -f).
+class Rbkb::Cli::Hexify < 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("-l", "--length LEN", Numeric, "Output lines of LEN bytes") do |l|
+      @opts[:len] = l
+    end
+
+    arg.on("-d", "--delim=DELIMITER", "DELIMITER between each byte") do |d|
+      @opts[:delim] = d
+    end
+
+    arg.on("-p", "--prefix=PREFIX", "PREFIX before each byte") do |p|
+      @opts[:prefix] = p
+    end
+
+    arg.on("-s", "--suffix=SUFFIX", "SUFFIX after each byte") do |s|
+      @opts[:suffix] = s
+    end
+  end
+
+  def parse(*args)
+    super(*args)
+
+    # blackbag-style space delimiter compatability
+    if @argv[0] == "+" and @opts[:delim].nil?
+      @opts[:delim]=" "
+      @argv.shift
+    end
+
+    parse_string_argument(:indat)
+    parse_catchall()
+  end
+
+  def go(*args)
+    super(*args)
+
+    # Default to standard input
+    @opts[:indat] ||= @stdin.read() 
+
+    indat = @opts.delete(:indat)
+    len = (@opts.delete(:len) || indat.length)
+
+    bail("Length must be greater than zero") unless(len > 0)
+
+    until (m = indat.slice!(0..len-1)).empty?
+      @stdout << m.hexify(@opts)
+      @stdout.puts((opts[:delim] and ! indat.empty?)? opts[:delim] : "\n")
+    end
+    self.exit(0)
+  end
+end
+

data/lib/rbkb/cli/len.rb

@@ -0,0 +1,76 @@
+require 'rbkb/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+
+# len prepends a binary length number in front of its input and outputs
+# raw on STDOUT
+class Rbkb::Cli::Len < Rbkb::Cli::Executable
+
+  def initialize(*args)
+    # endianness pair. index 0 is always the default
+    @endpair = [:big, :little]
+
+    super(*args) do |this|
+      {
+        :nudge => 0, 
+        :size => 4, 
+        :endian => @endpair[0],
+      }.each {|k,v| this.opts[k] ||= v}
+
+      yield this if block_given?
+    end
+  end
+
+  def make_parser()
+    super()
+    add_std_file_opt(:indat)
+    arg = @oparse
+    arg.banner += " <data | blank for stdin>"
+
+    arg.on("-n", "--nudge INT", Numeric, "Add integer to length") do |n|
+      @opts[:nudge] += n
+    end
+
+    arg.on("-s", "--size=SIZE", Numeric, 
+           "Size of length field in bytes") do |s|
+      bail("Size must be greater than 0") unless (@opts[:size] = s) > 0
+    end
+
+    arg.on("-x", "--[no-]swap", 
+           "Swap endianness. Default=#{@opts[:endian]}") do |x|
+      @opts[:endian] = @endpair[(x)? 1 : 0]
+    end
+
+    arg.on("-t", "--[no-]total", "Include size word in size") do |t|
+      @opts[:tot]=t
+    end
+
+    arg.on("-l", "--length=LEN", Numeric, 
+           "Ignore all other flags and use static LEN") do |l|
+      @opts[:static]=l
+    end
+  end
+
+
+  def parse(*args)
+    super(*args)
+    @opts[:indat] ||= @argv.shift
+    parse_catchall()
+    @opts[:indat] ||= @stdin.read
+  end
+
+
+  def go(*args)
+    super(*args)
+    unless len=@opts[:static]
+      len = @opts[:indat].size
+      len += @opts[:size] if @opts[:tot]
+      len += @opts[:nudge]
+    end
+    @stdout << len.to_bytes(@opts[:endian], @opts[:size]) << @opts[:indat]
+    self.exit(0)
+  end
+
+end
+

data/lib/rbkb/cli/rstrings.rb

@@ -0,0 +1,108 @@
+require 'rbkb/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# rstrings is Unix "strings" in ruby... with some extra stuff
+class Rbkb::Cli::Rstrings < Rbkb::Cli::Executable
+  def initialize(*args)
+    super(*args) do |this|
+      {
+        :start_off => 0, 
+        :end_off => -1, 
+        :encoding => :both, 
+        :minimum => 6,
+        :align => nil,
+        :indat => Array.new,
+        :fnames => Array.new,
+      }.each {|k,v| this.opts[k] ||= v }
+
+      yield this if block_given?
+    end
+  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,47 @@
+require 'rbkb/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# 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] ]
+    self.exit(0)
+  end
+
+end
+

data/lib/rbkb/cli/telson.rb

@@ -0,0 +1,87 @@
+require 'rbkb/plug/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# 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 "stubbed" network 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::PlugCli
+
+  def initialize(*args)
+    super(*args) do |this|
+      this.local_addr = "0.0.0.0"
+      this.local_port = 0
+    end
+
+    @persist = false
+  end
+
+
+  def make_parser()
+    arg = super()
+
+    arg.on("-r", "--reconnect", "Attempt to reconnect endlessly.") do
+      @persist=true
+    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
+  end
+
+
+  def parse(*args)
+    super(*args)
+
+    parse_target_argument()
+    parse_catchall()
+  end
+
+
+  def go(*args)
+    super(*args)
+    loop do
+      EventMachine.run {
+        if @transport == :TCP
+
+          c=EventMachine.bind_connect( @local_addr,
+                                       @local_port,
+                                       @target_addr, 
+                                       @target_port, 
+                                       Plug::Telson, 
+                                       @transport, 
+                                       @plug_opts )
+        elsif @transport == :UDP
+          c=EventMachine.open_datagram_socket( @local_addr, 
+                                               @local_port, 
+                                               Plug::Telson, 
+                                               @transport, 
+                                               @plug_opts )
+ 
+          c.peers.add_peer_manually(@target_addr, @target_port)
+
+        ### someday maybe raw or others?
+        else
+          raise "bad transport protocol"
+        end
+        EventMachine.start_server(@blit_addr, @blit_port, Plug::Blit, @blit_proto, c)
+        Plug::UI::verbose("** BLITSRV-#{@blit_addr}:#{@blit_port}(TCP) Started") # XXX
+      }
+      break unless @persist
+      Plug::UI::verbose("** RECONNECTING") # XXX
+    end
+  end
+end
+

data/lib/rbkb/cli/unhexify.rb

@@ -0,0 +1,50 @@
+require 'rbkb/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# 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] ||= Regexp.new('\s*')
+
+    @stdout << @opts[:indat].unhexify(@opts[:delim])
+
+    self.exit(0)
+  end
+end
+

data/lib/rbkb/cli/urldec.rb

@@ -0,0 +1,35 @@
+require 'rbkb/cli'
+
+# Copyright 2009 emonti at matasano.com 
+# See README.rdoc for license information
+#
+# 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])
+    self.exit(0)
+  end
+end
+