1281 lines
31 KiB
Python
1281 lines
31 KiB
Python
|
|
import base64
|
|
|
|
import sys
|
|
|
|
import math
|
|
|
|
import os
|
|
|
|
import marshal
|
|
|
|
import zlib
|
|
|
|
import random
|
|
|
|
import time
|
|
|
|
import ast
|
|
|
|
import astor
|
|
|
|
import ctypes
|
|
|
|
import string
|
|
|
|
from colorama import Fore, init
|
|
|
|
init()
|
|
|
|
__version__ = '1.0.2'
|
|
|
|
key = random.randint(0, 255)
|
|
|
|
class clear():
|
|
system = os.name
|
|
if system == 'nt':
|
|
os.system('cls')
|
|
elif system == 'posix':
|
|
os.system('clear')
|
|
else:
|
|
print('\n'*120)
|
|
|
|
def set_window_title(title):
|
|
ctypes.windll.kernel32.SetConsoleTitleW(title)
|
|
|
|
system = os.name
|
|
if system == 'nt':
|
|
set_window_title(f'RoseGuardian | {__version__}')
|
|
os.system('mode CON: COLS=140 LINES=25')
|
|
|
|
def slow_print(text, delay=0.1):
|
|
for char in text:
|
|
print(char, end='', flush=True)
|
|
time.sleep(delay)
|
|
print()
|
|
|
|
def random_name(length=10):
|
|
return ''.join(random.choice(string.ascii_letters) for _ in range(length))
|
|
|
|
def remove_comments(node):
|
|
for child in ast.walk(node):
|
|
if isinstance(child, ast.FunctionDef):
|
|
child.body = [n for n in child.body if not isinstance(n, ast.Expr) or not isinstance(n.value, ast.Str)]
|
|
elif isinstance(child, ast.ClassDef):
|
|
child.body = [n for n in child.body if not isinstance(n, ast.Expr) or not isinstance(n.value, ast.Str)]
|
|
elif isinstance(child, ast.AsyncFunctionDef):
|
|
child.body = [n for n in child.body if not isinstance(n, ast.Expr) or not isinstance(n.value, ast.Str)]
|
|
elif isinstance(child, ast.Module):
|
|
child.body = [n for n in child.body if not isinstance(n, ast.Expr) or not isinstance(n.value, ast.Str)]
|
|
|
|
def encode_strings(node):
|
|
for child in ast.walk(node):
|
|
if isinstance(child, ast.Str):
|
|
obfuscated = ''.join(f'{ord(c) ^ key:02x}' for c in child.s)
|
|
child.s = obfuscated
|
|
|
|
def replace_strings_with_decoding(node):
|
|
for child in ast.walk(node):
|
|
if isinstance(child, ast.Assign):
|
|
for target in child.targets:
|
|
if isinstance(target, ast.Name) and isinstance(child.value, ast.Str):
|
|
obfuscated = child.value.s
|
|
new_value = ast.Call(
|
|
func=ast.Name(id='decode_obfuscated_string', ctx=ast.Load()),
|
|
args=[ast.Str(s=obfuscated)],
|
|
keywords=[]
|
|
)
|
|
child.value = new_value
|
|
|
|
def remove_blank_lines(node):
|
|
for child in ast.walk(node):
|
|
if hasattr(child, 'body'):
|
|
child.body = [n for n in child.body if not isinstance(n, ast.Expr) or not isinstance(n.value, ast.Str)]
|
|
|
|
def rename_identifiers(node, mapping):
|
|
if isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
|
|
node.name = mapping.get(node.name, node.name)
|
|
|
|
if isinstance(node, ast.Name):
|
|
node.id = mapping.get(node.id, node.id)
|
|
|
|
if isinstance(node, ast.ClassDef):
|
|
node.name = mapping.get(node.name, node.name)
|
|
|
|
for child in ast.iter_child_nodes(node):
|
|
rename_identifiers(child, mapping)
|
|
|
|
def obfuscator1():
|
|
with open(os.path.abspath(sys.argv[1]), 'r') as f:
|
|
slow_print(Fore.RED + 'Reading source code...\n' + Fore.RESET, delay=0.005)
|
|
source_code = f.read()
|
|
|
|
def random_name():
|
|
return ''.join(random.choices(string.ascii_letters, k=10))
|
|
|
|
slow_print(Fore.RED + 'Parsing tree...\n' + Fore.RESET, delay=0.005)
|
|
|
|
tree = ast.parse(source_code)
|
|
|
|
slow_print(Fore.RED + 'Removing comments...\n' + Fore.RESET, delay=0.005)
|
|
|
|
remove_comments(tree)
|
|
|
|
slow_print(Fore.RED + 'Removing blank lines...\n' + Fore.RESET, delay=0.005)
|
|
|
|
remove_blank_lines(tree)
|
|
|
|
slow_print(Fore.RED + 'Changing class and function names...\n' + Fore.RESET, delay=0.005)
|
|
functions = set()
|
|
classes = set()
|
|
|
|
for node in ast.walk(tree):
|
|
if isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
|
|
functions.add(node.name)
|
|
elif isinstance(node, ast.ClassDef):
|
|
classes.add(node.name)
|
|
|
|
mapping = {name: random_name() for name in functions | classes}
|
|
|
|
rename_identifiers(tree, mapping)
|
|
|
|
slow_print(Fore.RED + 'Compressing and base64 encoding the marshalized objects...\n' + Fore.RESET, delay=0.005)
|
|
obfuscated_code = base64.b64encode(zlib.compress(marshal.dumps(astor.to_source(tree).encode())))
|
|
|
|
return obfuscated_code
|
|
|
|
def obfuscator0(input_file, output_file):
|
|
with open(input_file, 'r') as file:
|
|
source_code = file.read()
|
|
|
|
tree = ast.parse(source_code)
|
|
|
|
remove_comments(tree)
|
|
|
|
remove_blank_lines(tree)
|
|
|
|
encode_strings(tree)
|
|
|
|
variables = set()
|
|
functions = set()
|
|
classes = set()
|
|
|
|
for node in ast.walk(tree):
|
|
if isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
|
|
functions.add(node.name)
|
|
elif isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store):
|
|
variables.add(node.id)
|
|
elif isinstance(node, ast.ClassDef):
|
|
classes.add(node.name)
|
|
|
|
mapping = {name: random_name() for name in variables | functions | classes}
|
|
|
|
rename_identifiers(tree, mapping)
|
|
|
|
with open(output_file, 'w') as file:
|
|
file.write(f"key = {key}\n\n")
|
|
file.write("def decode_obfuscated_string(obfuscated_string):\n")
|
|
file.write(" encoded = bytes.fromhex(obfuscated_string)\n")
|
|
file.write(" decoded = ''.join(chr(b ^ key) for b in encoded)\n")
|
|
file.write(" return decoded\n\n")
|
|
replace_strings_with_decoding(tree)
|
|
file.write(ast.unparse(tree))
|
|
|
|
def get_junk():
|
|
|
|
_1 = '''def morphogenic_adapter():
|
|
pass
|
|
|
|
class quantum_oscillator:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def hyperbolic_momentum(self, _):
|
|
return self.hyperbolic_momentum(_)
|
|
|
|
def tachyon_cascade():
|
|
_ = quantum_oscillator()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def stellar_phase_converter():
|
|
_ = morphogenic_adapter()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def temporal_disruptor():
|
|
pass'''
|
|
|
|
_2 = '''def spectral_synthesizer():
|
|
pass
|
|
|
|
class warp_singularity:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def temporal_siphon(self, _):
|
|
return self.temporal_siphon(_)
|
|
|
|
def entropic_fluctuation():
|
|
_ = warp_singularity()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def quantum_reactor():
|
|
_ = spectral_synthesizer()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def graviton_matrix():
|
|
pass
|
|
'''
|
|
|
|
_3 = '''def quantum_resonator():
|
|
pass
|
|
|
|
class singularity_nexus:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def hyperspatial_field(self, _):
|
|
return self.hyperspatial_field(_)
|
|
|
|
def chronometric_analyzer():
|
|
_ = singularity_nexus()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def gravimetric_capacitor():
|
|
_ = quantum_resonator()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def tachyon_diffractor():
|
|
pass
|
|
'''
|
|
|
|
_4 = '''def nebula_processor():
|
|
pass
|
|
|
|
class interstellar_grid:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def quantum_encoder(self, _):
|
|
return self.quantum_encoder(_)
|
|
|
|
def cosmic_displacement():
|
|
_ = interstellar_grid()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def subspace_modulator():
|
|
_ = nebula_processor()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def dark_matter_calibrator():
|
|
pass
|
|
'''
|
|
|
|
_5 = '''def gravimetric_flux():
|
|
pass
|
|
|
|
class warp_inverter:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def subspace_transducer(self, _):
|
|
return self.subspace_transducer(_)
|
|
|
|
def chronal_conduit():
|
|
_ = warp_inverter()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def singularity_stabilizer():
|
|
_ = gravimetric_flux()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def entropic_reactor():
|
|
pass
|
|
'''
|
|
|
|
_6 = '''def quantum_transmitter():
|
|
pass
|
|
|
|
class flux_capacitor:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def tachyon_oscillator(self, _):
|
|
return self.tachyon_oscillator(_)
|
|
|
|
def spatial_phase():
|
|
_ = flux_capacitor()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def temporal_analyzer():
|
|
_ = quantum_transmitter()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def stellar_modulator():
|
|
pass
|
|
'''
|
|
|
|
_7 = '''def nebular_computron():
|
|
pass
|
|
|
|
class cosmic_relay:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def subspace_coil(self, _):
|
|
return self.subspace_coil(_)
|
|
|
|
def graviton_amplifier():
|
|
_ = cosmic_relay()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def singularity_catalyst():
|
|
_ = nebular_computron()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def temporal_enigma():
|
|
pass
|
|
'''
|
|
|
|
_8 = '''def hyperion_mechanism():
|
|
pass
|
|
|
|
class gravimetric_tensor:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def warp_crypt(self, _):
|
|
return self.warp_crypt(_)
|
|
|
|
def quantum_effluvium():
|
|
_ = gravimetric_tensor()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def subspace_resonator():
|
|
_ = hyperion_mechanism()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def temporal_reverberator():
|
|
pass
|
|
'''
|
|
|
|
_9 = '''def exo_quantum():
|
|
pass
|
|
|
|
class astro_waveform:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def flux_capacitance(self, _):
|
|
return self.flux_capacitance(_)
|
|
|
|
def chrono_stasis():
|
|
_ = astro_waveform()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def gravitic_magnetron():
|
|
_ = exo_quantum()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def subspace_scrambler():
|
|
pass
|
|
'''
|
|
|
|
_10 = '''def tachyon_entangler():
|
|
pass
|
|
|
|
class quantum_fusion:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def warp_induction(self, _):
|
|
return self.warp_induction(_)
|
|
|
|
def chrono_spectral():
|
|
_ = quantum_fusion()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def gravimetric_anomaly():
|
|
_ = tachyon_entangler()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def subspace_phase_lock():
|
|
pass
|
|
'''
|
|
|
|
_11 = '''def astral_inverter():
|
|
pass
|
|
|
|
class stellar_singularity:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def quantum_nucleus(self, _):
|
|
return self.quantum_nucleus(_)
|
|
|
|
def hyper_gravimetric():
|
|
_ = stellar_singularity()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def temporal_deflector():
|
|
_ = astral_inverter()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def subspace_injector():
|
|
pass
|
|
'''
|
|
|
|
_12 = '''def chrono_tesseract():
|
|
pass
|
|
|
|
class gravimetric_reactor:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def warp_manifold(self, _):
|
|
return self.warp_manifold(_)
|
|
|
|
def quantum_vortex():
|
|
_ = gravimetric_reactor()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def astral_siphon():
|
|
_ = chrono_tesseract()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def hyper_flux_analyzer():
|
|
pass
|
|
'''
|
|
|
|
_13 = '''def warp_oscillator():
|
|
pass
|
|
|
|
class gravimetric_disruptor:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def subspace_transmitter(self, _):
|
|
return self.subspace_transmitter(_)
|
|
|
|
def quantum_chronometer():
|
|
_ = gravimetric_disruptor()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def astral_magnetar():
|
|
_ = warp_oscillator()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def hyperbolic_reactor():
|
|
pass
|
|
'''
|
|
|
|
_14 = '''def temporal_nexus():
|
|
pass
|
|
|
|
class quantum_flux:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def warp_field(self, _):
|
|
return self.warp_field(_)
|
|
|
|
def stellar_maneuver():
|
|
_ = quantum_flux()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def subspace_chronicle():
|
|
_ = temporal_nexus()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def astral_deflector():
|
|
pass
|
|
'''
|
|
|
|
_15 = '''def warp_modulator():
|
|
pass
|
|
|
|
class gravimetric_inverter:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def quantum_matrix(self, _):
|
|
return self.quantum_matrix(_)
|
|
|
|
def stellar_entropy():
|
|
_ = gravimetric_inverter()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def temporal_spectral():
|
|
_ = warp_modulator()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def subspace_transmogrifier():
|
|
pass
|
|
'''
|
|
|
|
_16 = '''def quantum_fissure():
|
|
pass
|
|
|
|
class stellar_flux:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def warp_cloak(self, _):
|
|
return self.warp_cloak(_)
|
|
|
|
def chrono_singularity():
|
|
_ = stellar_flux()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def gravimetric_oscillation():
|
|
_ = quantum_fissure()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def astral_paradigm():
|
|
pass
|
|
'''
|
|
|
|
_17 = '''def genetic_analyzer():
|
|
pass
|
|
|
|
class dna_sequencer:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def genetic_encoder(self, _):
|
|
return self.genetic_encoder(_)
|
|
|
|
def mutation_inducer():
|
|
_ = dna_sequencer()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_))
|
|
'''
|
|
|
|
_18 = '''def neural_processor():
|
|
pass
|
|
|
|
class synaptic_matrix:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def dendritic_cascade(self, _):
|
|
return self.dendritic_cascade(_)
|
|
|
|
def cognitive_amplifier():
|
|
_ = synaptic_matrix()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def thought_inhibitor():
|
|
_ = neural_processor()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def consciousness_monitor():
|
|
pass
|
|
'''
|
|
|
|
_19 = '''def quantum_analyzer():
|
|
pass
|
|
|
|
class wave_function:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def entanglement_resolver(self, _):
|
|
return self.entanglement_resolver(_)
|
|
|
|
def probability_calculator():
|
|
_ = wave_function()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def uncertainty_optimizer():
|
|
_ = quantum_analyzer()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def wave_collapser():
|
|
pass
|
|
'''
|
|
|
|
_20 = '''def algorithm_optimizer():
|
|
pass
|
|
|
|
class computational_neuron:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def synaptic_connection(self, _):
|
|
return self.synaptic_connection(_)
|
|
|
|
def heuristic_generator():
|
|
_ = computational_neuron()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def pattern_analyzer():
|
|
_ = algorithm_optimizer()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def data_compiler():
|
|
pass
|
|
'''
|
|
|
|
_21 = '''def audio_processor():
|
|
pass
|
|
|
|
class waveform_converter:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def frequency_analyzer(self, _):
|
|
return self.frequency_analyzer(_)
|
|
|
|
def spectral_filter():
|
|
_ = waveform_converter()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def audio_resampler():
|
|
pass
|
|
'''
|
|
|
|
_22 = '''def data_encoder():
|
|
pass
|
|
|
|
class compression_algorithm:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def data_compressor(self, _):
|
|
return self.data_compressor(_)
|
|
|
|
def encryption_scheme():
|
|
_ = compression_algorithm()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def data_decoder():
|
|
pass
|
|
'''
|
|
|
|
_23 = '''def image_processor():
|
|
pass
|
|
|
|
class color_correction:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def hue_adjustment(self, _):
|
|
return self.hue_adjustment(_)
|
|
|
|
def image_filter():
|
|
_ = color_correction()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def image_resizer():
|
|
pass
|
|
'''
|
|
|
|
_24 = '''def text_analyzer():
|
|
pass
|
|
|
|
class sentiment_classifier:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def emotion_analysis(self, _):
|
|
return self.emotion_analysis(_)
|
|
|
|
def text_summarizer():
|
|
_ = sentiment_classifier()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def text_translator():
|
|
pass
|
|
'''
|
|
|
|
_25 = '''def financial_analyzer():
|
|
pass
|
|
|
|
class portfolio_optimizer:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def risk_assessment(self, _):
|
|
return self.risk_assessment(_)
|
|
|
|
def investment_strategy():
|
|
_ = portfolio_optimizer()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def asset_alocator():
|
|
pass
|
|
'''
|
|
|
|
_26 = '''def network_monitor():
|
|
pass
|
|
|
|
class packet_sniffer:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def traffic_analyzer(self, _):
|
|
return self.traffic_analyzer(_)
|
|
|
|
def security_audit():
|
|
_ = packet_sniffer()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def intrusion_detection():
|
|
pass
|
|
'''
|
|
|
|
_27 = '''def medical_diagnostic():
|
|
pass
|
|
|
|
class patient_monitor:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def vital_signs(self, _):
|
|
return self.vital_signs(_)
|
|
|
|
def disease_classifier():
|
|
_ = patient_monitor()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def treatment_planner():
|
|
pass
|
|
'''
|
|
|
|
_28 = '''def climate_sensor():
|
|
pass
|
|
|
|
class temperature_controller:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def climate_regulator(self, _):
|
|
return self.climate_regulator(_)
|
|
|
|
def humidity_adjuster():
|
|
_ = temperature_controller()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def air_quality_monitor():
|
|
pass
|
|
'''
|
|
|
|
_29 = '''def audio_processor():
|
|
return None
|
|
|
|
class WaveformConverter:
|
|
def __init__(self):
|
|
self.data = None
|
|
self.metadata = None
|
|
|
|
def frequency_analysis(self, data):
|
|
return self.frequency_analysis(data)
|
|
|
|
def SpectralFilter():
|
|
converter = WaveformConverter()
|
|
converter.data = lambda x, y: x(y) + x(x(x(x(y))))
|
|
|
|
def AudioResampler():
|
|
pass
|
|
'''
|
|
|
|
_30 = '''def DataEncoder():
|
|
return None
|
|
|
|
class CompressionAlgorithm:
|
|
def __init__(self):
|
|
self.buffer = None
|
|
self.settings = None
|
|
|
|
def CompressData(self, buffer):
|
|
return self.CompressData(buffer)
|
|
|
|
def EncryptionScheme():
|
|
algorithm = CompressionAlgorithm()
|
|
algorithm.buffer = lambda x, y: x(y) + x(x(x(x(y))))
|
|
|
|
def DataDecoder():
|
|
pass
|
|
'''
|
|
|
|
_31 = '''def ImageProcessor():
|
|
return None
|
|
|
|
class ColorCorrection:
|
|
def __init__(self):
|
|
self.settings = None
|
|
self.mask = None
|
|
|
|
def AdjustHue(self, image):
|
|
return self.AdjustHue(image)
|
|
|
|
def ImageFilter():
|
|
correction = ColorCorrection()
|
|
correction.mask = lambda x, y: x(y) + x(x(x(x(y))))
|
|
|
|
def ImageResizer():
|
|
pass
|
|
'''
|
|
|
|
_32 = '''def TextAnalyzer():
|
|
return None
|
|
|
|
class SentimentClassifier:
|
|
def __init__(self):
|
|
self.model = None
|
|
self.vocab = None
|
|
|
|
def AnalyzeEmotion(self, text):
|
|
return self.AnalyzeEmotion(text)
|
|
|
|
def TextSummarizer():
|
|
classifier = SentimentClassifier()
|
|
classifier.model = lambda x, y: x(y) + x(x(x(x(y))))
|
|
|
|
def TextTranslator():
|
|
pass
|
|
'''
|
|
|
|
_33 = '''def FinancialAnalyzer():
|
|
return None
|
|
|
|
class PortfolioOptimizer:
|
|
def __init__(self):
|
|
self.portfolio = None
|
|
self.strategy = None
|
|
|
|
def AssessRisk(self, portfolio):
|
|
return self.AssessRisk(portfolio)
|
|
|
|
def InvestmentStrategy():
|
|
optimizer = PortfolioOptimizer()
|
|
optimizer.strategy = lambda x, y: x(y) + x(x(x(x(y))))
|
|
|
|
def AssetAllocator():
|
|
pass
|
|
'''
|
|
|
|
_34 = '''def complex_processor():
|
|
result = 0
|
|
for i in range(10):
|
|
result += i * (i + 1) / (i + 2)
|
|
return result
|
|
|
|
class ComplexProcessor:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def process_data(self, data):
|
|
return self.process_data(data)
|
|
|
|
def perform_calculation():
|
|
_ = ComplexProcessor()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def simulate_system():
|
|
value = 1
|
|
for _ in range(5):
|
|
value *= value + 1
|
|
'''
|
|
|
|
_35 = '''def genetic_optimizer():
|
|
result = 1
|
|
for i in range(1, 11):
|
|
result *= i
|
|
return result
|
|
|
|
class GeneticAlgorithm:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def optimize(self):
|
|
pass
|
|
|
|
def calculate_fitness():
|
|
_ = GeneticAlgorithm()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def evaluate_population():
|
|
total = 0
|
|
for i in range(1, 6):
|
|
total += i**2
|
|
return total
|
|
'''
|
|
|
|
_36 = '''def particle_simulator():
|
|
result = 0
|
|
for i in range(1, 21):
|
|
result += i**3 - i**2 + i
|
|
return result
|
|
|
|
class ParticleSimulator:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def simulate(self, iterations):
|
|
return self.simulate(iterations)
|
|
|
|
def simulate_particles():
|
|
_ = ParticleSimulator()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def analyze_data():
|
|
data = [1, 2, 3, 4, 5]
|
|
result = sum(data) / len(data)
|
|
'''
|
|
|
|
_37 = '''def matrix_multiplier():
|
|
matrix_a = [[1, 2], [3, 4]]
|
|
matrix_b = [[5, 6], [7, 8]]
|
|
result = [[0, 0], [0, 0]]
|
|
|
|
for i in range(len(matrix_a)):
|
|
for j in range(len(matrix_b[0])):
|
|
for k in range(len(matrix_b)):
|
|
result[i][j] += matrix_a[i][k] * matrix_b[k][j]
|
|
|
|
return result'''
|
|
|
|
_38 = '''def newton_raphson():
|
|
def f(x):
|
|
return x**3 - 6 * x**2 + 11 * x - 6
|
|
|
|
def df(x):
|
|
return 3 * x**2 - 12 * x + 11
|
|
|
|
x0 = 1.0
|
|
for _ in range(5):
|
|
x0 = x0 - f(x0) / df(x0)
|
|
|
|
return x0
|
|
'''
|
|
|
|
_39 = '''def complex_integration():
|
|
def f(x):
|
|
return x**2 + 2 * x + 1
|
|
|
|
a = 0
|
|
b = 2
|
|
n = 1000
|
|
h = (b - a) / n
|
|
|
|
result = 0
|
|
for i in range(n):
|
|
result += h * (f(a + i*h) + f(a + (i+1)*h)) / 2
|
|
|
|
return result
|
|
'''
|
|
|
|
_40 = '''def random_walk():
|
|
import random
|
|
|
|
position = 0
|
|
steps = 1000
|
|
|
|
for _ in range(steps):
|
|
if random.random() < 0.5:
|
|
position += 1
|
|
else:
|
|
position -= 1
|
|
|
|
return position'''
|
|
|
|
_41 = '''def monte_carlo_simulation():
|
|
import random
|
|
|
|
inside_circle = 0
|
|
total_points = 100000
|
|
|
|
for _ in range(total_points):
|
|
x = random.uniform(-1, 1)
|
|
y = random.uniform(-1, 1)
|
|
|
|
if x**2 + y**2 <= 1:
|
|
inside_circle += 1
|
|
|
|
return 4 * inside_circle / total_points
|
|
'''
|
|
|
|
_42 = '''def complicated_function():
|
|
result = 0
|
|
for i in range(1, 11):
|
|
result += i**3 - i**2 + i
|
|
return result
|
|
|
|
class ComplicatedAlgorithm:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def execute(self):
|
|
pass
|
|
|
|
def execute_complicated_algorithm():
|
|
_ = ComplicatedAlgorithm()
|
|
_._ = lambda _, __: _.___(__) + _.___(_.___(_.__(_.___(_.__))))
|
|
|
|
def analyze_data():
|
|
import random
|
|
|
|
data = [random.randint(1, 100) for _ in range(10)]
|
|
result = sum(data) / len(data)
|
|
'''
|
|
|
|
_43 = '''def hard_equation_solver():
|
|
result = 0
|
|
for i in range(1, 11):
|
|
result += i**5 - i**4 + i**3 - i**2 + i - 1
|
|
return result
|
|
|
|
class EquationSolver:
|
|
def __init__(self):
|
|
self._ = None
|
|
self.__ = None
|
|
|
|
def solve(self):
|
|
pass
|
|
|
|
def quadratic_equation(self, a, b, c):
|
|
discriminant = b**2 - 4*a*c
|
|
if discriminant > 0:
|
|
x1 = (-b + discriminant**0.5) / (2*a)
|
|
x2 = (-b - discriminant**0.5) / (2*a)
|
|
return x1, x2
|
|
elif discriminant == 0:
|
|
x = -b / (2*a)
|
|
return x
|
|
else:
|
|
real_part = -b / (2*a)
|
|
imaginary_part = (abs(discriminant)**0.5) / (2*a)
|
|
return (real_part + imaginary_part * 1j, real_part - imaginary_part * 1j)
|
|
|
|
def integrate_polynomial(self, coefficients):
|
|
result = [coeff / (i+1) for i, coeff in enumerate(coefficients)]
|
|
result.append(0)
|
|
return result
|
|
|
|
def solve_equation():
|
|
_ = EquationSolver()
|
|
_.quadratic_equation(1, -3, 2)
|
|
|
|
def compute_fibonacci(n):
|
|
if n <= 0:
|
|
return 0
|
|
elif n == 1:
|
|
return 1
|
|
else:
|
|
return compute_fibonacci(n-1) + compute_fibonacci(n-2)
|
|
'''
|
|
|
|
_44 = '''def junk_function_1():
|
|
result = 0
|
|
for i in range(1, 6):
|
|
result += i**3 - i**2 + i - 1
|
|
return result
|
|
|
|
class RandomEquationSolver:
|
|
def __init__(self):
|
|
self.a = 5
|
|
self.b = 3
|
|
|
|
def solve(self):
|
|
return self.a * self.b + self.a - self.b
|
|
|
|
def random_operation(self):
|
|
return self.a**2 + self.b**3 - self.a * self.b
|
|
|
|
def solve_random_equation():
|
|
solver = RandomEquationSolver()
|
|
return solver.solve()
|
|
|
|
def compute_random_sequence(length):
|
|
return [i**2 - i + 1 for i in range(length)]
|
|
|
|
def find_random_factors(n):
|
|
factors = []
|
|
while n % 2 == 0:
|
|
factors.append(2)
|
|
n = n // 2
|
|
for i in range(3, int(n**0.5) + 1, 2):
|
|
while n % i == 0:
|
|
factors.append(i)
|
|
n = n // i
|
|
if n > 2:
|
|
factors.append(n)
|
|
return factors
|
|
|
|
def calculate_random_gcd(a, b):
|
|
while b:
|
|
a, b = b, a % b
|
|
return a
|
|
|
|
def generate_random_points(num_points):
|
|
points = []
|
|
for _ in range(num_points):
|
|
x = 2 * _ + 1
|
|
y = 3 * _ + 2
|
|
points.append((x, y))
|
|
return points
|
|
'''
|
|
|
|
_45 = '''def multiply_matrices(mat1, mat2):
|
|
result = []
|
|
for i in range(len(mat1)):
|
|
row = []
|
|
for j in range(len(mat2[0])):
|
|
total = 0
|
|
for k in range(len(mat2)):
|
|
total += mat1[i][k] * mat2[k][j]
|
|
row.append(total)
|
|
result.append(row)
|
|
return result
|
|
'''
|
|
|
|
return random.choice([_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45])
|
|
|
|
def write_code():
|
|
obfuscated_file = os.path.join(os.getcwd(), 'obfuscated_' + f"{os.path.basename(os.path.abspath(sys.argv[1]))}")
|
|
|
|
with open(os.path.join(obfuscated_file), 'w') as f:
|
|
|
|
if (len(sys.argv) > 2 and sys.argv[2].isdigit()):
|
|
|
|
f.write("""__obfuscator__ = 'RoseGuardian'
|
|
__author__ = 'gumbobr0t'
|
|
__github__ = 'https://github.com/DamagingRose/RoseGuardian'
|
|
__license__ = 'EPL-2.0'\n\n""")
|
|
|
|
slow_print(Fore.RED + 'Junk method detected...\n' + Fore.RESET, delay=0.005)
|
|
|
|
slow_print(Fore.RED + 'Pumping first junk layer into code...\n' + Fore.RESET, delay=0.005)
|
|
|
|
for i in range(math.ceil(int(sys.argv[2])/2)):
|
|
|
|
f.write(f'\n{get_junk()}')
|
|
|
|
if (len(sys.argv) > 3 and sys.argv[3].isdigit()):
|
|
|
|
if (sys.argv[3] == '0'):
|
|
|
|
slow_print(Fore.RED + 'Obfuscation method 0 detected...\n' + Fore.RESET, delay=0.005)
|
|
|
|
with open(os.path.abspath(sys.argv[1]), 'r') as file:
|
|
slow_print(Fore.RED + 'Reading source code...\n' + Fore.RESET, delay=0.005)
|
|
source_code = file.read()
|
|
|
|
slow_print(Fore.RED + 'Parsing tree...\n' + Fore.RESET, delay=0.005)
|
|
tree = ast.parse(source_code)
|
|
|
|
slow_print(Fore.RED + 'Removing comments...\n' + Fore.RESET, delay=0.005)
|
|
remove_comments(tree)
|
|
|
|
slow_print(Fore.RED + 'Removing blank lines...\n' + Fore.RESET, delay=0.005)
|
|
remove_blank_lines(tree)
|
|
|
|
slow_print(Fore.RED + 'Encoding strings...\n' + Fore.RESET, delay=0.005)
|
|
encode_strings(tree)
|
|
|
|
variables = set()
|
|
functions = set()
|
|
classes = set()
|
|
|
|
slow_print(Fore.RED + 'Changing class, function and variable names...\n' + Fore.RESET, delay=0.005)
|
|
|
|
for node in ast.walk(tree):
|
|
if isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
|
|
functions.add(node.name)
|
|
elif isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store):
|
|
variables.add(node.id)
|
|
elif isinstance(node, ast.ClassDef):
|
|
classes.add(node.name)
|
|
|
|
mapping = {name: random_name() for name in variables | functions | classes}
|
|
|
|
rename_identifiers(tree, mapping)
|
|
|
|
slow_print(Fore.RED + 'Adding self-decode to strings...\n' + Fore.RESET, delay=0.005)
|
|
f.write(f"\n\nkey = {key}\n\n")
|
|
f.write("def decode_obfuscated_string(obfuscated_string):\n")
|
|
f.write(" encoded = bytes.fromhex(obfuscated_string)\n")
|
|
f.write(" decoded = ''.join(chr(b ^ key) for b in encoded)\n")
|
|
f.write(" return decoded\n\n")
|
|
replace_strings_with_decoding(tree)
|
|
f.write(ast.unparse(tree))
|
|
|
|
if (sys.argv[3] == '1'):
|
|
|
|
slow_print(Fore.RED + 'Obfuscation method 1 detected...\n' + Fore.RESET, delay=0.005)
|
|
|
|
slow_print(Fore.RED + 'Writing obfuscated code to file...\n' + Fore.RESET, delay=0.005)
|
|
|
|
f.write('\n\nimport marshal, base64, zlib; exec(marshal.loads(zlib.decompress(base64.b64decode(' + repr(obfuscator1()) + '))))')
|
|
|
|
if (len(sys.argv) > 2 and sys.argv[2].isdigit()):
|
|
|
|
slow_print(Fore.RED + 'Pumping second junk layer into code...\n' + Fore.RESET, delay=0.005)
|
|
|
|
for i in range(math.ceil(int(sys.argv[2])/2)):
|
|
|
|
f.write(f'\n{get_junk()}')
|
|
|
|
if (len(sys.argv) != 4):
|
|
|
|
slow_print(Fore.RED + 'Usage: python RoseGuardian.py <filename> <junk layers> <obfuscation method>\n' + Fore.RESET, delay=0.005)
|
|
slow_print(Fore.RED + 'Example: python RoseGuardian.py <your file> 10 1\n' + Fore.RESET, delay=0.005)
|
|
|
|
sys.exit(0)
|
|
|
|
if (len(sys.argv) == 4):
|
|
|
|
if not os.path.exists(os.path.abspath(sys.argv[1])):
|
|
|
|
slow_print(Fore.RED + f'File {sys.argv[1]} was not found.\n' + Fore.RESET, delay=0.005)
|
|
|
|
sys.exit(0)
|
|
|
|
if os.path.splitext(os.path.abspath(sys.argv[1]))[1] not in ('.py', '.pyc'):
|
|
|
|
slow_print(Fore.RED + f'File {sys.argv[1]} is not a valid python file (.py or .pyc).\n' + Fore.RESET, delay=0.005)
|
|
|
|
sys.exit(0)
|
|
|
|
try:
|
|
|
|
write_code()
|
|
|
|
slow_print(Fore.RED + f'{sys.argv[1]} -> {"obfuscated_" + f"{sys.argv[1]}"}\n' + Fore.RESET, delay=0.005)
|
|
|
|
except Exception as e:
|
|
|
|
slow_print(Fore.RED + f'Failed to obfuscate {os.path.abspath(sys.argv[1])}.\n\nError: "{e}"\n' + Fore.RESET, delay=0.005)
|