Mirrors_Framework/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra.git synced 2026-05-31 20:33:11 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch

Browse Source 
'origin/GP-1519_ghirdra007_RecoverClass_replaceGetComponentA--SQUASHED'
into Ghidra_10.1

Conflicts:
	Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/ExtraScriptUtils.java
	Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/RTTIGccClassRecoverer.java
	Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/RTTIWindowsClassRecoverer.java
This commit is contained in:
ghidra1
2021-11-29 22:35:26 -05:00
parent aae2b95fcd 2aefe6a15d
commit 659892a810
8 changed files with 252 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Ghidra/Features/Decompiler/ghidra_scripts/RecoverClassesFromRTTIScript.java
-2
View File
@@ -179,8 +179,6 @@ public class RecoverClassesFromRTTIScript extends GhidraScript {
RTTIClassRecoverer recoverClassesFromRTTI; RTTIClassRecoverer recoverClassesFromRTTI;
ExtraScriptUtils extraUtils;
boolean nameVfunctions = false; boolean nameVfunctions = false;
@Override @Override
Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/EditStructureUtils.java
+35 -36
View File
@@ -22,9 +22,9 @@ import ghidra.program.model.data.*;
import ghidra.util.exception.CancelledException; import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor; import ghidra.util.task.TaskMonitor;
public class EditStructureUtils { class EditStructureUtils {
EditStructureUtils() { private EditStructureUtils() {
} }
@@ -42,7 +42,7 @@ public class EditStructureUtils {
* internal struct, false otherwise * internal struct, false otherwise
* @throws CancelledException if cancelled * @throws CancelledException if cancelled
*/ */
public boolean hasReplaceableComponentsAtOffset(Structure containingStruct, int offset, static boolean hasReplaceableComponentsAtOffset(Structure containingStruct, int offset,
Structure newInternalStruct, TaskMonitor monitor) throws CancelledException { Structure newInternalStruct, TaskMonitor monitor) throws CancelledException {
DataTypeComponent[] newStructComponents = newInternalStruct.getComponents(); DataTypeComponent[] newStructComponents = newInternalStruct.getComponents();
@@ -95,7 +95,7 @@ public class EditStructureUtils {
* @return true if there are at least length undefined size 1 components at the given offset in the given structure * @return true if there are at least length undefined size 1 components at the given offset in the given structure
* @throws CancelledException if cancelled * @throws CancelledException if cancelled
*/ */
public boolean hasEnoughUndefined1sAtOffset(Structure structure, int offset, int length, static boolean hasEnoughUndefined1sAtOffset(Structure structure, int offset, int length,
TaskMonitor monitor) throws CancelledException { TaskMonitor monitor) throws CancelledException {
if (structure.getLength() < offset + length) { if (structure.getLength() < offset + length) {
@@ -128,7 +128,7 @@ public class EditStructureUtils {
* @return true if successfully cleared from offset to offset+length, false otherwise * @return true if successfully cleared from offset to offset+length, false otherwise
* @throws CancelledException if cancelled * @throws CancelledException if cancelled
*/ */
public boolean clearLengthAtOffset(Structure structure, int offset, int length, static boolean clearLengthAtOffset(Structure structure, int offset, int length,
TaskMonitor monitor) throws CancelledException { TaskMonitor monitor) throws CancelledException {
if (structure.getLength() < offset + length) { if (structure.getLength() < offset + length) {
@@ -143,17 +143,10 @@ public class EditStructureUtils {
monitor.checkCanceled(); monitor.checkCanceled();
DataTypeComponent component = structure.getComponentAt(offset); DataTypeComponent component = structure.getComponentContaining(offset);
DataType dataType = component.getDataType();
// return false if it would clear too much offsetsToClear.add(component.getOffset());
if (offset + dataType.getLength() > endOfClear) { offset = component.getOffset() + component.getLength();
return false;
}
offsetsToClear.add(offset);
offset += dataType.getLength();
continue;
} }
@@ -178,11 +171,12 @@ public class EditStructureUtils {
* @param dataType the given data type * @param dataType the given data type
* @return true if given data type is undefined size 1, false otherwise * @return true if given data type is undefined size 1, false otherwise
*/ */
public boolean isUndefined1(DataType dataType) { static boolean isUndefined1(DataType dataType) {
if (isUndefined(dataType) && dataType.getLength() == 1) { if (Undefined.isUndefined(dataType) && dataType.getLength() == 1) {
return true; return true;
} }
return false; return false;
} }
@@ -191,7 +185,7 @@ public class EditStructureUtils {
* @param dataType the given data type * @param dataType the given data type
* @return true if given data type is undefined of any size, false otherwise * @return true if given data type is undefined of any size, false otherwise
*/ */
public boolean isUndefined(DataType dataType) { static boolean isUndefined(DataType dataType) {
if (dataType.getName().contains("undefined")) { if (dataType.getName().contains("undefined")) {
return true; return true;
} }
@@ -199,41 +193,46 @@ public class EditStructureUtils {
} }
/** /**
* Method to determine if there are at least the given length of undefined (any size) components at the given offset in the given structure * Method to determine if there are at least the given length of undefined (any size) components
* at the given offset in the given structure. This is only valid for non-packed structures.
* @param structure the given structure * @param structure the given structure
* @param offset the given offset * @param offset the given offset
* @param length the total length of undefined components to check for starting at given offset * @param length the total length of undefined components to check for starting at given offset
* @param monitor task monitor * @param monitor task monitor
* @return true if there are at least total length of undefined components at the given offset in the given structure * @return true if there are at least total length of undefined components at the given offset in the given structure
* @throws CancelledException if cancelled * @throws CancelledException if cancelled
* @throws IllegalArgumentException if a packed structure is passed in
*/ */
public boolean hasEnoughUndefinedsOfAnyLengthAtOffset(Structure structure, int offset, static boolean hasEnoughUndefinedsOfAnyLengthAtOffset(Structure structure, int offset,
int length, TaskMonitor monitor) throws CancelledException { int length, TaskMonitor monitor) throws CancelledException {
if (structure.getLength() < offset + length) { if (structure.isPackingEnabled()) {
return false; throw new IllegalArgumentException(
"Packed structures are not supported by this method");
} }
int endOfRange = offset + length; int endOfRange = offset + length;
if (offset < 0 || length <= 0 || structure.getLength() < endOfRange) {
return false;
}
while (offset < endOfRange) { while (offset < endOfRange) {
monitor.checkCanceled(); monitor.checkCanceled();
DataTypeComponent component = structure.getComponentAt(offset); DataTypeComponent component = structure.getComponentContaining(offset);
DataType dataType = component.getDataType(); DataType dataType = component.getDataType();
if (isUndefined(dataType)) {
offset += dataType.getLength();
if (offset > endOfRange) {
return false;
}
continue;
if (!Undefined.isUndefined(dataType)) {
return false;
} }
return false;
offset = component.getOffset() + component.getLength();
} }
return true; return true;
} }
@@ -251,7 +250,7 @@ public class EditStructureUtils {
* @throws IllegalArgumentException if issue inserting data type into structure * @throws IllegalArgumentException if issue inserting data type into structure
* @throws CancelledException if cancelled * @throws CancelledException if cancelled
*/ */
public Structure addDataTypeToStructure(Structure structure, int offset, static Structure addDataTypeToStructure(Structure structure, int offset,
DataType dataType, String fieldName, TaskMonitor monitor) DataType dataType, String fieldName, TaskMonitor monitor)
throws CancelledException, IllegalArgumentException { throws CancelledException, IllegalArgumentException {
@@ -292,7 +291,7 @@ public class EditStructureUtils {
* @return true if the given structure has room at the given offset to have a component of the given length added to it * @return true if the given structure has room at the given offset to have a component of the given length added to it
* @throws CancelledException if cancelled * @throws CancelledException if cancelled
*/ */
public boolean canAdd(Structure structureDataType, int offset, int lengthToAdd, static boolean canAdd(Structure structureDataType, int offset, int lengthToAdd,
TaskMonitor monitor) TaskMonitor monitor)
throws CancelledException { throws CancelledException {
@@ -332,7 +331,7 @@ public class EditStructureUtils {
* @return the number of undefined size 1 components in the given structure before the given offset * @return the number of undefined size 1 components in the given structure before the given offset
* @throws CancelledException if cancelled * @throws CancelledException if cancelled
*/ */
public int getNumberOfUndefinedsBeforeOffset(Structure structure, int offset, static int getNumberOfUndefinedsBeforeOffset(Structure structure, int offset,
TaskMonitor monitor) throws CancelledException { TaskMonitor monitor) throws CancelledException {
if (structure.getNumComponents() == 0) { if (structure.getNumComponents() == 0) {
@@ -364,7 +363,7 @@ public class EditStructureUtils {
* @return the number of undefined size 1 components starting at the given offset in the given structure * @return the number of undefined size 1 components starting at the given offset in the given structure
* @throws CancelledException if cancelled * @throws CancelledException if cancelled
*/ */
public int getNumberOfUndefinedsStartingAtOffset(Structure structure, int offset, static int getNumberOfUndefinedsStartingAtOffset(Structure structure, int offset,
TaskMonitor monitor) throws CancelledException { TaskMonitor monitor) throws CancelledException {
int numUndefineds = 0; int numUndefineds = 0;
Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/ExtraScriptUtils.java → Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/ExtendedFlatProgramAPI.java
+27 -26
View File
@@ -34,19 +34,13 @@ import ghidra.program.model.symbol.*;
import ghidra.util.exception.*; import ghidra.util.exception.*;
import ghidra.util.task.TaskMonitor; import ghidra.util.task.TaskMonitor;
public class ExtraScriptUtils extends FlatProgramAPI { public class ExtendedFlatProgramAPI extends FlatProgramAPI {
Program program; final int defaultPointerSize;
TaskMonitor taskMonitor;
int defaultPointerSize;
ExtraScriptUtils(Program program, TaskMonitor taskMonitor) { ExtendedFlatProgramAPI(Program program, TaskMonitor taskMonitor) {
this.program = program;
this.taskMonitor = taskMonitor;
currentProgram = program;
monitor = taskMonitor;
super(program, taskMonitor);
defaultPointerSize = program.getDefaultPointerSize(); defaultPointerSize = program.getDefaultPointerSize();
} }
@@ -66,7 +60,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
int numComponents = data.getNumComponents(); int numComponents = data.getNumComponents();
for (int ii = 0; ii < numComponents; ++ii) { for (int ii = 0; ii < numComponents; ++ii) {
taskMonitor.checkCanceled(); monitor.checkCanceled();
Data component = data.getComponent(ii); Data component = data.getComponent(ii);
if (!component.isPointer()) { if (!component.isPointer()) {
@@ -125,7 +119,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
} }
// check for or create function pointer if valid function pointed to // check for or create function pointer if valid function pointed to
Data data = program.getListing().getDefinedDataAt(address); Data data = currentProgram.getListing().getDefinedDataAt(address);
if (data != null) { if (data != null) {
if (data.isPointer() && getPointedToFunction(address) != null) { if (data.isPointer() && getPointedToFunction(address) != null) {
return true; return true;
@@ -143,10 +137,12 @@ public class ExtraScriptUtils extends FlatProgramAPI {
clearListing(address); clearListing(address);
return false; return false;
} }
catch (CancelledException e) {
throw e;
}
catch (Exception e) { catch (Exception e) {
return false; return false;
} }
} }
return false; return false;
@@ -165,8 +161,8 @@ public class ExtraScriptUtils extends FlatProgramAPI {
return false; return false;
} }
DataType nullPointer = program.getDataTypeManager().getPointer(null); DataType nullPointer = currentProgram.getDataTypeManager().getPointer(null);
Listing listing = program.getListing(); Listing listing = currentProgram.getListing();
Data d = listing.getDefinedDataAt(address); Data d = listing.getDefinedDataAt(address);
if (d == null) { if (d == null) {
try { try {
@@ -316,7 +312,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
*/ */
public Function createFunctionBefore(Address address, Byte expectedFiller) { public Function createFunctionBefore(Address address, Byte expectedFiller) {
PseudoDisassembler pseudoDisassembler = new PseudoDisassembler(program); PseudoDisassembler pseudoDisassembler = new PseudoDisassembler(currentProgram);
Instruction instructionBefore = getInstructionBefore(address); Instruction instructionBefore = getInstructionBefore(address);
@@ -419,7 +415,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
public int getNumberOfSameFillerBytesStartingAtAddress(Address firstAddress) public int getNumberOfSameFillerBytesStartingAtAddress(Address firstAddress)
throws CancelledException, MemoryAccessException { throws CancelledException, MemoryAccessException {
AddressSetView validMemory = program.getMemory().getLoadedAndInitializedAddressSet(); AddressSetView validMemory = currentProgram.getMemory().getLoadedAndInitializedAddressSet();
if (firstAddress == null) { if (firstAddress == null) {
return 0; return 0;
@@ -511,6 +507,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
return false; return false;
} }
catch (CancelledException e) { catch (CancelledException e) {
// FIXME: this should not be caught by this method and should propogate
return false; return false;
} }
@@ -526,10 +523,12 @@ public class ExtraScriptUtils extends FlatProgramAPI {
public AddressSet getSubroutineAddresses(Program program, Address address) public AddressSet getSubroutineAddresses(Program program, Address address)
throws CancelledException { throws CancelledException {
// FIXME: Should not be passing program arg
// Create a new address set to hold the entire selection. // Create a new address set to hold the entire selection.
AddressSet subroutineAddresses = new AddressSet(); AddressSet subroutineAddresses = new AddressSet();
IsolatedEntrySubModel model = new IsolatedEntrySubModel(program); IsolatedEntrySubModel model = new IsolatedEntrySubModel(currentProgram);
CodeBlock[] codeBlocksContaining = model.getCodeBlocksContaining(address, monitor); CodeBlock[] codeBlocksContaining = model.getCodeBlocksContaining(address, monitor);
for (CodeBlock element : codeBlocksContaining) { for (CodeBlock element : codeBlocksContaining) {
@@ -556,6 +555,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
return; return;
} }
// FIXME: if you pass a Function arg you should use its program not currentProgram
ReturnParameterImpl returnType = ReturnParameterImpl returnType =
new ReturnParameterImpl(function.getSignature().getReturnType(), currentProgram); new ReturnParameterImpl(function.getSignature().getReturnType(), currentProgram);
@@ -607,7 +607,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
int addressSize = address.getSize(); int addressSize = address.getSize();
if (addressSize == 64 && getIboIf64bit) { if (addressSize == 64 && getIboIf64bit) {
ImageBaseOffset32DataType ibo32 = ImageBaseOffset32DataType ibo32 =
new ImageBaseOffset32DataType(program.getDataTypeManager()); new ImageBaseOffset32DataType(currentProgram.getDataTypeManager());
int length = ibo32.getLength(); int length = ibo32.getLength();
DumbMemBufferImpl compMemBuffer = DumbMemBufferImpl compMemBuffer =
new DumbMemBufferImpl(currentProgram.getMemory(), address); new DumbMemBufferImpl(currentProgram.getMemory(), address);
@@ -654,7 +654,8 @@ public class ExtraScriptUtils extends FlatProgramAPI {
List<Symbol> symbolList = new ArrayList<Symbol>(); List<Symbol> symbolList = new ArrayList<Symbol>();
SymbolIterator symbols = program.getSymbolTable().getSymbols(namespace); // FIXME: if you are going to pass namespace arg you should use its program not currentProgram
SymbolIterator symbols = currentProgram.getSymbolTable().getSymbols(namespace);
while (symbols.hasNext()) { while (symbols.hasNext()) {
monitor.checkCanceled(); monitor.checkCanceled();
@@ -764,8 +765,9 @@ public class ExtraScriptUtils extends FlatProgramAPI {
List<Address> referenceAddresses = new ArrayList<Address>(); List<Address> referenceAddresses = new ArrayList<Address>();
// FIXME: if you pass a function arg you should use its program, not currentProgram
ReferenceIterator referencesToFunctionBIterator = ReferenceIterator referencesToFunctionBIterator =
program.getReferenceManager().getReferencesTo(bFunction.getEntryPoint()); currentProgram.getReferenceManager().getReferencesTo(bFunction.getEntryPoint());
while (referencesToFunctionBIterator.hasNext()) { while (referencesToFunctionBIterator.hasNext()) {
@@ -995,7 +997,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
*/ */
public void removeAllSymbolsAtAddress(Address address) throws CancelledException { public void removeAllSymbolsAtAddress(Address address) throws CancelledException {
SymbolTable symbolTable = program.getSymbolTable(); SymbolTable symbolTable = currentProgram.getSymbolTable();
Symbol primarySymbol = symbolTable.getPrimarySymbol(address); Symbol primarySymbol = symbolTable.getPrimarySymbol(address);
@@ -1031,7 +1033,8 @@ public class ExtraScriptUtils extends FlatProgramAPI {
*/ */
public boolean hasSymbolsInNamespace(Namespace namespace) { public boolean hasSymbolsInNamespace(Namespace namespace) {
SymbolIterator namespaceSymbols = program.getSymbolTable().getSymbols(namespace); // FIXME: if you are going to use a Namespace arg you should its program not currentProgram
SymbolIterator namespaceSymbols = currentProgram.getSymbolTable().getSymbols(namespace);
if (namespaceSymbols.hasNext()) { if (namespaceSymbols.hasNext()) {
return true; return true;
@@ -1047,8 +1050,7 @@ public class ExtraScriptUtils extends FlatProgramAPI {
* @return CategoryPath for new categoryName * @return CategoryPath for new categoryName
* @throws CancelledException if cancelled * @throws CancelledException if cancelled
*/ */
public CategoryPath createDataTypeCategoryPath(CategoryPath parent, String categoryName) public CategoryPath createDataTypeCategoryPath(CategoryPath parent, String categoryName) throws CancelledException {
throws CancelledException {
CategoryPath dataTypePath; CategoryPath dataTypePath;
@@ -1072,7 +1074,6 @@ public class ExtraScriptUtils extends FlatProgramAPI {
int index = 0; int index = 0;
String newCategoryName = new String(); String newCategoryName = new String();
while (index < categoryName.length()) { while (index < categoryName.length()) {
monitor.checkCanceled(); monitor.checkCanceled();
if (categoryName.substring(index).startsWith("::") && !insideBrackets) { if (categoryName.substring(index).startsWith("::") && !insideBrackets) {
Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/RTTIClassRecoverer.java
+1 -1
View File
@@ -154,7 +154,7 @@ public class RTTIClassRecoverer extends RecoveredClassUtils {
// if class is non-virtual have to search for an existing class datatype // if class is non-virtual have to search for an existing class datatype
if (!recoveredClass.hasVftable()) { if (!recoveredClass.hasVftable()) {
DataType[] possibleExistingClassStructures = DataType[] possibleExistingClassStructures =
extraUtils.getDataTypes(recoveredClass.getName()); extendedFlatAPI.getDataTypes(recoveredClass.getName());
if (possibleExistingClassStructures.length == 0) { if (possibleExistingClassStructures.length == 0) {
continue; continue;
} }
Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/RTTIGccClassRecoverer.java
+36 -31
View File
@@ -241,7 +241,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
recoveredClasses = recoverClassesFromVftables(vftableSymbols, true, true); recoveredClasses = recoverClassesFromVftables(vftableSymbols, true, true);
// find all typeinfo symbols and get their class namespace and create RecoveredClass object // find all typeinfo symbols and get their class namespace and create RecoveredClass object
List<Symbol> typeinfoSymbols = extraUtils.getListOfSymbolsInAddressSet( List<Symbol> typeinfoSymbols = extendedFlatAPI.getListOfSymbolsInAddressSet(
program.getAddressFactory().getAddressSet(), "typeinfo", true); program.getAddressFactory().getAddressSet(), "typeinfo", true);
// create class objects for each typeinfo struct and make a class to typeinfo mapping for each // create class objects for each typeinfo struct and make a class to typeinfo mapping for each
@@ -312,7 +312,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
} }
} }
Address specialTypeinfoRef = extraUtils.getSingleReferencedAddress(typeinfoAddress); Address specialTypeinfoRef = extendedFlatAPI.getSingleReferencedAddress(typeinfoAddress);
if (specialTypeinfoRef == null) { if (specialTypeinfoRef == null) {
if (DEBUG) { if (DEBUG) {
Msg.debug(this, Msg.debug(this,
@@ -441,7 +441,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
listOfVtableSymbols = findVtablesUsingTypeinfoRefs(); listOfVtableSymbols = findVtablesUsingTypeinfoRefs();
} }
else { else {
listOfVtableSymbols = extraUtils.getListOfSymbolsInAddressSet( listOfVtableSymbols = extendedFlatAPI.getListOfSymbolsInAddressSet(
program.getAddressFactory().getAddressSet(), VTABLE_LABEL, false); program.getAddressFactory().getAddressSet(), VTABLE_LABEL, false);
} }
@@ -484,7 +484,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
for (Address typeinfoRef : typeinfoReferencesNotInTypeinfoStructs) { for (Address typeinfoRef : typeinfoReferencesNotInTypeinfoStructs) {
monitor.checkCanceled(); monitor.checkCanceled();
Address typeinfoAddress = extraUtils.getPointer(typeinfoRef); Address typeinfoAddress = extendedFlatAPI.getPointer(typeinfoRef);
if (typeinfoAddress == null) { if (typeinfoAddress == null) {
continue; continue;
@@ -546,7 +546,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
// check for appropriately sized long that is value 0 to make sure the // check for appropriately sized long that is value 0 to make sure the
// vtable the typeinfo ref is in is the main one and skip otherwise since non-zero // vtable the typeinfo ref is in is the main one and skip otherwise since non-zero
// ones are internal vtables that will get processed with the main one // ones are internal vtables that will get processed with the main one
if (!extraUtils.hasNumZeros(longBeforeTypeinfoRef, defaultPointerSize)) { if (!extendedFlatAPI.hasNumZeros(longBeforeTypeinfoRef, defaultPointerSize)) {
return null; return null;
} }
@@ -573,7 +573,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
private Address getPointerToDefinedMemory(Address address) { private Address getPointerToDefinedMemory(Address address) {
Address pointer = extraUtils.getPointer(address); Address pointer = extendedFlatAPI.getPointer(address);
if (pointer == null) { if (pointer == null) {
return null; return null;
} }
@@ -909,7 +909,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
private Symbol getVTTBefore(Address address) throws CancelledException { private Symbol getVTTBefore(Address address) throws CancelledException {
// get all symbols named VTT and get the one directly before the given address // get all symbols named VTT and get the one directly before the given address
List<Symbol> vttSymbols = extraUtils.getListOfSymbolsInAddressSet( List<Symbol> vttSymbols = extendedFlatAPI.getListOfSymbolsInAddressSet(
program.getAddressFactory().getAddressSet(), "VTT", true); program.getAddressFactory().getAddressSet(), "VTT", true);
return getSymbolOnListBeforeAddress(address, vttSymbols); return getSymbolOnListBeforeAddress(address, vttSymbols);
@@ -1127,7 +1127,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
return false; return false;
} }
Reference[] referencesTo = extraUtils.getReferencesTo(address); Reference[] referencesTo = extendedFlatAPI.getReferencesTo(address);
if (referencesTo.length > 0) { if (referencesTo.length > 0) {
return false; return false;
} }
@@ -1156,7 +1156,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
return false; return false;
} }
List<Address> referenceFromAddresses = extraUtils.getReferenceFromAddresses(address); List<Address> referenceFromAddresses = extendedFlatAPI.getReferenceFromAddresses(address);
if (referenceFromAddresses.size() > 0) { if (referenceFromAddresses.size() > 0) {
return false; return false;
@@ -1221,7 +1221,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
return false; return false;
} }
if (extraUtils.hasNumZeros(vftableAddress, defaultPointerSize)) { if (extendedFlatAPI.hasNumZeros(vftableAddress, defaultPointerSize)) {
return true; return true;
} }
@@ -1230,7 +1230,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
if (!data.isPointer()) { if (!data.isPointer()) {
return false; return false;
} }
Address referencedAddress = extraUtils.getSingleReferencedAddress(vftableAddress); Address referencedAddress = extendedFlatAPI.getSingleReferencedAddress(vftableAddress);
if (referencedAddress == null) { if (referencedAddress == null) {
return false; return false;
} }
@@ -1314,7 +1314,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
// create a pointer and check to see if it is a reference to a valid memory location // create a pointer and check to see if it is a reference to a valid memory location
try { try {
api.createData(address, pointer); api.createData(address, pointer);
Address referencedAddress = extraUtils.getSingleReferencedAddress(address); Address referencedAddress = extendedFlatAPI.getSingleReferencedAddress(address);
// if it isn't a valid pointer, clear what we just created and increment to offset so // if it isn't a valid pointer, clear what we just created and increment to offset so
// the next can be checked // the next can be checked
@@ -1372,7 +1372,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
for (Address typeinfoAddress : typeinfoAddresses) { for (Address typeinfoAddress : typeinfoAddresses) {
Address specialTypeinfoRef = extraUtils.getSingleReferencedAddress(typeinfoAddress); Address specialTypeinfoRef = extendedFlatAPI.getSingleReferencedAddress(typeinfoAddress);
if (specialTypeinfoRef == null) { if (specialTypeinfoRef == null) {
continue; continue;
} }
@@ -1583,7 +1583,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
} }
Address stringReference = Address stringReference =
extraUtils.getSingleReferencedAddress(address.add(typeinfoNameComponent.getOffset())); extendedFlatAPI.getSingleReferencedAddress(address.add(typeinfoNameComponent.getOffset()));
Data stringData = api.getDataAt(stringReference); Data stringData = api.getDataAt(stringReference);
if (stringData == null) { if (stringData == null) {
@@ -1610,7 +1610,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
List<Address> typeinfoAddresses = new ArrayList<Address>(); List<Address> typeinfoAddresses = new ArrayList<Address>();
List<Symbol> typeinfoSymbols = extraUtils.getListOfSymbolsInAddressSet( List<Symbol> typeinfoSymbols = extendedFlatAPI.getListOfSymbolsInAddressSet(
program.getAddressFactory().getAddressSet(), "typeinfo", true); program.getAddressFactory().getAddressSet(), "typeinfo", true);
Iterator<Symbol> typeinfoIterator = typeinfoSymbols.iterator(); Iterator<Symbol> typeinfoIterator = typeinfoSymbols.iterator();
@@ -2102,7 +2102,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
*/ */
private RecoveredClass getParentClassFromParentTypeInfoRef(Address parentTypeinfoRef) { private RecoveredClass getParentClassFromParentTypeInfoRef(Address parentTypeinfoRef) {
Address parentAddress = extraUtils.getSingleReferencedAddress(parentTypeinfoRef); Address parentAddress = extendedFlatAPI.getSingleReferencedAddress(parentTypeinfoRef);
if (parentAddress == null) { if (parentAddress == null) {
return null; return null;
} }
@@ -2191,7 +2191,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
int offset = 0; int offset = 0;
Address address = extraUtils.getAddress(startAddress, offset); Address address = extendedFlatAPI.getAddress(startAddress, offset);
MemoryBlock currentMemoryBlock = program.getMemory().getBlock(startAddress); MemoryBlock currentMemoryBlock = program.getMemory().getBlock(startAddress);
@@ -2205,10 +2205,10 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
return null; return null;
} }
Address possibleTypeinfo = extraUtils.getPointer(address); Address possibleTypeinfo = extendedFlatAPI.getPointer(address);
if (possibleTypeinfo == null) { if (possibleTypeinfo == null) {
offset += defaultPointerSize; offset += defaultPointerSize;
address = extraUtils.getAddress(startAddress, offset); address = extendedFlatAPI.getAddress(startAddress, offset);
continue; continue;
} }
@@ -2218,7 +2218,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
return address; return address;
} }
offset += defaultPointerSize; offset += defaultPointerSize;
address = extraUtils.getAddress(startAddress, offset); address = extendedFlatAPI.getAddress(startAddress, offset);
} }
@@ -2235,7 +2235,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
List<Symbol> vftableSymbols = new ArrayList<Symbol>(); List<Symbol> vftableSymbols = new ArrayList<Symbol>();
// find all vtable symbols // find all vtable symbols
List<Symbol> listOfVtableSymbols = extraUtils.getListOfSymbolsInAddressSet( List<Symbol> listOfVtableSymbols = extendedFlatAPI.getListOfSymbolsInAddressSet(
program.getAddressFactory().getAddressSet(), VTABLE_LABEL, true); program.getAddressFactory().getAddressSet(), VTABLE_LABEL, true);
Iterator<Symbol> vtableIterator = listOfVtableSymbols.iterator(); Iterator<Symbol> vtableIterator = listOfVtableSymbols.iterator();
@@ -2269,7 +2269,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
continue; continue;
} }
Address vftableAddress = extraUtils.getAddress(typeinfoAddress, defaultPointerSize); Address vftableAddress = extendedFlatAPI.getAddress(typeinfoAddress, defaultPointerSize);
// no valid address here so continue // no valid address here so continue
if (vftableAddress == null) { if (vftableAddress == null) {
//createNewClass(vtableNamespace, false); //createNewClass(vtableNamespace, false);
@@ -2350,7 +2350,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
recoveredClasses.add(recoveredClass); recoveredClasses.add(recoveredClass);
} }
Address specialTypeinfoRef = extraUtils.getSingleReferencedAddress(typeinfoAddress); Address specialTypeinfoRef = extendedFlatAPI.getSingleReferencedAddress(typeinfoAddress);
if (specialTypeinfoRef == null) { if (specialTypeinfoRef == null) {
if (DEBUG) { if (DEBUG) {
Msg.debug(this, Msg.debug(this,
@@ -2652,7 +2652,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
* @return true if the given address could be a valid null pointer, false if not * @return true if the given address could be a valid null pointer, false if not
*/ */
private boolean isPossibleNullPointer(Address address) throws CancelledException { private boolean isPossibleNullPointer(Address address) throws CancelledException {
if (!extraUtils.hasNumZeros(address, defaultPointerSize)) { if (!extendedFlatAPI.hasNumZeros(address, defaultPointerSize)) {
return false; return false;
} }
return true; return true;
@@ -2665,7 +2665,7 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
*/ */
private boolean isPossibleFunctionPointer(Address address) { private boolean isPossibleFunctionPointer(Address address) {
Address possibleFunctionPointer = extraUtils.getPointer(address); Address possibleFunctionPointer = extendedFlatAPI.getPointer(address);
if (possibleFunctionPointer == null) { if (possibleFunctionPointer == null) {
return false; return false;
} }
@@ -2857,9 +2857,11 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
DataType classVftablePointer = vfPointerDataTypes.get(vftableAddress); DataType classVftablePointer = vfPointerDataTypes.get(vftableAddress);
// simple case the offset for vftablePtr is 0 // simple case the offset for vftablePtr is 0
if (structUtils.canAdd(classStructureDataType, 0, classVftablePointer.getLength(), if (EditStructureUtils.canAdd(classStructureDataType, 0,
classVftablePointer.getLength(),
monitor)) { monitor)) {
classStructureDataType = structUtils.addDataTypeToStructure(classStructureDataType, classStructureDataType =
EditStructureUtils.addDataTypeToStructure(classStructureDataType,
0, classVftablePointer, CLASS_VTABLE_PTR_FIELD_EXT, monitor); 0, classVftablePointer, CLASS_VTABLE_PTR_FIELD_EXT, monitor);
} }
@@ -2903,10 +2905,11 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
" : structure should exist but doesn't."); " : structure should exist but doesn't.");
} }
if (structUtils.canAdd(classStructureDataType, parentOffset, if (EditStructureUtils.canAdd(classStructureDataType, parentOffset,
baseClassStructure.getLength(), monitor)) { baseClassStructure.getLength(), monitor)) {
classStructureDataType = classStructureDataType =
structUtils.addDataTypeToStructure(classStructureDataType, parentOffset, EditStructureUtils.addDataTypeToStructure(classStructureDataType,
parentOffset,
baseClassStructure, baseClassStructure.getName(), monitor); baseClassStructure, baseClassStructure.getName(), monitor);
} }
} }
@@ -2917,7 +2920,8 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
int dataOffset = getDataOffset(recoveredClass, classStructureDataType); int dataOffset = getDataOffset(recoveredClass, classStructureDataType);
int dataLen = UNKNOWN; int dataLen = UNKNOWN;
if (dataOffset != NONE) { if (dataOffset != NONE) {
dataLen = structUtils.getNumberOfUndefinedsStartingAtOffset(classStructureDataType, dataLen =
EditStructureUtils.getNumberOfUndefinedsStartingAtOffset(classStructureDataType,
dataOffset, monitor); dataOffset, monitor);
} }
@@ -2927,7 +2931,8 @@ public class RTTIGccClassRecoverer extends RTTIClassRecoverer {
classStructureDataType, dataLen, dataOffset); classStructureDataType, dataLen, dataOffset);
if (recoveredClassDataStruct != null) { if (recoveredClassDataStruct != null) {
classStructureDataType = structUtils.addDataTypeToStructure(classStructureDataType, classStructureDataType = EditStructureUtils.addDataTypeToStructure(
classStructureDataType,
dataOffset, recoveredClassDataStruct, "data", monitor); dataOffset, recoveredClassDataStruct, "data", monitor);
} }
Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/RTTIWindowsClassRecoverer.java
+64 -53
View File
@@ -176,7 +176,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
figureOutClassDataMembers(recoveredClasses); figureOutClassDataMembers(recoveredClasses);
if (USE_SHORT_TEMPLATE_NAMES_IN_STRUCTURE_FIELDS) { if (USE_SHORT_TEMPLATE_NAMES_IN_STRUCTURE_FIELDS) {
extraUtils.createShortenedTemplateNamesForClasses(recoveredClasses); extendedFlatAPI.createShortenedTemplateNamesForClasses(recoveredClasses);
} }
createAndApplyClassStructures(recoveredClasses); createAndApplyClassStructures(recoveredClasses);
@@ -313,7 +313,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
continue; continue;
} }
Data data = extraUtils.getDataAt(symbol.getAddress()); Data data = extendedFlatAPI.getDataAt(symbol.getAddress());
if (data != null && if (data != null &&
data.getDataType().getName().contains(RTTI_BASE_COMPLETE_OBJECT_LOADER_DATA_NAME)) { data.getDataType().getName().contains(RTTI_BASE_COMPLETE_OBJECT_LOADER_DATA_NAME)) {
completeObjectLocatorSymbols.add(symbol); completeObjectLocatorSymbols.add(symbol);
@@ -352,7 +352,8 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
int sizeOfDt = completeObjLocatorDataType.getLength(); int sizeOfDt = completeObjLocatorDataType.getLength();
api.clearListing(address, address.add(sizeOfDt)); api.clearListing(address, address.add(sizeOfDt));
Data completeObjectLocator = extraUtils.createData(address, completeObjLocatorDataType); Data completeObjectLocator =
extendedFlatAPI.createData(address, completeObjLocatorDataType);
if (completeObjectLocator == null) { if (completeObjectLocator == null) {
return null; return null;
} }
@@ -379,7 +380,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
continue; continue;
} }
Data data = extraUtils.getDataAt(symbol.getAddress()); Data data = extendedFlatAPI.getDataAt(symbol.getAddress());
if (data != null && if (data != null &&
data.getDataType().getName().contains(RTTI_BASE_CLASS_DESCRIPTOR_DATA_NAME)) { data.getDataType().getName().contains(RTTI_BASE_CLASS_DESCRIPTOR_DATA_NAME)) {
baseClassDescriptorSymbols.add(symbol); baseClassDescriptorSymbols.add(symbol);
@@ -417,7 +418,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
api.clearListing(baseClassDescriptorAddress, baseClassDescriptorAddress.add(sizeOfDt)); api.clearListing(baseClassDescriptorAddress, baseClassDescriptorAddress.add(sizeOfDt));
Data baseClassDescArray = Data baseClassDescArray =
extraUtils.createData(baseClassDescriptorAddress, baseClassDescriptor); extendedFlatAPI.createData(baseClassDescriptorAddress, baseClassDescriptor);
if (baseClassDescArray == null) { if (baseClassDescArray == null) {
return null; return null;
} }
@@ -441,19 +442,19 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
for (int i = 0; i < numBaseClasses; i++) { for (int i = 0; i < numBaseClasses; i++) {
monitor.checkCanceled(); monitor.checkCanceled();
//TODO: extraUtils.getReferencedAddress(address, getIboIf64bit); //TODO: extendedFlatAPI.getReferencedAddress(address, getIboIf64bit);
Address baseClassDescriptorAddress = getReferencedAddress(address.add(i * 4)); Address baseClassDescriptorAddress = getReferencedAddress(address.add(i * 4));
Data baseClassDescriptor = extraUtils.getDataAt(baseClassDescriptorAddress); Data baseClassDescriptor = extendedFlatAPI.getDataAt(baseClassDescriptorAddress);
if (baseClassDescriptor == null || !baseClassDescriptor.getDataType() if (baseClassDescriptor == null || !baseClassDescriptor.getDataType()
.getName() .getName()
.equals( .equals(
RTTI_BASE_CLASS_DESCRIPTOR_DATA_NAME)) { RTTI_BASE_CLASS_DESCRIPTOR_DATA_NAME)) {
int num1 = extraUtils.getInt(baseClassDescriptorAddress.add(8)); int num1 = extendedFlatAPI.getInt(baseClassDescriptorAddress.add(8));
int num2 = extraUtils.getInt(baseClassDescriptorAddress.add(12)); int num2 = extendedFlatAPI.getInt(baseClassDescriptorAddress.add(12));
int num3 = extraUtils.getInt(baseClassDescriptorAddress.add(16)); int num3 = extendedFlatAPI.getInt(baseClassDescriptorAddress.add(16));
int num4 = extraUtils.getInt(baseClassDescriptorAddress.add(20)); int num4 = extendedFlatAPI.getInt(baseClassDescriptorAddress.add(20));
baseClassDescriptor = createBaseClassDescriptor(baseClassDescriptorAddress); baseClassDescriptor = createBaseClassDescriptor(baseClassDescriptorAddress);
if (baseClassDescriptor != null) { if (baseClassDescriptor != null) {
@@ -530,10 +531,10 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
private Address createClassHierarchyDescriptor(Address address, Namespace classNamespace) private Address createClassHierarchyDescriptor(Address address, Namespace classNamespace)
throws CancelledException, MemoryAccessException, InvalidInputException, Exception { throws CancelledException, MemoryAccessException, InvalidInputException, Exception {
//TODO: extraUtils.getReferencedAddress(address, getIboIf64bit); //TODO: extendedFlatAPI.getReferencedAddress(address, getIboIf64bit);
Address classHierarchyDescriptorAddress = getReferencedAddress(address); Address classHierarchyDescriptorAddress = getReferencedAddress(address);
Data classHierarchyStructure = extraUtils.getDataAt(classHierarchyDescriptorAddress); Data classHierarchyStructure = extendedFlatAPI.getDataAt(classHierarchyDescriptorAddress);
if (classHierarchyStructure != null && if (classHierarchyStructure != null &&
classHierarchyStructure.getDataType() classHierarchyStructure.getDataType()
@@ -578,7 +579,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
classHierarchyDescriptorAddress.add(sizeOfDt)); classHierarchyDescriptorAddress.add(sizeOfDt));
Data classHierarchyStructure = Data classHierarchyStructure =
extraUtils.createData(classHierarchyDescriptorAddress, classHDatatype); extendedFlatAPI.createData(classHierarchyDescriptorAddress, classHDatatype);
if (classHierarchyStructure == null) { if (classHierarchyStructure == null) {
return null; return null;
} }
@@ -611,13 +612,13 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
symbolTable.getPrimarySymbol(classHierarchyDescriptorAddress); symbolTable.getPrimarySymbol(classHierarchyDescriptorAddress);
Namespace classNamespace = classHierarchyDescriptorSymbol.getParentNamespace(); Namespace classNamespace = classHierarchyDescriptorSymbol.getParentNamespace();
int numBaseClasses = extraUtils.getInt(classHierarchyDescriptorAddress.add(8)); int numBaseClasses = extendedFlatAPI.getInt(classHierarchyDescriptorAddress.add(8));
//TODO: extraUtils.getReferencedAddress(address, getIboIf64bit); //TODO: extendedFlatAPI.getReferencedAddress(address, getIboIf64bit);
Address baseClassArrayAddress = Address baseClassArrayAddress =
getReferencedAddress(classHierarchyDescriptorAddress.add(12)); getReferencedAddress(classHierarchyDescriptorAddress.add(12));
Data baseClassDescArray = extraUtils.getDataAt(baseClassArrayAddress); Data baseClassDescArray = extendedFlatAPI.getDataAt(baseClassArrayAddress);
if (baseClassDescArray != null && baseClassDescArray.isArray()) { if (baseClassDescArray != null && baseClassDescArray.isArray()) {
baseClassArrayAddresses.add(baseClassArrayAddress); baseClassArrayAddresses.add(baseClassArrayAddress);
@@ -681,7 +682,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
api.clearListing(baseClassArrayAddress, api.clearListing(baseClassArrayAddress,
baseClassArrayAddress.add(numBaseClasses * sizeOfDt)); baseClassArrayAddress.add(numBaseClasses * sizeOfDt));
Data baseClassDescArray = Data baseClassDescArray =
extraUtils.createData(baseClassArrayAddress, baseClassDescArrayDT); extendedFlatAPI.createData(baseClassArrayAddress, baseClassDescArrayDT);
if (baseClassDescArray == null) { if (baseClassDescArray == null) {
return null; return null;
@@ -718,7 +719,8 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
continue; continue;
} }
Reference[] referencesTo = extraUtils.getReferencesTo(completeObjectLocatorAddress); Reference[] referencesTo =
extendedFlatAPI.getReferencesTo(completeObjectLocatorAddress);
if (referencesTo.length == 0) { if (referencesTo.length == 0) {
Msg.debug(this, "No refs to " + completeObjectLocatorAddress.toString()); Msg.debug(this, "No refs to " + completeObjectLocatorAddress.toString());
continue; continue;
@@ -802,7 +804,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
// this will work whether there is a created reference or not // this will work whether there is a created reference or not
int addressSize = address.getSize(); int addressSize = address.getSize();
if (addressSize == 32) { if (addressSize == 32) {
long offset = extraUtils.getInt(address); long offset = extendedFlatAPI.getInt(address);
return address.getNewAddress(offset); return address.getNewAddress(offset);
} }
@@ -810,7 +812,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
// this currently will workn only if there is a created reference // this currently will workn only if there is a created reference
// TODO: get ibo bytes and figure out what the ibo ref address would be // TODO: get ibo bytes and figure out what the ibo ref address would be
if (addressSize == 64) { if (addressSize == 64) {
Reference refs[] = extraUtils.getReferencesFrom(address); Reference refs[] = extendedFlatAPI.getReferencesFrom(address);
if (refs.length == 0) { if (refs.length == 0) {
return null; return null;
} }
@@ -853,7 +855,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
findVftableReferencesNotInFunction(vftableSymbols); findVftableReferencesNotInFunction(vftableSymbols);
if (unusedVftableReferences.size() > 0) { if (unusedVftableReferences.size() > 0) {
extraUtils.createUndefinedFunctions(unusedVftableReferences); extendedFlatAPI.createUndefinedFunctions(unusedVftableReferences);
} }
// create these automatically if found // create these automatically if found
@@ -915,7 +917,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
// Create Data Type Manager Category for given class // Create Data Type Manager Category for given class
// TODO: make this global and check it for null // TODO: make this global and check it for null
CategoryPath classPath = CategoryPath classPath =
extraUtils.createDataTypeCategoryPath(classDataTypesCategoryPath, extendedFlatAPI.createDataTypeCategoryPath(classDataTypesCategoryPath,
classNameWithNamespace); classNameWithNamespace);
RecoveredClass nonVftableClass = RecoveredClass nonVftableClass =
@@ -960,7 +962,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
*/ */
private List<Symbol> getListOfClassHierarchyDescriptors() throws CancelledException { private List<Symbol> getListOfClassHierarchyDescriptors() throws CancelledException {
List<Symbol> classHierarchyDescriptorList = extraUtils.getListOfSymbolsInAddressSet( List<Symbol> classHierarchyDescriptorList = extendedFlatAPI.getListOfSymbolsInAddressSet(
getInitializedMemory(), RTTI_CLASS_HIERARCHY_DESCRIPTOR_LABEL, false); getInitializedMemory(), RTTI_CLASS_HIERARCHY_DESCRIPTOR_LABEL, false);
return classHierarchyDescriptorList; return classHierarchyDescriptorList;
@@ -989,13 +991,13 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
Address vftableAddress = vftableIterator.next(); Address vftableAddress = vftableIterator.next();
Address ptrToColAddress = vftableAddress.subtract(defaultPointerSize); Address ptrToColAddress = vftableAddress.subtract(defaultPointerSize);
Data pointerToCompleteObjLocator = extraUtils.getDataAt(vftableAddress); Data pointerToCompleteObjLocator = extendedFlatAPI.getDataAt(vftableAddress);
if (pointerToCompleteObjLocator == null) { if (pointerToCompleteObjLocator == null) {
pointerToCompleteObjLocator = pointerToCompleteObjLocator =
extraUtils.createData(ptrToColAddress, pointerDataType); extendedFlatAPI.createData(ptrToColAddress, pointerDataType);
} }
Address colAddress = extraUtils.getReferencedAddress(ptrToColAddress, false); Address colAddress = extendedFlatAPI.getReferencedAddress(ptrToColAddress, false);
if (colAddress == null) { if (colAddress == null) {
Msg.debug(this, recoveredClass.getName() + Msg.debug(this, recoveredClass.getName() +
@@ -1005,7 +1007,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
Address addressOfOffset = colAddress.add(4); Address addressOfOffset = colAddress.add(4);
int offset = extraUtils.getInt(addressOfOffset); int offset = extendedFlatAPI.getInt(addressOfOffset);
recoveredClass.addClassOffsetToVftableMapping(offset, vftableAddress); recoveredClass.addClassOffsetToVftableMapping(offset, vftableAddress);
} }
@@ -1150,7 +1152,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
List<RecoveredClass> classHierarchy = new ArrayList<RecoveredClass>(); List<RecoveredClass> classHierarchy = new ArrayList<RecoveredClass>();
List<Symbol> symbols = extraUtils.getListOfSymbolsByNameInNamespace( List<Symbol> symbols = extendedFlatAPI.getListOfSymbolsByNameInNamespace(
RTTI_BASE_CLASS_ARRAY_LABEL, RTTI_BASE_CLASS_ARRAY_LABEL,
recoveredClass.getClassNamespace(), false); recoveredClass.getClassNamespace(), false);
@@ -1167,7 +1169,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
Address pointerAddress = rttiBaseClassDescriptorArray.getComponent(i).getAddress(); Address pointerAddress = rttiBaseClassDescriptorArray.getComponent(i).getAddress();
Address baseClassDescriptorAddress = Address baseClassDescriptorAddress =
extraUtils.getSingleReferencedAddress(pointerAddress); extendedFlatAPI.getSingleReferencedAddress(pointerAddress);
if (baseClassDescriptorAddress == null) { if (baseClassDescriptorAddress == null) {
return classHierarchy; return classHierarchy;
@@ -1218,11 +1220,11 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
private int getClassInheritanceFlag(Namespace classNamespace) private int getClassInheritanceFlag(Namespace classNamespace)
throws CancelledException, MemoryAccessException, AddressOutOfBoundsException { throws CancelledException, MemoryAccessException, AddressOutOfBoundsException {
List<Symbol> symbols = extraUtils.getListOfSymbolsByNameInNamespace( List<Symbol> symbols = extendedFlatAPI.getListOfSymbolsByNameInNamespace(
RTTI_CLASS_HIERARCHY_DESCRIPTOR_LABEL, classNamespace, false); RTTI_CLASS_HIERARCHY_DESCRIPTOR_LABEL, classNamespace, false);
if (symbols.size() >= 1) { if (symbols.size() >= 1) {
return (extraUtils.getInt(symbols.get(0).getAddress().add(4))); return (extendedFlatAPI.getInt(symbols.get(0).getAddress().add(4)));
} }
return NONE; return NONE;
@@ -1353,7 +1355,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
// iterate over base class array and for each parent class of the given recovered class // iterate over base class array and for each parent class of the given recovered class
// get the mdisp, pdisp, vdisp info // get the mdisp, pdisp, vdisp info
List<Symbol> baseClassArray = extraUtils.getListOfSymbolsByNameInNamespace( List<Symbol> baseClassArray = extendedFlatAPI.getListOfSymbolsByNameInNamespace(
RTTI_BASE_CLASS_ARRAY_LABEL, recoveredClass.getClassNamespace(), false); RTTI_BASE_CLASS_ARRAY_LABEL, recoveredClass.getClassNamespace(), false);
// this should never happen // this should never happen
@@ -1386,7 +1388,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
Address pointerAddress = baseClassArrayData.getComponent(i).getAddress(); Address pointerAddress = baseClassArrayData.getComponent(i).getAddress();
Address baseClassDescriptorAddress = Address baseClassDescriptorAddress =
extraUtils.getReferencedAddress(pointerAddress, true); extendedFlatAPI.getReferencedAddress(pointerAddress, true);
if (baseClassArrayAddress == null) { if (baseClassArrayAddress == null) {
continue; continue;
} }
@@ -1591,7 +1593,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
getTargetAddressFromPcodeOp(offsetPcodeOpPair.getPcodeOp()); getTargetAddressFromPcodeOp(offsetPcodeOpPair.getPcodeOp());
Address vbtableAddress = Address vbtableAddress =
extraUtils.getSingleReferencedAddress(listingAddress); extendedFlatAPI.getSingleReferencedAddress(listingAddress);
if (vbtableAddress == null) { if (vbtableAddress == null) {
continue; continue;
@@ -1950,7 +1952,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
if (possibleVftable == null) { if (possibleVftable == null) {
Function referencedFunction = Function referencedFunction =
extraUtils.getReferencedFunction(classReferenceAddress, true); extendedFlatAPI.getReferencedFunction(classReferenceAddress, true);
if (referencedFunction == null) { if (referencedFunction == null) {
continue; continue;
} }
@@ -2298,7 +2300,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
Address pointerAddress = baseClassArrayData.getComponent(i).getAddress(); Address pointerAddress = baseClassArrayData.getComponent(i).getAddress();
Address baseClassDescriptorAddress = Address baseClassDescriptorAddress =
extraUtils.getReferencedAddress(pointerAddress, true); extendedFlatAPI.getReferencedAddress(pointerAddress, true);
if (baseClassDescriptorAddress == null) { if (baseClassDescriptorAddress == null) {
continue; continue;
} }
@@ -2361,7 +2363,8 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
dataLength = baseClassStructure.getLength() - lengthOfVirtualParent; dataLength = baseClassStructure.getLength() - lengthOfVirtualParent;
} }
if (structUtils.canAdd(classStructureDataType, baseClassOffset, dataLength, if (EditStructureUtils.canAdd(classStructureDataType, baseClassOffset,
dataLength,
monitor)) { monitor)) {
classStructureDataType = classStructureDataType =
addIndividualComponentsToStructure(classStructureDataType, addIndividualComponentsToStructure(classStructureDataType,
@@ -2371,10 +2374,11 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
} }
// else copy whole baseClass structure to the class Structure // else copy whole baseClass structure to the class Structure
if (structUtils.canAdd(classStructureDataType, baseClassOffset, if (EditStructureUtils.canAdd(classStructureDataType, baseClassOffset,
baseClassStructure.getLength(), monitor)) { baseClassStructure.getLength(), monitor)) {
classStructureDataType = classStructureDataType =
structUtils.addDataTypeToStructure(classStructureDataType, baseClassOffset, EditStructureUtils.addDataTypeToStructure(classStructureDataType,
baseClassOffset,
baseClassStructure, baseClassStructure.getName(), monitor); baseClassStructure, baseClassStructure.getName(), monitor);
} }
@@ -2390,11 +2394,12 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
baseClassOffset = api.getInt(recoveredClass.getVbtableAddress().add(vdisp)) + pdisp; baseClassOffset = api.getInt(recoveredClass.getVbtableAddress().add(vdisp)) + pdisp;
if (structUtils.canAdd(classStructureDataType, baseClassOffset, if (EditStructureUtils.canAdd(classStructureDataType, baseClassOffset,
baseClassStructure.getLength(), monitor)) { baseClassStructure.getLength(), monitor)) {
classStructureDataType = classStructureDataType =
structUtils.addDataTypeToStructure(classStructureDataType, baseClassOffset, EditStructureUtils.addDataTypeToStructure(classStructureDataType,
baseClassOffset,
baseClassStructure, baseClassStructure.getName(), monitor); baseClassStructure, baseClassStructure.getName(), monitor);
} }
@@ -2422,9 +2427,10 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
DataType classVftablePointer = vfPointerDataTypes.get(vftableAddress); DataType classVftablePointer = vfPointerDataTypes.get(vftableAddress);
if (structUtils.canAdd(classStructureDataType, offset.intValue(), if (EditStructureUtils.canAdd(classStructureDataType, offset.intValue(),
classVftablePointer.getLength(), monitor)) { classVftablePointer.getLength(), monitor)) {
classStructureDataType = structUtils.addDataTypeToStructure(classStructureDataType, classStructureDataType = EditStructureUtils.addDataTypeToStructure(
classStructureDataType,
offset.intValue(), classVftablePointer, CLASS_VTABLE_PTR_FIELD_EXT, monitor); offset.intValue(), classVftablePointer, CLASS_VTABLE_PTR_FIELD_EXT, monitor);
} }
@@ -2440,7 +2446,8 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
int dataOffset = getDataOffset(recoveredClass, classStructureDataType); int dataOffset = getDataOffset(recoveredClass, classStructureDataType);
int dataLen = UNKNOWN; int dataLen = UNKNOWN;
if (dataOffset != NONE) { if (dataOffset != NONE) {
dataLen = structUtils.getNumberOfUndefinedsStartingAtOffset(classStructureDataType, dataLen =
EditStructureUtils.getNumberOfUndefinedsStartingAtOffset(classStructureDataType,
dataOffset, monitor); dataOffset, monitor);
} }
@@ -2450,7 +2457,8 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
classStructureDataType, dataLen, dataOffset); classStructureDataType, dataLen, dataOffset);
if (recoveredClassDataStruct != null) { if (recoveredClassDataStruct != null) {
classStructureDataType = structUtils.addDataTypeToStructure(classStructureDataType, classStructureDataType =
EditStructureUtils.addDataTypeToStructure(classStructureDataType,
dataOffset, recoveredClassDataStruct, dataOffset, recoveredClassDataStruct,
classStructureDataType.getName() + "_data", monitor); classStructureDataType.getName() + "_data", monitor);
} }
@@ -2517,11 +2525,12 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
monitor.checkCanceled(); monitor.checkCanceled();
// if enough empty bytes - add class vftable pointer // if enough empty bytes - add class vftable pointer
if (structUtils.canAdd(classStructureDataType, vftableOffset, if (EditStructureUtils.canAdd(classStructureDataType, vftableOffset,
classVftablePointer.getLength(), monitor)) { classVftablePointer.getLength(), monitor)) {
classStructureDataType = classStructureDataType =
structUtils.addDataTypeToStructure(classStructureDataType, vftableOffset, EditStructureUtils.addDataTypeToStructure(classStructureDataType,
vftableOffset,
classVftablePointer, CLASS_VTABLE_PTR_FIELD_EXT, monitor); classVftablePointer, CLASS_VTABLE_PTR_FIELD_EXT, monitor);
addedVftablePointer = true; addedVftablePointer = true;
@@ -2638,7 +2647,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
return false; return false;
} }
int numUndefined1s = int numUndefined1s =
structUtils.getNumberOfUndefinedsStartingAtOffset(structure, 0, monitor); EditStructureUtils.getNumberOfUndefinedsStartingAtOffset(structure, 0, monitor);
if (structure.getLength() == numUndefined1s) { if (structure.getLength() == numUndefined1s) {
return true; return true;
} }
@@ -2685,7 +2694,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
Address pointerAddress = baseClassArrayData.getComponent(i).getAddress(); Address pointerAddress = baseClassArrayData.getComponent(i).getAddress();
Address baseClassDescriptorAddress = Address baseClassDescriptorAddress =
extraUtils.getReferencedAddress(pointerAddress, true); extendedFlatAPI.getReferencedAddress(pointerAddress, true);
if (baseClassDescriptorAddress == null) { if (baseClassDescriptorAddress == null) {
continue; continue;
} }
@@ -2735,7 +2744,7 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
*/ */
private Data getBaseClassArray(RecoveredClass recoveredClass) throws CancelledException { private Data getBaseClassArray(RecoveredClass recoveredClass) throws CancelledException {
List<Symbol> baseClassArray = extraUtils.getListOfSymbolsByNameInNamespace( List<Symbol> baseClassArray = extendedFlatAPI.getListOfSymbolsByNameInNamespace(
RTTI_BASE_CLASS_ARRAY_LABEL, recoveredClass.getClassNamespace(), false); RTTI_BASE_CLASS_ARRAY_LABEL, recoveredClass.getClassNamespace(), false);
if (baseClassArray.size() != 1) { if (baseClassArray.size() != 1) {
@@ -2792,9 +2801,11 @@ public class RTTIWindowsClassRecoverer extends RTTIClassRecoverer {
DataType vbaseStructPointer = dataTypeManager.getPointer(vbtableStructure); DataType vbaseStructPointer = dataTypeManager.getPointer(vbtableStructure);
int dataLength = vbaseStructPointer.getLength(); int dataLength = vbaseStructPointer.getLength();
if (structUtils.canAdd(classStructureDataType, vbtableOffset, dataLength, monitor)) { if (EditStructureUtils.canAdd(classStructureDataType, vbtableOffset, dataLength,
monitor)) {
classStructureDataType = structUtils.addDataTypeToStructure(classStructureDataType, classStructureDataType =
EditStructureUtils.addDataTypeToStructure(classStructureDataType,
vbtableOffset, vbaseStructPointer, "vbtablePtr", monitor); vbtableOffset, vbaseStructPointer, "vbtablePtr", monitor);
} }
Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/RecoveredClass.java
+14 -14
View File
@@ -95,7 +95,6 @@ public class RecoveredClass {
private static final int NONE = -1; private static final int NONE = -1;
TaskMonitor monitor = TaskMonitor.DUMMY; TaskMonitor monitor = TaskMonitor.DUMMY;
EditStructureUtils structUtils;
RecoveredClass(String name, CategoryPath classPath, Namespace classNamespace, RecoveredClass(String name, CategoryPath classPath, Namespace classNamespace,
@@ -105,7 +104,6 @@ public class RecoveredClass {
this.classNamespace = classNamespace; this.classNamespace = classNamespace;
this.dataTypeManager = dataTypeManager; this.dataTypeManager = dataTypeManager;
this.structUtils = new EditStructureUtils();
} }
public String getName() { public String getName() {
@@ -531,11 +529,11 @@ public class RecoveredClass {
// if the new component is a non-empty structure, check to see if the current // if the new component is a non-empty structure, check to see if the current
// structure has undefined or equivalent components and replace with new struct if so // structure has undefined or equivalent components and replace with new struct if so
if (newComponentDataType instanceof Structure) { if (newComponentDataType instanceof Structure) {
if (structUtils.hasReplaceableComponentsAtOffset(computedClassStructure, if (EditStructureUtils.hasReplaceableComponentsAtOffset(computedClassStructure,
offset, (Structure) newComponentDataType, monitor)) { offset, (Structure) newComponentDataType, monitor)) {
boolean successfulClear = boolean successfulClear =
structUtils.clearLengthAtOffset(computedClassStructure, offset, EditStructureUtils.clearLengthAtOffset(computedClassStructure, offset,
length, monitor); length, monitor);
if (successfulClear) { if (successfulClear) {
@@ -547,13 +545,14 @@ public class RecoveredClass {
} }
// if current component is undefined size 1 and new component is not undefined size 1 // if current component is undefined size 1 and new component is not undefined size 1
// then replace it // and there are enough undefineds for it to fit, then replace it
if (structUtils.isUndefined1(currentComponentDataType) && if (EditStructureUtils.isUndefined1(currentComponentDataType) &&
!structUtils.isUndefined1(newComponentDataType)) { !EditStructureUtils.isUndefined1(newComponentDataType)) {
if (structUtils.hasEnoughUndefinedsOfAnyLengthAtOffset(computedClassStructure, if (EditStructureUtils.hasEnoughUndefinedsOfAnyLengthAtOffset(
computedClassStructure,
offset, length, monitor)) { offset, length, monitor)) {
boolean successfulClear = boolean successfulClear =
structUtils.clearLengthAtOffset(computedClassStructure, offset, EditStructureUtils.clearLengthAtOffset(computedClassStructure, offset,
length, monitor); length, monitor);
if (successfulClear) { if (successfulClear) {
@@ -567,13 +566,14 @@ public class RecoveredClass {
// if new component is not an undefined data type and the current componenent(s) // if new component is not an undefined data type and the current componenent(s)
// that make up new component length are all undefineds then clear and replace // that make up new component length are all undefineds then clear and replace
// the current component(s) with the new one // the current component(s) with the new one
if (structUtils.isUndefined(currentComponentDataType) && if (Undefined.isUndefined(currentComponentDataType) &&
!structUtils.isUndefined(newComponentDataType)) { !Undefined.isUndefined(newComponentDataType)) {
if (structUtils.hasEnoughUndefinedsOfAnyLengthAtOffset(computedClassStructure, if (EditStructureUtils.hasEnoughUndefinedsOfAnyLengthAtOffset(
computedClassStructure,
offset, length, monitor)) { offset, length, monitor)) {
boolean successfulClear = boolean successfulClear =
structUtils.clearLengthAtOffset(computedClassStructure, offset, EditStructureUtils.clearLengthAtOffset(computedClassStructure, offset,
length, monitor); length, monitor);
if (successfulClear) { if (successfulClear) {
@@ -601,7 +601,7 @@ public class RecoveredClass {
continue; continue;
} }
if (structUtils.isUndefined1(dataType)) { if (EditStructureUtils.isUndefined1(dataType)) {
dataType = new Undefined1DataType(); dataType = new Undefined1DataType();
DataTypeComponent component = DataTypeComponent component =
computedClassStructure.getComponentAt(offset.intValue()); computedClassStructure.getComponentAt(offset.intValue());
Ghidra/Features/Decompiler/ghidra_scripts/classrecovery/RecoveredClassUtils.java
+75 -77
View File
File diff suppressed because it is too large Load Diff