Skip to content

Ghidra is a software reverse engineering (SRE) framework

7.7 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.*;

import com.google.gson.JsonArray;

import ghidra.app.util.importer.MessageLog;
import ghidra.program.model.address.*;
import ghidra.program.model.listing.*;
import ghidra.program.model.symbol.*;
import ghidra.util.exception.*;
import ghidra.util.task.TaskLauncher;
import ghidra.util.task.TaskMonitor;
import sarif.SarifProgramOptions;
import sarif.export.SarifWriterTask;
import sarif.export.extlib.SarifClassesNamespaceWriter;
import sarif.export.extlib.SarifExternalLibraryWriter;

/**
 * SARIF for external library table for resolved external references.
 */
public class ExternalLibSarifMgr extends SarifMgr {

	public static String KEY = "EXT_LIBRARY";
	public static String SUBKEY0 = "External.Library";
	public static String SUBKEY1 = "External.Location";

	private ExternalManager extManager;
	private boolean libraries = true;

	ExternalLibSarifMgr(Program program, MessageLog log) {
		super(KEY, program, log);
		extManager = program.getExternalManager();
		externalMap = new HashMap<>();
	}

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

	@Override
	protected void readResults(List<Map<String, Object>> list, SarifProgramOptions options,
			TaskMonitor monitor)
			throws AddressFormatException, CancelledException {
		if (list != null) {
			monitor.setMessage("Processing " + key + "...");
			monitor.setMaximum(list.size() * 2);

			for (Map<String, Object> result : list) {
				monitor.checkCancelled();
				read(result, options, monitor);
				monitor.increment();
			}
			libraries = false;
			for (Map<String, Object> result : list) {
				monitor.checkCancelled();
				read(result, options, monitor);
				monitor.increment();
			}

		}
		else {
			monitor.setMessage("Skipping over " + key + " ...");
		}
	}

	/**
	 * Process the entry point section of the SARIF file.
	 * 
	 * @param result  sarif reader
	 * @param monitor monitor that can be canceled
	 */
	@Override
	public boolean read(Map<String, Object> result, SarifProgramOptions options,
			TaskMonitor monitor)
			throws CancelledException {
		try {
			String symbol = (String) result.get("symbol");
			if (libraries && symbol == null) {
				processExternalLib(result);
				return true;
			}
			if (!libraries && symbol != null) {
				processExternalLocation(result);
				return true;
			}
			return false;
		}
		catch (Exception e) {
			log.appendException(e);
		}
		return false;
	}

	private void processExternalLib(Map<String, Object> result)
			throws InvalidInputException, DuplicateNameException {

		String progName = (String) result.get("name");
		// check to make sure that we do not clear any
		// external refs that have already been resolved
		Library library = extManager.getExternalLibrary(progName);
		if (library != null) {
			return; // already has a value--don't override it
		}

		// NB: Can't use "DEFAULT" here or result.get("sourceType") which may be "DEFAULT"
		String source = (String) result.get("sourceType");
		SourceType sourceType = getSourceType(source);
		if (sourceType.equals(SourceType.DEFAULT)) {
			sourceType = SourceType.IMPORTED;
		}
		library = extManager.addExternalLibraryName(progName, sourceType);

		// NOTE: It is assumed that a full export/import will maintain the ordered sequence of Libraries

		// NOTE: Skip setting library location within project which is unlikely to match-up properly
		// String progPath = (String) result.get("location");
		// if (progPath != null) {
		// 	extManager.setExternalPath(progName, progPath, sourceType == SourceType.USER_DEFINED);
		// }
	}

	private void processExternalLocation(Map<String, Object> result) throws IOException {

		try {
			String name = (String) result.get("name");
			String libraryName = (String) result.get("libraryName");
			String location = (String) result.get("location");
			Address address = getLocation(result);
			String extern = (String) result.get("externalAddress");
			String source = (String) result.get("source");
			SourceType sourceType = getSourceType(source);
			if (sourceType.equals(SourceType.DEFAULT)) {
				sourceType = SourceType.IMPORTED;
			}
			boolean isClass = (boolean) result.get("isClass");
			Namespace namespace = walkNamespace(program.getGlobalNamespace(), location + "::",
				address, sourceType, isClass);
			String name0 = (String) result.get("originalImportedName");

			ExternalLocation loc =
				addExternal(result, name, libraryName, address, sourceType, namespace, name0);
			externalMap.put(extern, loc);
		}
		catch (InvalidInputException | AddressOverflowException e) {
			log.appendException(e);
		}
	}

	private ExternalLocation addExternal(Map<String, Object> result, String name,
			String libraryName, Address address,
			SourceType sourceType,
			Namespace namespace, String name0) throws InvalidInputException {
		Library library = getLibrary(libraryName);
		ExternalLocation loc;
		if ((boolean) result.get("isFunction")) {
			if (name0 != null) {
				loc = extManager.addExtFunction(library, namespace, name0, address, sourceType,
					false);
			}
			else {
				loc = extManager.addExtFunction(library, name, address, sourceType, true);
			}
		}
		else {
			if (name0 != null) {
				loc = extManager.addExtLocation(library, namespace, name0, address, sourceType,
					false);
			}
			else {
				loc =
					extManager.addExtLocation(library, namespace, name, address, sourceType, true);
			}
		}
		return loc;
	}

	private Library getLibrary(String libraryName) {
		Symbol librarySymbol = program.getSymbolTable().getLibrarySymbol(libraryName);
		return librarySymbol == null ? null : (Library) librarySymbol.getObject();
	}

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

	/**
	 * Write out the SARIF for the external library table.
	 * 
	 * @param results writer for SARIF
	 * @param monitor monitor that can be canceled should be written
	 * @throws IOException
	 */
	void write(JsonArray results, TaskMonitor monitor) throws IOException, CancelledException {
		monitor.setMessage("Writing EXTERNAL LIBRARIES ...");

		String[] externalNames = extManager.getExternalLibraryNames();
		List<String> request0 = new ArrayList<>();
		for (String name : externalNames) {
			request0.add(name);
		}

		writeExtAsSARIF(program, request0, results);

		Iterator<GhidraClass> classNamespaces = program.getSymbolTable().getClassNamespaces();
		List<GhidraClass> request1 = new ArrayList<>();
		while (classNamespaces.hasNext()) {
			request1.add(classNamespaces.next());
		}

		writeNamespaceAsSARIF(program, request1, results);

	}

	public static void writeExtAsSARIF(Program program, List<String> request, JsonArray results)
			throws IOException {
		SarifExternalLibraryWriter writer =
			new SarifExternalLibraryWriter(program.getExternalManager(), request, null);
		new TaskLauncher(new SarifWriterTask("Libraries", writer, results), null);
	}

	public static void writeNamespaceAsSARIF(Program program, List<GhidraClass> request,
			JsonArray results) throws IOException {
		SarifClassesNamespaceWriter writer = new SarifClassesNamespaceWriter(
			program.getExternalManager(), program.getSymbolTable(), request, null);
		new TaskLauncher(new SarifWriterTask("Libraries", writer, results), null);
	}

}