emonti-rbkb 0.6.1.3 → 0.6.2

data/bin/hexify

@@ -1,85 +1,5 @@
 #!/usr/bin/env ruby
-# Author Eric Monti (emonti at matasano)
-#
-# hexify converts a string or raw data to hex characters. Input can be 
-# supplied via stdin, a string argument, or a file (with -f).
-#
-# Usage: hexify [options] <data | blank for stdin>
-#     -h, --help                       Show this message
-#     -v, --version                    Show version and exit
-#     -f, --file FILENAME              Input from FILENAME
-#     -l, --length LEN                 Hexify in lines of LEN bytes
-#     -d, --delim=DELIMITER            DELIMITER between each byte
-#     -p, --prefix=PREFIX              PREFIX before each byte
-#     -s, --suffix=SUFFIX              SUFFIX after each byte
-#
 
-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>"
-
-#------------------------------------------------------------------------------
-# Add local options
-
-arg.on("-l", "--length LEN", Numeric, "Hexify in 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
-
-
-#------------------------------------------------------------------------------
-# Parse arguments
-arg.parse!(ARGV) rescue bail "Error: #{$!}\nUse -h|--help for more info."
-
-# original-style spacing compatability
-if ARGV[0] == "+" and OPTS[:delim].nil?
-  OPTS[:delim]=" "
-  ARGV.shift
-end
-
-# 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
-
-indat = OPTS.delete(:indat)
-len = OPTS.delete(:len)
-
-exit 1 unless((len ||= indat.length) > 0)
-
-until (m = indat.slice!(0..len-1)).empty?
-  print m.hexify(OPTS)
-  puts (OPTS[:delim] and not indat.empty?)? OPTS[:delim] : "\n"
-end
+require "rbkb/cli/hexify"
 
+Rbkb::Cli::Hexify.run()

data/bin/len

@@ -1,74 +1,5 @@
 #!/usr/bin/env ruby
-# Author Eric Monti (emonti at matasano)
-#
-# len prepends a binary length number in front of its input and writes it
-# raw on STDOUT
-#
-# Usage: len [options] <data | blank for stdin>
-#     -h, --help                       Show this message
-#     -v, --version                    Show version and exit
-#     -f, --file FILENAME              Input from FILENAME
-#     -n, --nudge INT                  Add integer to length
-#     -s, --size=SIZE                  Size of length field in bytes
-#     -x, --[no-]swap                  Swap endianness. Default=big
-#     -t, --[no-]total                 Include size word in size
-#     -l, --length=LEN                 Ignore all else and use LEN
-#
 
-require 'rbkb'
-require 'rbkb/command_line'
-
-include RBkB::CommandLine
-
-#-------------------------------------------------------------------------------
-# Init options and arg parsing
-
-# endianness pair. index 0 is always the default
-endpair = [:big, :little]
-
-OPTS = {:nudge => 0, :size => 4, :endian => endpair[0]}
-
-arg = bkb_stdargs(nil, OPTS)
-arg = bkb_inputargs(arg, OPTS)
-
-arg.banner += " <data | blank for stdin>"
-
-#------------------------------------------------------------------------------
-# Add local options
-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 else and use LEN") do |l|
-  OPTS[:static]=l
-end
-
-#------------------------------------------------------------------------------
-# Parse arguments
-arg.parse!(ARGV) rescue bail "Error: #{$!}\n#{arg}"
-
-OPTS[:indat] ||= ARGV.shift
-OPTS[:indat] ||= STDIN.read
-
-bail "Error: Too many arguments\n##{arg}" if ARGV.shift
-
-unless len=OPTS[:static]
-  len = OPTS[:indat].size
-  len += OPTS[:size] if OPTS[:tot]
-  len += OPTS[:nudge]
-end
-
-STDOUT.write len.to_bytes(OPTS[:endian], OPTS[:size]) << OPTS[:indat]
+require "rbkb/cli/len"
 
+Rbkb::Cli::Len.run()

data/bin/plugsrv

@@ -1,8 +1,7 @@
 #!/usr/bin/env ruby
-#
+# TODO refactor into rbkb/plug and add blit support
 #
 
-require 'rubygems'
 require 'eventmachine'
 require 'socket'
 require 'optparse'
@@ -13,7 +12,7 @@ def bail(*msg)
   exit 1
 end
 
-class Plug
+class PlugSrv
   module UI
     def log( *msg )
       unless PLUG_OPTS[:quiet]
@@ -65,7 +64,7 @@ class Plug
 
       srv.controller = cli.controller = ctrl
     end
-  end # class Plug::Controller
+  end # class PlugSrv::Controller
 
 
   module BaseTCP
@@ -108,7 +107,7 @@ class Plug
 
 
   module TCPListener
-    include Plug::BaseTCP
+    include PlugSrv::BaseTCP
     attr_accessor :tgtaddr, :tgtport
 
     def post_init
@@ -117,7 +116,7 @@ class Plug
       @sock_peer = Socket.unpack_sockaddr_in(get_peername).reverse
       @sock_peername = @sock_peer.join(':')
 
-      @controller = Plug::Controller.proxy(self)
+      @controller = PlugSrv::Controller.proxy(self)
 
       notify_connection
     end
@@ -126,7 +125,7 @@ class Plug
 
 
   module TCPClient
-    include Plug::BaseTCP
+    include PlugSrv::BaseTCP
     attr_accessor :connected
 
     def post_init
@@ -142,79 +141,75 @@ class Plug
 
   end # module TCPClient
 
-end # module Plug
+end # module PlugSrv
 
 PLUG_OPTS={ :quiet => false, :out => STDOUT }
 
-  if __FILE__ == $0
-
-
-  #############################################################################
-  ### MAIN
-  #############################################################################
-  #
-  # Get arguments
-  opts = OptionParser.new do |opts|
-    opts.banner = "Usage: #{$0} [options] target:tport[@[laddr:]lport]\n",
-                  "  <target:tport>  = the address of the target service\n",
-                  "  <@laddr:lport> = optional address and port to listen on\n"
 
-    opts.separator ""
-    opts.separator "Options:"
+#############################################################################
+### MAIN
+#############################################################################
+#
+# Get arguments
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options] target:tport[@[laddr:]lport]\n",
+                "  <target:tport>  = the address of the target service\n",
+                "  <@laddr:lport> = optional address and port to listen on\n"
 
