mirror of
https://github.com/NationalSecurityAgency/ghidra
synced 2024-10-13 05:33:02 +00:00
Convert java InjectPayload
This commit is contained in:
caheckman
parent
2d690404fe
commit
9c2ce9b395
|
|
@ -18,7 +18,8 @@ package ghidra.app.util.pcodeInject;
|
|||
import ghidra.javaclass.format.DescriptorDecoder;
|
||||
import ghidra.javaclass.format.JavaClassConstants;
|
||||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.program.model.data.*;
|
||||
import ghidra.program.model.data.DataType;
|
||||
import ghidra.program.model.data.DataTypeManager;
|
||||
|
||||
/**
|
||||
*
|
||||
|
|
@ -43,6 +44,7 @@ public class ArrayMethods {
|
|||
private ArrayMethods(){
|
||||
throw new AssertionError();
|
||||
}
|
||||
|
||||
/**
|
||||
* Emits pcode for the multianewarray op, which is used to create new multi-dimensional arrays
|
||||
* It is modeled with two black-box pcode ops: multianewarrayOp and multianewarrayProcessAdditionalDimensionsOp.
|
||||
|
|
@ -53,23 +55,22 @@ public class ArrayMethods {
|
|||
* are array dimensions. Additional array dimensions are consumed from the stack with calls to
|
||||
* multianewarrayProcessAdditionalDimensionsOp, which takes a reference returned by multianewarrayOp as its first argument
|
||||
* and a dimension as its second argument.
|
||||
* @param pCode is the pcode accumulator
|
||||
* @param constantPoolIndex
|
||||
* @param constantPool
|
||||
* @param dimensions
|
||||
* @return
|
||||
*/
|
||||
public static String getPcodeForMultiANewArray(int constantPoolIndex, AbstractConstantPoolInfoJava[] constantPool,
|
||||
public static void getPcodeForMultiANewArray(PcodeOpEmitter pCode, int constantPoolIndex,
|
||||
AbstractConstantPoolInfoJava[] constantPool,
|
||||
int dimensions) {
|
||||
StringBuilder pCode = new StringBuilder();
|
||||
|
||||
|
||||
//pop all of the dimensions off the stack
|
||||
for (int i = dimensions; i >= 1; --i){
|
||||
String iAsString = Integer.toString(i);
|
||||
PcodeTextEmitter.emitPopCat1Value(pCode, DIMENSION + iAsString);
|
||||
pCode.emitPopCat1Value(DIMENSION + iAsString);
|
||||
}
|
||||
|
||||
PcodeTextEmitter.emitAssignVarnodeFromPcodeOpCall(pCode, CLASS_NAME, 4, ConstantPoolJava.CPOOL_OP, "0", Integer.toString(constantPoolIndex),ConstantPoolJava.CPOOL_MULTIANEWARRAY);
|
||||
pCode.emitAssignVarnodeFromPcodeOpCall(CLASS_NAME, 4, ConstantPoolJava.CPOOL_OP, "0",
|
||||
Integer.toString(constantPoolIndex), ConstantPoolJava.CPOOL_MULTIANEWARRAY);
|
||||
|
||||
|
||||
//emit the call to multianewarrayOp
|
||||
|
|
@ -92,18 +93,18 @@ public class ArrayMethods {
|
|||
multianewarrayOpArgs[i] = DIMENSION + Integer.toString(i);
|
||||
}
|
||||
}
|
||||
PcodeTextEmitter.emitAssignVarnodeFromPcodeOpCall(pCode, ARRAY_REF, 4, MULTIANEWARRAY, CLASS_NAME,"dim1","dim2");
|
||||
pCode.emitAssignVarnodeFromPcodeOpCall(ARRAY_REF, 4, MULTIANEWARRAY, CLASS_NAME, "dim1",
|
||||
"dim2");
|
||||
|
||||
|
||||
|
||||
//consume any additional arguments
|
||||
for (int i = MAX_PCODE_OP_ARGS; i <= dimensions; ++i){
|
||||
String[] args = {ARRAY_REF, DIMENSION + Integer.toString(i)};
|
||||
PcodeTextEmitter.emitVoidPcodeOpCall(pCode, PROCESS_ADDITIONAL_DIMENSIONS, args);
|
||||
pCode.emitVoidPcodeOpCall(PROCESS_ADDITIONAL_DIMENSIONS, args);
|
||||
}
|
||||
|
||||
PcodeTextEmitter.emitPushCat1Value(pCode, ARRAY_REF);
|
||||
return pCode.toString();
|
||||
pCode.emitPushCat1Value(ARRAY_REF);
|
||||
}
|
||||
/**
|
||||
* The array type codes can be found in the JVM documentation for the
|
||||
|
|
|
|||
|
|
@ -19,20 +19,26 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
|||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.program.model.lang.InjectContext;
|
||||
import ghidra.program.model.listing.Program;
|
||||
import ghidra.program.model.pcode.PcodeOp;
|
||||
|
||||
public class InjectGetField extends InjectPayloadJava {
|
||||
|
||||
public InjectGetField(String sourceName, SleighLanguage language) {
|
||||
super(sourceName, language);
|
||||
public InjectGetField(String sourceName, SleighLanguage language, long uniqBase) {
|
||||
super(sourceName, language, uniqBase);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPcodeText(Program program, String context) {
|
||||
InjectContext injectContext = getInjectContext(program, context);
|
||||
public String getName() {
|
||||
return PcodeInjectLibraryJava.GETFIELD;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PcodeOp[] getPcode(Program program, InjectContext con) {
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset();
|
||||
String pcodeText = ReferenceMethods.getPcodeForGetField(constantPoolIndex, constantPool);
|
||||
return pcodeText;
|
||||
int constantPoolIndex = (int) con.inputlist.get(0).getOffset();
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase);
|
||||
ReferenceMethods.getPcodeForGetField(pCode, constantPoolIndex, constantPool);
|
||||
return pCode.getPcodeOps();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,20 +19,25 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
|||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.program.model.lang.InjectContext;
|
||||
import ghidra.program.model.listing.Program;
|
||||
import ghidra.program.model.pcode.PcodeOp;
|
||||
|
||||
public class InjectGetStatic extends InjectPayloadJava {
|
||||
|
||||
public InjectGetStatic(String sourceName, SleighLanguage language) {
|
||||
super(sourceName, language);
|
||||
public InjectGetStatic(String sourceName, SleighLanguage language, long uniqBase) {
|
||||
super(sourceName, language, uniqBase);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPcodeText(Program program, String context) {
|
||||
InjectContext injectContext = getInjectContext(program, context);
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset();
|
||||
String pcodeText = ReferenceMethods.getPcodeForGetStatic(constantPoolIndex, constantPool);
|
||||
return pcodeText;
|
||||
public String getName() {
|
||||
return PcodeInjectLibraryJava.GETSTATIC;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PcodeOp[] getPcode(Program program, InjectContext con) {
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) con.inputlist.get(0).getOffset();
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase);
|
||||
ReferenceMethods.getPcodeForGetStatic(pCode, constantPoolIndex, constantPool);
|
||||
return pCode.getPcodeOps();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,20 +19,25 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
|||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.program.model.lang.InjectContext;
|
||||
import ghidra.program.model.listing.Program;
|
||||
import ghidra.program.model.pcode.PcodeOp;
|
||||
|
||||
public class InjectInvokeDynamic extends InjectPayloadJava {
|
||||
|
||||
public InjectInvokeDynamic(String sourceName, SleighLanguage language) {
|
||||
super(sourceName, language);
|
||||
public InjectInvokeDynamic(String sourceName, SleighLanguage language, long uniqBase) {
|
||||
super(sourceName, language, uniqBase);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPcodeText(Program program, String context) {
|
||||
InjectContext injectContext = getInjectContext(program, context);
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset();
|
||||
String pcodeText = InvokeMethods.getPcodeForInvokeDynamic(constantPoolIndex, constantPool);
|
||||
return pcodeText;
|
||||
public String getName() {
|
||||
return PcodeInjectLibraryJava.INVOKE_DYNAMIC;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PcodeOp[] getPcode(Program program, InjectContext con) {
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) con.inputlist.get(0).getOffset();
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase);
|
||||
InvokeMethods.getPcodeForInvokeDynamic(pCode, constantPoolIndex, constantPool);
|
||||
return pCode.getPcodeOps();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,20 +19,26 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
|||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.program.model.lang.InjectContext;
|
||||
import ghidra.program.model.listing.Program;
|
||||
import ghidra.program.model.pcode.PcodeOp;
|
||||
|
||||
public class InjectInvokeInterface extends InjectPayloadJava {
|
||||
|
||||
public InjectInvokeInterface(String sourceName, SleighLanguage language) {
|
||||
super(sourceName, language);
|
||||
public InjectInvokeInterface(String sourceName, SleighLanguage language, long uniqBase) {
|
||||
super(sourceName, language, uniqBase);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPcodeText(Program program, String context) {
|
||||
InjectContext injectContext = getInjectContext(program, context);
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset();
|
||||
String pcodeText = InvokeMethods.getPcodeForInvoke(constantPoolIndex, constantPool, JavaInvocationType.INVOKE_INTERFACE);
|
||||
return pcodeText;
|
||||
public String getName() {
|
||||
return PcodeInjectLibraryJava.INVOKE_INTERFACE;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PcodeOp[] getPcode(Program program, InjectContext con) {
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) con.inputlist.get(0).getOffset();
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase);
|
||||
InvokeMethods.getPcodeForInvoke(pCode, constantPoolIndex, constantPool,
|
||||
JavaInvocationType.INVOKE_INTERFACE);
|
||||
return pCode.getPcodeOps();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,20 +19,26 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
|||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.program.model.lang.InjectContext;
|
||||
import ghidra.program.model.listing.Program;
|
||||
import ghidra.program.model.pcode.PcodeOp;
|
||||
|
||||
public class InjectInvokeSpecial extends InjectPayloadJava {
|
||||
|
||||
public InjectInvokeSpecial(String sourceName, SleighLanguage language) {
|
||||
super(sourceName, language);
|
||||
public InjectInvokeSpecial(String sourceName, SleighLanguage language, long uniqBase) {
|
||||
super(sourceName, language, uniqBase);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPcodeText(Program program, String context) {
|
||||
InjectContext injectContext = getInjectContext(program, context);
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset();
|
||||
String pcodeText = InvokeMethods.getPcodeForInvoke(constantPoolIndex, constantPool, JavaInvocationType.INVOKE_SPECIAL);
|
||||
return pcodeText;
|
||||
public String getName() {
|
||||
return PcodeInjectLibraryJava.INVOKE_SPECIAL;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PcodeOp[] getPcode(Program program, InjectContext con) {
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) con.inputlist.get(0).getOffset();
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase);
|
||||
InvokeMethods.getPcodeForInvoke(pCode, constantPoolIndex, constantPool,
|
||||
JavaInvocationType.INVOKE_SPECIAL);
|
||||
return pCode.getPcodeOps();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,20 +19,26 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
|||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.program.model.lang.InjectContext;
|
||||
import ghidra.program.model.listing.Program;
|
||||
import ghidra.program.model.pcode.PcodeOp;
|
||||
|
||||
public class InjectInvokeStatic extends InjectPayloadJava {
|
||||
|
||||
public InjectInvokeStatic(String sourceName, SleighLanguage language) {
|
||||
super(sourceName, language);
|
||||
public InjectInvokeStatic(String sourceName, SleighLanguage language, long uniqBase) {
|
||||
super(sourceName, language, uniqBase);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPcodeText(Program program, String context) {
|
||||
InjectContext injectContext = getInjectContext(program, context);
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset();
|
||||
String pcodeText = InvokeMethods.getPcodeForInvoke(constantPoolIndex, constantPool, JavaInvocationType.INVOKE_STATIC);
|
||||
return pcodeText;
|
||||
public String getName() {
|
||||
return PcodeInjectLibraryJava.INVOKE_STATIC;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PcodeOp[] getPcode(Program program, InjectContext con) {
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) con.inputlist.get(0).getOffset();
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase);
|
||||
InvokeMethods.getPcodeForInvoke(pCode, constantPoolIndex, constantPool,
|
||||
JavaInvocationType.INVOKE_STATIC);
|
||||
return pCode.getPcodeOps();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,20 +19,26 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
|||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.program.model.lang.InjectContext;
|
||||
import ghidra.program.model.listing.Program;
|
||||
import ghidra.program.model.pcode.PcodeOp;
|
||||
|
||||
public class InjectInvokeVirtual extends InjectPayloadJava {
|
||||
|
||||
public InjectInvokeVirtual(String sourceName, SleighLanguage language) {
|
||||
super(sourceName, language);
|
||||
public InjectInvokeVirtual(String sourceName, SleighLanguage language, long uniqBase) {
|
||||
super(sourceName, language, uniqBase);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPcodeText(Program program, String context) {
|
||||
InjectContext injectContext = getInjectContext(program, context);
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset();
|
||||
String pcodeText = InvokeMethods.getPcodeForInvoke(constantPoolIndex, constantPool, JavaInvocationType.INVOKE_VIRTUAL);
|
||||
return pcodeText;
|
||||
public String getName() {
|
||||
return PcodeInjectLibraryJava.INVOKE_VIRTUAL;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PcodeOp[] getPcode(Program program, InjectContext con) {
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) con.inputlist.get(0).getOffset();
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase);
|
||||
InvokeMethods.getPcodeForInvoke(pCode, constantPoolIndex, constantPool,
|
||||
JavaInvocationType.INVOKE_VIRTUAL);
|
||||
return pCode.getPcodeOps();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,20 +19,25 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
|||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.program.model.lang.InjectContext;
|
||||
import ghidra.program.model.listing.Program;
|
||||
import ghidra.program.model.pcode.PcodeOp;
|
||||
|
||||
public class InjectLdc extends InjectPayloadJava {
|
||||
|
||||
public InjectLdc(String sourceName, SleighLanguage language) {
|
||||
super(sourceName, language);
|
||||
public InjectLdc(String sourceName, SleighLanguage language, long uniqBase) {
|
||||
super(sourceName, language, uniqBase);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPcodeText(Program program, String context) {
|
||||
InjectContext injectContext = getInjectContext(program, context);
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset();
|
||||
String pcodeText = LdcMethods.getPcodeForLdc(constantPoolIndex, constantPool);
|
||||
return pcodeText;
|
||||
public String getName() {
|
||||
return PcodeInjectLibraryJava.LDC;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PcodeOp[] getPcode(Program program, InjectContext con) {
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) con.inputlist.get(0).getOffset();
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, constantPoolIndex, constantPool);
|
||||
return pCode.getPcodeOps();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,21 +19,26 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
|||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.program.model.lang.InjectContext;
|
||||
import ghidra.program.model.listing.Program;
|
||||
import ghidra.program.model.pcode.PcodeOp;
|
||||
|
||||
public class InjectMultiANewArray extends InjectPayloadJava {
|
||||
|
||||
public InjectMultiANewArray(String sourceName, SleighLanguage language) {
|
||||
super(sourceName, language);
|
||||
public InjectMultiANewArray(String sourceName, SleighLanguage language, long uniqBase) {
|
||||
super(sourceName, language, uniqBase);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPcodeText(Program program, String context) {
|
||||
InjectContext injectContext = getInjectContext(program, context);
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset();
|
||||
int dimensions = (int) injectContext.inputlist.get(1).getOffset();
|
||||
String pcodeText = ArrayMethods.getPcodeForMultiANewArray(constantPoolIndex, constantPool, dimensions);
|
||||
return pcodeText;
|
||||
public String getName() {
|
||||
return PcodeInjectLibraryJava.MULTIANEWARRAY;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PcodeOp[] getPcode(Program program, InjectContext con) {
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) con.inputlist.get(0).getOffset();
|
||||
int dimensions = (int) con.inputlist.get(1).getOffset();
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase);
|
||||
ArrayMethods.getPcodeForMultiANewArray(pCode, constantPoolIndex, constantPool, dimensions);
|
||||
return pCode.getPcodeOps();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,25 +17,12 @@ package ghidra.app.util.pcodeInject;
|
|||
|
||||
import java.io.IOException;
|
||||
|
||||
import javax.xml.parsers.SAXParser;
|
||||
import javax.xml.parsers.SAXParserFactory;
|
||||
|
||||
import org.xml.sax.*;
|
||||
|
||||
import ghidra.app.plugin.processors.sleigh.SleighException;
|
||||
import ghidra.app.plugin.processors.sleigh.PcodeEmit;
|
||||
import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
||||
import ghidra.app.plugin.processors.sleigh.template.ConstructTpl;
|
||||
import ghidra.app.plugin.processors.sleigh.template.OpTpl;
|
||||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.pcodeCPort.slgh_compile.PcodeParser;
|
||||
import ghidra.program.model.lang.*;
|
||||
import ghidra.program.model.lang.InjectContext;
|
||||
import ghidra.program.model.lang.InjectPayload;
|
||||
import ghidra.program.model.listing.Program;
|
||||
import ghidra.program.model.pcode.PcodeXMLException;
|
||||
import ghidra.sleigh.grammar.Location;
|
||||
import ghidra.util.Msg;
|
||||
import ghidra.util.xml.XmlUtilities;
|
||||
import ghidra.xml.XmlPullParser;
|
||||
import ghidra.xml.XmlPullParserFactory;
|
||||
|
||||
/**
|
||||
* Subclasses of this class are used to generate pcode to inject for modeling
|
||||
|
|
@ -43,51 +30,18 @@ import ghidra.xml.XmlPullParserFactory;
|
|||
*
|
||||
*/
|
||||
|
||||
public abstract class InjectPayloadJava extends InjectPayloadCallother {
|
||||
private SleighLanguage language;
|
||||
private SAXParser saxParser;
|
||||
public abstract class InjectPayloadJava implements InjectPayload {
|
||||
protected SleighLanguage language;
|
||||
protected long uniqueBase;
|
||||
private String sourceName;
|
||||
|
||||
/**
|
||||
* Subclasses use this method to generate pcode text for a particular java
|
||||
* bytecode op requiring pcode injection.
|
||||
*
|
||||
* @param program The program containing the op.
|
||||
* @param context The context associated with the op.
|
||||
* @return
|
||||
*/
|
||||
abstract String getPcodeText(Program program, String context);
|
||||
|
||||
public InjectPayloadJava(String sourceName, SleighLanguage language) {
|
||||
super(sourceName);
|
||||
public InjectPayloadJava(String sourceName, SleighLanguage language, long uniqBase) {
|
||||
this.language = language;
|
||||
try {
|
||||
saxParser = getSAXParser();
|
||||
}
|
||||
catch (PcodeXMLException e) {
|
||||
// TODO Auto-generated catch block
|
||||
e.printStackTrace();
|
||||
}
|
||||
this.sourceName = sourceName;
|
||||
this.uniqueBase = uniqBase;
|
||||
}
|
||||
|
||||
SleighLanguage getLanguage() {
|
||||
return language;
|
||||
}
|
||||
|
||||
InjectContext getInjectContext(Program program, String context) {
|
||||
InjectContext injectContext = new InjectContext();
|
||||
injectContext.language = language;
|
||||
try {
|
||||
injectContext.restoreXml(saxParser, context, program.getAddressFactory());
|
||||
saxParser.reset();
|
||||
}
|
||||
catch (PcodeXMLException e1) {
|
||||
Msg.info(this, e1.getMessage());
|
||||
e1.printStackTrace();
|
||||
}
|
||||
return injectContext;
|
||||
}
|
||||
|
||||
AbstractConstantPoolInfoJava[] getConstantPool(Program program) {
|
||||
protected static AbstractConstantPoolInfoJava[] getConstantPool(Program program) {
|
||||
ConstantPoolJava cPool = null;
|
||||
try {
|
||||
cPool = new ConstantPoolJava(program);
|
||||
|
|
@ -99,87 +53,38 @@ public abstract class InjectPayloadJava extends InjectPayloadCallother {
|
|||
return cPool.getConstantPool();
|
||||
}
|
||||
|
||||
//from DecompileCallback.java
|
||||
private static SAXParser getSAXParser() throws PcodeXMLException {
|
||||
try {
|
||||
SAXParserFactory saxParserFactory = XmlUtilities.createSecureSAXParserFactory(false);
|
||||
saxParserFactory.setFeature("http://xml.org/sax/features/namespaces", false);
|
||||
saxParserFactory.setFeature("http://xml.org/sax/features/validation", false);
|
||||
return saxParserFactory.newSAXParser();
|
||||
}
|
||||
catch (Exception e) {
|
||||
Msg.error(PcodeInjectLibraryJava.class, e.getMessage());
|
||||
throw new PcodeXMLException("Failed to instantiate XML parser", e);
|
||||
}
|
||||
@Override
|
||||
public int getType() {
|
||||
return InjectPayload.CALLOTHERFIXUP_TYPE;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method is used to generate and compile pcode for a given
|
||||
* callotherfixup.
|
||||
*
|
||||
* @param parser Used to parse pcode.
|
||||
* @param program The program containing the callotherfixup
|
||||
* @param context The context of the callotherfixup.
|
||||
* @return An array of OpTpl (for passing to
|
||||
* PcodeInjectLibrary.adjustUniqueBase)
|
||||
*/
|
||||
public OpTpl[] getPcode(PcodeParser parser, Program program, String context) {
|
||||
String sourceName = getSource();
|
||||
Location loc = new Location(sourceName, 1);
|
||||
@Override
|
||||
public String getSource() {
|
||||
return sourceName;
|
||||
}
|
||||
|
||||
InjectParameter[] input = getInput();
|
||||
for (InjectParameter element : input) {
|
||||
parser.addOperand(loc, element.getName(), element.getIndex());
|
||||
}
|
||||
InjectParameter[] output = getOutput();
|
||||
for (InjectParameter element : output) {
|
||||
parser.addOperand(loc, element.getName(), element.getIndex());
|
||||
}
|
||||
@Override
|
||||
public int getParamShift() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
String pcodeText = getPcodeText(program, context);
|
||||
String constructTplXml =
|
||||
PcodeParser.stringifyTemplate(parser.compilePcode(pcodeText, sourceName, 1));
|
||||
if (constructTplXml == null) {
|
||||
throw new SleighException("pcode compile failed " + sourceName);
|
||||
}
|
||||
final SAXParseException[] exception = new SAXParseException[1];
|
||||
XmlPullParser xmlParser = null;
|
||||
try {
|
||||
xmlParser =
|
||||
XmlPullParserFactory.create(constructTplXml, sourceName, new ErrorHandler() {
|
||||
@Override
|
||||
public void warning(SAXParseException e) throws SAXException {
|
||||
Msg.warn(this, e.getMessage());
|
||||
}
|
||||
@Override
|
||||
public void inject(InjectContext context, PcodeEmit emit) {
|
||||
// Not used
|
||||
}
|
||||
|
||||
@Override
|
||||
public void fatalError(SAXParseException e) throws SAXException {
|
||||
exception[0] = e;
|
||||
}
|
||||
@Override
|
||||
public boolean isFallThru() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void error(SAXParseException e) throws SAXException {
|
||||
exception[0] = e;
|
||||
}
|
||||
}, false);
|
||||
}
|
||||
catch (SAXException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
@Override
|
||||
public InjectParameter[] getInput() {
|
||||
return null;
|
||||
}
|
||||
|
||||
ConstructTpl constructTpl = new ConstructTpl();
|
||||
try {
|
||||
constructTpl.restoreXml(xmlParser, language.getAddressFactory());
|
||||
}
|
||||
catch (UnknownInstructionException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
if (exception[0] != null) {
|
||||
throw new SleighException("pcode compiler returned invalid xml " + sourceName,
|
||||
exception[0]);
|
||||
}
|
||||
OpTpl[] opTemplates = constructTpl.getOpVec();
|
||||
setTemplate(constructTpl);
|
||||
return opTemplates;
|
||||
@Override
|
||||
public InjectParameter[] getOutput() {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ import java.util.ArrayList;
|
|||
import java.util.List;
|
||||
|
||||
import ghidra.app.plugin.processors.sleigh.PcodeEmit;
|
||||
import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
||||
import ghidra.javaclass.format.*;
|
||||
import ghidra.javaclass.format.constantpool.ConstantPoolUtf8Info;
|
||||
import ghidra.program.model.address.Address;
|
||||
|
|
@ -35,10 +36,36 @@ public class InjectPayloadJavaParameters implements InjectPayload {
|
|||
|
||||
private InjectParameter[] noParams;
|
||||
private boolean analysisStateRecoverable;
|
||||
private AddressSpace constantSpace;
|
||||
private int paramSpaceID;
|
||||
private int lvaID;
|
||||
private Varnode temp4;
|
||||
private Varnode temp8;
|
||||
private Varnode zero;
|
||||
private Varnode four;
|
||||
private Varnode eight;
|
||||
private Varnode LVA;
|
||||
|
||||
public InjectPayloadJavaParameters() {
|
||||
public InjectPayloadJavaParameters(SleighLanguage language, long uniqBase) {
|
||||
noParams = new InjectParameter[0];
|
||||
analysisStateRecoverable = true;
|
||||
constantSpace = language.getAddressFactory().getConstantSpace();
|
||||
AddressSpace uniqueSpace = language.getAddressFactory().getUniqueSpace();
|
||||
Address temp4Address = uniqueSpace.getAddress(uniqBase);
|
||||
Address temp8Address = uniqueSpace.getAddress(uniqBase + 0x10);
|
||||
AddressSpace paramSpace = language.getAddressFactory().getAddressSpace("parameterSpace");
|
||||
paramSpaceID = paramSpace.getSpaceID();
|
||||
AddressSpace lva = language.getAddressFactory().getAddressSpace("localVariableArray");
|
||||
lvaID = lva.getSpaceID();
|
||||
//create temp storage locations
|
||||
temp4 = new Varnode(temp4Address, 4);
|
||||
temp8 = new Varnode(temp8Address, 8);
|
||||
//create varnodes for incrementing pointer by 4 or 8 bytes
|
||||
zero = new Varnode(constantSpace.getAddress(0), 4);
|
||||
four = new Varnode(constantSpace.getAddress(4), 4);
|
||||
eight = new Varnode(constantSpace.getAddress(8), 4);
|
||||
Address LVAregAddress = language.getRegister("LVA").getAddress();
|
||||
LVA = new Varnode(LVAregAddress, 4);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -110,34 +137,15 @@ public class InjectPayloadJavaParameters implements InjectPayload {
|
|||
return new PcodeOp[0];
|
||||
}
|
||||
|
||||
AddressSpace paramSpace = program.getAddressFactory().getAddressSpace("parameterSpace");
|
||||
int paramSpaceID = paramSpace.getSpaceID();
|
||||
AddressSpace lva = program.getAddressFactory().getAddressSpace("localVariableArray");
|
||||
int lvaID = lva.getSpaceID();
|
||||
AddressSpace constant = program.getAddressFactory().getConstantSpace();
|
||||
|
||||
PcodeOp[] resOps = new PcodeOp[1 + 3*numOps];
|
||||
int seqNum = 0;
|
||||
|
||||
//create varnodes for incrementing pointer by 4 or 8 bytes
|
||||
Varnode zero = new Varnode(constant.getAddress(0),4);
|
||||
Varnode four = new Varnode(constant.getAddress(4),4);
|
||||
Varnode eight = new Varnode(constant.getAddress(8),4);
|
||||
Address LVAregAddress = program.getRegister("LVA").getAddress();
|
||||
Varnode LVA = new Varnode(LVAregAddress,4);
|
||||
|
||||
//initialize LVA to contain 0
|
||||
PcodeOp copy = new PcodeOp(con.baseAddr,seqNum, PcodeOp.COPY);
|
||||
copy.setInput(zero, 0);
|
||||
copy.setOutput(LVA);
|
||||
resOps[seqNum++] = copy;
|
||||
|
||||
//create temp storage locations
|
||||
Address temp4Address = analysisState.getNextUniqueAddress();
|
||||
Varnode temp4 = new Varnode(temp4Address,4);
|
||||
Address temp8Address = analysisState.getNextUniqueAddress();
|
||||
Varnode temp8 = new Varnode(temp8Address,8);
|
||||
|
||||
Varnode tempLocation = null;
|
||||
Varnode increment = null;
|
||||
|
||||
|
|
@ -152,13 +160,13 @@ public class InjectPayloadJavaParameters implements InjectPayload {
|
|||
}
|
||||
//copy value from parameterSpace to temporary
|
||||
PcodeOp load = new PcodeOp(con.baseAddr, seqNum, PcodeOp.LOAD);
|
||||
load.setInput(new Varnode(constant.getAddress(paramSpaceID),4), 0);
|
||||
load.setInput(new Varnode(constantSpace.getAddress(paramSpaceID), 4), 0);
|
||||
load.setInput(LVA, 1);
|
||||
load.setOutput(tempLocation);
|
||||
resOps[seqNum++] = load;
|
||||
//copy temporary to LVA
|
||||
PcodeOp store = new PcodeOp(con.baseAddr, seqNum, PcodeOp.STORE);
|
||||
store.setInput(new Varnode(constant.getAddress(lvaID),4), 0);
|
||||
store.setInput(new Varnode(constantSpace.getAddress(lvaID), 4), 0);
|
||||
store.setInput(LVA,1);
|
||||
store.setInput(tempLocation, 2);
|
||||
resOps[seqNum++] = store;
|
||||
|
|
|
|||
|
|
@ -19,20 +19,25 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
|||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.program.model.lang.InjectContext;
|
||||
import ghidra.program.model.listing.Program;
|
||||
import ghidra.program.model.pcode.PcodeOp;
|
||||
|
||||
public class InjectPutField extends InjectPayloadJava {
|
||||
|
||||
public InjectPutField(String sourceName, SleighLanguage language) {
|
||||
super(sourceName, language);
|
||||
public InjectPutField(String sourceName, SleighLanguage language, long uniqBase) {
|
||||
super(sourceName, language, uniqBase);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPcodeText(Program program, String context) {
|
||||
InjectContext injectContext = getInjectContext(program, context);
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset();
|
||||
String pcodeText = ReferenceMethods.getPcodeForPutField(constantPoolIndex, constantPool);
|
||||
return pcodeText;
|
||||
public String getName() {
|
||||
return PcodeInjectLibraryJava.PUTFIELD;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PcodeOp[] getPcode(Program program, InjectContext con) {
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) con.inputlist.get(0).getOffset();
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase);
|
||||
ReferenceMethods.getPcodeForPutField(pCode, constantPoolIndex, constantPool);
|
||||
return pCode.getPcodeOps();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,20 +19,25 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
|||
import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava;
|
||||
import ghidra.program.model.lang.InjectContext;
|
||||
import ghidra.program.model.listing.Program;
|
||||
import ghidra.program.model.pcode.PcodeOp;
|
||||
|
||||
public class InjectPutStatic extends InjectPayloadJava {
|
||||
|
||||
public InjectPutStatic(String sourceName, SleighLanguage language) {
|
||||
super(sourceName, language);
|
||||
public InjectPutStatic(String sourceName, SleighLanguage language, long uniqBase) {
|
||||
super(sourceName, language, uniqBase);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPcodeText(Program program, String context) {
|
||||
InjectContext injectContext = getInjectContext(program, context);
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset();
|
||||
String pcodeText = ReferenceMethods.getPcodeForPutStatic(constantPoolIndex, constantPool);
|
||||
return pcodeText;
|
||||
public String getName() {
|
||||
return PcodeInjectLibraryJava.PUTSTATIC;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PcodeOp[] getPcode(Program program, InjectContext con) {
|
||||
AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program);
|
||||
int constantPoolIndex = (int) con.inputlist.get(0).getOffset();
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase);
|
||||
ReferenceMethods.getPcodeForPutStatic(pCode, constantPoolIndex, constantPool);
|
||||
return pCode.getPcodeOps();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,14 +16,10 @@
|
|||
package ghidra.app.util.pcodeInject;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
import org.jdom.JDOMException;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import ghidra.app.plugin.processors.sleigh.SleighLanguage;
|
||||
import ghidra.app.plugin.processors.sleigh.template.OpTpl;
|
||||
import ghidra.pcodeCPort.slgh_compile.PcodeParser;
|
||||
import ghidra.program.model.lang.*;
|
||||
import ghidra.program.model.listing.Program;
|
||||
|
||||
|
|
@ -114,92 +110,45 @@ public class PcodeInjectLibraryJava extends PcodeInjectLibrary {
|
|||
|
||||
public static final String PUTFIELD = "putFieldCallOther";
|
||||
public static final String PUTSTATIC = "putStaticCallOther";
|
||||
public static final String SOURCENAME = "javainternal";
|
||||
|
||||
//size of one stack element in the jvm (in bytes)
|
||||
public static final int REFERENCE_SIZE = 4;
|
||||
|
||||
private SleighLanguage language;
|
||||
private Set<String> implementedOps;
|
||||
private PcodeParser parser;
|
||||
private Map<String, InjectPayloadJava> implementedOps;
|
||||
private InjectPayloadJavaParameters paramPayload;
|
||||
|
||||
public PcodeInjectLibraryJava(SleighLanguage l) {
|
||||
super(l);
|
||||
language = l;
|
||||
implementedOps = new HashSet<>();
|
||||
implementedOps.add(GETFIELD);
|
||||
implementedOps.add(GETSTATIC);
|
||||
implementedOps.add(INVOKE_DYNAMIC);
|
||||
implementedOps.add(INVOKE_INTERFACE);
|
||||
implementedOps.add(INVOKE_SPECIAL);
|
||||
implementedOps.add(INVOKE_STATIC);
|
||||
implementedOps.add(INVOKE_VIRTUAL);
|
||||
implementedOps.add(LDC);
|
||||
implementedOps.add(LDC2_W);
|
||||
implementedOps.add(LDC_W);
|
||||
implementedOps.add(MULTIANEWARRAY);
|
||||
implementedOps.add(PUTFIELD);
|
||||
implementedOps.add(PUTSTATIC);
|
||||
long offset = l.getUniqueBase();
|
||||
implementedOps = new HashMap<>();
|
||||
implementedOps.put(GETFIELD, new InjectGetField(SOURCENAME, l, offset));
|
||||
offset += 0x100;
|
||||
implementedOps.put(GETSTATIC, new InjectGetStatic(SOURCENAME, l, offset));
|
||||
offset += 0x100;
|
||||
implementedOps.put(INVOKE_DYNAMIC, new InjectInvokeDynamic(SOURCENAME, l, offset));
|
||||
offset += 0x100;
|
||||
implementedOps.put(INVOKE_INTERFACE, new InjectInvokeInterface(SOURCENAME, l, offset));
|
||||
offset += 0x100;
|
||||
implementedOps.put(INVOKE_SPECIAL, new InjectInvokeSpecial(SOURCENAME, l, offset));
|
||||
offset += 0x100;
|
||||
implementedOps.put(INVOKE_STATIC, new InjectInvokeStatic(SOURCENAME, l, offset));
|
||||
offset += 0x100;
|
||||
implementedOps.put(INVOKE_VIRTUAL, new InjectInvokeVirtual(SOURCENAME, l, offset));
|
||||
offset += 0x100;
|
||||
InjectPayloadJava ldcInject = new InjectLdc(SOURCENAME, l, offset);
|
||||
offset += 0x100;
|
||||
implementedOps.put(LDC, ldcInject);
|
||||
implementedOps.put(LDC2_W, ldcInject);
|
||||
implementedOps.put(LDC_W, ldcInject);
|
||||
implementedOps.put(MULTIANEWARRAY, new InjectMultiANewArray(SOURCENAME, l, offset));
|
||||
offset += 0x100;
|
||||
implementedOps.put(PUTFIELD, new InjectPutField(SOURCENAME, l, offset));
|
||||
offset += 0x100;
|
||||
implementedOps.put(PUTSTATIC, new InjectPutStatic(SOURCENAME, l, offset));
|
||||
offset += 0x100;
|
||||
|
||||
String translateSpec = language.buildTranslatorTag(language.getAddressFactory(),
|
||||
getUniqueBase(), language.getSymbolTable());
|
||||
|
||||
paramPayload = null;
|
||||
parser = null;
|
||||
try {
|
||||
parser = new PcodeParser(translateSpec);
|
||||
}
|
||||
catch (JDOMException e1) {
|
||||
e1.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected InjectPayloadSleigh allocateInject(String sourceName, String name, int tp) {
|
||||
InjectPayloadJava payload = null;
|
||||
if (tp != InjectPayload.CALLOTHERFIXUP_TYPE) {
|
||||
return super.allocateInject(sourceName, name, tp);
|
||||
}
|
||||
switch (name) {
|
||||
case GETFIELD:
|
||||
payload = new InjectGetField(sourceName, language);
|
||||
break;
|
||||
case GETSTATIC:
|
||||
payload = new InjectGetStatic(sourceName, language);
|
||||
break;
|
||||
case INVOKE_DYNAMIC:
|
||||
payload = new InjectInvokeDynamic(sourceName, language);
|
||||
break;
|
||||
case INVOKE_INTERFACE:
|
||||
payload = new InjectInvokeInterface(sourceName, language);
|
||||
break;
|
||||
case INVOKE_SPECIAL:
|
||||
payload = new InjectInvokeSpecial(sourceName, language);
|
||||
break;
|
||||
case INVOKE_STATIC:
|
||||
payload = new InjectInvokeStatic(sourceName, language);
|
||||
break;
|
||||
case INVOKE_VIRTUAL:
|
||||
payload = new InjectInvokeVirtual(sourceName, language);
|
||||
break;
|
||||
case LDC:
|
||||
case LDC2_W:
|
||||
case LDC_W:
|
||||
payload = new InjectLdc(sourceName, language);
|
||||
break;
|
||||
case MULTIANEWARRAY:
|
||||
payload = new InjectMultiANewArray(sourceName, language);
|
||||
break;
|
||||
case PUTFIELD:
|
||||
payload = new InjectPutField(sourceName, language);
|
||||
break;
|
||||
case PUTSTATIC:
|
||||
payload = new InjectPutStatic(sourceName, language);
|
||||
break;
|
||||
default:
|
||||
return super.allocateInject(sourceName, name, InjectPayload.CALLOTHERFIXUP_TYPE);
|
||||
}
|
||||
return payload;
|
||||
paramPayload = new InjectPayloadJavaParameters(l, offset);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -208,27 +157,14 @@ public class PcodeInjectLibraryJava extends PcodeInjectLibrary {
|
|||
*/
|
||||
public InjectPayload getPayload(int type, String name, Program program, String context) {
|
||||
if (type == InjectPayload.CALLMECHANISM_TYPE) {
|
||||
if (paramPayload == null) {
|
||||
paramPayload = new InjectPayloadJavaParameters();
|
||||
}
|
||||
return paramPayload;
|
||||
}
|
||||
|
||||
if (!implementedOps.contains(name)) {
|
||||
InjectPayloadJava payload = implementedOps.get(name);
|
||||
if (payload == null) {
|
||||
return super.getPayload(type, name, program, context);
|
||||
}
|
||||
|
||||
InjectPayloadJava payload =
|
||||
(InjectPayloadJava) super.getPayload(InjectPayload.CALLOTHERFIXUP_TYPE, name, program,
|
||||
context);
|
||||
|
||||
synchronized (parser) {
|
||||
OpTpl[] opTemplates = payload.getPcode(parser, program, context);
|
||||
adjustUniqueBase(opTemplates);
|
||||
//clear the added symbols so that the parser can be used again without
|
||||
//duplicate symbol name conflicts.
|
||||
parser.clearSymbols();
|
||||
}
|
||||
return payload;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -100,18 +100,24 @@ public class PcodeOpEmitter {
|
|||
return PcodeOp.COPY;
|
||||
}
|
||||
|
||||
public PcodeOpEmitter(SleighLanguage language, Address opAddr) {
|
||||
public PcodeOpEmitter(SleighLanguage language, Address opAddr, long uniqBase) {
|
||||
nameToReg = new HashMap<String, Varnode>();
|
||||
opList = new ArrayList<PcodeOp>();
|
||||
this.language = language;
|
||||
constSpace = language.getAddressFactory().getConstantSpace();
|
||||
defSpace = language.getDefaultSpace();
|
||||
uniqueSpace = language.getAddressFactory().getUniqueSpace();
|
||||
uniqueBase = language.getUniqueBase();
|
||||
uniqueBase = uniqBase;
|
||||
opAddress = opAddr;
|
||||
seqnum = 0;
|
||||
spVarnode = findRegister("SP");
|
||||
defSpaceId = getConstant(defSpace.getSpaceID(), 8);
|
||||
defSpaceId = getConstant(defSpace.getSpaceID(), 4);
|
||||
}
|
||||
|
||||
public PcodeOp[] getPcodeOps() {
|
||||
PcodeOp[] res = new PcodeOp[opList.size()];
|
||||
opList.toArray(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
public void defineTemp(String name, int size) {
|
||||
|
|
@ -171,7 +177,7 @@ public class PcodeOpEmitter {
|
|||
in = new Varnode[2];
|
||||
in[0] = spVarnode;
|
||||
in[1] = getConstant(8, spVarnode.getSize());
|
||||
op = new PcodeOp(opAddress, seqnum++, PcodeOp.INT_SUB, in, spVarnode);
|
||||
op = new PcodeOp(opAddress, seqnum++, PcodeOp.INT_ADD, in, spVarnode);
|
||||
opList.add(op);
|
||||
}
|
||||
|
||||
|
|
@ -189,7 +195,7 @@ public class PcodeOpEmitter {
|
|||
in = new Varnode[2];
|
||||
in[0] = spVarnode;
|
||||
in[1] = getConstant(4, spVarnode.getSize());
|
||||
op = new PcodeOp(opAddress, seqnum++, PcodeOp.INT_SUB, in, spVarnode);
|
||||
op = new PcodeOp(opAddress, seqnum++, PcodeOp.INT_ADD, in, spVarnode);
|
||||
opList.add(op);
|
||||
}
|
||||
|
||||
|
|
@ -295,8 +301,7 @@ public class PcodeOpEmitter {
|
|||
public void emitWriteToMemory(String space, int size, String offset, String value) {
|
||||
Varnode[] in = new Varnode[3];
|
||||
AddressSpace spc = language.getAddressFactory().getAddressSpace(space);
|
||||
// TODO: find correct space id
|
||||
in[0] = getConstant(spc.getSpaceID(), 8);
|
||||
in[0] = getConstant(spc.getSpaceID(), 4);
|
||||
if (offset.charAt(0) <= '9') {
|
||||
String[] piece = offset.split(":");
|
||||
int sz = Integer.parseInt(piece[1]);
|
||||
|
|
|
|||
|
|
@ -35,12 +35,14 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
|
||||
private SleighLanguage language;
|
||||
private Address opAddress;
|
||||
private long uniqueBase;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
language =
|
||||
(SleighLanguage) getLanguageService().getLanguage(new LanguageID("JVM:BE:32:default"));
|
||||
opAddress = language.getAddressFactory().getDefaultAddressSpace().getAddress(0x10000);
|
||||
uniqueBase = language.getUniqueBase();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -58,11 +60,11 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
InvokeMethods.emitPcodeToResolveMethodReference(pCode, 1, constantPool,
|
||||
JavaInvocationType.INVOKE_DYNAMIC);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expected.emitAssignRegisterFromPcodeOpCall(InvokeMethods.CALL_TARGET,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_INVOKEDYNAMIC);
|
||||
assertEquals("incorrect pcode for dynamic invocation", expected, pCode);
|
||||
|
|
@ -84,12 +86,12 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
pCode.defineTemp(InvokeMethods.THIS, 4);
|
||||
InvokeMethods.emitPcodeToResolveMethodReference(pCode, 1, constantPool,
|
||||
JavaInvocationType.INVOKE_INTERFACE);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expected.defineTemp(InvokeMethods.THIS, 4);
|
||||
expected.emitAssignRegisterFromPcodeOpCall(InvokeMethods.CALL_TARGET,
|
||||
ConstantPoolJava.CPOOL_OP, InvokeMethods.THIS, "1",
|
||||
|
|
@ -113,12 +115,12 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
pCode.defineTemp(InvokeMethods.THIS, 4);
|
||||
InvokeMethods.emitPcodeToResolveMethodReference(pCode, 1, constantPool,
|
||||
JavaInvocationType.INVOKE_SPECIAL);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expected.defineTemp(InvokeMethods.THIS, 4);
|
||||
expected.emitAssignRegisterFromPcodeOpCall(InvokeMethods.CALL_TARGET,
|
||||
ConstantPoolJava.CPOOL_OP, InvokeMethods.THIS, "1",
|
||||
|
|
@ -142,11 +144,11 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
InvokeMethods.emitPcodeToResolveMethodReference(pCode, 1, constantPool,
|
||||
JavaInvocationType.INVOKE_STATIC);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expected.emitAssignRegisterFromPcodeOpCall(InvokeMethods.CALL_TARGET,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_INVOKESTATIC);
|
||||
assertEquals("incorrect pcode for static method invocation", expected, pCode);
|
||||
|
|
@ -168,12 +170,12 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
pCode.defineTemp(InvokeMethods.THIS, 4);
|
||||
InvokeMethods.emitPcodeToResolveMethodReference(pCode, 1, constantPool,
|
||||
JavaInvocationType.INVOKE_VIRTUAL);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expected.defineTemp(InvokeMethods.THIS, 4);
|
||||
expected.emitAssignRegisterFromPcodeOpCall(InvokeMethods.CALL_TARGET,
|
||||
ConstantPoolJava.CPOOL_OP, InvokeMethods.THIS, "1",
|
||||
|
|
@ -183,9 +185,9 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
|
||||
@Test
|
||||
public void testEmitPcodeToReverseStackNoParamsNoThis() {
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
//InvokeMethods.emitPcodeToReverseStack(pCode, new ArrayList<JavaComputationalCategory>(), false);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
assertEquals("incorrect pcode reversing stack: no params no this", expected, pCode);
|
||||
}
|
||||
|
||||
|
|
@ -205,10 +207,10 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
InvokeMethods.getPcodeForInvoke(pCode, 1, constantPool, JavaInvocationType.INVOKE_DYNAMIC);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
String descriptor = DescriptorDecoder.getDescriptorForInvoke(1, constantPool,
|
||||
JavaInvocationType.INVOKE_DYNAMIC);
|
||||
List<JavaComputationalCategory> categories =
|
||||
|
|
|
|||
|
|
@ -50,12 +50,14 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
private static final int COUNT_LOW_BYTE = 9;
|
||||
private SleighLanguage language;
|
||||
private Address opAddress;
|
||||
private long uniqueBase;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
language =
|
||||
(SleighLanguage) getLanguageService().getLanguage(new LanguageID("JVM:BE:32:default"));
|
||||
opAddress = language.getAddressFactory().getDefaultAddressSpace().getAddress(0x10000);
|
||||
uniqueBase = language.getUniqueBase();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -67,9 +69,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
TestClassFileCreator.appendInteger(classFile, 0x12345678);
|
||||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 1, constantPool);
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC);
|
||||
expectedPcode.emitPushCat1Value(LdcMethods.VALUE);
|
||||
|
|
@ -80,9 +82,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
TestClassFileCreator.appendInteger(classFile, 0x11111111);
|
||||
classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
pCode = new PcodeOpEmitter(language, opAddress);
|
||||
pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 2, constantPool);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "2", ConstantPoolJava.CPOOL_LDC);
|
||||
expectedPcode.emitPushCat1Value(LdcMethods.VALUE);
|
||||
|
|
@ -99,10 +101,10 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 1, constantPool);
|
||||
//+1 to skip over the tag
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC);
|
||||
expectedPcode.emitPushCat1Value(LdcMethods.VALUE);
|
||||
|
|
@ -114,10 +116,10 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
|
||||
pCode = new PcodeOpEmitter(language, opAddress);
|
||||
pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 2, constantPool);
|
||||
//+1 for tag of first float, +4 for data of first float, +1 for tag of 2nd float
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "2", ConstantPoolJava.CPOOL_LDC);
|
||||
expectedPcode.emitPushCat1Value(LdcMethods.VALUE);
|
||||
|
|
@ -133,10 +135,10 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
TestClassFileCreator.appendDouble(classFile, 2.0);
|
||||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 1, constantPool);
|
||||
//+1 to skip over the tag
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 8,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC2_W);
|
||||
expectedPcode.emitPushCat2Value(LdcMethods.VALUE);
|
||||
|
|
@ -148,9 +150,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
TestClassFileCreator.appendDouble(classFile, 4.0);
|
||||
classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
pCode = new PcodeOpEmitter(language, opAddress);
|
||||
pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 3, constantPool);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 8,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "3", ConstantPoolJava.CPOOL_LDC2_W);
|
||||
expectedPcode.emitPushCat2Value(LdcMethods.VALUE);
|
||||
|
|
@ -166,9 +168,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
TestClassFileCreator.appendLong(classFile, 0x123456789l);
|
||||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 1, constantPool);
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 8,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC2_W);
|
||||
expectedPcode.emitPushCat2Value(LdcMethods.VALUE);
|
||||
|
|
@ -180,9 +182,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
TestClassFileCreator.appendLong(classFile, 0x1111111111l);
|
||||
classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
pCode = new PcodeOpEmitter(language, opAddress);
|
||||
pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 3, constantPool);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 8,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "3", ConstantPoolJava.CPOOL_LDC2_W);
|
||||
expectedPcode.emitPushCat2Value(LdcMethods.VALUE);
|
||||
|
|
@ -199,9 +201,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
TestClassFileCreator.appendUtf8(classFile, "input1");
|
||||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 1, constantPool);
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC);
|
||||
expectedPcode.emitPushCat1Value(LdcMethods.VALUE);
|
||||
|
|
@ -214,9 +216,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
TestClassFileCreator.appendUtf8(classFile, "input2");
|
||||
classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
pCode = new PcodeOpEmitter(language, opAddress);
|
||||
pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 3, constantPool);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "3", ConstantPoolJava.CPOOL_LDC);
|
||||
expectedPcode.emitPushCat1Value(LdcMethods.VALUE);
|
||||
|
|
@ -233,10 +235,10 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
TestClassFileCreator.appendUtf8(classFile, "Ljava/lang/Integer;");
|
||||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 1, constantPool);
|
||||
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC);
|
||||
expectedPcode.emitPushCat1Value(LdcMethods.VALUE);
|
||||
|
|
@ -249,9 +251,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
TestClassFileCreator.appendUtf8(classFile, "Ljava/lang/String;");
|
||||
classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
pCode = new PcodeOpEmitter(language, opAddress);
|
||||
pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 3, constantPool);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "3", ConstantPoolJava.CPOOL_LDC);
|
||||
expectedPcode.emitPushCat1Value(LdcMethods.VALUE);
|
||||
|
|
@ -268,13 +270,13 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
TestClassFileCreator.appendUtf8(classFile, "(I)Ljava/lang/Integer;");
|
||||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 1, constantPool);
|
||||
//+1 to skip over the tag of the MethodType element
|
||||
//+2 to skip over data of MethodType element (2-byte ref to utf8 element)
|
||||
//+1 to skip over tag of utf8 element
|
||||
//+2 to skip over length of utf8 element
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC);
|
||||
expectedPcode.emitPushCat1Value(LdcMethods.VALUE);
|
||||
|
|
@ -287,9 +289,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest {
|
|||
TestClassFileCreator.appendUtf8(classFile, "(I)Ljava/lang/Integer;");
|
||||
classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
pCode = new PcodeOpEmitter(language, opAddress);
|
||||
pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
LdcMethods.getPcodeForLdc(pCode, 3, constantPool);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress);
|
||||
expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "3", ConstantPoolJava.CPOOL_LDC);
|
||||
expectedPcode.emitPushCat1Value(LdcMethods.VALUE);
|
||||
|
|
|
|||
|
|
@ -33,16 +33,14 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest
|
|||
|
||||
private SleighLanguage language;
|
||||
private Address opAddress;
|
||||
|
||||
public ReferenceMethodsTest() {
|
||||
|
||||
}
|
||||
private long uniqueBase;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
language =
|
||||
(SleighLanguage) getLanguageService().getLanguage(new LanguageID("JVM:BE:32:default"));
|
||||
opAddress = language.getAddressFactory().getDefaultAddressSpace().getAddress(0x10000);
|
||||
uniqueBase = language.getUniqueBase();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -61,10 +59,10 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
ReferenceMethods.getPcodeForGetStatic(pCode, 1, constantPool);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.TEMP_1, 4,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_GETSTATIC);
|
||||
expected.emitAssignVarnodeFromDereference(ReferenceMethods.VALUE, 4,
|
||||
|
|
@ -89,10 +87,10 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
ReferenceMethods.getPcodeForGetStatic(pCode, 1, constantPool);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
|
||||
expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.TEMP_1, 8,
|
||||
ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_GETSTATIC);
|
||||
|
|
@ -119,14 +117,14 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
ReferenceMethods.getPcodeForPutStatic(pCode, 1, constantPool);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expected.emitPopCat1Value(ReferenceMethods.NEW_VALUE);
|
||||
expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.STATIC_OFFSET,
|
||||
4, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_PUTSTATIC);
|
||||
expected.emitWriteToMemory(PcodeTextEmitter.RAM, 4,
|
||||
expected.emitWriteToMemory(PcodeOpEmitter.RAM, 4,
|
||||
ReferenceMethods.STATIC_OFFSET, ReferenceMethods.NEW_VALUE);
|
||||
assertEquals(pCode, expected);
|
||||
}
|
||||
|
|
@ -147,14 +145,14 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
ReferenceMethods.getPcodeForPutStatic(pCode, 1, constantPool);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expected.emitPopCat2Value(ReferenceMethods.NEW_VALUE);
|
||||
expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.STATIC_OFFSET,
|
||||
4, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_PUTSTATIC);
|
||||
expected.emitWriteToMemory(PcodeTextEmitter.RAM, 8,
|
||||
expected.emitWriteToMemory(PcodeOpEmitter.RAM, 8,
|
||||
ReferenceMethods.STATIC_OFFSET, ReferenceMethods.NEW_VALUE);
|
||||
assertEquals(pCode, expected);
|
||||
}
|
||||
|
|
@ -175,10 +173,10 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
ReferenceMethods.getPcodeForGetField(pCode, 1, constantPool);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expected.emitPopCat1Value(ReferenceMethods.OBJECT_REF);
|
||||
expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.TEMP_1, 4,
|
||||
ConstantPoolJava.CPOOL_OP, ReferenceMethods.OBJECT_REF, "1",
|
||||
|
|
@ -205,10 +203,10 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
ReferenceMethods.getPcodeForGetField(pCode, 1, constantPool);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expected.emitPopCat1Value(ReferenceMethods.OBJECT_REF);
|
||||
expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.TEMP_1, 8,
|
||||
ConstantPoolJava.CPOOL_OP, ReferenceMethods.OBJECT_REF, "1",
|
||||
|
|
@ -235,16 +233,16 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
ReferenceMethods.getPcodeForPutField(pCode, 1, constantPool);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expected.emitPopCat1Value(ReferenceMethods.NEW_VALUE);
|
||||
expected.emitPopCat1Value(ReferenceMethods.OBJECT_REF);
|
||||
expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.FIELD_OFFSET,
|
||||
4, ConstantPoolJava.CPOOL_OP, ReferenceMethods.OBJECT_REF, "1",
|
||||
ConstantPoolJava.CPOOL_PUTFIELD);
|
||||
expected.emitWriteToMemory(PcodeTextEmitter.RAM, 4,
|
||||
expected.emitWriteToMemory(PcodeOpEmitter.RAM, 4,
|
||||
ReferenceMethods.FIELD_OFFSET, ReferenceMethods.NEW_VALUE);
|
||||
|
||||
assertEquals(pCode, expected);
|
||||
|
|
@ -266,16 +264,16 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest
|
|||
byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile);
|
||||
AbstractConstantPoolInfoJava[] constantPool =
|
||||
TestClassFileCreator.getConstantPoolFromBytes(classFileBytes);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
ReferenceMethods.getPcodeForPutField(pCode, 1, constantPool);
|
||||
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress);
|
||||
PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase);
|
||||
expected.emitPopCat2Value(ReferenceMethods.NEW_VALUE);
|
||||
expected.emitPopCat1Value(ReferenceMethods.OBJECT_REF);
|
||||
expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.FIELD_OFFSET,
|
||||
4, ConstantPoolJava.CPOOL_OP, ReferenceMethods.OBJECT_REF, "1",
|
||||
ConstantPoolJava.CPOOL_PUTFIELD);
|
||||
expected.emitWriteToMemory(PcodeTextEmitter.RAM, 8,
|
||||
expected.emitWriteToMemory(PcodeOpEmitter.RAM, 8,
|
||||
ReferenceMethods.FIELD_OFFSET, ReferenceMethods.NEW_VALUE);
|
||||
|
||||
assertEquals(pCode, expected);
|
||||
|
|
|
|||
Loading…
Reference in a new issue