librex 0.0.68 → 0.0.70

data/lib/rex/encoder/xor.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 module Rex
@@ -11,58 +10,58 @@ module Encoder
 ###
 class Xor
 
-	attr_accessor :raw, :encoded, :badchars, :opts, :key, :fkey # :nodoc:
-
-	#
-	# wrap that in a wanna be static class
-	#
-	def self.encode(*args)
-		self.new.encode(*args)
-	end
-
-	#
-	# Return the class associated with this encoder.
-	#
-	def encoder()
-		self.class::EncoderKlass
-	end
-
-	#
-	# This method encodes the supplied data, taking into account the badchar
-	# list, and returns the encoded buffer.
-	#
-	def encode(data, badchars = '', opts = { })
-		self.raw      = data
-		self.badchars = badchars
-		self.opts     = opts
-
-		# apply any transforms to the plaintext data
-		data = _unencoded_transform(data)
-
-		self.encoded, self.key, self.fkey = encoder().find_key_and_encode(data, badchars)
-
-		# apply any transforms to the encoded data
-		self.encoded = _encoded_transform(encoded)
-
-		return _prepend() + encoded + _append()
-	end
-
-	protected
-	def _unencoded_transform(data) # :nodoc:
-		data
-	end
-
-	def _encoded_transform(data) # :nodoc:
-		data
-	end
-
-	def _prepend() # :nodoc:
-		""
-	end
-
-	def _append() # :nodoc:
-		""
-	end
+  attr_accessor :raw, :encoded, :badchars, :opts, :key, :fkey # :nodoc:
+
+  #
+  # wrap that in a wanna be static class
+  #
+  def self.encode(*args)
+    self.new.encode(*args)
+  end
+
+  #
+  # Return the class associated with this encoder.
+  #
+  def encoder()
+    self.class::EncoderKlass
+  end
+
+  #
+  # This method encodes the supplied data, taking into account the badchar
+  # list, and returns the encoded buffer.
+  #
+  def encode(data, badchars = '', opts = { })
+    self.raw      = data
+    self.badchars = badchars
+    self.opts     = opts
+
+    # apply any transforms to the plaintext data
+    data = _unencoded_transform(data)
+
+    self.encoded, self.key, self.fkey = encoder().find_key_and_encode(data, badchars)
+
+    # apply any transforms to the encoded data
+    self.encoded = _encoded_transform(encoded)
+
+    return _prepend() + encoded + _append()
+  end
+
+  protected
+  def _unencoded_transform(data) # :nodoc:
+    data
+  end
+
+  def _encoded_transform(data) # :nodoc:
+    data
+  end
+
+  def _prepend() # :nodoc:
+    ""
+  end
+
+  def _append() # :nodoc:
+    ""
+  end
 
 end
 

data/lib/rex/encoder/xor/dword.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'rex/encoder/xor'
@@ -10,5 +9,5 @@ require 'rex/encoding/xor/dword'
 #
 ###
 class Rex::Encoder::Xor::Dword < Rex::Encoder::Xor
-	EncoderKlass = Rex::Encoding::Xor::Dword
+  EncoderKlass = Rex::Encoding::Xor::Dword
 end

data/lib/rex/encoder/xor/dword_additive.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'rex/encoder/xor'
@@ -10,5 +9,5 @@ require 'rex/encoding/xor/dword_additive'
 #
 ###
 class Rex::Encoder::Xor::DwordAdditive < Rex::Encoder::Xor
-	EncoderKlass = Rex::Encoding::Xor::DwordAdditive
+  EncoderKlass = Rex::Encoding::Xor::DwordAdditive
 end

data/lib/rex/encoders/xor_dword.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'rex/arch/x86'
@@ -13,24 +12,24 @@ module Encoders
 #
 ###
 class XorDword < Rex::Encoder::Xor::Dword
