aastdlib 0.0.3

data/lib/aastdlib.rb

@@ -0,0 +1,12 @@
+require "terminal-table"
+require "aastdlib/version"
+
+path = __FILE__.split('/')
+path = path[0..(path.count - 2)].join('/')
+path += '/aastdlib/'
+
+Dir::entries(path).keep_if {|e| e =~ /\.rb$/}.each { |f| require(path+f) }
+
+module Aastdlib
+  # Your code goes here...
+end

data/lib/aastdlib/array.rb

@@ -0,0 +1,20 @@
+class Array
+
+    # Accepts a value that is check against each element
+    # in the array itself and returns a new array containing
+    # the index for each matching element.
+	def indices(value)
+		counter = 0
+		indices = []
+
+		self.each do |v|
+			indices << counter if value == v
+			counter+=1
+		end
+
+		return indices
+
+	end
+
+
+end

data/lib/aastdlib/file.rb

@@ -0,0 +1,23 @@
+class File
+
+    def self.check_and_open(filename, mode="r+")
+
+        raise "Error: File doesn't exist (#{filename})" if !File::exist?(filename)
+
+        file = File::open(filename, mode)
+
+        if block_given?
+
+            yield(file)
+            file.close
+            return
+
+        else
+
+            return file
+
+        end
+
+    end
+
+end

data/lib/aastdlib/hash.rb

@@ -0,0 +1,22 @@
+class Hash
+
+    # Return a copy of the hash with each key converted
+    # to a string.
+	def stringify_keys()
+
+		stringified = {}
+		self.each {|k,v| stringified[k.to_s] = v}
+		return stringified
+
+	end
+
+    # _Hash is modified inline!_ Converts each key to a string.
+	def stringify_keys!()
+
+		stringified = self.stringify_keys()
+		self.clear
+		stringified.each {|k,v| self[k] = v}
+
+	end
+
+end

data/lib/aastdlib/integer.rb

@@ -0,0 +1,16 @@
+class Integer
+
+    # Return a copy of the integer in base 16. The
+    # pack argument determines whether or not the value
+    # should be packed to binary form using Array::pack().
+    def to_hex_string(pack=false)
+
+        out = self.to_s(16)
+        out = ("0"+out) if out.length == 1
+        out = [out].pack('H*') if pack
+
+        return out
+
+    end
+
+end

data/lib/aastdlib/object.rb

@@ -0,0 +1,200 @@
+class Object
+
+    # Declare and define an instance variable for a given object.
+    # Name is the instance variable name and value is the item assigned
+    # to that instance variable. Convenience determines whether getter/setter
+    # methods are defined as well.
+    def declare_and_define_ivar(name:, value:, convenience: true)
+
+    	if name =~ /^@/
+
+    		iv_handle = name
+    		name = name.to_s.gsub('@','')
+
+    	else
+
+    		iv_handle = ('@'+name)
+
+    	end
+
+    	iv_handle = iv_handle.to_sym if iv_handle.respond_to?(:to_sym)
+
+        self.instance_variable_set(iv_handle, value)
+
+        if convenience
+
+        	# getter
+        	self.define_singleton_method(name) do
+        		self.instance_variable_get(iv_handle)
+        	end
+
+        	# setter
+        	self.define_singleton_method(name+'=') do |value|
+        		self.instance_variable_set(iv_handle, value)
+        	end
+
+        end
+
+    end
+
+    # Convenience method for declare_and_define_ivar()
+    def define_ivar(name:, value:, convenience: true)
+
+    	self.declare_and_define_ivar(name: name, value: value)
+
+    end
+
+    # Using terminal-table, format all instance variables in a
+    # visually appealing text-based table.
+	def instance_variable_table()
+
+		rows = []
+		table = Terminal::Table.new()
+		table.headings = ['Instance Variable', 'Object']
+		table.title = "#{self.class}: Instance Vairables"
+
+		self.instance_variables.each do |iv|
+
+			rows << [iv.to_s,self.instance_variable_get(iv)]
+			
+		end
+
+		table.rows = rows
+
+		return table
+
+	end
+
+    # Inspect the object all pretty like.
+	def pretty_inspect()
+
+		tab_count = 0
+
+		out = self.inspect.gsub("@","\n\t@")
+			.lines
+
+		expanded = ""
+
+		counter = out.length
+		(0..counter-1).each do |n|
+
+			line = out[n]
+
+			expanded += ("\t"*tab_count) + line
+
+			tab_count += 1 if line =~ /\=\#\</
+
+			if line =~ /\>\,/ and tab_count != 0
+
+				tab_count -= 1
+
+			end
+
+		end
+
+		return expanded
+
+	end
+
+    # Pretty inspect and print it to stdout.
+	def pi(obj)
+
+		puts
+		puts obj.pretty_inspect
+		puts
+
+	end
+
+    # Using terminal-table, print a visually appealing table detailing
+    # methods offered by the object. Valid arguments to _type_ include:
+    # - private
+    # - public
+    # - protected
+	def method_table(type=nil)
+
+		mlists = {
+			methods: [],
+			private: [],
+			protected: [],
+			public: []
+		}
+
+		if type
+
+			case type
+
+			when :private
+
+				self.private_methods.sort.each  {|m| mlists[:private] << m}
+
+			when :protected
+
+				self.protected_methods.sort.each {|m| mlists[:protected] << m}
+
+			when :public
+
+				self.public_methods.sort.each  {|m| mlists[:public] << m}
+
+			end
+
+		else
+
+			self.methods.sort.each {|m| mlists[:methods] << m} unless type
+			self.private_methods.sort.each  {|m| mlists[:private] << m}
+			self.protected_methods.sort.each {|m| mlists[:protected] << m}
+			self.public_methods.sort.each  {|m| mlists[:public] << m}
+
+		end
+
+		mlists.delete_if {|k,v| v == []}
+
+		if mlists.count < 1
+
+			if type
+
+				puts "[+] No methods of #{type} type available!"
+
+			else
+
+				puts "[+] No methods available!"
+
+			end
+
+			return
+
+		end
+
+		lengths = []
+		headings = ['#']
+
+		mlists.each do |k,v|
+			headings << k.to_s.gsub('_',' ').capitalize
+			lengths << v.length
+		end
+
+		max_len = lengths.uniq.sort.last
+
+		table = Terminal::Table.new()
+		table.headings = headings
+		table.title = "Methods: #{self.class}"
+
+		rows = []
+
+		max_len.times do |n|
+
+			row = []
+
+			row << n
+			mlists.each { |k,v|	row << mlists[k][n] }
+
+			rows << row
+
+		end
+
+		table.rows = rows
+
+		return table
+
+	end
+
+end

