Ghidra Pcode Rewriting: 在指定位置插入或修改Pcode

背景

一道奇怪的题目

为什么不用IDA的microcode？

1. IDA没有提供单个指令的IR lifting接口，你只能制定一个函数或者EA范围，你不能直接提供给IDA一个bytes buffer和起始地址就直接让他lift到microcode，这是个很大的问题。

2. IDA本身没有提供针对IR的parser，也就是说你没有办法直接用文本编写一个microcode指令，然后直接丢给IDA解析。你必须使用IDA提供的程序化接口强行手动写IR

准备工作

如何获取Pcode？

1. 从反汇编获取Pcode

2. 手写Pcode

Ghidra是怎么把Pcode传给Decompiler的？

如何正确输出Pcode？

			PcodeEmitPacked emit =
				new PcodeEmitPacked(encoder, walker, context, fallOffset, override);

			emit.emitHeader();
			emit.build(walker.getConstructor().getTempl(), -1);
			emit.resolveRelatives();
			if (!isindelayslot) {
				emit.resolveFinalFallthrough();
			}
			emit.emitTail();

思路1：给encoder增加一个wrapper

class EncoderWrap extends PatchPackedEncode implements PatchEncoder {
	public boolean interceptHeader = false;
	public boolean interceptTail = false;
	
	public boolean check() {
		if (interceptHeader) {
			// XXXX: 如果调用栈中包含 emitHeader，则直接返回
	        for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
	            if ("emitHeader".equals(ste.getMethodName())) {
	                return true;
	            }
	        }
		}
		if (interceptTail) {
	        for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
	            if ("emitTail".equals(ste.getMethodName())) {
	                return true;
	            }
	        }
		}
        return false;
	}
	public void openElement(ElementId elemId) throws IOException {
		if (check()) {
			return;
		}
		super.openElement(elemId);
	}
	...
}

var tmpEncoder = new EncoderWrap();
tmpEncoder.clear();
tmpEncoder.interceptHeader = false;
tmpEncoder.interceptTail = false;
for (int i = 0; i < patchedIns.length; i++) {
	var instr = patchedIns[i];
	if (i != 0) {
		tmpEncoder.interceptHeader = true;
	}
	if (i == patchedIns.length - 1) {
		tmpEncoder.interceptTail = false;
	}
	instr.getPrototype()
		.getPcodePacked(tmpEncoder, instr.getInstructionContext(),
				new InstructionPcodeOverride(instr));
}
tmpEncoder.writeTo(((PatchPackedEncode)encoder).getOutputStream());

思路2：直接把整个getPcodePacked方法抄过来，然后自己控制Emit哪部分

• emitHeader：主要输出Instruction的信息，比如fall offset（下一条指令的位置）等，没啥大问题

• build：输出指令核心部分

• resolveRelatives：负责处理labelref数组里面的重定位

• emitTail：只闭合element，剩下啥都不干

SleighParserContext protoContext = (SleighParserContext) context.getParserContext();
//	 if (delaySlotByteCnt > 0) {} // disable delay slot detect
ParserWalker walker = new ParserWalker(protoContext);
walker.baseState();

PcodeEmitPacked emit =
	new PcodeEmitPacked(encoder, walker, context, instrPrototype.getLength(), override);

emit.emitHeader();
for (int i = 0; i < patchedIns.length; i++) {
	var insproto = (SleighInstructionPrototype)patchedIns[i].getPrototype();
	
	var instr = patchedIns[i];
	ParserWalker walker2 = new ParserWalker((SleighParserContext) instr.getInstructionContext().getParserContext());
	walker2.baseState();
	PcodeEmitPacked emit2 =
			new PcodeEmitPacked(encoder, walker2, context, instrPrototype.getLength(), override);
	emit2.build(walker2.getConstructor().getTempl(), -1);
}
emit.resolveRelatives();
emit.emitTail();

寻找合适的Hook点

思路1：hook getPcodePacked函数

思路2：同时hook全部getPcode系列函数

思路3：从更底层的位置直接整个替换掉Pcode

1. 分析内部field结构

• SleighInstructionPrototype的初始化直接发生构造函数里的resolve函数调用，所以直接在这里hook

• 通过调试观察结构，可以看到整个指令的信息存放在了

private ConstructState rootState;

• rootState里面存放了ct，Constructor自然对应的是Sleigh里面的constructor概念

private Constructor ct;

• Constructor里面存了ConstructTpl，是Sleigh解析slaspec后得到的模板

private ConstructTpl templ;		// The main p-code template section

• 里面进一步存了OpTpl，OpTpl就是实际的Pcode

private OpTpl[] vec;				// The semantic action of constructor

1. 用反射+unsafe写一个代码，复制一份新的rootState，然后修改里面的Pcode，发现虽然Pcode替换上去了，但是完全没有生效

2. 打断点调试，可以看到代码里检测了hashCode相同的prototype，然后自动使用cache的prototype，所以我们不止需要shallowCopy，还同时需要修改hashcode

3. 修完后，会发现Disassemble的时候会出错，报错在cacheTreeInfo方法的walkTemplates调用里面，检查发现是因为没有同步更新substate（resolvedStates），这个field是用来针对Pcode里面的 MULTIEQUAL Opcode的（其实就是Phi Node）

			var patchedIns = info.instrs;
			var opvec = new ArrayList<OpTpl>();
			var resolvedStates = new ArrayList<ConstructState>();
			for (var ins : info.instrs) {
				var state = ((SleighInstructionPrototype)ins.getPrototype()).getRootState();
				var curOpVec = state.getConstructor().getTempl().getOpVec();
				for (var i = 0; i < state.getNumSubStates(); i++) {
					resolvedStates.add(state.getSubState(i));
				}
				opvec.addAll(Arrays.asList(curOpVec));
			}
			var rootState = instrPrototype.getRootState();
			var ct = rootState.getConstructor();
			 
			var newct = shallowCloneWithoutConstructor(ct);
			var newtempl = new ConstructTpl(opvec.toArray(new OpTpl[0]));
			setField(newct, "templ", newtempl);
			setField(newct, "id", (int)(0x1234568 + buf.getAddress().getOffset()));
			setField(rootState, "ct", newct);
			setField(rootState, "resolvedStates", resolvedStates);
			setField(instrPrototype, "hashcode", rootState.hashCode());

1. 接着修完后续发现还会有更多的问题通过…虽然反汇编并不会报错，但是在getPcode的时候又会报错。

• Constructor、ConstructState这些东西太过复杂， Ghidra在这里实现了一整套树状的东西，并在上面做了大量的遍历操作。

• 这些东西本来也不是让Java层去创建的：所有的这些函数完全都是从每个类的decode函数deserialize出来的，并没有标准的构造函数，因此完全无法从Java层直接构建。

• 由于没有任何的内部代码在动态修改prototype，Ghidra在这一部分完全没有一个很好的设计文档，只有零散的函数注释，导致完全没有办法快速梳理出来这一块的逻辑在干什么。

最终方案：hook全部getPcode系列函数并更新InstructionPrototype

var oriState = instrPrototype.getRootState();
for (var ins : info.instrs) {
	var state = ((SleighInstructionPrototype)ins.getPrototype()).getRootState();
	setField(instrPrototype, "rootState", state);
	callMethod(instrPrototype, "cacheTreeInfo");
}
setField(instrPrototype, "rootState", oriState);