Nixyri/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra.git synced 2024-10-23 21:50:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added GnuDemanglerFormat, changed analyzer options

Browse Source 
All available demangler formats have been added to GnuDemanglerFormat.
The options in GnuDemanglerAnalyzer now only reflect the available
formats to remove any user error when specifying a format. This also
prevents a format from being used on a demangler which doesn't support
it.
This commit is contained in:
astrelsky 2020-08-19 14:27:57 -04:00 committed by dragonmacher
parent ce78b860be
commit 0fcab24073
9 changed files with 454 additions and 365 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
Ghidra/Features/Base/src/main/help/help/topics/AutoAnalysisPlugin/AutoAnalysis.htm
View File

@ -388,32 +388,15 @@
that Ghidra contains (<B>version 2.33.1</B> as of this writing). Turning this that Ghidra contains (<B>version 2.33.1</B> as of this writing). Turning this
option on will also invoke the now deprecated previous version of the demangler option on will also invoke the now deprecated previous version of the demangler
(<B>version 2.24</B>) if the preferred demangler cannot demangle a given symbol. (<B>version 2.24</B>) if the preferred demangler cannot demangle a given symbol.
This option only has an effect when the demangler format is available in both
the deprecated and modern demanglers.
</P> </P>
<P> <P>
Support for older demangling styles was removed in <CODE>c++filt (v2.32)</CODE>. Support for older demangling styles was removed in <CODE>c++filt (v2.32)</CODE>.
Specifically, the following formats are no longer supported: Specifically, the following formats are no longer supported:
<CODE>Lucid, ARM, HP, and EDG</CODE>. To use these formats, you must enable <CODE>Lucid, ARM, HP, GNU, and EDG</CODE>. For these formats, the deprecated
usage of the deprecated demangler, which is <B>version 2.24</B>. Further, you demangler, which is <B>version 2.24</B>, will automatically be used.
may have to pass the required external demangler options using the Ghidra
option below.
</P> </P>
<P>
<U><B>Use External Demangler Options</B></U> -
This allows users to pass settings to the demangler. As an example, you can enter
in this Ghidra option text field the following text to use the <CODE>rust</CODE>
format: <CODE>-s rust</CODE>. This is not needed for
normal operation. To see a full list of supported options, query each demangler
directly using the <CODE>--help</CODE> switch.
</P>
<P>
The GNU demanglers can be found at:
<CODE CLASS="path">
&lt;GHIDRA_INSTALL_DIR&gt;/GPL/DemanglerGnu/build/os/&lt;OS&gt;/
</CODE><BR>
</P>
<BLOCKQUOTE> <BLOCKQUOTE>
<P> <P>

101
Ghidra/Features/GnuDemangler/src/main/java/ghidra/app/plugin/core/analysis/GnuDemanglerAnalyzer.java
View File