data/lib/aastdlib/string.rb

@@ -0,0 +1,377 @@
+#!/usr/bin/ruby
+# encoding: ASCII-8BIT
+
+# Extension of the String class.
+class String
+
+	require 'base64'
+
+	HEX_VALUES = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f" +
+	"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" +
+	"\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f" +
+	"\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f" +
+	"\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f" +
+	"\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f" +
+	"\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f" +
+	"\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f" +
+	"\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" +
+	"\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" +
+	"\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf" +
+	"\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf" +
+	"\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" +
+	"\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf" +
+	"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" +
+	"\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff"
+
+	# generate all hex values and return them in a string
+	def self.generate_all_hex_values(upcase=true)
+
+		s = ""
+
+		256.times do |n|
+
+			n = n.to_s(16)
+			n = n.upcase if upcase
+			n = '0' + n if n.length < 2
+			s += '\x' + n
+
+		end
+
+		return s
+
+	end
+
+	# Insert a string at a random index within this string
+	def rando_insert(str)
+
+		unless self.length > 1
+
+			raise "String length is too short! length must be 2 or greater (len >= 2)"
+
+		end
+
+		return self.dup.insert(rand(0..(self.length-1)), str)
+
+	end
+
+	# return the string with a border at the top and bottom of the string
+	# border character can be altered
+	def borderize(char='-')
+
+		border = char * self.length
+		return "#{border}\n#{self}\n#{border}"
+
+	end
+
+	# trim the string to a particular length and echo it to stdout as a
+	# script ready string
+	def prettyfi(max_len=60)
+
+		if self.length < max_len
+
+			out = self
+
+		else
+
+			# holds output fragments
+			buff = []
+
+			start, _end = 0, (max_len-1)
+
+			ind,counter = -1, 0
+
+			chunk = ""
+			while c = self[ind+=1]
+
+				counter += 1
+				chunk += c
+
+				if counter == (max_len) or ind == (self.length-1)
+
+					buff << '"' + chunk + '"'
+					chunk = ""
+					counter = 0
+
+				end
+
+			end
+
+			out = buff.join(" +\n")
+
+		end
+
+		return out
+		
+	end
+
+	# same thing as prettyfi but converts contents of the string
+	# to \x format
+	def prettyfi_shellcode(prefix: '\x', limit: 16)
+
+		ary = self.bin_to_array
+
+		output = ""
+
+		# Maximum index position of split array
+		max = (ary.length - 1)
+
+		# Bottom of slice range
+		floor = 0
+
+		# Top of slice range
+		ceiling = (limit-1)
+
+		while true
+
+			slice = prefix + ary.slice(floor..ceiling).join(prefix)
+
+			output += '"' + slice + '"'
+
+			break if ceiling >= max
+
+			floor += limit
+			ceiling += limit
+			output += "+\n"
+
+		end
+
+		return output
+
+	end
+
+    # Prefix the string with a symbol wrapped in two characters.
+    def prefix(symbol: '+', wrapper: ["[","]"], space_char: " ", space_rep: 1, ind_char: "", ind_rep: 1)
+
+        # build the indention string
+        indention = ind_char * ind_rep
+
+        # build the spacer string
+        spacer = space_char * space_rep
+
+        # build the symbol string
+        symbol = indention + wrapper.insert(1,symbol).join('') + spacer
+
+        return symbol + self
+
+    end
+
+    # Returna a duplicate of the string with a character prefix.
+    def simple_prefix(char)
+
+    	return char+self
+
+    end
+
+    # Return a duplicate of the string with a character on each side.
+    def wrap(char)
+
+    	return char+self+char
+
+    end
+
+    # Return a duplicate of the string suffixed with a single character.
+    def suffix(char)
+
+    	return self+char
+
+    end
+
+    # Convert the string to a CSV value. Setting comma delimit to false
+    # will return the string wrapped in double quotes.
+    def to_csv_value(comma_delimit=true)
+
+    	return comma_delimit ? self.wrap('"').suffix(',') : self.wrap('"')
+
+    end
+
+    # Return the string will all :: and capital letters converted to
+    # underscores.
+	def to_underscore()
+
+		# sauce: https://stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
+		return self.gsub(/::/, '/')
+			.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+			.gsub(/([a-z\d])([A-Z])/,'\1_\2')
+			.tr("-", "_")
+			.downcase
+
+	end
+
+    # Convenience method for to_underscore()
+	def snake_name()
+
+		return self.to_underscore
+
+	end
+
+    # Return a duplicate of the string prefixed with @ converted to a symbol.
+	def to_instance_variable_name(snake_case=true, symbolize=true)
+
+		name = self.to_s
+		name = name.to_underscore if snake_case
+		name = ('@' + name) if name !~ /^@/ 
+		name = name.to_sym if symbolize
+
+		return name
+
+	end
+
+    # Convenience method for to_instance_variable_name()
+	def to_ivar_name(snake_case=true, symbolize=true)
+
+		to_instance_variable_name(snake_case, symbolize)
+
+	end
+
+    # Pads each binary component in the string with \x00. A duplicate
+    # of the string is modified and returned.
+	def utf_pad()
+
+		return self.unpack('H2'*self.bytesize)
+			.map {|l| l = "\x00" + [l].pack('H2')}
+			.join('')
+
+	end
+
+    # Return the string as an array of base 16 values. Base can be altered by
+    # updating the _radix_ argument.
+	def bin_to_array(upcase: true, radix: 16)
+
+		return self.bytes.map do |b|
+
+					if upcase
+						b = b.to_s(radix).upcase
+					else
+						b = b.to_s(radix)
+					end
+
+					if b.length < 2
+						b = '0' + b
+					else
+						b
+					end
+
+				end
+
+	end
+
+    # Returns a duplicate of the string unpacked in \x literal form. Useful
+    # when dynamically generating shellcode.
+	def to_hex_string(literal: true, prefix: '\x')
+
+		out = self.bin_to_array()
+
+		if literal
+			out = prefix + out.join(prefix)
+		else
+            out = out.map!  {|e| [e].pack("H2") }.join('')
+		end
+
+		return out
+
+	end
+
+    # Return a duplicate string in literal form with each character
+    # suffixed with \u
+	def to_utf8(prefix='\u')
+
+		return prefix + self.bin_to_array.join(prefix)
+
+	end
+
+    # Return a duplicate string in literal from where each char is
+    # converted to utf16 literal format. Endianness can be altered
+    # via the _endianness_ argument.
+	def to_utf16(endianness='le')
+
+		if endianness !~ /^(le|be)$/i
+
+			raise "Error: valid arguments to endianness parameter: le or be"
+
+		end
+
+		pad = '00'
+		prefix = '\u'
+
+		# get a copy of the string in hex form
+		# and pad each byte
+		buff = prefix + self.bin_to_array
+				.map do |b|
+
+					if endianness =~ /^le$/i 
+						(b = b + pad)
+					else
+						(b = pad + b)
+					end
+
+				end.join(prefix)
+
+		return buff
+
+	end
+
+    # Poor mans URL encoding: each character is unpacked to
+    # it's hex form and then suffixed with %.
+	def to_url_encoded()
+		return '%' + self.bin_to_array.join('%')
+	end
+
+    # Base64 encode and return a duplicate string.
+	def to_base64(strict=false)
+		if strict
+			return Base64::strict_encode64(self)
+		else
+			return Base64::encode64(self)
+		end
+	end
+
+    # Base64 decde and return a duplicate string.
+	def decode64(strict=false)
+		if strict
+			return Base64::strict_decode64(self)
+		else
+			return Base64::decode64(self)
+		end
+	end
+
+    # Encode and return a duplicate of the string in _0b0010110_ format.
+	def to_binary(prefix='0b')
+
+		return prefix+self.bytes
+				.map do |b|
+
+					b = b.to_s(2)
+					b = '0' * (8 - b.length) + b
+
+				end
+				.join(prefix)
+
+	end
+
+    # Return a duplicate of the string with the case altered randomly.
+	def obfuscate_case()
+
+		return self.split('').map do |c|
+
+			if rand(0..1) > 0
+
+				c = c.upcase
+
+			else
+
+				c = c.downcase
+
+			end
+
+		end.join('')
+
+	end
+
+    # Inser _string_ at a random place in the current string.
+	def obfuscate_string_insert(string)
+
+		return self.insert(rand(0..(self.length - 1)), string)
+
+	end
+
+end