Skip to content

Ghidra is a software reverse engineering (SRE) framework

5.4 KB
Raw Blame
/* ###
 * IP: GHIDRA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package sarif.managers;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import com.google.gson.JsonArray;

import generic.stl.Pair;
import ghidra.app.util.importer.MessageLog;
import ghidra.program.disassemble.Disassembler;
import ghidra.program.disassemble.DisassemblerMessageListener;
import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressOverflowException;
import ghidra.program.model.address.AddressRange;
import ghidra.program.model.address.AddressRangeImpl;
import ghidra.program.model.address.AddressSet;
import ghidra.program.model.address.AddressSetView;
import ghidra.program.model.listing.FlowOverride;
import ghidra.program.model.listing.Instruction;
import ghidra.program.model.listing.InstructionIterator;
import ghidra.program.model.listing.Listing;
import ghidra.program.model.listing.Program;
import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskLauncher;
import ghidra.util.task.TaskMonitor;
import sarif.SarifProgramOptions;
import sarif.export.SarifWriterTask;
import sarif.export.code.SarifCodeWriter;

public class CodeSarifMgr extends SarifMgr implements DisassemblerMessageListener {

	public static String KEY = "CODE";
	public static String SUBKEY = "Code";
	public static String SUBKEY2 = "Override";

	public CodeSarifMgr(Program program, MessageLog log) {
		super(KEY, program, log);
	}

	////////////////////////////
	// SARIF READ CURRENT DTD //
	////////////////////////////

	@Override
	public boolean read(Map<String, Object> result, SarifProgramOptions options, TaskMonitor monitor)
			throws CancelledException {

		AddressSet set = new AddressSet();

		try {
			getLocations(result, set);
		} catch (AddressOverflowException e) {
			log.appendException(e);
		}

		String msg = (String) result.get("Message");

		AddressSet disset = set.intersect(program.getMemory());
		if (!disset.equals(set)) {
			log.appendMsg("Disassembly address set changed to " + disset.toString());
		}
		disassemble(disset, monitor);

		if (msg.equals(SUBKEY2)) {
			Instruction inst = program.getListing().getInstructionAt(set.getMinAddress());
			String override = (String) result.get("kind");
			inst.setFlowOverride(FlowOverride.valueOf(override));
		}
		return true;
	}

	public void disassemble(AddressSet set, TaskMonitor monitor) {
		Disassembler disassembler = Disassembler.getDisassembler(program, monitor, this);
		try {
			Listing listing = program.getListing();
			while (!set.isEmpty() && !monitor.isCancelled()) {
				Address start = set.getMinAddress();
				AddressSet disset = disassembler.disassemble(start, set);
				if (disset.isEmpty()) {
					Instruction instr = listing.getInstructionAt(start);
					if (instr == null) {
						AddressRange skipRange = set.iterator().next();
						log.appendMsg("Expected valid Instruction at " + start);
						log.appendMsg("...skipping code range " + skipRange.getMinAddress() + " to "
								+ skipRange.getMaxAddress());
						set.delete(skipRange);
					} else {
						set.deleteRange(instr.getMinAddress(), instr.getMaxAddress());
					}
				} else {
					set.delete(disset);
				}
			}
		} catch (Exception e) {
			log.appendMsg("Error during disassembly: " + e.getMessage());
		}
	}

	@Override
	public void disassembleMessageReported(String msg) {
		log.appendMsg("Error from disassembler: " + msg);
	}

	/////////////////////////////
	// SARIF WRITE CURRENT DTD //
	/////////////////////////////

	void write(JsonArray results, AddressSetView set, TaskMonitor monitor) throws IOException, CancelledException {
		monitor.setMessage("Writing CODE ...");

		List<AddressRange> request = new ArrayList<>();
		List<Pair<Instruction, FlowOverride>> requestOverride = new ArrayList<>();
		InstructionIterator it = null;
		if (set == null) {
			it = program.getListing().getInstructions(true);
		} else {
			it = program.getListing().getInstructions(set, true);
		}

		while (it.hasNext()) {
			Instruction inst = it.next();
			Address start = inst.getMinAddress();
			Address end = inst.getMaxAddress();
			while (it.hasNext()) {
				inst = it.next();
				FlowOverride override = inst.getFlowOverride();
				if (!override.equals(FlowOverride.NONE)) {
					requestOverride.add(new Pair<Instruction, FlowOverride>(inst, override));
				}

				if (!end.isSuccessor(inst.getMinAddress())) {
					request.add(new AddressRangeImpl(start, end));
					start = inst.getMinAddress();
				}
				end = inst.getMaxAddress();
				monitor.checkCancelled();
			}
			request.add(new AddressRangeImpl(start, end));
		}

		writeAsSARIF(request, requestOverride, results);
	}

	public static void writeAsSARIF(List<AddressRange> request, List<Pair<Instruction, FlowOverride>> request2,
			JsonArray results) throws IOException {
		SarifCodeWriter writer = new SarifCodeWriter(request, request2, null);
		new TaskLauncher(new SarifWriterTask(SUBKEY, writer, results), null);
	}

}