Skip to content

Ghidra is a software reverse engineering (SRE) framework

Fix signedness of SymbolicPropogator constant folds

mi11ione66a6bb6c7db2
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/program/util/SymbolicPropogator.java b/Ghidra/Features/Base/src/main/java/ghidra/program/util/SymbolicPropogator.java
index bedd1ca7d8..420be8c261 100644
--- a/Ghidra/Features/Base/src/main/java/ghidra/program/util/SymbolicPropogator.java
+++ b/Ghidra/Features/Base/src/main/java/ghidra/program/util/SymbolicPropogator.java
@@ -1400,7 +1400,7 @@ public class SymbolicPropogator {
longVal1 = vContext.getConstant(val1, evaluator);
longVal2 = vContext.getConstant(val2, evaluator);
if (longVal1 != null && longVal2 != null) {
- lresult = longVal1 >> longVal2;
+ lresult = longVal1 >>> longVal2;
result = vContext.createConstantVarnode(lresult, val1.getSize());
}
vContext.putValue(out, result, mustClearAll);
@@ -1412,7 +1412,7 @@ public class SymbolicPropogator {
longVal1 = vContext.getConstant(val1, evaluator);
longVal2 = vContext.getConstant(val2, evaluator);
if (longVal1 != null && longVal2 != null) {
- lresult = longVal1 >>> longVal2;
+ lresult = longVal1 >> longVal2;
result = vContext.createConstantVarnode(lresult, val1.getSize());
}
vContext.putValue(out, result, mustClearAll);
@@ -1437,7 +1437,7 @@ public class SymbolicPropogator {
longVal2 = vContext.getConstant(val2, evaluator);
if (longVal1 != null & longVal2 != null) {
if (longVal2 != 0) {
- lresult = longVal1 / longVal2;
+ lresult = Long.divideUnsigned(longVal1, longVal2);
result = vContext.createConstantVarnode(lresult, val1.getSize());
}
}
@@ -1465,7 +1465,7 @@ public class SymbolicPropogator {
longVal2 = vContext.getConstant(val2, evaluator);
if (longVal1 != null && longVal2 != null) {
if (longVal2 != 0) {
- lresult = longVal1 % longVal2;
+ lresult = Long.remainderUnsigned(longVal1, longVal2);
result = vContext.createConstantVarnode(lresult, val1.getSize());
}
}
diff --git a/Ghidra/Features/Base/src/test/java/ghidra/program/util/SymbolicPropogatorTest.java b/Ghidra/Features/Base/src/test/java/ghidra/program/util/SymbolicPropogatorTest.java
new file mode 100644
index 0000000000..f55148a8ee
--- /dev/null
+++ b/Ghidra/Features/Base/src/test/java/ghidra/program/util/SymbolicPropogatorTest.java
@@ -0,0 +1,132 @@
+/* ###
+ * 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.program.util;
+
+import static org.junit.Assert.*;
+
+import org.junit.*;
+
+import generic.test.AbstractGenericTest;
+import ghidra.program.database.ProgramBuilder;
+import ghidra.program.model.address.*;
+import ghidra.program.model.lang.Register;
+import ghidra.program.model.listing.Program;
+import ghidra.program.util.SymbolicPropogator.Value;
+import ghidra.util.task.TaskMonitor;
+
+/**
+ * Constant folding of INT_RIGHT, INT_DIV and INT_REM, which are unsigned, and INT_SRIGHT,
+ * which is signed. Each program below is loaded at 0x1000 and the register values are read
+ * at the trailing return instruction.
+ */
+public class SymbolicPropogatorTest extends AbstractGenericTest {
+
+ private ProgramBuilder builder;
+ private Program program;
+ private SymbolicPropogator symEval;
+
+ @After
+ public void tearDown() {
+ if (builder != null) {
+ builder.dispose();
+ }
+ }
+
+ @Test
+ public void testUnsignedShiftFold() throws Exception {
+ // MOV RBX,-0x8000000000000000
+ // SHR RBX,0x4
+ // MOV RCX,-0x8000000000000000
+ // SAR RCX,0x4
+ // MOV R8,-0x8000000000000000
+ // SHR R8,0x3c
+ // MOV ESI,0xfffffff0
+ // SAR ESI,0x4
+ // MOV EDI,0xfffffff0
+ // SHR EDI,0x4
+ // RET
+ Address ret = flowConstants(ProgramBuilder._X64,
+ "48 bb 00 00 00 00 00 00 00 80 48 c1 eb 04 48 b9 00 00 00 00 00 00 00 80 " +
+ "48 c1 f9 04 49 b8 00 00 00 00 00 00 00 80 49 c1 e8 3c be f0 ff ff ff " +
+ "c1 fe 04 bf f0 ff ff ff c1 ef 04 c3");
+
+ assertRegister(ret, "RBX", 0x0800000000000000L);
+ assertRegister(ret, "RCX", 0xf800000000000000L);
+ assertRegister(ret, "R8", 0x8L);
+ assertRegister(ret, "RSI", 0xffffffffL);
+ assertRegister(ret, "RDI", 0x0fffffffL);
+ }
+
+ @Test
+ public void testUnsignedDivideAndRemainderFold() throws Exception {
+ // MOV RDX,0x0
+ // MOV RAX,-0x7fffffffffffffff
+ // MOV RCX,0x3
+ // DIV RCX
+ // RET
+ Address ret = flowConstants(ProgramBuilder._X64,
+ "48 c7 c2 00 00 00 00 48 b8 01 00 00 00 00 00 00 80 48 c7 c1 03 00 00 00 " +
+ "48 f7 f1 c3");
+
+ assertRegister(ret, "RAX", 0x2aaaaaaaaaaaaaabL);
+ assertRegister(ret, "RDX", 0x0L);
+ }
+
+ @Test
+ public void testBitfieldInsertMaskFold() throws Exception {
+ // mov x14,#0x0
+ // mov x13,#-0x1
+ // bfxil x14,x13,#0x0,#0x3e
+ // ret
+ //
+ // AARCH64 builds the field mask as 0xffffffffffffffff >> (64 - width)
+ Address ret = flowConstants(ProgramBuilder._AARCH64,
+ "0e 00 80 d2 0d 00 80 92 ae f5 40 b3 c0 03 5f d6");
+
+ assertRegister(ret, "x14", 0x3fffffffffffffffL);
+ }
+
+ private Address flowConstants(String languageName, String byteString) throws Exception {
+ builder = new ProgramBuilder("propogate", languageName);
+ builder.setBytes("0x1000", byteString);
+
+ program = builder.getProgram();
+ AddressSetView body = new AddressSet(program.getMemory());
+ builder.disassemble(body, false);
+
+ int id = program.startTransaction("Test");
+ try {
+ symEval = new SymbolicPropogator(program, false);
+ symEval.flowConstants(builder.addr("0x1000"), body, new ContextEvaluatorAdapter(), true,
+ TaskMonitor.DUMMY);
+ }
+ finally {
+ program.endTransaction(id, true);
+ }
+
+ return program.getListing().getInstructionContaining(body.getMaxAddress()).getAddress();
+ }
+
+ private void assertRegister(Address address, String registerName, long expected) {
+ Register register = program.getRegister(registerName);
+ assertNotNull("No such register " + registerName, register);
+
+ Value value = symEval.getRegisterValue(address, register);
+ assertNotNull(registerName + " has no value at " + address, value);
+ assertFalse(registerName + " is register relative", value.isRegisterRelativeValue());
+ assertEquals(registerName, Long.toHexString(expected), Long.toHexString(value.getValue()));
+ }
+}