Save project as GZF

[clearbluejar]

def analyze_program(self, df_or_prog: Union["ghidra.framework.model.DomainFile", "ghidra.program.model.listing.Program"], require_symbols: bool, force_analysis: bool = False, verbose_analysis: bool = False):

     from ghidra.program.flatapi import FlatProgramAPI
     from ghidra.framework.model import DomainFile
     from ghidra.program.model.listing import Program
     from ghidra.util.task import ConsoleTaskMonitor
     from ghidra.program.util import GhidraProgramUtilities
     from ghidra.app.script import GhidraScriptUtil
     from ghidra.app.util.pdb import PdbProgramAttributes

     if isinstance(df_or_prog, DomainFile):
         program = self.project.openProgram("/", df_or_prog.getName(), False)
     elif isinstance(df_or_prog, Program):
         program = df_or_prog

     self.logger.info(f"Analyzing: {program}")

     for gdt in self.gdts:
         self.logger.info(f"Loading GDT: {gdt}")
         if not Path(gdt).exists():
             raise FileNotFoundError(f'GDT Path not found {gdt}')
         self.apply_gdt(program, gdt)

     gdt_names = [name for name in program.getDataTypeManager().getSourceArchives()]
     if len(gdt_names) > 0:
         print(f'Using file gdts: {gdt_names}')

     try:
         if verbose_analysis or self.verbose_analysis:
             monitor = ConsoleTaskMonitor()
             flat_api = FlatProgramAPI(program, monitor)
         else:
             flat_api = FlatProgramAPI(program)

         pdb_attr = PdbProgramAttributes(program)
         # force_reload_for_symbols = not pdb_attr.isPdbLoaded(
         # ) and not self.no_symbols and pdb_attr.isProgramAnalyzed()
         force_reload_for_symbols = False

         if force_reload_for_symbols:
             self.set_analysis_option_bool(program, 'PDB Universal', True)
             self.logger.info('Symbols missing. Re-analysis is required. Setting PDB Universal: True')
             self.logger.debug(f'pdb loaded: {pdb_attr.isPdbLoaded()} prog analyzed: {pdb_attr.isProgramAnalyzed()}')

         if GhidraProgramUtilities.shouldAskToAnalyze(program) or force_analysis or self.force_analysis or force_reload_for_symbols:
             GhidraScriptUtil.acquireBundleHostReference()

             # handle large binaries more efficiently
             # see ghidra/issues/4573 (turn off feature Shared Return Calls )
             if program and program.getFunctionManager().getFunctionCount() > 1000:
                 self.logger.warn(f"Turning off 'Shared Return Calls' for {program}")
                 self.set_analysis_option_bool(
                     program, 'Shared Return Calls.Assume Contiguous Functions Only', False)

             # TODO make this argument optional, or provide custom analyzer config parsing
             # This really helps with decompilation, was turned off by default in 10.x
             self.set_analysis_option_bool(program, 'Decompiler Parameter ID', True)

             if self.no_symbols:
                 self.logger.warn(f'Disabling symbols for analysis! --no-symbols flag: {self.no_symbols}')
                 self.set_analysis_option_bool(program, 'PDB Universal', False)

             self.logger.info(f'Starting Ghidra analysis of {program}...')
             try:
                 flat_api.analyzeAll(program)
                 if hasattr(GhidraProgramUtilities, 'setAnalyzedFlag'):
                     GhidraProgramUtilities.setAnalyzedFlag(program, True)
                 elif hasattr(GhidraProgramUtilities, 'markProgramAnalyzed'):
                     GhidraProgramUtilities.markProgramAnalyzed(program)
                 else:
                     raise Exception('Missing set analyzed flag method!')
             finally:
                 for gdt in self.gdts:
                     self.logger.info(f"Loading GDT: {gdt}")
                     if not Path(gdt).exists():
                         raise FileNotFoundError(f'GDT Path not found {gdt}')


                     self.apply_gdt(program, gdt)
                 GhidraScriptUtil.releaseBundleHostReference()
                 self.project.save(program)
         else:
             self.logger.info(f"Analysis already complete.. skipping {program}!")
     finally:
         from java.io import File
         self.project.saveAsPackedFile(program, File(f'/tmp/{program.name}.gzf'), True)
         self.project.close(program)