librex 0.0.68 → 0.0.70

data/lib/rex/encoding/xor/exceptions.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 module Rex
@@ -10,8 +9,8 @@ module Exception
 end
 
 class KeySearchError < ::Exception
-	include Exception
-	MSG = "Error finding a key."
+  include Exception
+  MSG = "Error finding a key."
 end
 
 end end end

data/lib/rex/encoding/xor/generic.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'rex/encoding/xor/exceptions'
@@ -10,138 +9,138 @@ module Xor
 
 class Generic
 
-	def Generic.keysize
-		# special case:
-		# 0 means we encode based on the length of the key
-		# we don't enforce any perticular key length
-		return 0
-	end
-
-	#
-	# Now for some internal check methods
-	#	
-
-	# hook stylies!
-	# return index of offending byte or nil
-	def Generic._check(data, key, badchars)
-		return _check_key(key, badchars) || _check_encode(data, key, badchars)
-	end
-	def Generic._check_key(key, badchars)
-		return Rex::Text.badchar_index(key, badchars)
-	end
-	def Generic._check_encode(data, key, badchars)
-		return Rex::Text.badchar_index(encode(data, key), badchars)
-	end
-
-	def Generic.find_key(data, badchars)
-		return _find_good_key(data, _find_bad_keys(data, badchars), badchars)
-	end
-
-	# !!! xxx MAKE THESE BITCHE PRIVATE
-
-	#
-	# Find a list of bytes that can't be valid xor keys, from the data and badchars.
-	# This returns a Array of hashes, length keysize
-	#
-	def Generic._find_bad_keys(data, badchars)
-
-		ksize = keysize
-
-		# array of hashes for the bad characters based
-		# on their position in the data
-		badkeys = [ ]
-		ksize.times { badkeys << { } }
-
-		badchars.each_byte { |badchar|
-			pos = 0
-			data.each_byte { |char|
-				badkeys[pos % ksize][char ^ badchar] = true
-				pos += 1
-			}
-		}
-
-		return badkeys
-	end
-
-	#
-	# (Hopefully) find a good key, from badkeys and badchars
-	#
-	def Generic._find_good_key(data, badkeys, badchars)
-
-		ksize = keysize
-		strip = 0
-		key   = ""
-
-		while strip < keysize
-
-			kbyte = rand(256)
-
-			catch(:found_kbyte) do
-				256.times {
-
-					if !badkeys[strip][kbyte] && !badchars[kbyte.chr]
-						throw :found_kbyte
-					end
-					
-					kbyte = (kbyte + 1) & 0xff
-				}
-
-				raise KeySearchError, "Exhausted byte space for strip #{strip}!", caller
-			end
-
-			key << kbyte
-			strip += 1
-		end
-
-		# ok, we should have a good key now, lets double check...
-		if _check(data, key, badchars)
-			raise KeySearchError, "Key found, but bad character check failed!", caller
-		end
-
-		return key
-	end
-
-	def Generic.encode(buf, key)
-
-		if !key.kind_of?(String)
-			raise ::ArgumentError, "Key must be a string!", caller
-		end
-
-		len = key.length
-
-		if len == 0
-			raise ::ArgumentError, "Zero key length!", caller
-		end
-
-		if keysize != 0 && keysize != len
-			raise ::ArgumentError, "Key length #{len}, expected #{keysize}", caller
-		end
-
-		encoded = ""
-		pos     = 0
-
-		while pos < buf.length
-			encoded += (buf[pos,1].unpack("C*")[0] ^ key[pos % len, 1].unpack("C*")[0]).chr
-			key = _encode_mutate_key(buf, key, pos, len)
-			pos += 1
-		end
-
-		return [ encoded, key ]
+  def Generic.keysize
+    # special case:
+    # 0 means we encode based on the length of the key
+    # we don't enforce any perticular key length
+    return 0
+  end
 
-	end
+  #
+  # Now for some internal check methods
+  #
 
-	# kind of ghetto, but very convenient for mutating keys
-	# by default, do no key mutations
-	def Generic._encode_mutate_key(buf, key, pos, len)
-		return key
-	end
+  # hook stylies!
+  # return index of offending byte or nil
+  def Generic._check(data, key, badchars)
+    return _check_key(key, badchars) || _check_encode(data, key, badchars)
+  end
+  def Generic._check_key(key, badchars)
+    return Rex::Text.badchar_index(key, badchars)
+  end
+  def Generic._check_encode(data, key, badchars)
+    return Rex::Text.badchar_index(encode(data, key), badchars)
+  end
 
