Parent

Class/Module Index [+]

Quicksearch

Rex::Encoding::Xor::Generic

Public Class Methods

_check(data, key, badchars) click to toggle source

hook stylies! return index of offending byte or nil

# File lib/rex/encoding/xor/generic.rb, line 24
def Generic._check(data, key, badchars)
        return _check_key(key, badchars) || _check_encode(data, key, badchars)
end
_check_encode(data, key, badchars) click to toggle source
# File lib/rex/encoding/xor/generic.rb, line 30
def Generic._check_encode(data, key, badchars)
        return Rex::Text.badchar_index(encode(data, key), badchars)
end
_check_key(key, badchars) click to toggle source
# File lib/rex/encoding/xor/generic.rb, line 27
def Generic._check_key(key, badchars)
        return Rex::Text.badchar_index(key, badchars)
end
_encode_mutate_key(buf, key, pos, len) click to toggle source

kind of ghetto, but very convenient for mutating keys by default, do no key mutations

# File lib/rex/encoding/xor/generic.rb, line 133
def Generic._encode_mutate_key(buf, key, pos, len)
        return key
end
_find_bad_keys(data, badchars) click to toggle source

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

# File lib/rex/encoding/xor/generic.rb, line 44
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
_find_good_key(data, badkeys, badchars) click to toggle source

(Hopefully) find a good key, from badkeys and badchars

# File lib/rex/encoding/xor/generic.rb, line 67
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
encode(buf, key) click to toggle source
# File lib/rex/encoding/xor/generic.rb, line 102
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
find_key(data, badchars) click to toggle source
# File lib/rex/encoding/xor/generic.rb, line 34
def Generic.find_key(data, badchars)
        return _find_good_key(data, _find_bad_keys(data, badchars), badchars)
end
find_key_and_encode(data, badchars) click to toggle source

maybe a bit a smaller of method name?

# File lib/rex/encoding/xor/generic.rb, line 138
def Generic.find_key_and_encode(data, badchars)
        key        = find_key(data, badchars)
        enc, fkey  = encode(data, key)
        return [ enc, key, fkey ]
end
keysize() click to toggle source
# File lib/rex/encoding/xor/generic.rb, line 11
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

[Validate]

Generated with the Darkfish Rdoc Generator 2.