@ -15,10 +15,6 @@
*/ */
package ghidra.app.plugin.core.analysis; package ghidra.app.plugin.core.analysis;
import java.io.IOException;
import org.apache.commons.lang3.StringUtils;
import ghidra.app.util.demangler.*; import ghidra.app.util.demangler.*;
import ghidra.app.util.demangler.gnu.*; import ghidra.app.util.demangler.gnu.*;
import ghidra.app.util.importer.MessageLog; import ghidra.app.util.importer.MessageLog;
@ -51,15 +47,14 @@ public class GnuDemanglerAnalyzer extends AbstractDemanglerAnalyzer {
"Signals to use the deprecated demangler when the modern demangler cannot demangle a " + "Signals to use the deprecated demangler when the modern demangler cannot demangle a " +
"given string"; "given string";
static final String OPTION_NAME_DEMANGLER_PARAMETERS = static final String OPTION_NAME_DEMANGLER_FORMAT = "Demangler Format";
"Use External Demangler Options"; private static final String OPTION_DESCRIPTION_DEMANGLER_FORMAT =
private static final String OPTION_DESCRIPTION_DEMANGLER_PARAMETERS = "The demangling format to use";
"Signals to use pass the given parameters to the demangler program";
private boolean doSignatureEnabled = true; private boolean doSignatureEnabled = true;
private boolean demangleOnlyKnownPatterns = false; private boolean demangleOnlyKnownPatterns = false;
private GnuDemanglerFormat demanglerFormat = GnuDemanglerFormat.AUTO;
private boolean useDeprecatedDemangler = false; private boolean useDeprecatedDemangler = false;
private String demanglerParameters = "";
private GnuDemangler demangler = new GnuDemangler(); private GnuDemangler demangler = new GnuDemangler();
@ -84,11 +79,11 @@ public class GnuDemanglerAnalyzer extends AbstractDemanglerAnalyzer {
help, help,
OPTION_DESCRIPTION_USE_KNOWN_PATTERNS); OPTION_DESCRIPTION_USE_KNOWN_PATTERNS);
options.registerOption(OPTION_NAME_DEMANGLER_FORMAT, demanglerFormat, help,
OPTION_DESCRIPTION_DEMANGLER_FORMAT);
options.registerOption(OPTION_NAME_USE_DEPRECATED_DEMANGLER, useDeprecatedDemangler, help, options.registerOption(OPTION_NAME_USE_DEPRECATED_DEMANGLER, useDeprecatedDemangler, help,
OPTION_DESCRIPTION_DEPRECATED_DEMANGLER); OPTION_DESCRIPTION_DEPRECATED_DEMANGLER);
options.registerOption(OPTION_NAME_DEMANGLER_PARAMETERS, demanglerParameters, help,
OPTION_DESCRIPTION_DEMANGLER_PARAMETERS);
} }
@Override @Override
@ -96,94 +91,28 @@ public class GnuDemanglerAnalyzer extends AbstractDemanglerAnalyzer {
doSignatureEnabled = options.getBoolean(OPTION_NAME_APPLY_SIGNATURE, doSignatureEnabled); doSignatureEnabled = options.getBoolean(OPTION_NAME_APPLY_SIGNATURE, doSignatureEnabled);
demangleOnlyKnownPatterns = demangleOnlyKnownPatterns =
options.getBoolean(OPTION_NAME_DEMANGLE_USE_KNOWN_PATTERNS, demangleOnlyKnownPatterns); options.getBoolean(OPTION_NAME_DEMANGLE_USE_KNOWN_PATTERNS, demangleOnlyKnownPatterns);
demanglerFormat = options.getEnum(OPTION_NAME_DEMANGLER_FORMAT, GnuDemanglerFormat.AUTO);
if (demanglerFormat.isDeprecatedFormat() && demanglerFormat.isModernFormat()) {
useDeprecatedDemangler = useDeprecatedDemangler =
options.getBoolean(OPTION_NAME_USE_DEPRECATED_DEMANGLER, useDeprecatedDemangler); options.getBoolean(OPTION_NAME_USE_DEPRECATED_DEMANGLER, useDeprecatedDemangler);
} else {
demanglerParameters = useDeprecatedDemangler = demanglerFormat.isDeprecatedFormat();
options.getString(OPTION_NAME_DEMANGLER_PARAMETERS, demanglerParameters); }
} }
@Override @Override
protected DemanglerOptions getOptions() { protected DemanglerOptions getOptions() {
GnuDemanglerOptions options = new GnuDemanglerOptions(); GnuDemanglerOptions options = new GnuDemanglerOptions(demanglerFormat, useDeprecatedDemangler);
options.setDoDisassembly(true); options.setDoDisassembly(true);
options.setApplySignature(doSignatureEnabled); options.setApplySignature(doSignatureEnabled);
options.setDemangleOnlyKnownPatterns(demangleOnlyKnownPatterns); options.setDemangleOnlyKnownPatterns(demangleOnlyKnownPatterns);
options.setDemanglerApplicationArguments(demanglerParameters);
return options; return options;
} }
@Override
protected boolean validateOptions(DemanglerOptions demanglerOtions, MessageLog log) {
GnuDemanglerOptions options = (GnuDemanglerOptions) demanglerOtions;
String applicationArguments = options.getDemanglerApplicationArguments();
if (StringUtils.isBlank(applicationArguments)) {
return true;
}
// Check that the supplied arguments will work with at least one of the requested
// demanglers. (Different versions of the GNU demangler support different arguments.)
String demanglerName = options.getDemanglerName();
try {
GnuDemanglerNativeProcess.getDemanglerNativeProcess(demanglerName,
applicationArguments);
return true;
}
catch (IOException e) {
log.appendMsg(getName(), "Invalid options for GNU dangler '" + demanglerName +
"': " + applicationArguments);
log.appendException(e);
}
if (useDeprecatedDemangler) {
// see if the options work in the deprecated demangler
GnuDemanglerOptions deprecatedOptions = options.withDeprecatedDemangler();
String deprecatedName = deprecatedOptions.getDemanglerName();
try {
GnuDemanglerNativeProcess.getDemanglerNativeProcess(deprecatedName,
applicationArguments);
return true;
}
catch (IOException e) {
log.appendMsg(getName(),
"Invalid options for GNU dangler '" + deprecatedName + "': " +
applicationArguments);
log.appendException(e);
}
}
return false;
}
@Override @Override
protected DemangledObject doDemangle(String mangled, DemanglerOptions demanglerOtions, protected DemangledObject doDemangle(String mangled, DemanglerOptions demanglerOtions,
MessageLog log) MessageLog log) throws DemangledException {
throws DemangledException { return demangler.demangle(mangled, (GnuDemanglerOptions) demanglerOtions);
GnuDemanglerOptions options = (GnuDemanglerOptions) demanglerOtions;
DemangledObject demangled = null;
try {
demangled = demangler.demangle(mangled, options);
}
catch (DemangledException e) {
if (!useDeprecatedDemangler) {
throw e; // let our parent handle this
}
}
if (demangled != null) {
return demangled;
}
if (useDeprecatedDemangler) {
GnuDemanglerOptions newOptions = options.withDeprecatedDemangler();
demangled = demangler.demangle(mangled, newOptions);
}
return demangled;
} }
} }