-	# maybe a bit a smaller of method name?
-	def Generic.find_key_and_encode(data, badchars)
-		key        = find_key(data, badchars)
-		enc, fkey  = encode(data, key)
-		return [ enc, key, fkey ]
-	end
+  def Generic.find_key(data, badchars)
+    return _find_good_key(data, _find_bad_keys(data, badchars), badchars)
+  end
+
+  # !!! xxx MAKE THESE PRIVATE
+
+  #
+  # Find a list of bytes that can't be valid xor keys, from the data and badchars.
+  # This returns a Array of hashes, length keysize
+  #
+  def Generic._find_bad_keys(data, badchars)
+
+    ksize = keysize
+
+    # array of hashes for the bad characters based
+    # on their position in the data
+    badkeys = [ ]
+    ksize.times { badkeys << { } }
+
+    badchars.each_byte { |badchar|
+      pos = 0
+      data.each_byte { |char|
+        badkeys[pos % ksize][char ^ badchar] = true
+        pos += 1
+      }
+    }
+
+    return badkeys
+  end
+
+  #
+  # (Hopefully) find a good key, from badkeys and badchars
+  #
+  def Generic._find_good_key(data, badkeys, badchars)
+
+    ksize = keysize
+    strip = 0
+    key   = ""
+
+    while strip < keysize
+
+      kbyte = rand(256)
+
+      catch(:found_kbyte) do
+        256.times {
+
+          if !badkeys[strip][kbyte] && !badchars[kbyte.chr]
+            throw :found_kbyte
+          end
+
+          kbyte = (kbyte + 1) & 0xff
+        }
+
+        raise KeySearchError, "Exhausted byte space for strip #{strip}!", caller
+      end
+
+      key << kbyte
+      strip += 1
+    end
+
+    # ok, we should have a good key now, lets double check...
+    if _check(data, key, badchars)
+      raise KeySearchError, "Key found, but bad character check failed!", caller
+    end
+
+    return key
+  end
+
+  def Generic.encode(buf, key)
+
+    if !key.kind_of?(String)
+      raise ::ArgumentError, "Key must be a string!", caller
+    end
+
+    len = key.length
+
+    if len == 0
+      raise ::ArgumentError, "Zero key length!", caller
+    end
+
+    if keysize != 0 && keysize != len
+      raise ::ArgumentError, "Key length #{len}, expected #{keysize}", caller
+    end
+
+    encoded = ""
+    pos     = 0
+
+    while pos < buf.length
+      encoded += (buf[pos,1].unpack("C*")[0] ^ key[pos % len, 1].unpack("C*")[0]).chr
+      key = _encode_mutate_key(buf, key, pos, len)
+      pos += 1
+    end
+
+    return [ encoded, key ]
+
+  end
+
+  # kind of ghetto, but very convenient for mutating keys
+  # by default, do no key mutations
+  def Generic._encode_mutate_key(buf, key, pos, len)
+    return key
+  end
+
+  # maybe a bit a smaller of method name?
+  def Generic.find_key_and_encode(data, badchars)
+    key        = find_key(data, badchars)
+    enc, fkey  = encode(data, key)
+    return [ enc, key, fkey ]
+  end
 
 
 end end end end # Generic/Xor/Encoding/Rex

data/lib/rex/encoding/xor/qword.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'rex/encoding/xor/generic'
@@ -9,8 +8,8 @@ module Xor
 
 class Qword < Generic
 
-	def Qword.keysize
-		8
-	end
+  def Qword.keysize
+    8
+  end
 
 end end end end

data/lib/rex/encoding/xor/word.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'rex/encoding/xor/generic'
@@ -15,8 +14,8 @@ module Xor
 
 class Word < Generic
 
-	def Word.keysize
-		2
-	end
+  def Word.keysize
+    2
+  end
 
 end end end end # Word/Xor/Encoding/Rex

data/lib/rex/exceptions.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 module Rex
@@ -17,11 +16,11 @@ end
 #
 ###
 class TimeoutError < Interrupt
-	include Exception
+  include Exception
 
-	def to_s
-		"Operation timed out."
-	end
+  def to_s
+    "Operation timed out."
+  end
 end
 
 ###
@@ -31,11 +30,11 @@ end
 #
 ###
 class NotImplementedError < ::NotImplementedError
-	include Exception
+  include Exception
 
-	def to_s
-		"The requested method is not implemented."
-	end
+  def to_s
+    "The requested method is not implemented."
+  end
 end
 
 ###
@@ -44,7 +43,7 @@ end
 #
 ###
 class RuntimeError < ::RuntimeError
-	include Exception
+  include Exception
 end
 
 ###
@@ -53,19 +52,19 @@ end
 #
 ###
 class ArgumentError < ::ArgumentError
-	include Exception
-
-	def initialize(message = nil)
-		@message = message
-	end
-
-	def to_s
-		str = 'An invalid argument was specified.'
-		if @message
-			str << " #{@message}"
-		end
-		str
-	end
+  include Exception
+
+  def initialize(message = nil)
+    @message = message
+  end
+
+  def to_s
+    str = 'An invalid argument was specified.'
+    if @message
+      str << " #{@message}"
+    end
+    str
+  end
 end
 
 ###
@@ -75,11 +74,11 @@ end
 #
 ###
 class ArgumentParseError < ::ArgumentError
-	include Exception
+  include Exception
 