-    opts.on_tail("-h", "--help", "Show this message") do
-      puts opts
-      exit 1
-    end
+  opts.separator ""
+  opts.separator "Options:"
 
-    opts.on("-o", "--output FILE", "send output to a file") do |o|
-      PLUG_OPTS[:out] = File.open(o, "w") rescue (bail $!)
-    end
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit 1
+  end
 
-    opts.on("-l", "--listen ADDR:PORT", 
-            "optional listener address:port", 
-            "(default: 0.0.0.0:<tport>)"
-           ) do |addr|
+  opts.on("-o", "--output FILE", "send output to a file") do |o|
+    PLUG_OPTS[:out] = File.open(o, "w") rescue (bail $!)
+  end
 
-      unless m = /^([\w\.]+)?(?::(\d+))?$/.match(addr)
-        STDERR.puts "invalid listener address"
-        exit 1
-      end
-      PLUG_OPTS[:svraddr] = m[1]
-      PLUG_OPTS[:svrport] = (m[2])? m[2].to_i : nil
-    end
+  opts.on("-l", "--listen ADDR:PORT", 
+          "optional listener address:port", 
+          "(default: 0.0.0.0:<tport>)"
+         ) do |addr|
 
-    opts.on("-q", "--[no-]quiet", "Suppress/Enable conversation dumps.") do |q|
-      PLUG_OPTS[:quiet] = q
+    unless m = /^([\w\.]+)?(?::(\d+))?$/.match(addr)
+      STDERR.puts "invalid listener address"
+      exit 1
     end
+    PLUG_OPTS[:svraddr] = m[1]
+    PLUG_OPTS[:svrport] = (m[2])? m[2].to_i : nil
+  end
 
+  opts.on("-q", "--[no-]quiet", "Suppress/Enable conversation dumps.") do |q|
+    PLUG_OPTS[:quiet] = q
   end
 
-  opts.parse!(ARGV) rescue (STDERR.puts $!; exit 1)
+end
 
+opts.parse!(ARGV) rescue (STDERR.puts $!; exit 1)
 
-  # Get target/listen argument
-  rx = /^([\w\.]+):(\d+)(?:@(?:([\w\.]+):)?(\d+))?$/
-  unless (m = rx.match(ARGV.shift)) and ARGV.shift.nil?
-    $stderr.puts opts.banner
-    exit 1
-  end
 