-	module Backend
-		def _prepend
-			# set the counter to the rounded up number of dwords to decode
-			Rex::Arch::X86.set(
-				Rex::Arch::X86::ECX,
-				(encoded.length - 1 >> 2) + 1,
-				badchars
-			) +
-			"\xe8\xff\xff\xff" +                # call $+4
-			"\xff\xc0" +                        # inc eax
-			"\x5e" +                            # pop esi
-			"\x81\x76\x0e" + key +              # xor_xor: xor [esi + 0x0e], $xorkey
-			"\x83\xee\xfc" +                    # sub esi, -4
-			"\xe2\xf4"                          # loop xor_xor
-		end
-	end
+  module Backend
+    def _prepend
+      # set the counter to the rounded up number of dwords to decode
+      Rex::Arch::X86.set(
+        Rex::Arch::X86::ECX,
+        (encoded.length - 1 >> 2) + 1,
+        badchars
+      ) +
+      "\xe8\xff\xff\xff" +                # call $+4
+      "\xff\xc0" +                        # inc eax
+      "\x5e" +                            # pop esi
+      "\x81\x76\x0e" + key +              # xor_xor: xor [esi + 0x0e], $xorkey
+      "\x83\xee\xfc" +                    # sub esi, -4
+      "\xe2\xf4"                          # loop xor_xor
+    end
+  end
 
-	include Backend
+  include Backend
 end
 
 end end

data/lib/rex/encoders/xor_dword_additive.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'rex/encoder/xor/dword_additive'
@@ -14,41 +13,41 @@ module Rex
 module Encoders
 
 class XorDwordAdditive < Rex::Encoder::Xor::DwordAdditive
-	module Backend
-
-		def _unencoded_transform(data)
-			# check for any dword aligned zeros that would falsely terminate the decoder
-			idx = 0
-			while true
-				idx = data.index("\x00\x00\x00\x00", idx)
-				break if !idx
-				if idx & 3 == 0
-					raise RuntimeError, "Unencoded data cannot have a dword aligned 0 dword!", caller()
-				end
-				idx += 1
-			end
-
-			# pad to a dword boundary and append null dword for termination
-			data = data + ("\x00" * ((4 - data.length & 3) & 3)) + "\x00\x00\x00\x00"
-		end
-
-		def _prepend
-			"\xfc"                + # cld
-			"\xbb" + key          + # mov ebx, key
-			"\xeb\x0c"            + # jmp short 0x14
-			"\x5e"                + # pop esi
-			"\x56"                + # push esi
-			"\x31\x1e"            + # xor [esi], ebx
-			"\xad"                + # lodsd
-			"\x01\xc3"            + # add ebx, eax
-			"\x85\xc0"            + # test eax, eax
-			"\x75\xf7"            + # jnz 0xa
-			"\xc3"                + # ret
-			"\xe8\xef\xff\xff\xff"  # call 0x8
-		end
-	end
-
-	include Backend
+  module Backend
+
+    def _unencoded_transform(data)
+      # check for any dword aligned zeros that would falsely terminate the decoder
+      idx = 0
+      while true
+        idx = data.index("\x00\x00\x00\x00", idx)
+        break if !idx
+        if idx & 3 == 0
+          raise RuntimeError, "Unencoded data cannot have a dword aligned 0 dword!", caller()
+        end
+        idx += 1
+      end
+
+      # pad to a dword boundary and append null dword for termination
+      data = data + ("\x00" * ((4 - data.length & 3) & 3)) + "\x00\x00\x00\x00"
+    end
+
+    def _prepend
+      "\xfc"                + # cld
+      "\xbb" + key          + # mov ebx, key
+      "\xeb\x0c"            + # jmp short 0x14
+      "\x5e"                + # pop esi
+      "\x56"                + # push esi
+      "\x31\x1e"            + # xor [esi], ebx
+      "\xad"                + # lodsd
+      "\x01\xc3"            + # add ebx, eax
+      "\x85\xc0"            + # test eax, eax
+      "\x75\xf7"            + # jnz 0xa
+      "\xc3"                + # ret
+      "\xe8\xef\xff\xff\xff"  # call 0x8
+    end
+  end
+
+  include Backend
 end
 
 end end

data/lib/rex/encoding/xor.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 #

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

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

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

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

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

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 require 'rex/encoding/xor/exceptions'
@@ -16,78 +15,78 @@ module Xor
 
 class DwordAdditive < Generic
 
