PyGhidra: Constructing a Program

[bdemick]

Follow-up to #7333 - via PyGhidra I now have access to the script instance, and can create a project and empty program, but attempting to do anything with the created program object seems to yield:

java.lang.java.lang.IllegalStateException: java.lang.IllegalStateException: Database is closed

I've tried mimicking the steps that a loader performs, using MotorolaHexLoader.java as an example, but am definitely missing something. Any suggestions?

The (slightly condensed) example script:

log = MessageLog()
offset = 0x100000
test_file = Path("/home/user1/files/file.bin")
monitor = TaskMonitor.DUMMY
si = PyGhidraScriptProvider().getScriptInstance(None, None)
proj_location = Path.joinpath(test_file.parent, "gproj")

if not proj_location.exists():
    os.makedirs(proj_location)

proj = GhidraProject.createProject(proj_location, "testproject", False)
# Note the call to proj.getProject(), it's subtle, but important
state = GhidraState(None, proj.getProject(), None, None, None, None)
si.set(state, TaskMonitor.DUMMY, PrintWriter(System.out))
program = si.createProgram("test_program", LanguageID("x86:LE:64:default"))
program.setEventsEnabled(False)
# Failing here with:
# java.lang.java.lang.IllegalStateException: java.lang.IllegalStateException: Database is closed
tid = program.startTransaction("Starting memory block creation")

if program.isClosed():
    print("program is not open, exiting")
    exit()

state.setCurrentProgram(program)
si.set(state, TaskMonitor.DUMMY, PrintWriter(System.out))

with test_file.open("rb") as f:
    f.seek(offset)
    data = f.read(0x1000)
    in_stream = ByteArrayInputStream(data)
    MemoryBlockUtils.createInitializedBlock(
        program,
        False,
        "test_block",
        si.toAddr(offset),
        in_stream,
        0x1000,
        "test_comment",
        "test_source",
        True,
        False,
        True,
        log,
        monitor,
    )
program.endTransaction(tid, True)
program.setEventsEnabled(True)

if program.canSave():
    program.save("Saving changes before packing", monitor)
    proj.save(program)

proj.close()

dom_file = program.getDomainFile()
outfile = File(f"test_project.gzf")
dom_file.packFile(outfile, monitor)

[ryanmkurtz]

The root of the issue is here:

ghidra/Ghidra/Features/Base/src/main/java/ghidra/app/script/GhidraScript.java

Lines 3683 to 3693 in 20285e2

	public void openProgram(Program program) {
	PluginTool tool = state.getTool();
	if (tool == null) {
	return;
	}
	ProgramManager pm = tool.getService(ProgramManager.class);
	pm.openProgram(program);
	end(true);
	GhidraState newState = new GhidraState(tool, tool.getProject(), program, null, null, null);
	set(newState, monitor, writer);
	start();

The first param of your state = GhidraState(None, proj.getProject(), None, None, None, None) line is the tool that is causing the openProgram() method to exit early.

[ryanmkurtz]

I will play with an alternate implementation today. You probably shouldn't be going through the GhidraScript API when operating from this environment.

[ryanmkurtz]

How about just

proj = GhidraProject.createProject(proj_location, "testproject", False)
root_folder = proj.getRootFolder();
language = DefaultLanguageService.getLanguageService().getLanguage(LanguageID("x86:LE:64:default"))
spec = language.getDefaultCompilerSpec()
consumer = Object()
program = ProgramDB("test_program", language, spec, consumer);
program.setEventsEnabled(False)
tid = program.startTransaction("Starting memory block creation")

[bdemick]

Thanks! This approach seems to have worked to create the program without using the GhidraScript module. The test script I was working on is also missing a step (which I think you had started to carry out in your snippet here) to create a file in the project and save it. The full working script:

from pathlib import Path
import os

import pyghidra
from pyghidra.launcher import HeadlessPyGhidraLauncher

HeadlessPyGhidraLauncher().start()

from ghidra.app.util import MemoryBlockUtils
from ghidra.app.util.importer import MessageLog
from ghidra.base.project import GhidraProject
from ghidra.program.database import ProgramDB
from ghidra.program.flatapi import FlatProgramAPI
from ghidra.program.model.lang import LanguageID
from ghidra.program.util import DefaultLanguageService
from ghidra.util.task import TaskMonitor
from java.io import ByteArrayInputStream, File
from java.lang import Object


def main():
    log = MessageLog()
    offset = 0x100000
    pth = Path("/home/user1/files/file.bin")
    monitor = TaskMonitor.DUMMY
    lid = LanguageID("x86:LE:64:default")
    language = DefaultLanguageService.getLanguageService().getLanguage(lid)
    spec = language.getDefaultCompilerSpec()
    consumer = Object()
    program = ProgramDB("test_program", language, spec, consumer)
    api = FlatProgramAPI(program)
    tmploc = Path.joinpath(pth.parent, "gproj")

    if not tmploc.exists():
        os.makedirs(tmploc)

    program.setEventsEnabled(False)
    tid = program.startTransaction("Starting load")

    if program.isClosed():
        print("program is not open, exiting")
        exit()

    with pth.open("rb") as f:
        f.seek(offset)
        data = f.read(0x1000)
        in_stream = ByteArrayInputStream(data)
        MemoryBlockUtils.createInitializedBlock(
            program,
            False,
            "test_block",
            api.toAddr(offset),
            in_stream,
            0x1000,
            "test_comment",
            "test_source",
            True,
            False,
            True,
            log,
            monitor,
        )

    program.endTransaction(tid, True)
    program.setEventsEnabled(True)

    proj = GhidraProject.createProject(tmploc, "test_project", False)
    root_folder = proj.getRootFolder()
    root_folder.createFile("test_program", program, monitor)
    program.save("test", monitor)
    proj.save(program)

    # GhidraProject.saveAsPackedFile(program, outfile, False) throws a type error on the ProgramDB object
    dom_file = program.getDomainFile()
    outfile = File(str(pth.joinpath(pth.parent, "test_export.gzf")))
    dom_file.packFile(outfile, monitor)
    proj.close()


if __name__ == "__main__":
    main()