# MIT License # Copyright (c) 2017 Balazs Bucsay # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import sys if "encoding.py" in sys.argv[0]: print("[-] Instead of poking around just try: python xfltreat.py --help") sys.exit(-1) import math import struct import base64 class id(): def get_name(self): return "Plaintext" def encode(self, text): return text def decode(self, text): return text def get_maximum_length(self, cap): return cap class Base85_DNS(): def get_name(self): return "Base85 DNS" def encode(self, text): return base64.b85encode(text).replace("=","") def decode(self, text): if len(text) % 4: text += "="*(4-(len(text)%4)) return base64.b85decode(text) def get_maximum_length(self, cap): full = int(math.floor(cap / 4))*3 remn = int(math.floor(((cap % 4)/4.0)*3)) return full + remn class Base64_DNS(): def get_name(self): return "Base64 DNS" def encode(self, text): return base64.b64encode(text).replace("=","").replace("/", "-").replace("+", "_") def decode(self, text): if len(text) % 4: text += "="*(4-(len(text)%4)) return base64.b64decode(text.replace("-", "/").replace("_", "+")) def get_maximum_length(self, cap): full = int(math.floor(cap / 4))*3 remn = int(math.floor(((cap % 4)/4.0)*3)) return full + remn class Base64(): def get_name(self): return "Base64" def encode(self, text): return base64.b64encode(text).replace("=","") def decode(self, text): if len(text) % 4: text += "="*(4-(len(text)%4)) try: return base64.b64decode(text) except: return "" def get_maximum_length(self, cap): full = int(math.floor(cap / 4))*3 remn = int(math.floor(((cap % 4)/4.0)*3)) return full + remn class Base32(): def get_name(self): return "Base32" def encode(self, text): return base64.b32encode(text).replace("=","").lower() def decode(self, text): if len(text) % 8: text += "="*(8-(len(text)%8)) try: return base64.b32decode(text.upper()) except: return "" def get_maximum_length(self, cap): full = int(math.floor(cap / 8))*5 remn = int(math.floor(((cap % 8)/8.0)*5)) return full + remn class Base16(): def get_name(self): return "Base16" def encode(self, text): return base64.b16encode(text).lower() def decode(self, text): try: return base64.b16decode(text.upper()) except: return "" def get_maximum_length(self, cap): return int(math.floor(cap/2)) class ASCII85(): def get_name(self): return "ASCII 85" def encode(self, text): encoded_text = "" if len(text) % 4: text += "\x00"*(4-(len(text)%4)) for i in range(0, len(text)/4): c = struct.unpack(">I", text[i*4:(i+1)*4])[0] N0 = (c/52200625) % 85 + 33 N1 = (c/614125) % 85 + 33 N2 = (c/7225) % 85 + 33 N3 = (c/85) % 85 + 33 N4 = c % 85 + 33 encoded_text += chr(N0)+chr(N1)+chr(N2)+chr(N3)+chr(N4) return encoded_text.replace(".","{") def decode(self, text): if len(text) % 5: return None decoded_text = "" text = text.replace("{",".") for i in range(0, len(text)/5): encoded_text = text[i*5:(i+1)*5] N0 = ord(encoded_text[0]) - 33 N1 = ord(encoded_text[1]) - 33 N2 = ord(encoded_text[2]) - 33 N3 = ord(encoded_text[3]) - 33 N4 = ord(encoded_text[4]) - 33 c = N0*52200625 + N1*614125 + N2*7225 + N3*85 + N4 decoded_text += struct.pack(">I", c) return decoded_text def get_maximum_length(self, cap): full = int(math.floor(cap / 5))*4 return full # taken from: https://github.com/aberaud/base91-python # Base91 encode/decode for Python 2 and Python 3 # # Copyright (c) 2012 Adrien Beraud # Copyright (c) 2015 Guillaume Jacquenot # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # * Neither the name of Adrien Beraud, Wisdom Vibes Pte. Ltd., nor the names # of its contributors may be used to endorse or promote products derived # from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # class Base91(): def __init__(self): # modified table . -> '' self.base91_alphabet = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '#', '$', '%', '&', '(', ')', '*', '+', ',', '\'', '/', ':', ';', '<', '=', '>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~', '"'] self.decode_table = dict((v,k) for k,v in enumerate(self.base91_alphabet)) def get_name(self): return "Base91" def decode(self, encoded_str): ''' Decode Base91 string to a bytearray ''' v = -1 b = 0 n = 0 out = bytearray() for strletter in encoded_str: if not strletter in self.decode_table: continue c = self.decode_table[strletter] if(v < 0): v = c else: v += c*91 b |= v << n n += 13 if (v & 8191)>88 else 14 while True: out += struct.pack('B', b&255) b >>= 8 n -= 8 if not n>7: break v = -1 if v+1: out += struct.pack('B', (b | v << n) & 255 ) return out def encode(self, bindata): ''' Encode a bytearray to a Base91 string ''' b = 0 n = 0 out = '' for count in range(len(bindata)): byte = bindata[count:count+1] b |= struct.unpack('B', byte)[0] << n n += 8 if n>13: v = b & 8191 if v > 88: b >>= 13 n -= 13 else: v = b & 16383 b >>= 14 n -= 14 out += self.base91_alphabet[v % 91] + self.base91_alphabet[v // 91] if n: out += self.base91_alphabet[b % 91] if n>7 or b>90: out += self.base91_alphabet[b // 91] return out def get_maximum_length(self, cap): return int(float(cap)*(1/1.2306)) class Base128(): def __init__(self): # iodined tested values self.base128_alphabet = "" self.base128_alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" self.base128_alphabet += "\xbc\xbd\xbe\xbf" self.base128_alphabet += "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" self.base128_alphabet += "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf" self.base128_alphabet += "\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef" self.base128_alphabet += "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd" self.base128_alphabet = list(self.base128_alphabet) self.base128_revalphabet = [0] * 256 for i in range(0, 128): c = ord(self.base128_alphabet[i]) self.base128_revalphabet[c] = i def get_name(self): return "Base128" def encodeblock(self, block): blen = len(block) out = "" out += self.base128_alphabet[ord(block[0:1]) >> 1] if blen > 1: out += self.base128_alphabet[(((ord(block[0:1]) & 0x01) << 6) & 0xFF) | ((ord(block[1:2]) >> 2) & 0xFF)] else: out += self.base128_alphabet[(((ord(block[0:1]) & 0x01) << 6) & 0xFF)] return out if blen > 2: out += self.base128_alphabet[(((ord(block[1:2]) & 0x03) << 5) & 0xFF) | ((ord(block[2:3]) >> 3) & 0xFF)] else: out += self.base128_alphabet[(((ord(block[1:2]) & 0x03) << 5) & 0xFF)] return out if blen > 3: out += self.base128_alphabet[(((ord(block[2:3]) & 0x07) << 4) & 0xFF) | ((ord(block[3:4]) >> 4) & 0xFF)] else: out += self.base128_alphabet[(((ord(block[2:3]) & 0x07) << 4) & 0xFF)] return out if blen > 4: out += self.base128_alphabet[(((ord(block[3:4]) & 0x0F) << 3) & 0xFF) | ((ord(block[4:5]) >> 5) & 0xFF)] else: out += self.base128_alphabet[(((ord(block[3:4]) & 0x0F) << 3) & 0xFF)] return out if blen > 5: out += self.base128_alphabet[(((ord(block[4:5]) & 0x1F) << 2) & 0xFF) | ((ord(block[5:6]) >> 6) & 0xFF)] else: out += self.base128_alphabet[(((ord(block[4:5]) & 0x1F) << 2) & 0xFF)] return out if blen > 6: out += self.base128_alphabet[(((ord(block[5:6]) & 0x3F) << 1) & 0xFF) | ((ord(block[6:7]) >> 7) & 0xFF)] out += self.base128_alphabet[ord(block[6:7]) & 0x7F] else: out += self.base128_alphabet[(((ord(block[5:6]) & 0x3F) << 1) & 0xFF)] return out return out def decodeblock(self, block): blen = len(block) out = "" if blen < 8: block += "a" out += chr(((self.base128_revalphabet[ord(block[0:1])] << 1) & 0xFF) | ((self.base128_revalphabet[ord(block[1:2])] >> 6) & 0xFF)) if blen > 2: out += chr(((self.base128_revalphabet[ord(block[1:2])] << 2) & 0xFF) | ((self.base128_revalphabet[ord(block[2:3])] >> 5) & 0xFF)) if blen > 3: out += chr(((self.base128_revalphabet[ord(block[2:3])] << 3) & 0xFF) | ((self.base128_revalphabet[ord(block[3:4])] >> 4) & 0xFF)) if blen > 4: out += chr(((self.base128_revalphabet[ord(block[3:4])] << 4) & 0xFF) | ((self.base128_revalphabet[ord(block[4:5])] >> 3) & 0xFF)) if blen > 5: out += chr(((self.base128_revalphabet[ord(block[4:5])] << 5) & 0xFF) | ((self.base128_revalphabet[ord(block[5:6])] >> 2) & 0xFF)) if blen > 6: out += chr(((self.base128_revalphabet[ord(block[5:6])] << 6) & 0xFF) | ((self.base128_revalphabet[ord(block[6:7])] >> 1) & 0xFF)) if blen > 7: out += chr(((self.base128_revalphabet[ord(block[6:7])] << 7) & 0xFF) | (self.base128_revalphabet[ord(block[7:8])] & 0xFF)) return out def encode(self, text): result = "" for i in range(0,int(math.ceil(float(len(text)) / 7.0))): result += self.encodeblock(text[i*7:(i+1)*7]) return result def decode(self, text): result = "" for i in range(0,int(math.ceil(float(len(text)) / 8.0))): result += self.decodeblock(text[i*8:(i+1)*8]) return result def get_maximum_length(self, cap): full = int(math.floor(cap / 8))*7 remn = int(math.floor(((cap % 8)/8.0)*7)) return full + remn