-	def DwordAdditive.keysize
-		4
-	end
-
-	def DwordAdditive._packspec
-		'V'
-	end
-
-	def DwordAdditive.pack_key(key)
-		return [ key ].pack(_packspec)
-	end
-	def DwordAdditive.unpack_key(key)
-		return key.unpack(_packspec)[0]
-	end
-
-	# hook in the key mutation routine of encode for the additive feedback
-	def DwordAdditive._encode_mutate_key(buf, key, pos, len)
-		if (pos + 1) % len == 0
-			# add the last len bytes (in this case 4) with the key,
-			# dropping off any overflow
-			key = pack_key(
-			  unpack_key(key) + unpack_key(buf[pos - (len - 1), len]) &
-			    (1 << (len << 3)) - 1
-			)
-		end
-
-		return key
-	end
-
-	#
-	# I realize this algorithm is broken.  We invalidate some keys
-	# in _find_bad_keys that could actually be perfectly fine.  However,
-	# it seems to work ok for now, and this is all just a lame adhoc method.
-	# Maybe someday we can revisit this and make it a bit less ghetto...
-	#
-
-	def DwordAdditive._find_good_key(data, badkeys, badchars)
-
-		ksize  = keysize
-		kstart = ""
-		ksize.times { kstart << rand(256) } # random key starting place
-
-		key = kstart.dup
-
-		#
-		# now for the ghettoness of an algorithm:
-		#  try the random key we picked
-		#  if the key failed, figure out which key byte corresponds
-		#  increment that key byte
-		#  if we wrapped a byte all the way around, fail :(
-		#
-
-		loop do
-			# ok, try to encode it, any bad chars present?
-			pos = _check(data, key, badchars)
-
-			# yay, no problems, we found a key!
-			break if !pos
-
-			strip = pos % ksize
-
-			# increment the offending key byte
-			key[strip] = key[strip] + 1 & 0xff
-
-			# We wrapped around!
-			if key[strip] == kstart[strip]
-				raise KeySearchError, "Key space exhausted on strip #{strip}!", caller
-			end
-		end
-
-		return key
-	end
+  def DwordAdditive.keysize
+    4
+  end
+
+  def DwordAdditive._packspec
+    'V'
+  end
+
+  def DwordAdditive.pack_key(key)
+    return [ key ].pack(_packspec)
+  end
+  def DwordAdditive.unpack_key(key)
+    return key.unpack(_packspec)[0]
+  end
+
+  # hook in the key mutation routine of encode for the additive feedback
+  def DwordAdditive._encode_mutate_key(buf, key, pos, len)
+    if (pos + 1) % len == 0
+      # add the last len bytes (in this case 4) with the key,
+      # dropping off any overflow
+      key = pack_key(
+        unpack_key(key) + unpack_key(buf[pos - (len - 1), len]) &
+          (1 << (len << 3)) - 1
+      )
+    end
+
+    return key
+  end
+
+  #
+  # I realize this algorithm is broken.  We invalidate some keys
+  # in _find_bad_keys that could actually be perfectly fine.  However,
+  # it seems to work ok for now, and this is all just a lame adhoc method.
+  # Maybe someday we can revisit this and make it a bit less ghetto...
+  #
+
+  def DwordAdditive._find_good_key(data, badkeys, badchars)
+
+    ksize  = keysize
+    kstart = ""
+    ksize.times { kstart << rand(256) } # random key starting place
+
+    key = kstart.dup
+
+    #
+    # now for the ghettoness of an algorithm:
+    #  try the random key we picked
+    #  if the key failed, figure out which key byte corresponds
+    #  increment that key byte
+    #  if we wrapped a byte all the way around, fail :(
+    #
+
+    loop do
+      # ok, try to encode it, any bad chars present?
+      pos = _check(data, key, badchars)
+
+      # yay, no problems, we found a key!
+      break if !pos
+
+      strip = pos % ksize
+
+      # increment the offending key byte
+      key[strip] = key[strip] + 1 & 0xff
+
+      # We wrapped around!
+      if key[strip] == kstart[strip]
+        raise KeySearchError, "Key space exhausted on strip #{strip}!", caller
+      end
+    end
+
+    return key
+  end
 
 end end end end # DwordAdditive/Xor/Encoding/Rex