-	def to_s
-		"The argument could not be parsed correctly."
-	end
+  def to_s
+    "The argument could not be parsed correctly."
+  end
 end
 
 ###
@@ -88,15 +87,15 @@ end
 #
 ###
 class AmbiguousArgumentError < ::RuntimeError
-	include Exception
+  include Exception
 
-	def initialize(name = nil)
-		@name = name
-	end
+  def initialize(name = nil)
+    @name = name
+  end
 
-	def to_s
-		"The name #{@name} is ambiguous."
-	end
+  def to_s
+    "The name #{@name} is ambiguous."
+  end
 end
 
 ###
@@ -105,19 +104,19 @@ end
 #
 ###
 class StreamClosedError < ::IOError
-	include Exception
+  include Exception
 
-	def initialize(stream)
-		@stream = stream
-	end
+  def initialize(stream)
+    @stream = stream
+  end
 
-	def stream
-		@stream
-	end
+  def stream
+    @stream
+  end
 
-	def to_s
-		"Stream #{@stream} is closed."
-	end
+  def to_s
+    "Stream #{@stream} is closed."
+  end
 end
 
 ##
@@ -132,11 +131,11 @@ end
 #
 ###
 module SocketError
-	include Exception
+  include Exception
 
-	def to_s
-		"A socket error occurred."
-	end
+  def to_s
+    "A socket error occurred."
+  end
 end
 
 ###
@@ -146,26 +145,26 @@ end
 #
 ###
 module HostCommunicationError
-	def initialize(addr = nil, port = nil)
-		self.host = addr
-		self.port = port
-	end
-
-	#
-	# This method returns a printable address and optional port associated
-	# with the host that triggered the exception.
-	#
-	def addr_to_s
-		if host and port
-			"(#{host}:#{port})"
-		elsif host
-			"(#{host})"
-		else
-			""
-		end
-	end
-
-	attr_accessor :host, :port
+  def initialize(addr = nil, port = nil)
+    self.host = addr
+    self.port = port
+  end
+
+  #
+  # This method returns a printable address and optional port associated
+  # with the host that triggered the exception.
+  #
+  def addr_to_s
+    if host and port
+      "(#{host}:#{port})"
+    elsif host
+      "(#{host})"
+    else
+      ""
+    end
+  end
+
+  attr_accessor :host, :port
 end
 
 
@@ -175,8 +174,8 @@ end
 #
 ###
 class ConnectionError < ::IOError
-	include SocketError
-	include HostCommunicationError
+  include SocketError
+  include HostCommunicationError
 end
 
 ###
@@ -186,9 +185,9 @@ end
 #
 ###
 class ConnectionRefused < ConnectionError
-	def to_s
-		"The connection was refused by the remote host #{addr_to_s}."
-	end
+  def to_s
+    "The connection was refused by the remote host #{addr_to_s}."
+  end
 end
 
 ###
@@ -198,9 +197,9 @@ end
 #
 ###
 class HostUnreachable < ConnectionError
-	def to_s
-		"The host #{addr_to_s} was unreachable."
-	end
+  def to_s
+    "The host #{addr_to_s} was unreachable."
+  end
 end
 
 ###
@@ -209,9 +208,9 @@ end
 #
 ###
 class ConnectionTimeout < ConnectionError
-	def to_s
-		"The connection timed out #{addr_to_s}."
-	end
+  def to_s
+    "The connection timed out #{addr_to_s}."
+  end
 end
 
 
@@ -225,12 +224,12 @@ end
 #
 ###
 class AddressInUse < ConnectionError
-	include SocketError
-	include HostCommunicationError
+  include SocketError
+  include HostCommunicationError
 
-	def to_s
-		"The address is already in use #{addr_to_s}."
-	end
+  def to_s
+    "The address is already in use #{addr_to_s}."
+  end
 end
 
 ###
@@ -239,17 +238,17 @@ end
 #
 ###
 class UnsupportedProtocol < ::ArgumentError
-	include SocketError
+  include SocketError
 
-	def initialize(proto = nil)
-		self.proto = proto
-	end
+  def initialize(proto = nil)
+    self.proto = proto
+  end
 
-	def to_s
-		"The protocol #{proto} is not supported."
-	end
+  def to_s
+    "The protocol #{proto} is not supported."
+  end
 
-	attr_accessor :proto
+  attr_accessor :proto
 end
 
 
@@ -259,17 +258,17 @@ end
 #
 ###
 class ConnectionProxyError < ConnectionError
-	def initialize(host,port,ptype,reason)
-		super(host,port)
-		self.ptype = ptype
-		self.reason = reason
-	end
+  def initialize(host,port,ptype,reason)
+    super(host,port)
+    self.ptype = ptype
+    self.reason = reason
+  end
 
-	def to_s
-		self.ptype + ": " + self.reason
-	end
+  def to_s
+    self.ptype + ": " + self.reason
+  end
 
-	attr_accessor :ptype, :reason
+  attr_accessor :ptype, :reason
 end
 
 end