-  PLUG_OPTS[:tgtaddr] = m[1]
-  PLUG_OPTS[:tgtport] = m[2].to_i
-  PLUG_OPTS[:svraddr] ||= (m[3] || "0.0.0.0")
-  PLUG_OPTS[:svrport] ||= (m[4] || PLUG_OPTS[:tgtport]).to_i
+# Get target/listen argument
+rx = /^([\w\.]+):(\d+)(?:@(?:([\w\.]+):)?(\d+))?$/
+unless (m = rx.match(ARGV.shift)) and ARGV.shift.nil?
+  $stderr.puts opts.banner
+  exit 1
+end
 
+PLUG_OPTS[:tgtaddr] = m[1]
+PLUG_OPTS[:tgtport] = m[2].to_i
+PLUG_OPTS[:svraddr] ||= (m[3] || "0.0.0.0")
+PLUG_OPTS[:svrport] ||= (m[4] || PLUG_OPTS[:tgtport]).to_i
 
-  # Start controller
-  ctrl = Plug::Controller.new(PLUG_OPTS[:tgtaddr], PLUG_OPTS[:tgtport], Plug::TCPClient)
 
-  # Start event loop
-  Plug::UI.log "%Starting TCP PlugServer #{PLUG_OPTS[:svraddr]}:#{PLUG_OPTS[:svrport]} -> #{PLUG_OPTS[:tgtaddr]}:#{PLUG_OPTS[:tgtport]}"
+# Start controller
+ctrl = PlugSrv::Controller.new(PLUG_OPTS[:tgtaddr], PLUG_OPTS[:tgtport], PlugSrv::TCPClient)
 
-  EventMachine::run {
-    EventMachine::start_server(PLUG_OPTS[:svraddr], PLUG_OPTS[:svrport], Plug::TCPListener)
-  }
+# Start event loop
+PlugSrv::UI.log "%Starting TCP PlugServer #{PLUG_OPTS[:svraddr]}:#{PLUG_OPTS[:svrport]} -> #{PLUG_OPTS[:tgtaddr]}:#{PLUG_OPTS[:tgtport]}"
 
+EventMachine::run {
+  EventMachine::start_server(PLUG_OPTS[:svraddr], PLUG_OPTS[:svrport], PlugSrv::TCPListener)
+}
 
-end

data/bin/rstrings

@@ -1,123 +1,5 @@
 #!/usr/bin/env ruby
-#
-# rstrings is "strings"... in ruby... with extra stuff
-#
-# Usage: rstrings [options] <file | blank for stdin>
-#   -h, --help                       Show this message
-#   -v, --version                    Show version and exit
-#   -s, --start=OFFSET               Start at offset
-#   -e, --end=OFFSET                 End at offset
-#   -t, --encoding-type=TYPE         Encoding: ascii|unicode|both (default=both)
-#   -l, --min-length=NUM             Minimum length of strings (default=6)
-#   -a, --align=ALIGNMENT            Match only on alignment (default=none)
-# 
 
-require 'rbkb'
-require 'rbkb/command_line'
-
-include RBkB::CommandLine
-
-#-------------------------------------------------------------------------------
-# Init options and arg parsing
-OPTS = {
-  :start_off => 0, 
-  :end_off => -1, 
-  :encoding => :both, 
-  :minimum => 6,
-  :align => nil,
-  :indat => Array.new,
-  :fnames => Array.new,
-}
-
-arg = bkb_stdargs(nil, OPTS)
-
-arg.banner += " <file | blank for stdin>"
-
-#------------------------------------------------------------------------------
-# Add local options
-
-arg.on("-s", "--start=OFFSET", "Start at offset") do |s|
-  unless m=/^(?:(\d+)|0x([A-Fa-f0-9]+))$/.match(s)
-    raise "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)
-    raise "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 raise "bad alignment '#{a}'"
-end
-
-
-#------------------------------------------------------------------------------
-# Parse arguments
-arg.parse!(ARGV) rescue bail "Error: #{$!}\n#{arg}"
-
-# default string arg
-if OPTS[:indat].empty? and not ARGV.empty?
-  while a=ARGV.shift
-    OPTS[:indat] << File.read(a) rescue(bail "Error: Can't open '#{a}'")
-    OPTS[:fnames] << a
-  end
-end
-
-# catchall
-if ARGV.length != 0 
-  bail "Error: bad arguments - #{ARGV.join(' ')}\n#{arg}"
-end
-
-if OPTS[:indat].empty?
-  OPTS[:indat] << STDIN.read() if OPTS[:indat].empty?
-  OPTS[:fnames] << "[STDIN]"
-end
-
-#------------------------------------------------------------------------------
-# Do stuff
-
-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
-
-begin
-  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]
-        print "#{OPTS[:fnames][i]}:"
-      end
-      puts "#{(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}"
-    end
-    i+=1
-  end
-rescue
-#  STDERR.puts $!
-#  exit 1
-end
+require "rbkb/cli/rstrings"
 
