├── .gitignore ├── README.md ├── __init__.py ├── decoders ├── .bases_decoder.py.swp ├── __init__.py ├── __init__.pyc ├── bases_decoder.py ├── bases_decoder.pyc ├── caesar_decoder.py ├── caesar_decoder.pyc ├── scytale_decoder.py ├── scytale_decoder.pyc ├── vigenere_decoder.py ├── vigenere_decoder.pyc ├── xor_cypher.py └── xor_cypher.pyc ├── easy_cryptoCTF.py └── tmp ├── 0.028621638010378092.txt ├── 0.09361380389872842.txt ├── 0.11411360824969652.txt ├── 0.12144132218275128.txt ├── 0.14260522594941727.txt ├── 0.17927112162191583.txt ├── 0.21641415437365574.txt ├── 0.21672560463028012.txt ├── 0.2518925508988099.txt ├── 0.2646508963995675.txt ├── 0.26861495792834567.txt ├── 0.28803935022453264.txt ├── 0.4225313645421436.txt ├── 0.4246012898035789.txt ├── 0.43453381673102465.txt ├── 0.4535275638528682.txt ├── 0.47466569280198834.txt ├── 0.4793869295958353.txt ├── 0.5626420513476698.txt ├── 0.568228201740018.txt ├── 0.5694778659043671.txt ├── 0.6645134678041613.txt ├── 0.6760450794320814.txt ├── 0.7153105320811051.txt ├── 0.7350579947540936.txt ├── 0.7784963079635459.txt ├── 0.8150306176966942.txt ├── 0.8204764978241375.txt ├── 0.8612793012507403.txt ├── 0.9103753863507522.txt ├── 0.9160325155889513.txt ├── 0.9259872995204668.txt ├── 0.9415332899178024.txt ├── 0.9498606056662584.txt ├── 0.9642161731890961.txt ├── 0.9751206528381291.txt └── test /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | *.DS_Store 3 | *.txt 4 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # easy_cryptoCTF 2 | Try to decrypt strings and files: 3 | ``` 4 | python easy_cryptoCTF.py -c -f -s -x -b -e -t -d -n 5 | ``` 6 | ## XOR(-x) 7 | - [x] simple 8 | - [x] double 9 | - [x] Last char as key 10 | - [x] Last xored char as key 11 | - [x] Subs to key last char 12 | - [x] Subs to key last xored char 13 | - [x] Key plus last char 14 | - [x] Key plus last xored char 15 | 16 | ## Bases(-b) 17 | - [x] Base 64 (all positions of the typical alphabet) 18 | - [x] Base 64 (all positions of the url safe alphabet) 19 | - [x] Base 32 (all positions of the typical alphabet) 20 | - [x] Check Base85 21 | - [x] Check Base58 22 | 23 | ## Caesar(-e) 24 | - [x] Ascii lowercase alphabet 25 | - [x] Ascii uppercase alphabet 26 | - [x] Ascii lowercase alphabet + ascii uppercase alphabet 27 | - [x] Ascii lowercase alphabet + ascii uppercase alphabet + digits 28 | - [x] Ascii uppercase alphabet + ascii lowercase alphabet + digits 29 | 30 | ## Scytale(-t) 31 | - [x] Try to decrypt using all possible scytale numbers 32 | 33 | ## Autopwn of Featherduster(-d) 34 | - [x] Executes Featherduster and shows the output 35 | 36 | -------------------------------------------------------------------------------- /__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/carlospolop/easy_cryptoCTF/a2e1e8135027d5a63f697a25248c92890c202759/__init__.py -------------------------------------------------------------------------------- /decoders/.bases_decoder.py.swp: -------------------------------------------------------------------------------- 1 | b0nano 2.5.3 "+str(base58.b58decode_check(self.buffer))) 111 | self.to_print.append("Could be Base58") 112 | except: 113 | self.to_print.append("No base 58") 114 | 115 | #Bruteforce 116 | if self.bool_base64: 117 | pad = 4 - (len(self.buffer) % 4) 118 | if pad == 4 or pad < 3: 119 | for i in range (0,62): 120 | custom_alphabet = self.std_alphabet64[len(self.std_alphabet64)-(i+2):62] + self.std_alphabet64[:len(self.std_alphabet64)-(i+2)] + self.std_alphabet64[62:] 121 | self.final_decrypt['base']['64'][custom_alphabet] = self.b64_simple(custom_alphabet) 122 | for i in range (0,62): 123 | custom_alphabet = self.std_alphabet64_url[len(self.std_alphabet64_url)-(i+2):62] + self.std_alphabet64_url[:len(self.std_alphabet64_url)-(i+2)] + self.std_alphabet64_url[62:] 124 | self.final_decrypt['base']['64'][custom_alphabet] = self.b64_simple(custom_alphabet) 125 | 126 | if self.bool_base32: 127 | pad = 8 - (len(self.buffer) % 8) 128 | if pad == 8 or pad < 3: 129 | for i in range (0,32): 130 | custom_alphabet = self.std_alphabet32[len(self.std_alphabet32)-i:] + self.std_alphabet32[:len(self.std_alphabet32)-i] 131 | self.final_decrypt['base']['32'][custom_alphabet] = self.b32_simple(custom_alphabet) 132 | 133 | return self.final_decrypt 134 | 135 | def mprint(self): 136 | if self.is_reverse: 137 | print "###### Reverse Bases ######" 138 | else: 139 | print "###### Normal Bases ######" 140 | 141 | print "Usefull URLS:" 142 | for val in self.usefull_urls: 143 | print val 144 | print 145 | 146 | for val in self.to_print: 147 | print val 148 | 149 | if self.final_decrypt['base']['64'] != {}: 150 | print "---> Base64 <---" 151 | for key in self.final_decrypt['base']['64'].keys(): 152 | val = self.final_decrypt['base']['64'][key] 153 | if all(c in string.printable for c in val): 154 | print val +" --> ( "+key+" )" 155 | 156 | if self.final_decrypt['base']['32'] != {}: 157 | print "---> Base32 <---" 158 | for key in self.final_decrypt['base']['32'].keys(): 159 | val = self.final_decrypt['base']['32'][key] 160 | if all(c in string.printable for c in val): 161 | print val +" --> ( "+key+" )" 162 | 163 | print "###### Bases END ######\n" 164 | -------------------------------------------------------------------------------- /decoders/bases_decoder.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/carlospolop/easy_cryptoCTF/a2e1e8135027d5a63f697a25248c92890c202759/decoders/bases_decoder.pyc -------------------------------------------------------------------------------- /decoders/caesar_decoder.py: -------------------------------------------------------------------------------- 1 | import string 2 | 3 | class Caesar_BF: 4 | def __init__(self, buffer, is_reverse, search=None): 5 | self.buffer = buffer.replace("\n", "") 6 | self.is_reverse = is_reverse 7 | self.final_decrypt = {} 8 | self.search = search 9 | self.found = False 10 | self.found_array = [] 11 | 12 | self.final_decrypt['caesar'] = {} 13 | 14 | 15 | def get_found(self): 16 | return self.found 17 | 18 | def get_found_array(self): 19 | return self.found_array 20 | 21 | def check_found(self, toCheck): 22 | if self.search in toCheck: 23 | self.found = True 24 | self.found_array.append(toCheck) 25 | return toCheck 26 | 27 | def print_found(self): 28 | for val in self.found_array: 29 | print val 30 | 31 | def caesar_simple(self, alphabet, shift): 32 | shifted_alphabet = alphabet[shift:] + alphabet[:shift] 33 | table = string.maketrans(alphabet, shifted_alphabet) 34 | return self.check_found(self.buffer.translate(table)) 35 | 36 | def caesar_loop(self, alphabet): #Recorremos cada posible posicion del alfabeto 37 | for i in range(0, len(alphabet)): 38 | self.final_decrypt['caesar'][alphabet+"_shift:"+str(i)] = self.caesar_simple(alphabet, i) 39 | 40 | def bruteForce(self): #Todas las posibles posiciones iniciales de cada alfabeto a probar 41 | alphabet = string.ascii_lowercase 42 | self.caesar_loop(alphabet) 43 | alphabet = string.ascii_uppercase 44 | self.caesar_loop(alphabet) 45 | alphabet = string.ascii_lowercase + string.ascii_uppercase 46 | self.caesar_loop(alphabet) 47 | alphabet = string.ascii_lowercase + string.ascii_uppercase + string.digits 48 | self.caesar_loop(alphabet) 49 | alphabet = string.ascii_uppercase + string.ascii_lowercase + string.digits 50 | self.caesar_loop(alphabet) 51 | alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' 52 | self.caesar_loop(alphabet) 53 | 54 | return self.final_decrypt 55 | 56 | 57 | def mprint(self): 58 | if self.is_reverse: 59 | print "###### Reverse Caesar ######" 60 | else: 61 | print "###### Normal Caesar ######" 62 | 63 | for key in self.final_decrypt['caesar'].keys(): 64 | val = self.final_decrypt['caesar'][key] 65 | print val +" --> ( "+key+" )" 66 | print "###### Caesar END ######\n" 67 | -------------------------------------------------------------------------------- /decoders/caesar_decoder.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/carlospolop/easy_cryptoCTF/a2e1e8135027d5a63f697a25248c92890c202759/decoders/caesar_decoder.pyc -------------------------------------------------------------------------------- /decoders/scytale_decoder.py: -------------------------------------------------------------------------------- 1 | import string 2 | 3 | class Scytale_BF: 4 | def __init__(self, buffer, is_reverse, search=None): 5 | self.buffer = buffer.replace("\n", "") 6 | self.is_reverse = is_reverse 7 | self.final_decrypt = {} 8 | self.search = search 9 | self.found = False 10 | self.found_array = [] 11 | self.usefull_urls = ["https://www.dcode.fr/scytale-cipher"] 12 | 13 | self.final_decrypt['scytale'] = {} 14 | 15 | def get_found(self): 16 | return self.found 17 | 18 | def get_found_array(self): 19 | return self.found_array 20 | 21 | def check_found(self, toCheck): 22 | if self.search in toCheck: 23 | self.found = True 24 | self.found_array.append(toCheck) 25 | return toCheck 26 | 27 | def print_found(self): 28 | for val in self.found_array: 29 | print val 30 | 31 | 32 | def simple_scytale(self,num_elem): 33 | result = "" 34 | split_list = [self.buffer[x:x+num_elem] for x in range(0, len(self.buffer),num_elem)] 35 | for cont_i in range(0,num_elem): 36 | for cont in range(0,len(split_list)): 37 | result += split_list[cont][cont_i] 38 | 39 | self.final_decrypt['scytale'][str(num_elem)] = self.check_found(result) 40 | 41 | 42 | def bruteForce(self): 43 | for i in range(2,len(self.buffer)/2): 44 | if len(self.buffer) % i == 0 and len(self.buffer) != i: 45 | self.simple_scytale(i) 46 | 47 | return self.final_decrypt 48 | 49 | 50 | def mprint(self): 51 | if self.is_reverse: 52 | print "###### Reverse Scytale ######" 53 | else: 54 | print "###### Normal Scytale ######" 55 | 56 | print "Usefull URLS:" 57 | for val in self.usefull_urls: 58 | print val 59 | print 60 | 61 | for key in self.final_decrypt['scytale'].keys(): 62 | val = self.final_decrypt['scytale'][key] 63 | print val +" --> ( "+key+" )" 64 | print "###### Scytale END ######\n" 65 | -------------------------------------------------------------------------------- /decoders/scytale_decoder.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/carlospolop/easy_cryptoCTF/a2e1e8135027d5a63f697a25248c92890c202759/decoders/scytale_decoder.pyc -------------------------------------------------------------------------------- /decoders/vigenere_decoder.py: -------------------------------------------------------------------------------- 1 | from itertools import cycle 2 | 3 | 4 | class Vigenere_BF: 5 | def __init__(self, buffer, key, search=None): 6 | self.buffer = buffer 7 | self.key = key 8 | self.alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_{}' 9 | self.final_decrypt = {} 10 | self.search = search 11 | self.found = False 12 | self.found_array = [] 13 | 14 | def get_found(self): 15 | return self.found 16 | 17 | def get_found_array(self): 18 | return self.found_array 19 | 20 | def check_found(self, toCheck): 21 | if self.search in toCheck: 22 | self.found = True 23 | self.found_array.append(toCheck) 24 | return toCheck 25 | 26 | def print_found(self): 27 | for val in self.found_array: 28 | print val 29 | 30 | def vigeasy_decrypt(self, alphabet): 31 | """Encrypt the string and return the ciphertext""" 32 | cyphertext = self.buffer 33 | cyphertext = cyphertext[:len(cyphertext)-len(self.key)] 34 | pairs = zip(cyphertext, cycle(self.key)) 35 | result = '' 36 | for pair in pairs: 37 | (x,y)=pair 38 | total = alphabet.index(x) - alphabet.index(y) 39 | if total < 0: 40 | total += len(alphabet) 41 | result += alphabet[total % len(alphabet)] 42 | return self.check_found(result) 43 | 44 | def vigeasy_decrypt_loop(self): 45 | for i in range (0, len(self.alphabet)-3): 46 | alphabet = self.alphabet[len(self.alphabet)-(i+3):62] + self.alphabet[:len(self.alphabet)-(i+3)] + self.alphabet[62:] 47 | self.final_decrypt['vigenere'][alphabet] = self.vigeasy_decrypt(alphabet) 48 | 49 | def bruteForce(self): 50 | try: 51 | self.final_decrypt['vigenere'] = {} 52 | self.vigeasy_decrypt_loop() 53 | return self.final_decrypt 54 | except: 55 | pass 56 | 57 | def mprint(self): 58 | print "###### Vigenere ######" 59 | for val in self.final_decrypt['vigenere'].values(): 60 | print val 61 | print "###### Vigenere END ######" -------------------------------------------------------------------------------- /decoders/vigenere_decoder.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/carlospolop/easy_cryptoCTF/a2e1e8135027d5a63f697a25248c92890c202759/decoders/vigenere_decoder.pyc -------------------------------------------------------------------------------- /decoders/xor_cypher.py: -------------------------------------------------------------------------------- 1 | import string 2 | 3 | def check_type_buffer(buffer): 4 | if(len(buffer)>2 and (buffer[:2] != "0x" and buffer[len(buffer)-2:len(buffer)] != "x0")): 5 | return buffer.replace("\n", "") 6 | 7 | if buffer[:2] == "0x": 8 | buffer = buffer.replace("0x", "") 9 | else: 10 | buffer = buffer.replace("x0", "") 11 | split_hex = [buffer[x:x+2] for x in range(0, len(buffer),2)] 12 | hex_list = [chr(int(hex_str, 16)) for hex_str in split_hex] 13 | return hex_list 14 | 15 | class XOR_cypher: 16 | def __init__(self, buffer, is_reverse, search=None): 17 | self.buffer = check_type_buffer(buffer) 18 | self.is_reverse = is_reverse 19 | self.key = ord('\x00') 20 | self.final_decrypt = {} 21 | self.search = search 22 | self.found = False 23 | self.found_array = [] 24 | 25 | self.final_decrypt['xor'] = {} 26 | self.final_decrypt['xor']['simple'] = {} 27 | self.final_decrypt['xor']['key_lastChar'] = {} 28 | self.final_decrypt['xor']['key_lastXORChar'] = {} 29 | self.final_decrypt['xor']['key_subs_lastChar'] = {} 30 | self.final_decrypt['xor']['key_plus_lastChar'] = {} 31 | self.final_decrypt['xor']['key_subs_lastXORChar'] = {} 32 | self.final_decrypt['xor']['key_plus_lastXORChar'] = {} 33 | 34 | 35 | def get_found(self): 36 | return self.found 37 | 38 | def get_found_array(self): 39 | return self.found_array 40 | 41 | def check_found(self, xored): 42 | if self.search in xored: 43 | self.found = True 44 | self.found_array.append(xored) 45 | return xored 46 | 47 | def print_found(self): 48 | for val in self.found_array: 49 | print val 50 | 51 | def simple(self): #Hacemos Xor con la misma Key a todos 52 | final = "" 53 | key = self.key 54 | for char in self.buffer: 55 | enc_char = ord(char) ^ key & 0xff 56 | final += chr(enc_char) 57 | return self.check_found(final) 58 | 59 | def double(self): #Hacemos Xor probando todas las combinaciones de dos claves 60 | self.final_decrypt['xor']['double'] = {} 61 | key = self.key 62 | secKey = ord('\x00') 63 | while (True): 64 | final = "" 65 | #print str(key) +" "+ str(secKey) 66 | for i in range(0, len(self.buffer), 2): 67 | enc_char = ord(self.buffer[i]) ^ key & 0xff 68 | final += chr(enc_char) 69 | if i+1 < len(self.buffer): 70 | sec_enc_char = ord(self.buffer[i+1]) ^ secKey & 0xff 71 | final += chr(sec_enc_char) 72 | self.final_decrypt['xor']['double'][str(self.key)+str(secKey)] = self.check_found(final) 73 | 74 | if (secKey == ord('\xff')): 75 | break 76 | secKey += 1 77 | 78 | def key_lastChar(self): #Hacemos xor usando como key el char anterior 79 | final = "" 80 | key = self.key 81 | for char in self.buffer: 82 | enc_char = ord(char) ^ key & 0xff 83 | final += chr(enc_char) 84 | key = ord(char) & 0xff 85 | return self.check_found(final) 86 | 87 | def key_lastXORChar(self): #Hacemos xor usando como key el resultado del xor del char anterior 88 | final = "" 89 | key = self.key 90 | for char in self.buffer: 91 | enc_char = ord(char) ^ key & 0xff 92 | final += chr(enc_char) 93 | key = enc_char 94 | return self.check_found(final) 95 | 96 | def key_subs_lastChar(self): #Hacemos xor usando como key el resultado de la key anterior menos el char anterior 97 | final = "" 98 | key = self.key 99 | for char in self.buffer: 100 | enc_char = ord(char) ^ key & 0xff 101 | final += chr(enc_char) 102 | key = key - ord(char) & 0xff 103 | return self.check_found(final) 104 | 105 | def key_plus_lastChar(self): #Hacemos xor usando como key el resultado de la key anterior mas el char anterior 106 | final = "" 107 | key = self.key 108 | for char in self.buffer: 109 | enc_char = ord(char) ^ key & 0xff 110 | final += chr(enc_char) 111 | key = key + ord(char) & 0xff 112 | return self.check_found(final) 113 | 114 | def key_subs_lastXORChar(self): #Hacemos xor usando como key el resultado de la key anterior menos el charXOR anterior 115 | final = "" 116 | key = self.key 117 | for char in self.buffer: 118 | enc_char = ord(char) ^ key & 0xff 119 | final += chr(enc_char) 120 | key = key - enc_char 121 | return self.check_found(final) 122 | 123 | def key_plus_lastXORChar(self): #Hacemos xor usando como key el resultado de la key anterior mas el charXOR anterior 124 | final = "" 125 | key = self.key 126 | for char in self.buffer: 127 | enc_char = ord(char) ^ key & 0xff 128 | final += chr(enc_char) 129 | key = key + enc_char 130 | return self.check_found(final) 131 | 132 | def bruteForce(self): 133 | 134 | while (True): 135 | self.final_decrypt['xor']['simple'][str(self.key)] = self.simple() 136 | self.double() 137 | self.final_decrypt['xor']['key_lastChar'][str(self.key)] = self.key_lastChar() 138 | self.final_decrypt['xor']['key_lastXORChar'][str(self.key)] = self.key_lastXORChar() 139 | self.final_decrypt['xor']['key_subs_lastChar'][str(self.key)] = self.key_subs_lastChar() 140 | self.final_decrypt['xor']['key_plus_lastChar'][str(self.key)] = self.key_plus_lastChar() 141 | self.final_decrypt['xor']['key_subs_lastXORChar'][str(self.key)] = self.key_subs_lastXORChar() 142 | self.final_decrypt['xor']['key_plus_lastXORChar'][str(self.key)] = self.key_plus_lastXORChar() 143 | if (self.key == ord('\xff')): 144 | break 145 | self.key += 1 146 | return self.final_decrypt 147 | 148 | def mprint(self): 149 | if self.is_reverse: 150 | print "###### Reverse XOR ######" 151 | else: 152 | print "###### Normal XOR ######" 153 | 154 | for val_key in self.final_decrypt['xor'].keys(): 155 | print "\t ---> "+val_key+" <---" 156 | for second_key in self.final_decrypt['xor'][val_key].keys(): 157 | val = self.final_decrypt['xor'][val_key][second_key] 158 | if all(c in string.printable for c in val): 159 | print val +" --> ( "+second_key+" )" 160 | print "######## XOR END ########\n" 161 | -------------------------------------------------------------------------------- /decoders/xor_cypher.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/carlospolop/easy_cryptoCTF/a2e1e8135027d5a63f697a25248c92890c202759/decoders/xor_cypher.pyc -------------------------------------------------------------------------------- /easy_cryptoCTF.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | import sys, os, getopt 3 | from subprocess import Popen, PIPE 4 | 5 | from decoders import XOR_cypher, Bases_BF, Caesar_BF, Scytale_BF #,Vigenere_BF 6 | 7 | def main(argv): 8 | hlp = " -c -f -s -x -b -e -t -d -n" 9 | try: 10 | opts, args = getopt.getopt(argv,"hc:s:f:xbetdn",["console=","search=","ifile=","xor","base","caesar","scytale","featherduster","noprint"]) 11 | except getopt.GetoptError: 12 | print hlp 13 | sys.exit(2) 14 | 15 | general_urls = ["Cyberchef: https://gchq.github.io/CyberChef/", "Muchos decoders: https://www.dcode.fr/tools-list", "BrainFuck: http://esoteric.sange.fi/brainfuck/impl/interp/i.html", "Vigenere: https://www.guballa.de/vigenere-solver", "UuDecoder(begin ): http://uuencode.online-domain-tools.com/", "Base 85: https://www.dcode.fr/ascii-85-encoding"] 16 | crypto_tools = ["xortool - Uncypher Xor files using the frecuency of characters: https://github.com/hellman/xortool", "HashIdentifier: https://code.google.com/archive/p/hash-identifier/downloads", "HashKill: https://github.com/gat3way/hashkill", "CTF-Tools: https://github.com/zardus/ctf-tools"] 17 | toDecrypt, search, outputfile = "", "", "" 18 | is_input_file, try_all, try_xor, try_base, try_caesar, try_scytale, try_featherduster, print_each = False, True, False, False, False, False, False, True 19 | 20 | for opt, arg in opts: 21 | if opt == '-h': 22 | print hlp 23 | sys.exit() 24 | 25 | elif opt in ("-c", "--command"): 26 | toDecrypt = arg 27 | 28 | elif opt in ("-f", "--ifile"): 29 | inputfile = arg 30 | if (os.path.isfile(inputfile)): 31 | is_input_file = True 32 | with open(inputfile, 'r') as f: 33 | toDecrypt = f.read() 34 | else: 35 | print "Not a file: "+inputfile 36 | sys.exit(-1) 37 | 38 | elif opt in ("-x","--xor"): 39 | try_all = False 40 | try_xor = True 41 | 42 | elif opt in ("-b","--base"): 43 | try_all = False 44 | try_base = True 45 | 46 | elif opt in ("-e","--caesar"): 47 | try_all = False 48 | try_caesar = True 49 | 50 | elif opt in ("-t","--scytale"): 51 | try_all = False 52 | try_scytale = True 53 | 54 | elif opt in ("-d","--featherduster"): 55 | try_all = False 56 | try_featherduster = True 57 | 58 | elif opt in ("-s", "--search"): 59 | search = arg 60 | 61 | elif opt in ("-n", "--noprint"): 62 | print_each = False 63 | 64 | 65 | if toDecrypt == "": 66 | print hlp 67 | sys.exit(-1) 68 | 69 | print "Text input: "+toDecrypt 70 | 71 | toDecrypt_i = toDecrypt[::-1] 72 | 73 | # XOR MODULE 74 | xorbf = XOR_cypher(toDecrypt, False, search) 75 | xorbf_i = XOR_cypher(toDecrypt_i, True, search) 76 | if try_all or try_xor: 77 | final_decrypt_xor = xorbf.bruteForce() 78 | final_decrypt_xor_i = xorbf_i.bruteForce() 79 | 80 | 81 | # BASE MODULE 82 | bbf = Bases_BF(toDecrypt, False, search) 83 | bbf_i = Bases_BF(toDecrypt_i, True, search) 84 | if try_all or try_base: 85 | final_decrypt_bases = bbf.bruteForce() 86 | final_decrypt_bases_i = bbf_i.bruteForce() 87 | 88 | 89 | # Caesar MODULE 90 | cbf = Caesar_BF(toDecrypt, False, search) 91 | cbf_i = Caesar_BF(toDecrypt_i, True, search) 92 | if try_all or try_caesar: 93 | final_decrypt_caesar = cbf.bruteForce() 94 | final_decrypt_caesar_i = cbf_i.bruteForce() 95 | 96 | 97 | # Scytale MODULE 98 | sbf = Scytale_BF(toDecrypt, False, search) 99 | sbf_i = Scytale_BF(toDecrypt_i, True, search) 100 | if try_all or try_scytale: 101 | final_decrypt_scytale = sbf.bruteForce() 102 | final_decrypt_scytale_i = sbf_i.bruteForce() 103 | 104 | 105 | # Featherduster MODULE 106 | f_stdout,f_stderr = "", "" 107 | if (try_all or try_featherduster) and is_input_file: 108 | pw = Popen("echo autopwn | /usr/local/bin/featherduster "+ inputfile, stdout=PIPE, stderr=PIPE, shell=True) 109 | f_stdout,f_stderr = pw.communicate() 110 | 111 | 112 | # Vigenere MODULE 113 | # Falta anadirle is_reverse 114 | #vbf = Vigenere_BF(toDecrypt, "password", search) 115 | #final_decrypt_vigenere = vbf.bruteForce() 116 | #vbf.mprint() 117 | 118 | #vbf_i = Vigenere_BF(toDecrypt_i, "password", search) 119 | #final_decrypt_vigenere_i = vbf_i.bruteForce() 120 | #vbf_i.mprint() 121 | 122 | 123 | 124 | ######## Print output ######### 125 | print "###### General Usefull URLs ######" 126 | for url in general_urls: 127 | print url 128 | for tool in crypto_tools: 129 | print tool 130 | print "###### End URLs ######" 131 | 132 | #Search MODULE 133 | if search != "": 134 | print "###### Search ######" 135 | if xorbf.get_found(): 136 | print "!/\!/\!/\!/\!/\!/\! SEARCH FOUND IN NORMAL XOR" 137 | xorbf.print_found() 138 | if xorbf_i.get_found(): 139 | print "!/\!/\!/\!/\!/\!/\! SEARCH FOUND IN XOR USING REVERSE STRING" 140 | xorbf_i.print_found() 141 | 142 | if bbf.get_found(): 143 | print "!/\!/\!/\!/\!/\!/\! SEARCH FOUND IN NORMAL BASES" 144 | bbf.print_found() 145 | if bbf_i.get_found(): 146 | print "!/\!/\!/\!/\!/\!/\! SEARCH FOUND IN BASES USING REVERSE STRING" 147 | bbf_i.print_found() 148 | 149 | if cbf.get_found(): 150 | print "!/\!/\!/\!/\!/\!/\! SEARCH FOUND IN NORMAL CAESAR" 151 | cbf.print_found() 152 | if cbf_i.get_found(): 153 | print "!/\!/\!/\!/\!/\!/\! SEARCH FOUND IN CAESAR USING REVERSE STRING" 154 | cbf_i.print_found() 155 | 156 | if sbf.get_found(): 157 | print "!/\!/\!/\!/\!/\!/\! SEARCH FOUND IN NORMAL SCYTALE" 158 | sbf_i.print_found() 159 | if sbf_i.get_found(): 160 | print "!/\!/\!/\!/\!/\!/\! SEARCH FOUND IN SCYTALE USING REVERSE STRING" 161 | sbf_i.print_found() 162 | #if vbf.get_found(): 163 | # print "!/\!/\!/\!/\!/\!/\! SEARCH FOUND IN FIRST VIGENERE" 164 | # vbf.print_found() 165 | #if vbf_i.get_found(): 166 | # print "!/\!/\!/\!/\!/\!/\! SEARCH FOUND IN VIGENERE USING REVERSE STRING" 167 | # vbf_i.print_found() 168 | print "###### End Search ######" 169 | print 170 | 171 | print "###### FeatherDuster ######" 172 | if f_stderr: 173 | print " ---> ERROR <---" 174 | print f_stderr 175 | print f_stdout 176 | print "###### End FeatherDuster ######" 177 | print 178 | 179 | if print_each: 180 | xorbf.mprint() 181 | xorbf_i.mprint() 182 | bbf.mprint() 183 | bbf_i.mprint() 184 | cbf.mprint() 185 | cbf_i.mprint() 186 | sbf.mprint() 187 | sbf_i.mprint() 188 | 189 | if __name__ == "__main__": 190 | main(sys.argv[1:]) 191 | -------------------------------------------------------------------------------- /tmp/0.028621638010378092.txt: -------------------------------------------------------------------------------- 1 | 9v3/5IyQjesPTDvTbAMucg== -------------------------------------------------------------------------------- /tmp/0.09361380389872842.txt: -------------------------------------------------------------------------------- 1 | asdasdasdasdas -------------------------------------------------------------------------------- /tmp/0.11411360824969652.txt: -------------------------------------------------------------------------------- 1 | NBXWYYLBNVUWO3Y= -------------------------------------------------------------------------------- /tmp/0.12144132218275128.txt: -------------------------------------------------------------------------------- 1 | 751054112131290075798434111898297311412 -------------------------------------------------------------------------------- /tmp/0.14260522594941727.txt: -------------------------------------------------------------------------------- 1 | asdamsioanufaeifeaf -------------------------------------------------------------------------------- /tmp/0.17927112162191583.txt: -------------------------------------------------------------------------------- 1 | 0x6760636e6e62666860 -------------------------------------------------------------------------------- /tmp/0.21641415437365574.txt: -------------------------------------------------------------------------------- 1 | asdasddafadfasgfadfgsfasdfs -------------------------------------------------------------------------------- /tmp/0.21672560463028012.txt: -------------------------------------------------------------------------------- 1 | ljsdkchvabsdvasdv -------------------------------------------------------------------------------- /tmp/0.2518925508988099.txt: -------------------------------------------------------------------------------- 1 | ajsdfluiabfuabeyfvywefkbjwefljwef -------------------------------------------------------------------------------- /tmp/0.2646508963995675.txt: -------------------------------------------------------------------------------- 1 | etneotrnlhoesionsalneaxdjofvqrit -------------------------------------------------------------------------------- /tmp/0.26861495792834567.txt: -------------------------------------------------------------------------------- 1 | Jshshs -------------------------------------------------------------------------------- /tmp/0.28803935022453264.txt: -------------------------------------------------------------------------------- 1 | asdasf -------------------------------------------------------------------------------- /tmp/0.4225313645421436.txt: -------------------------------------------------------------------------------- 1 | dfsdfsdfsdfdsfdsf -------------------------------------------------------------------------------- /tmp/0.4246012898035789.txt: -------------------------------------------------------------------------------- 1 | auyvfkyudBDVKUYIUefyvwuefbliwqef -------------------------------------------------------------------------------- /tmp/0.43453381673102465.txt: -------------------------------------------------------------------------------- 1 | asdasdfasfdafdafasda -------------------------------------------------------------------------------- /tmp/0.4535275638528682.txt: -------------------------------------------------------------------------------- 1 | lbhadfyuajycybatvcauyiucyauvtwec -------------------------------------------------------------------------------- /tmp/0.47466569280198834.txt: -------------------------------------------------------------------------------- 1 | tofpkofcbebmifmZ -------------------------------------------------------------------------------- /tmp/0.4793869295958353.txt: -------------------------------------------------------------------------------- 1 | 2L6r6cUe8LmR8 -------------------------------------------------------------------------------- /tmp/0.5626420513476698.txt: -------------------------------------------------------------------------------- 1 | 3vQB7B6MrGQZaxCuFg4oh 2 | -------------------------------------------------------------------------------- /tmp/0.568228201740018.txt: -------------------------------------------------------------------------------- 1 | asdasddafadfasgfadfgsfasdfs -------------------------------------------------------------------------------- /tmp/0.5694778659043671.txt: -------------------------------------------------------------------------------- 1 | asdadfgsasgamdsfñioauñyiae7vf -------------------------------------------------------------------------------- /tmp/0.6645134678041613.txt: -------------------------------------------------------------------------------- 1 | aaommhtsgxiazjwlgcqiuutkkwdjswdj -------------------------------------------------------------------------------- /tmp/0.6760450794320814.txt: -------------------------------------------------------------------------------- 1 | aG9sYWFtaWdv -------------------------------------------------------------------------------- /tmp/0.7153105320811051.txt: -------------------------------------------------------------------------------- 1 | ljsdkchvabsdvasdv -------------------------------------------------------------------------------- /tmp/0.7350579947540936.txt: -------------------------------------------------------------------------------- 1 | asdamsioanufaeifeaf -------------------------------------------------------------------------------- /tmp/0.7784963079635459.txt: -------------------------------------------------------------------------------- 1 | tofpkofcbebmifmZ -------------------------------------------------------------------------------- /tmp/0.8150306176966942.txt: -------------------------------------------------------------------------------- 1 | asdasdfasfdafdafasda -------------------------------------------------------------------------------- /tmp/0.8204764978241375.txt: -------------------------------------------------------------------------------- 1 | dfsdfsdfsdf -------------------------------------------------------------------------------- /tmp/0.8612793012507403.txt: -------------------------------------------------------------------------------- 1 | adsfasdfagfgafgfsgafgasdfsdfafa -------------------------------------------------------------------------------- /tmp/0.9103753863507522.txt: -------------------------------------------------------------------------------- 1 | Mxnlr Fhvdu vh ghwxyr xq lqvwdqwh dqwh hn ulr dwruohqwdgr sru ndv gxgdv. Fuxcdunr vljqlilfded frohwhu xqd lnhjdnlgdg: frqyhuwluvh hq hqholjr gh nd Uhsxenlfd h lqlfldu nd jxhuud flyln. Mxnlr Fhvdu glr nd rughq d vxv wursdv gh fuxcdu hn ulr, surqxqfldqgr hq ndwlq nd iudvh dnhd ldfwd hvw, vhjxq Vxhwrqlr hq vx reud Ylgdv gh nrv grfh fhvduhv. Gh dfxhugr frq Snxwdufr (hq vxv Ylgdv Sdudnhndv), Mxnlr Fhvdu flwr hq julhjr nd iudvh ghn gudodwxujr dwhqlhqvh Ohqdqgur, xqr gh vxv dxwruhv suhihulgrv: ¡Txh hoslhfh hn mxhjr!. Nd fndyh sdud vxshudu hvwh uhwr hv hn ulr txh fuxcr Mxnlr Fhvdu -------------------------------------------------------------------------------- /tmp/0.9160325155889513.txt: -------------------------------------------------------------------------------- 1 | auyvfkyudBDVKUYIUefyvwuefbliwqef -------------------------------------------------------------------------------- /tmp/0.9259872995204668.txt: -------------------------------------------------------------------------------- 1 | hhshsys -------------------------------------------------------------------------------- /tmp/0.9415332899178024.txt: -------------------------------------------------------------------------------- 1 | a6c47bc58ae93db6ece13f1e28666bac -------------------------------------------------------------------------------- /tmp/0.9498606056662584.txt: -------------------------------------------------------------------------------- 1 | 0x9791939f9e93969990 -------------------------------------------------------------------------------- /tmp/0.9642161731890961.txt: -------------------------------------------------------------------------------- 1 | 2L6r6cUe8LmR8 -------------------------------------------------------------------------------- /tmp/0.9751206528381291.txt: -------------------------------------------------------------------------------- 1 | lbhadfyuajycybatvcauyiucyauvtwec -------------------------------------------------------------------------------- /tmp/test: -------------------------------------------------------------------------------- 1 | XUEGTZFZARLMOWPAQRNUPLQKWPRJABVURBFBAWYEEYPILJRZMPCJAPRXANSGZZZAPNTFOJLRIBNCLBGOWGABWJRXXVASZCAJEADVDMQGQRTBWKVVLRRETAPZSFWJEKUHIGWFPVPOTUESLTCNEOEUDIYHIETJDALYXRMPYTLYAVTDSMQGPCHBMMGYESTFCARBIEAMHWEJWNNEDEVZGUETHMEKMADJNIGKHOYXCQGORTTIPTRZXRRPQBUKGBRSPACURQIORIYVLNBFEQAZLRCJAPRXXRXU 2 | --------------------------------------------------------------------------------