def test_structs():
s = SimState(arch='AMD64')
register_types(parse_types("""
struct abcd {
int a;
long b;
};
"""))
s.mem[0x8000].struct.abcd = {'a': 10, 'b': 20}
assert s.mem[0x8000].struct.abcd.a.concrete == 10
assert s.solver.eval(s.memory.load(0x8000, 16), cast_to=bytes) == bytes.fromhex('0a000000000000001400000000000000')
def test_structs():
s = SimState(arch='AMD64')
register_types(parse_types("""
struct abcd {
int a;
long b;
};
"""))
s.mem[0x8000].struct.abcd = {'a': 10, 'b': 20}
assert s.mem[0x8000].struct.abcd.a.concrete == 10
assert s.solver.eval(
s.memory.load(0x8000, 16),
cast_to=bytes) == bytes.fromhex('0a000000000000001400000000000000')
def test_structs():
s = SimState(arch='AMD64')
register_types(parse_types("""
struct abcd {
int a;
long b;
};
"""))
s.memory.store(0x8000, bytes(16))
s.mem[0x8000].struct.abcd = {'a': 10, 'b': 20}
nose.tools.assert_equal(s.mem[0x8000].struct.abcd.a.concrete, 10)
nose.tools.assert_equal(
s.solver.eval(s.memory.load(0x8000, 16), cast_to=bytes),
bytes.fromhex('0a000000000000001400000000000000'))
def test_structs():
s = SimState(arch="AMD64")
register_types(
parse_types("""
struct test_structs {
int a;
long b;
};
"""))
s.memory.store(0x8000, bytes(16))
s.mem[0x8000].struct.test_structs = {"a": 10, "b": 20}
assert s.mem[0x8000].struct.test_structs.a.concrete == 10
assert s.solver.eval(
s.memory.load(0x8000, 16),
cast_to=bytes) == bytes.fromhex("0a000000000000001400000000000000")
def test_struct_bitfield_simple():
"""
Tests if a struct with bitfields like
struct {
uint32_t a:8, b:1, c:23;
}
can be used with a memview
:return:
"""
state = SimState(arch="AMD64")
register_types(
SimStruct(
name="bitfield_struct",
pack=True,
fields=OrderedDict([
("a", SimTypeNumOffset(8, signed=False)),
("b", SimTypeNumOffset(1, signed=False)),
("c", SimTypeNumOffset(23, signed=False)),
]),
))
data = [
(b"\x0e\x02\x00\x00", (14, 0, 1)),
(b"\x14T\x00\x00", (20, 0, 42)),
(b"\x04\n\x01\x00", (4, 0, 133)),
(b"\x04j\x01\x00", (4, 0, 181)),
(b"\x04\xa2\x01\x00", (4, 0, 209)),
(b"\x04\xf4\x01\x00", (4, 0, 250)),
(b"\x04\\\x02\x00", (4, 0, 302)),
(b"\x04\x98\x02\x00", (4, 0, 332)),
(b"\x04\xe0\x02\x00", (4, 0, 368)),
(b"\x04\x1e\x03\x00", (4, 0, 399)),
]
state.memory.store(
0x8000,
b"\x0e\x02\x00\x00"
b"\x14T\x00\x00"
b"\x04\n\x01\x00"
b"\x04j\x01\x00"
b"\x04\xa2\x01\x00"
b"\x04\xf4\x01\x00"
b"\x04\\\x02\x00"
b"\x04\x98\x02\x00"
b"\x04\xe0\x02\x00"
b"\x04\x1e\x03\x00",
)
view = state.mem[0x8000].struct.bitfield_struct.array(5)
for (idx, (b, result)) in enumerate(data):
v = view[idx]
s = v.concrete
assert (s.a == result[0]
), f"Field a was {s.a}, expected {result[0]}, from bytes {b}"
assert (
v.a.concrete == result[0]
), f"Field a was {v.a.concrete}, expected {result[0]}, from bytes {b}"
assert (s.b == result[1]
), f"Field b was {s.b}, expected {result[1]}, from bytes {b}"
assert (v.b.concrete == result[1]
), f"Field b was {s.b}, expected {result[1]}, from bytes {b}"
assert (s.c == result[2]
), f"Field c was {s.c}, expected {result[2]}, from bytes {b}"
assert (
v.c.concrete == result[2]
), f"Field c was {v.c.concrete}, expected {result[2]}, from bytes {b}"
def register_jni_relevant_data_type():
register_types(parse_type('struct JNINativeMethod ' +\
'{const char* name;' +\
'const char* signature;' +\
'void* fnPtr;}'))