21
Ghidra/Features/GnuDemangler/src/main/java/ghidra/app/util/demangler/gnu/GnuDemangler.java
View File

@ -72,11 +72,11 @@ public class GnuDemangler implements Demangler {
public DemangledObject demangle(String mangled, DemanglerOptions demanglerOtions) public DemangledObject demangle(String mangled, DemanglerOptions demanglerOtions)
throws DemangledException { throws DemangledException {
if (skip(mangled, demanglerOtions)) { GnuDemanglerOptions options = getGnuOptions(demanglerOtions);
if (skip(mangled, options)) {
return null; return null;
} }
GnuDemanglerOptions options = getGnuOptions(demanglerOtions);
String originalMangled = mangled; String originalMangled = mangled;
String globalPrefix = null; String globalPrefix = null;
if (mangled.startsWith(GLOBAL_PREFIX)) { if (mangled.startsWith(GLOBAL_PREFIX)) {
@ -163,7 +163,7 @@ public class GnuDemangler implements Demangler {
applicationOptions); applicationOptions);
} }
private boolean skip(String mangled, DemanglerOptions options) { private boolean skip(String mangled, GnuDemanglerOptions options) {
// Ignore versioned symbols which are generally duplicated at the same address // Ignore versioned symbols which are generally duplicated at the same address
if (mangled.indexOf("@") > 0) { // do not demangle versioned symbols if (mangled.indexOf("@") > 0) { // do not demangle versioned symbols
@ -179,22 +179,29 @@ public class GnuDemangler implements Demangler {
return false; // let it go through return false; // let it go through
} }
// TODO provide some checks specific to the other formats
GnuDemanglerFormat format = options.getDemanglerFormat();
if (format == GnuDemanglerFormat.AUTO) {
return false;
}
if (format == GnuDemanglerFormat.GNUV3) {
// add to this list if we find any other known GNU start patterns // add to this list if we find any other known GNU start patterns
if (mangled.startsWith("_Z")) { if (mangled.startsWith("_Z")) {
return false; return false;
} }
else if (mangled.startsWith("__Z")) { if (mangled.startsWith("__Z")) {
return false; return false;
} }
else if (mangled.startsWith("h__")) { if (mangled.startsWith("h__")) {
return false; // not sure about this one return false; // not sure about this one
} }
else if (mangled.startsWith("?")) { if (mangled.startsWith("?")) {
return false; // not sure about this one return false; // not sure about this one
} }
else if (isGnu2Or3Pattern(mangled)) { if (isGnu2Or3Pattern(mangled)) {
return false; return false;
} }
}
return true; return true;
} }

80
Ghidra/Features/GnuDemangler/src/main/java/ghidra/app/util/demangler/gnu/GnuDemanglerFormat.java Normal file
View File

@ -0,0 +1,80 @@
/* ###
* 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 ghidra.app.util.demangler.gnu;
/**
* Enum representation of the available GnuDemangler formats
*/
public enum GnuDemanglerFormat {
// OLD: none,auto,gnu,lucid,arm,hp,edg,gnu-v3,java,gnat
// NEW: none,auto,gnu-v3,java,gnat,dlang,rust
/** Automatic mangling format detection */
AUTO("", 0),
/** GNUv2 mangling format */
GNU("gnu", -1),
/** lucid mangling format */
LUCID("lucid", -1),
/** arm mangling format */
ARM("arm", -1),
/** hp mangling format */
HP("hp", -1),
/** mangling format used by the Edison Design Group (EDG) compiler */
EDG("edg", -1),
/** GNUv3 mangling format */
GNUV3("gnu-v3", 0),
/** Java mangling format */
JAVA("java", 0),
/** GNAT Ada compiler mangling format */
GNAT("gnat", 0),
/** D mangling format */
DLANG("dlang", 1),
/** Rust mangling format */
RUST("rust", 1);
/** the format option string */
private final String format;
/** private sentinal. deprecated = -1, both = 0, new = 1 */
private final byte version;
private GnuDemanglerFormat(String format, int version) {
this.format = format;
this.version = (byte) version;
}
/**
* Checks if this format is available in the deprecated gnu demangler
* @return true if this format is available in the deprecated gnu demangler
*/
public boolean isDeprecatedFormat() {
return version <= 0;
}
/**
* Checks if this format is available in a modern version of the gnu demangler
* @return true if this format is available in a modern version of the gnu demangler.
*/
public boolean isModernFormat() {
return version >= 0;
}
/**
* Gets the format option to be passed to the demangler via the <code>-s</code> option
* @return the format option to be passed to the demangler
*/
public String getFormat() {
return format;
}
}

96
Ghidra/Features/GnuDemangler/src/main/java/ghidra/app/util/demangler/gnu/GnuDemanglerOptions.java
View File

@ -43,11 +43,27 @@ public class GnuDemanglerOptions extends DemanglerOptions {
*/ */
public static final String GNU_DEMANGLER_DEFAULT = GNU_DEMANGLER_V2_33_1; public static final String GNU_DEMANGLER_DEFAULT = GNU_DEMANGLER_V2_33_1;
private String demanglerName = GNU_DEMANGLER_DEFAULT; private final GnuDemanglerFormat format;
private String demanglerApplicationArguments; private final boolean isDeprecated;
public GnuDemanglerOptions() { public GnuDemanglerOptions() {
// use default values // use default values
this(GnuDemanglerFormat.AUTO);
}
public GnuDemanglerOptions(GnuDemanglerFormat format) {
this.format = format;
// default to the "new" demangler if the format is available in both
this.isDeprecated = !format.isModernFormat();
}
public GnuDemanglerOptions(GnuDemanglerFormat format, boolean deprecated) {
this.format = format;
this.isDeprecated = deprecated;
if (!isValidFormat(format, deprecated)) {
throw new IllegalArgumentException(
format.name() + " is not available in the "+getDemanglerName());
}
} }
public GnuDemanglerOptions(DemanglerOptions copy) { public GnuDemanglerOptions(DemanglerOptions copy) {
@ -55,26 +71,59 @@ public class GnuDemanglerOptions extends DemanglerOptions {
if (copy instanceof GnuDemanglerOptions) { if (copy instanceof GnuDemanglerOptions) {
GnuDemanglerOptions gCopy = (GnuDemanglerOptions) copy; GnuDemanglerOptions gCopy = (GnuDemanglerOptions) copy;
demanglerName = gCopy.demanglerName; format = gCopy.format;
demanglerApplicationArguments = gCopy.demanglerApplicationArguments; isDeprecated = gCopy.isDeprecated;
} else {
format = GnuDemanglerFormat.AUTO;
isDeprecated = false;
} }
} }
private GnuDemanglerOptions(GnuDemanglerOptions copy, GnuDemanglerFormat format,
boolean deprecated) {
super(copy);
this.format = format;
this.isDeprecated = deprecated;
}
/** /**
* Returns the external demangler executable name to be used for demangling. The * Returns the external demangler executable name to be used for demangling. The
* default value is {@link #GNU_DEMANGLER_DEFAULT}. * default value is {@link #GNU_DEMANGLER_DEFAULT}.
* @return the name * @return the name
*/ */
public String getDemanglerName() { public String getDemanglerName() {
return demanglerName; return isDeprecated ? GNU_DEMANGLER_V2_24 : GNU_DEMANGLER_V2_33_1;
} }
/** /**
* Sets the external demangler executable name to be used for demangling * A convenience method to copy the state of this options object, changing the
* @param name the name * demangler executable name and demangler format to the specified values.
* @param format the demangling format to use
* @param isDeprecated true to use the deprecated gnu demangler, else false
* @return the new options
* @throws IllegalArgumentException if the current format is not available in the
* selected demangler.
*/ */
public void setDemanglerName(String name) { public GnuDemanglerOptions withDemanglerFormat(GnuDemanglerFormat format, boolean isDeprecated)
this.demanglerName = name; throws IllegalArgumentException {
if (this.format == format && this.isDeprecated == isDeprecated) {
return this;
}
if (isValidFormat(format, isDeprecated)) {
return new GnuDemanglerOptions(this, format, isDeprecated);
}
throw new IllegalArgumentException(
format.name() + " is not available in the "+getDemanglerName());
}
private static boolean isValidFormat(GnuDemanglerFormat format, boolean isDeprecated) {
if (isDeprecated && format.isDeprecatedFormat()) {
return true;
}
if (!isDeprecated && format.isModernFormat()) {
return true;
}
return false;
} }
/** /**
@ -82,26 +131,19 @@ public class GnuDemanglerOptions extends DemanglerOptions {
* @return the arguments * @return the arguments
*/ */
public String getDemanglerApplicationArguments() { public String getDemanglerApplicationArguments() {
return demanglerApplicationArguments; if (format == GnuDemanglerFormat.AUTO) {
// no format argument
return "";
}
return "-s " + format.getFormat();
} }
/** /**
* Sets the arguments to be passed to the external demangler executable * Gets the current demangler format
* @param args the arguments * @return the demangler format
*/ */
public void setDemanglerApplicationArguments(String args) { public GnuDemanglerFormat getDemanglerFormat() {
this.demanglerApplicationArguments = args; return format;
}
/**
* A convenience method to copy the state of this options object, changing the
* demangler executable name to the deprecated demangler
* @return the new options
*/
public GnuDemanglerOptions withDeprecatedDemangler() {
GnuDemanglerOptions newOptions = new GnuDemanglerOptions(this);
newOptions.setDemanglerName(GNU_DEMANGLER_V2_24);
return newOptions;
} }
@Override @Override
@ -111,8 +153,8 @@ public class GnuDemanglerOptions extends DemanglerOptions {
"\tdoDisassembly: " + doDisassembly() + ",\n" + "\tdoDisassembly: " + doDisassembly() + ",\n" +
"\tapplySignature: " + applySignature() + ",\n" + "\tapplySignature: " + applySignature() + ",\n" +
"\tdemangleOnlyKnownPatterns: " + demangleOnlyKnownPatterns() + ",\n" + "\tdemangleOnlyKnownPatterns: " + demangleOnlyKnownPatterns() + ",\n" +
"\tdemanglerName: " + demanglerName + ",\n" + "\tdemanglerName: " + getDemanglerName() + ",\n" +
"\tdemanglerApplicationArguments: " + demanglerApplicationArguments + ",\n" + "\tdemanglerApplicationArguments: " + getDemanglerApplicationArguments() + ",\n" +
"}"; "}";
//@formatter:on //@formatter:on
} }

8
Ghidra/Features/GnuDemangler/src/main/java/ghidra/app/util/demangler/gnu/GnuDemanglerParser.java
View File

@ -43,12 +43,8 @@ public class GnuDemanglerParser {
private static final String TYPEINFO_FOR = "typeinfo for "; private static final String TYPEINFO_FOR = "typeinfo for ";
private static final String COVARIANT_RETURN_THUNK = "covariant return thunk"; private static final String COVARIANT_RETURN_THUNK = "covariant return thunk";
private static final Set<String> ADDRESS_TABLE_PREFIXES = Set.of( private static final Set<String> ADDRESS_TABLE_PREFIXES =
CONSTRUCTION_VTABLE_FOR, Set.of(CONSTRUCTION_VTABLE_FOR, VTT_FOR, VTABLE_FOR, TYPEINFO_FN_FOR, TYPEINFO_FOR);
VTT_FOR,
VTABLE_FOR,
TYPEINFO_FN_FOR,
TYPEINFO_FOR);
private static final String OPERATOR = "operator"; private static final String OPERATOR = "operator";
private static final String LAMBDA = "lambda"; private static final String LAMBDA = "lambda";

128
Ghidra/Features/GnuDemangler/src/test/java/ghidra/app/plugin/core/analysis/GnuDemanglerAnalyzerTest.java
View File

@ -17,13 +17,11 @@ package ghidra.app.plugin.core.analysis;
import static org.junit.Assert.*; import static org.junit.Assert.*;
import java.util.Arrays;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import ghidra.app.cmd.label.AddLabelCmd; import ghidra.app.cmd.label.AddLabelCmd;
import ghidra.app.util.demangler.gnu.GnuDemanglerOptions; import ghidra.app.util.demangler.gnu.GnuDemanglerFormat;
import ghidra.app.util.importer.MessageLog; import ghidra.app.util.importer.MessageLog;
import ghidra.framework.options.Options; import ghidra.framework.options.Options;
import ghidra.program.database.ProgramBuilder; import ghidra.program.database.ProgramBuilder;
@ -34,7 +32,6 @@ import ghidra.program.model.symbol.*;
import ghidra.test.AbstractGhidraHeadlessIntegrationTest; import ghidra.test.AbstractGhidraHeadlessIntegrationTest;
import ghidra.test.ToyProgramBuilder; import ghidra.test.ToyProgramBuilder;
import ghidra.util.Msg; import ghidra.util.Msg;
import ghidra.util.StringUtilities;
import ghidra.util.task.TaskMonitor; import ghidra.util.task.TaskMonitor;
public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadlessIntegrationTest { public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadlessIntegrationTest {
@ -99,6 +96,7 @@ public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadlessIntegrationT
Address addr = addr("0x110"); Address addr = addr("0x110");
createSymbol(addr, mangled); createSymbol(addr, mangled);
setFormat(GnuDemanglerFormat.AUTO);
setOption(GnuDemanglerAnalyzer.OPTION_NAME_USE_DEPRECATED_DEMANGLER, true); setOption(GnuDemanglerAnalyzer.OPTION_NAME_USE_DEPRECATED_DEMANGLER, true);
analyze(); analyze();
@ -106,24 +104,6 @@ public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadlessIntegrationT
assertDemangled(addr, "__dt"); assertDemangled(addr, "__dt");
} }
@Test
public void testMangledString_WithArguments_Valid() {
//
// The below demangles to std::io::Read::read_to_end
//
String mangled = "_ZN3std2io4Read11read_to_end17hb85a0f6802e14499E";
Address addr = addr("0x110");
createSymbol(addr, mangled);
setOption(GnuDemanglerAnalyzer.OPTION_NAME_DEMANGLER_PARAMETERS, "-s rust");
analyze();
assertDemangled(addr, "read_to_end");
}
@Test @Test
public void testMangledString_WithArguments_ValidButWrongFormat() { public void testMangledString_WithArguments_ValidButWrongFormat() {
@ -135,7 +115,7 @@ public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadlessIntegrationT
Address addr = addr("0x110"); Address addr = addr("0x110");
createSymbol(addr, mangled); createSymbol(addr, mangled);
setOption(GnuDemanglerAnalyzer.OPTION_NAME_DEMANGLER_PARAMETERS, "-s dlang"); setFormat(GnuDemanglerFormat.DLANG);
analyze(); analyze();
@ -143,105 +123,36 @@ public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadlessIntegrationT
} }
@Test @Test
public void testMangledString_WithArguments_Invalid() { public void testUseDeprecatedOptionRemoval_WithDeprecatedFormat() {
setFormat(GnuDemanglerFormat.GNU);
// Options options = program.getOptions("Analyzers");
// The below demangles to std::io::Read::read_to_end assertFalse(options.contains(GnuDemanglerAnalyzer.OPTION_NAME_USE_DEPRECATED_DEMANGLER));
//
String mangled = "_ZN3std2io4Read11read_to_end17hb85a0f6802e14499E";
Address addr = addr("0x110");
createSymbol(addr, mangled);
setOption(GnuDemanglerAnalyzer.OPTION_NAME_DEMANGLER_PARAMETERS, "-s badformatname");
analyze();
assertNotDemangled(addr, "read_to_end");
assertMessageLogLine("java.io.IOException: Error starting demangler with command");
assertMessageLogLine("Invalid options", GnuDemanglerOptions.GNU_DEMANGLER_V2_33_1);
} }
@Test @Test
public void testDeprecatedMangledString_WithArguments_Invalid() { public void testUseDeprecatedOptionRemoval_WithRecentFormat() {
setFormat(GnuDemanglerFormat.RUST);
// Options options = program.getOptions("Analyzers");
// The below demangles to std::io::Read::read_to_end assertFalse(options.contains(GnuDemanglerAnalyzer.OPTION_NAME_USE_DEPRECATED_DEMANGLER));
//
String mangled = "_ZN3std2io4Read11read_to_end17hb85a0f6802e14499E";
Address addr = addr("0x110");
createSymbol(addr, mangled);
setOption(GnuDemanglerAnalyzer.OPTION_NAME_USE_DEPRECATED_DEMANGLER, true);
setOption(GnuDemanglerAnalyzer.OPTION_NAME_DEMANGLER_PARAMETERS, "-s badformatname");
analyze();
assertNotDemangled(addr, "read_to_end");
assertMessageLogLine("java.io.IOException: Error starting demangler with command");
assertMessageLogLine("Invalid options", GnuDemanglerOptions.GNU_DEMANGLER_V2_33_1);
assertMessageLogLine("Invalid options", GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
} }
@Test @Test
public void testDeprecatedMangledString_WithArguments_InvalidModernArguments_ValidDeprecatedArguments() { public void testUseDeprecatedOptionAddition() {
// remove it first
// testUseDeprecatedOptionRemoval_WithDeprecatedFormat();
// The below demangles to std::io::Read::read_to_end setFormat(GnuDemanglerFormat.AUTO);
// Options options = program.getOptions("Analyzers");
String mangled = "_ZN3std2io4Read11read_to_end17hb85a0f6802e14499E"; assertTrue(options.contains(GnuDemanglerAnalyzer.OPTION_NAME_USE_DEPRECATED_DEMANGLER));
Address addr = addr("0x110");
createSymbol(addr, mangled);
setOption(GnuDemanglerAnalyzer.OPTION_NAME_USE_DEPRECATED_DEMANGLER, true);
setOption(GnuDemanglerAnalyzer.OPTION_NAME_DEMANGLER_PARAMETERS, "-s arm");
analyze();
assertNotDemangled(addr, "read_to_end");
assertMessageLogLine("java.io.IOException: Error starting demangler with command");
assertMessageLogLine("Invalid options", GnuDemanglerOptions.GNU_DEMANGLER_V2_33_1);
assertMessageNotInLogLine("Invalid options", GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
} }
// things missed: // things missed:
// -demangle error case in base class...this is OK // -demangle error case in base class...this is OK
// -error case in applyTo method in base class // -error case in applyTo method in base class
// -use deprecated demangler case in validateOptions
//================================================================================================== //==================================================================================================
// Private Methods // Private Methods
//================================================================================================== //==================================================================================================
private void assertMessageLogLine(String... expected) {
String allMessages = log.toString();
String[] logLines = allMessages.split("\n");
for (String line : logLines) {
if (StringUtilities.containsAllIgnoreCase(line, expected)) {
return;
}
}
fail("The folllowing source text did not have a line containing:\n" +
Arrays.toString(expected) + "\n\nActual Text:\n" + allMessages);
}
private void assertMessageNotInLogLine(String... expected) {
String allMessages = log.toString();
String[] logLines = allMessages.split("\n");
for (String line : logLines) {
if (StringUtilities.containsAllIgnoreCase(line, expected)) {
fail("The folllowing source text unexpectedly has a line containing:\n" +
Arrays.toString(expected) + "\n\nActual Text:\n" + allMessages);
}
}
}
private void analyze() { private void analyze() {
tx(program, () -> analyzer.added(program, program.getMemory(), TaskMonitor.DUMMY, log)); tx(program, () -> analyzer.added(program, program.getMemory(), TaskMonitor.DUMMY, log));
} }
@ -288,14 +199,15 @@ public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadlessIntegrationT
fail("Could not find option '" + optionName + "'"); fail("Could not find option '" + optionName + "'");
} }
private void setOption(String optionName, String value) { private void setFormat(GnuDemanglerFormat format) {
String optionName = GnuDemanglerAnalyzer.OPTION_NAME_DEMANGLER_FORMAT;
String fullOptionName = analyzer.getName() + Options.DELIMITER_STRING + optionName; String fullOptionName = analyzer.getName() + Options.DELIMITER_STRING + optionName;
Options options = program.getOptions("Analyzers"); Options options = program.getOptions("Analyzers");
for (String name : options.getOptionNames()) { for (String name : options.getOptionNames()) {
if (name.equals(fullOptionName)) { if (name.equals(fullOptionName)) {
tx(program, () -> options.setString(optionName, value)); tx(program, () -> options.setEnum(optionName, format));
// we must call this manually, since we are not using a tool // we must call this manually, since we are not using a tool
analyzer.optionsChanged(options, program); analyzer.optionsChanged(options, program);

160
Ghidra/Features/GnuDemangler/src/test/java/ghidra/app/util/demangler/gnu/GnuDemanglerOptionsTest.java Normal file
View File

@ -0,0 +1,160 @@
/* ###
* 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 ghidra.app.util.demangler.gnu;
import ghidra.test.AbstractGhidraHeadlessIntegrationTest;
import org.junit.Test;
import static ghidra.app.util.demangler.gnu.GnuDemanglerFormat.*;
import java.io.IOException;
public class GnuDemanglerOptionsTest extends AbstractGhidraHeadlessIntegrationTest {
@Test
public void testAuto_withDeprecated() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(AUTO, true);
getNativeProcess(options);
}
@Test
public void testAuto_withModern() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(AUTO, false);
getNativeProcess(options);
}
@Test
public void testGnu_withDeprecated() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(GNU, true);
getNativeProcess(options);
}
@Test(expected = IllegalArgumentException.class)
public void testGnu_withModern() {
new GnuDemanglerOptions(GNU, false);
}
@Test
public void testLucid_withDeprecated() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(LUCID, true);
getNativeProcess(options);
}
@Test(expected = IllegalArgumentException.class)
public void testLucid_withModern() {
new GnuDemanglerOptions(LUCID, false);
}
@Test
public void testArm_withDeprecated() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(ARM, true);
getNativeProcess(options);
}
@Test(expected = IllegalArgumentException.class)
public void testArm_withModern() {
new GnuDemanglerOptions(ARM, false);
}
@Test
public void testHp_withDeprecated() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(HP, true);
getNativeProcess(options);
}
@Test(expected = IllegalArgumentException.class)
public void testHp_withModern() {
new GnuDemanglerOptions(HP, false);
}
@Test
public void testEdg_withDeprecated() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(EDG, true);
getNativeProcess(options);
}
@Test(expected = IllegalArgumentException.class)
public void testEdg_withModern() {
new GnuDemanglerOptions(EDG, false);
}
@Test
public void testGnuV3_withDeprecated() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(GNUV3, true);
getNativeProcess(options);
}
@Test
public void testGnuV3_withModern() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(GNUV3, false);
getNativeProcess(options);
}
@Test
public void testJava_withDeprecated() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(JAVA, true);
getNativeProcess(options);
}
@Test
public void testJava_withModern() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(JAVA, false);
getNativeProcess(options);
}
@Test
public void testGnat_withDeprecated() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(GNAT, true);
getNativeProcess(options);
}
@Test
public void testGnat_withModern() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(GNAT, false);
getNativeProcess(options);
}
@Test(expected = IllegalArgumentException.class)
public void testDlang_withDeprecated() {
new GnuDemanglerOptions(DLANG, true);
}
@Test
public void testDlang_withModern() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(DLANG, false);
getNativeProcess(options);
}
@Test(expected = IllegalArgumentException.class)
public void testRust_withDeprecated() {
new GnuDemanglerOptions(RUST, true);
}
@Test
public void testRust_withModern() throws IOException {
GnuDemanglerOptions options = new GnuDemanglerOptions(RUST, false);
getNativeProcess(options);
}
private static GnuDemanglerNativeProcess getNativeProcess(GnuDemanglerOptions options)
throws IOException {
String demanglerName = options.getDemanglerName();
String applicationOptions = options.getDemanglerApplicationArguments();
return GnuDemanglerNativeProcess.getDemanglerNativeProcess(demanglerName,
applicationOptions);
}
}

28
Ghidra/Features/GnuDemangler/src/test/java/ghidra/app/util/demangler/gnu/GnuDemanglerTest.java
View File

@ -157,23 +157,6 @@ public class GnuDemanglerTest extends AbstractGenericTest {
assertEquals("ABC", d.getValue()); assertEquals("ABC", d.getValue());
} }
@Test
public void testDemangler_Format_EDG_DemangleOnlyKnownPatterns_False()
throws DemangledException {
String mangled = "_$_10MyFunction";
GnuDemangler demangler = new GnuDemangler();
demangler.canDemangle(program);// this perform initialization
GnuDemanglerOptions options = new GnuDemanglerOptions();
options.setDemangleOnlyKnownPatterns(false);
options.setDemanglerName(GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
DemangledObject result = demangler.demangle(mangled, options);
assertNotNull(result);
assertEquals("undefined MyFunction::~MyFunction(void)", result.getSignature(false));
}
@Test @Test
public void testDemangler_Format_EDG_DemangleOnlyKnownPatterns_True() public void testDemangler_Format_EDG_DemangleOnlyKnownPatterns_True()
throws DemangledException { throws DemangledException {
@ -192,16 +175,15 @@ public class GnuDemanglerTest extends AbstractGenericTest {
GnuDemangler demangler = new GnuDemangler(); GnuDemangler demangler = new GnuDemangler();
demangler.canDemangle(program);// this perform initialization demangler.canDemangle(program);// this perform initialization
GnuDemanglerOptions options = new GnuDemanglerOptions(); GnuDemanglerOptions options = new GnuDemanglerOptions(GnuDemanglerFormat.EDG);
options.setDemangleOnlyKnownPatterns(true); // do not try
options.setDemanglerName(GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
DemangledObject result = demangler.demangle(mangled, options); DemangledObject result = demangler.demangle(mangled, options);
assertNull(result); assertNull(result);
} }
@Test @Test
public void testDemangler_Format_CodeWarrior_MacOS8or9() throws DemangledException { public void testDemangler_Format_CodeWarrior_MacOS8or9() throws DemangledException {
// NOTE: mangled CodeWarrior format symbols with templates will fail
// This is because the GNU demangler does not support CodeWarrior
// .scroll__10TTextPanelFUcsi // .scroll__10TTextPanelFUcsi
String mangled = ".scroll__10TTextPanelFUcsi"; String mangled = ".scroll__10TTextPanelFUcsi";
@ -209,9 +191,7 @@ public class GnuDemanglerTest extends AbstractGenericTest {
GnuDemangler demangler = new GnuDemangler(); GnuDemangler demangler = new GnuDemangler();
demangler.canDemangle(program);// this perform initialization demangler.canDemangle(program);// this perform initialization
GnuDemanglerOptions options = new GnuDemanglerOptions(); GnuDemanglerOptions options = new GnuDemanglerOptions(GnuDemanglerFormat.AUTO, true);
options.setDemangleOnlyKnownPatterns(false);
options.setDemanglerName(GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
DemangledObject result = demangler.demangle(mangled, options); DemangledObject result = demangler.demangle(mangled, options);
assertNotNull(result); assertNotNull(result);
assertEquals("undefined TTextPanel::scroll(unsigned char,short,int)", assertEquals("undefined TTextPanel::scroll(unsigned char,short,int)",