+Rbkb::Cli::Rstrings.run()

data/bin/slice

@@ -1,74 +1,5 @@
 #!/usr/bin/env ruby
-# (emonti at matasano) Matasano Security LLC
-#
-# slice.rb : returns a slice from input
-# just a shell interface to a string slice operation
-#
-# Usage: slice [options] start (no args when using -r|-x)
-#     -h, --help                       Show this message
-#     -v, --version                    Show version and exit
-#     -f, --file FILENAME              Input from FILENAME
-#     -r, --range=START[:END]          Start and optional end range
-#     -x, --hexrange=START[:END]       same, but in hex
-#
 
-require 'rbkb'
-require 'rbkb/command_line'
-
-include RBkB::CommandLine
-
-OPTS = {:last => -1}
-arg = bkb_stdargs(nil, OPTS)
-arg = bkb_inputargs(arg, OPTS)
-
-arg.banner += " start (no args when using -r|-x|)"
-
-arg.on("-r", "--range=START[:END]", "Start and optional end range") do |r|
-
-  raise "-x and -r are mutually exclusive" if OPTS[:first]
-
-  unless m=/^(-?[0-9]+)(?::(-?[0-9]+))?$/.match(r)
-    raise "invalid range #{r.inspect}"
-  end
-
-  OPTS[:first] = $1.to_i
-  OPTS[:last] = $2.to_i if $2
-end
-
-arg.on("-x", "--hexrange=START[:END]", "same, but in hex") do |r|
-
-  raise "-x and -r are mutually exclusive" if OPTS[:first]
-
-  unless m=/^(-?[0-9a-f]+)(?::(-?[0-9a-f]+))?$/i.match(r)
-    raise "invalid range #{r.inspect}"
-  end
-
-  OPTS[:first]=($1[0,1] == '-')? ($1[1..-1]).hex_to_num * -1 : $1.hex_to_num
-  if $2
-    OPTS[:last]=($2[0,1] == '-')? ($2[1..-1]).hex_to_num * -1 : $2.hex_to_num
-  end
-end
-
-begin
-  arg.parse!
-
-  OPTS[:first] ||= ARGV.shift
-
-  unless( ARGV.length != 1 and (
-              OPTS[:first].kind_of?(Numeric) or 
-              /^-?\d+$/.match(OPTS[:first]) )
-        )
-    raise "bad arguments"
-  end
-
-  OPTS[:first] = OPTS[:first].to_i
-
-  OPTS[:indat] ||= STDIN.read()
-
-  # drumroll... and substring:
-  STDOUT.write OPTS[:indat][ OPTS[:first] .. OPTS[:last] ]
-
-rescue
-  bail "Error: #{$!}\n#{arg}"
-end
+require "rbkb/cli/slice"
 
+Rbkb::Cli::Slice.run()

data/bin/telson

@@ -1,109 +1,5 @@
 #!/usr/bin/env ruby
-# telson <emonti at matasano> 3/15/2008
-#----------------------------------------------------------------------
-#
-# 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.
-# 
-#----------------------------------------------------------------------
-#
-# Usage: telson -h
-#
 
-require 'rbkb'
-require 'rbkb/plug'
-require 'rbkb/command_line'
-
-include RBkB::CommandLine
-
-Plug::UI::LOGCFG[:verbose] = true
-Plug::UI::LOGCFG[:dump] = :hex
-
-
-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
-
-arg = bkb_stdargs(nil, {})
-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)
-    raise "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")
-end
-
-arg.on("-q", "--quiet", "Turn off verbose logging") do
-  Plug::UI::LOGCFG[:verbose] = false
-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
-    raise "Invalid listen argument: #{p.inspect}"
-  end
-end
-
-
-arg.parse!(ARGV) rescue bail "Error: #{$!}\nUse -h|--help for more info."
-
-# Get target argument
-unless (m = /^([\w\.]+):(\d+)$/.match(ARGV.shift)) and ARGV.shift.nil?
-  bail arg
-end
-
-t_addr = m[1]
-t_port = m[2].to_i
-
-loop do
-  EventMachine.run {
-    if proto == :TCP
-      bail "Sorry: --source only works with UDP. Blame EventMachine!" 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")
-  }
-  break unless persist
-  Plug::UI::verbose("** RECONNECTING")
-end
+require "rbkb/cli/telson"
 
+Rbkb::Cli::Telson.run()