emonti-rbkb 0.6.1.3 → 0.6.2

data/bin/unhexify

@@ -1,65 +1,5 @@
 #!/usr/bin/env ruby
-# Author Eric Monti (emonti at matasano)
-#
-# 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).
-# 
-# Usage: unhexify [options] <data | blank for stdin>
-#     -h, --help                       Show this message
-#     -v, --version                    Show version and exit
-#     -f, --file FILENAME              Input from FILENAME
-#     -d, --delim DELIMITER            DELIMITER regex between hex chunks
-# 
 
-require 'rbkb'
-require 'rbkb/command_line'
-
-include RBkB::CommandLine
-
-#-------------------------------------------------------------------------------
-# Init options and arg parsing
-OPTS = {}
-arg = bkb_stdargs(nil, OPTS)
-
-arg.banner += " <data | blank for stdin>"
-
-arg = bkb_inputargs(arg, OPTS)
-
-#------------------------------------------------------------------------------
-# Add local options
-
-arg.on("-d", "--delim DELIMITER", 
-  "DELIMITER regex between hex chunks") do |d|
-    OPTS[:delim] = Regexp.new(d.gsub('\\\\', '\\'))
-end
-
-#------------------------------------------------------------------------------
-# Parse arguments
-arg.parse!(ARGV) rescue bail "Error: #{$!}\n#{arg}"
-
-# default string arg
-if OPTS[:indat].nil? and a=ARGV.shift
-	OPTS[:indat] = a.dup 
-end
-
-# catchall
-if ARGV.length != 0 
-    bail "Error: bad arguments - #{ARGV.join(' ')}\n#{arg}"
-end
-
-OPTS[:indat] ||= STDIN.read()
-
-#------------------------------------------------------------------------------
-# Do stuff
-
-OPTS[:indat].delete!("\r\n")
-OPTS[:indat]
-
-OPTS[:delim] ||= /\s*/
-
-unless out = OPTS[:indat].unhexify(OPTS[:delim])
-    bail "Error: Failed parsing as hex"
-end
-
-STDOUT.write(out)
+require "rbkb/cli/unhexify"
 
+Rbkb::Cli::Unhexify.run()

data/bin/urldec

@@ -1,56 +1,5 @@
 #!/usr/bin/env ruby
-# Author Eric Monti (emonti at matasano)
-#
-# urldec converts a url-encoded string back to its raw form.
-# (url encoding is really just fancy hex encoding)
-#
-# Usage: urldec [options] <data | blank for stdin>
-#     -h, --help                       Show this message
-#     -v, --version                    Show version and exit
-#     -f, --file FILENAME              Input from FILENAME
-#     -p, --[no-]plus                  Convert '+' to space (default is true)
-#
 
-require 'rbkb'
-require 'rbkb/command_line'
-
-include RBkB::CommandLine
-
-#-------------------------------------------------------------------------------
-# Init options and arg parsing
-OPTS = {}
-arg = bkb_stdargs(nil, OPTS)
-
-arg.banner += " <data | blank for stdin>"
-
-arg = bkb_inputargs(arg, OPTS)
-
-arg.on("-p", "--[no-]plus", "Convert '+' to space (default is true)") do |p|
-  OPTS[:noplus] = (not p)
-end
-
-
-#------------------------------------------------------------------------------
-# Add local options here
-
-#------------------------------------------------------------------------------
-# Parse arguments
-arg.parse!(ARGV) rescue bail "Error: #{$!}\n#{arg}"
-
-# default string arg
-if OPTS[:indat].nil? and a=ARGV.shift
-	OPTS[:indat] = a
-end
-
-# catchall
-if ARGV.length != 0 
-    bail "Error: bad arguments - #{ARGV.join(' ')}\n#{arg}"
-end
-
-OPTS[:indat] ||= STDIN.read()
-
-#------------------------------------------------------------------------------
-# Do stuff
-
-STDOUT.write(OPTS[:indat].urldec(:noplus => OPTS[:noplus]))
+require "rbkb/cli/urldec"
 
+Rbkb::Cli::Urldec.run()

data/bin/urlenc

@@ -1,55 +1,5 @@
 #!/usr/bin/env ruby
-# Author Eric Monti (emonti at matasano)
-#
-# urlenc converts a string or raw data to a url-encoded string 
-# (url encoding is really just fancy hex encoding)
-#
-# Usage: urlenc [options] <data | blank for stdin>
-#     -h, --help                       Show this message
-#     -v, --version                    Show version and exit
-#     -f, --file FILENAME              Input from FILENAME
-#     -p, --[no-]plus                  Convert spaces to '+' (default is false)
-#
 
-require 'rbkb'
-require 'rbkb/command_line'
-
-include RBkB::CommandLine
-
-#------------------------------------------------------------------------------
-# Init options and arg parsing
-OPTS = {}
-arg = bkb_stdargs(nil, OPTS)
-arg = bkb_inputargs(arg, OPTS)
-
-arg.banner += " <data | blank for stdin>"
-
-arg.on("-p", "--[no-]plus", "Convert spaces to '+' (default is false)") do |p|
-  OPTS[:plus] = p
-end
-
-#------------------------------------------------------------------------------
-# Add local options here
-
-#------------------------------------------------------------------------------
-# Parse arguments
-arg.parse!(ARGV) rescue bail "Error: #{$!}\nUse -h|--help for more info."
-
-# default string arg
-if OPTS[:indat].nil? and a=ARGV.shift
-	OPTS[:indat] = a.dup 
-end
-
-# catchall
-if ARGV.length != 0 
-    bail "Error: bad arguments - #{ARGV.join(' ')}\n-h|--help for more info."
-end
-
-# Default to standard input
-OPTS[:indat] ||= STDIN.read()
-
-#------------------------------------------------------------------------------
-# Do stuff
-
-puts OPTS[:indat].urlenc(:plus => OPTS[:plus])
+require "rbkb/cli/urlenc"
 
