def compile_with_standard_library(vbs: SourceFile) -> Result:
cpl = Compiler()
ast = Parser.parse_file(vbs)
cpl.add_module(ast, reference.ProceduralModule, "main_module")
program = cpl.link_standard_library(cpl.program)
return program.to_dict()
def compile_input_file(input_file: str) -> Program:
path = Path(input_file)
if path.is_dir():
# A directory must be a project containing VBA source files
return Compiler.compile_project(input_file)
with open(input_file, "rb") as f:
content = f.read()
# Try to deserialize an already compiled program
try:
serializer = Serializer()
obj = serializer.deserialize(content)
if type(obj) == Program:
return obj
except SerializationError:
pass
# Compile an Office document or VBA source files
units = []
if magic_from_buffer(content, mime=True) == "text/plain":
if not input_file.endswith(".vbs"):
input_file += ".vbs"
units.append(Unit.from_content(content.decode("utf-8"), input_file))
else:
vba_parser = VBA_Parser(input_file, data=content)
for _, _, vba_filename, vba_code in vba_parser.extract_all_macros():
units.append(Unit.from_content(vba_code, vba_filename))
return Compiler.compile_units(units)
def interpreting(vbs: SourceFile) -> Result:
ast = Parser.parse_file(vbs)
comp = Compiler()
comp.add_module(ast, reference.ProceduralModule, "main_module")
program = comp.link_standard_library(comp.program)
interp = interpreter.Interpreter(program)
interp.run("Main")
return interp._outside_world.to_dict(reproducible=True)
def deobfuscate(
vbs: SourceFile,
level: int,
rename_symbols: bool,
classifier: Optional[ManglingClassifier] = None,
) -> Dict[str, AST]:
program = Compiler.compile_file(vbs)
deobfuscator = Deobfuscator(
program,
evaluation_level=level,
rename_symbols=rename_symbols,
mangling_classifier=classifier,
)
clean_asts = {
module: deobfuscator.deobfuscate(ast)
for module, ast in program.asts.items()
}
return clean_asts
def execute_program(program: Program, entry_point: str) -> None:
linked_program = Compiler.link_standard_library(program)
return Interpreter.run_program(linked_program, entry_point)
def compile_single_file(vbs: SourceFile) -> Result:
return Compiler.compile_file(vbs).to_dict()
def compile_project(project: SourceFile) -> Result:
return Compiler.compile_project(project).to_dict()
def test_serialization_deserialization():
program = Compiler.compile_file(source_path("interpreter_01"))
serial = Serializer.serialize(program)
deserial = Serializer.deserialize(serial)
assert_equals(type(program), type(deserial))
assert_equals(program.to_dict(), deserial.to_dict())