emonti-rbkb 0.6.1.1

data/bin/hexify

@@ -0,0 +1,85 @@
+#!/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
+

data/bin/len

@@ -0,0 +1,74 @@
+#!/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]
+

data/bin/rex

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+#
+# lazy form of ruby -e "xxxx". All commandline arguments get smeared to
+# pure ruby.
+
+require 'pp'
+require 'rbkb'
+
+eval ARGV.join(' ');
+

data/bin/rstrings

@@ -0,0 +1,123 @@
+#!/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
+

data/bin/slice

@@ -0,0 +1,74 @@
+#!/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
+

data/bin/telson

@@ -0,0 +1,109 @@
+#!/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
+