+Rbkb::Cli::Urlenc.run()

data/bin/xor

@@ -1,60 +1,5 @@
 #!/usr/bin/env ruby
-# Author Eric Monti (emonti at matasano)
-#
-# repeating string xor
-#
-# Usage: xor [options] -k|-s <key> <data | stdin>
-#     -h, --help                       Show this message
-#     -v, --version                    Show version and exit
-#     -f, --file FILENAME              Input from FILENAME
-# 
-#   Key options (one of the following is required):
-#     -s, --strkey STRING              xor against bare STRING
-#     -x, --hexkey HEXSTR              xor against decoded HEXSTR
-# 
 
-require 'rbkb'
-require 'rbkb/command_line'
-
-include RBkB::CommandLine
-
-#-------------------------------------------------------------------------------
-# Init options and arg parsing
-OPTS = {}
-arg = bkb_stdargs(nil, OPTS)
-arg = bkb_inputargs(arg, OPTS)
-
-arg.banner += " -k|-s <key> <data | stdin>"
-
-#------------------------------------------------------------------------------
-# Add local options
-arg.separator ""
-arg.separator "  Key options (one of the following is required):"
-
-arg.on("-s", "--strkey STRING", "xor against bare 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 decoded 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
-
-#------------------------------------------------------------------------------
-# Parse arguments
-arg.parse!(ARGV) rescue bail "Error: #{$!}\n#{arg}"
-
-bail "You must specify a key with -s or -x\n#{arg}" unless OPTS[:key]
-
-OPTS[:indat] ||= ARGV.shift
-
-if ARGV.length != 0
-    bail "Error: bad arguments - #{ARGV.join(' ')}\n-h|--help for more info."
-end
-
-OPTS[:indat] ||= STDIN.read()
-
-STDOUT.write OPTS[:indat].xor(OPTS[:key])
+require "rbkb/cli/xor"
 
+Rbkb::Cli::Xor.run()

data/lib/rbkb/cli/b64.rb

@@ -0,0 +1,27 @@
+require 'rbkb/cli'
+
+# 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>"
+
+    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_catchall()
+  end
+
+  def go(*args)
+    super(*args)
+    @stdout << @opts[:indat].b64(opts[:len]).chomp + "\n"
+  end
+end
+

data/lib/rbkb/cli/bgrep.rb

@@ -0,0 +1,78 @@
+require 'rbkb/cli'
+
+# searches for a binary string in input. string can be provided 'hexified'
+class Rbkb::Cli::Bgrep < Rbkb::Cli::Executable
+  def initialize(*args)
+    super(*args)
+    @opts[:start_off] ||= 0
+    @opts[:end_off] ||= -1
+  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", "Suppress prefixing of filenames.") do |n|
+      @opts[:suppress_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|
+        print "#{fname}:" if fname and not @opts[:suppress_fname]
+
+        puts("#{(hit_start).to_hex.rjust(8,"0")}:"+
+             "#{(hit_end).to_hex.rjust(8,"0")}:b:"+
+             "#{match.inspect}")
+      end
+
+      break unless fname=@argv.shift
+      dat = do_file_read(fname)
+    end
+  end
+end
+

data/lib/rbkb/cli/blit.rb

@@ -0,0 +1,86 @@
+require 'rbkb/cli'
+require 'rbkb/plug'
+
+# 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,20 @@
+require 'rbkb/cli'
+
+# 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
+  end
+end
+

data/lib/rbkb/cli/crc32.rb

@@ -0,0 +1,29 @@
+require 'rbkb/cli'
+
+# 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()
+    super()
+    add_std_file_opt(:indat)
+    add_range_opts(:first, :last)
+  end
+
+  def parse(*args)
+    super(*args)
+    parse_catchall()
+  end
+
+  def go(*args)
+    super(*args)
+    @opts[:indat] ||= @stdin.read()
+    @stdout.puts @opts[:indat][ @opts[:first] .. @opts[:last] ].crc32.to_hex
+  end
+end
+
+

data/lib/rbkb/cli/d64.rb

@@ -0,0 +1,22 @@
+require 'rbkb/cli'
+
+# 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>"
+  end
+
+  def parse(*args)
+    super(*args)
+    parse_string_argument(:indat)
+    parse_catchall()
+  end
+
+  def go(*args)
+    super(*args)
+    @stdout << @opts[:indat].d64
+    self.exit(0)
+  end
+end
+

data/lib/rbkb/cli/dedump.rb

@@ -0,0 +1,47 @@
+require 'rbkb/cli'
+
+# 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)
+    @opts[:len] ||= 16
+  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/hexify.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require 'rbkb/cli'
+
+# 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|
+      bail("Length must be greater than zero") unless (@opts[:len] = l) > 0
+    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)
+
+    self.exit(1) unless((len ||= indat.length) > 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,70 @@
+require 'rbkb/cli'
+
+# 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)
+    super(*args)
+
+    # endianness pair. index 0 is always the default
+    @endpair = [:big, :little]
+    {
+      :nudge => 0, 
+      :size => 4, 
+      :endian => @endpair[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("-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]
+  end
+
+end
+