def test_serialize_state_with_closed_files(self) -> None:
# regression test: issue 954
platform = self.linux
filename = platform.current.push_bytes("/bin/true\x00")
fd = platform.sys_open(filename, os.O_RDONLY, 0o600)
platform.sys_close(fd)
pickle_dumps(platform)
def testContextSerialization(self):
import pickle as pickle
initial_file = ""
new_file = ""
new_new_file = ""
constraints = ConstraintSet()
initial_state = State(constraints, FakePlatform())
initial_state.context["step"] = 10
initial_file = pickle_dumps(initial_state)
with initial_state as new_state:
self.assertEqual(initial_state.context["step"], 10)
self.assertEqual(new_state.context["step"], 10)
new_state.context["step"] = 20
self.assertEqual(initial_state.context["step"], 10)
self.assertEqual(new_state.context["step"], 20)
new_file = pickle_dumps(new_state)
with new_state as new_new_state:
self.assertEqual(initial_state.context["step"], 10)
self.assertEqual(new_state.context["step"], 20)
self.assertEqual(new_new_state.context["step"], 20)
new_new_state.context["step"] += 10
self.assertEqual(initial_state.context["step"], 10)
self.assertEqual(new_state.context["step"], 20)
self.assertEqual(new_new_state.context["step"], 30)
new_new_file = pickle_dumps(new_new_state)
self.assertEqual(initial_state.context["step"], 10)
self.assertEqual(new_state.context["step"], 20)
self.assertEqual(new_new_state.context["step"], 30)
self.assertEqual(initial_state.context["step"], 10)
self.assertEqual(new_state.context["step"], 20)
self.assertEqual(initial_state.context["step"], 10)
del initial_state
del new_state
del new_new_state
initial_state = pickle.loads(initial_file)
self.assertEqual(initial_state.context["step"], 10)
new_state = pickle.loads(new_file)
self.assertEqual(new_state.context["step"], 20)
new_new_state = pickle.loads(new_new_file)
self.assertEqual(new_new_state.context["step"], 30)
def testBasicPickle(self):
import pickle
cs = ConstraintSet()
# make array of 32->8 bits
array = cs.new_array(32)
# make free 32bit bitvector
key = cs.new_bitvec(32)
# assert that the array is 'A' at key position
array = array.store(key, ord("A"))
# let's restrict key to be greater than 1000
cs.add(key.ugt(1000))
cs = pickle.loads(pickle_dumps(cs))
self.assertTrue(self.solver.check(cs))
def check(ty: Type, pickle_size=None, sizeof=None, **kwargs):
x = ty(**kwargs)
"""
print(
type(x),
"\n Pickle size:",
len(pickle_dumps(x)),
"\n GetSizeOf:",
sys.getsizeof(x),
"\n Slotted:",
not hasattr(x, "__dict__"),
)
"""
self.assertEqual(len(pickle_dumps(x)), pickle_size)
if sys.version_info[1] == 6: # Python 3.6
self.assertEqual(sys.getsizeof(x), sizeof)
elif sys.version_info[1] == 7: # Python 3.7
self.assertEqual(sys.getsizeof(x), sizeof + 8)
elif sys.version_info[1] >= 8: # Python 3.8+
self.assertEqual(sys.getsizeof(x), sizeof - 8)
self.assertFalse(hasattr(x, "__dict__")) # slots!
self.assertTrue(hasattr(x, "_taint")) # taint!
checked.add(ty)
def test_ConstraintsForking(self):
solver = self.solver
import pickle
cs = ConstraintSet()
# make free 32bit bitvectors
x = cs.new_bitvec(8)
y = cs.new_bitvec(8)
# linear relation
# cs.add(x+y*5 == 0)
# Fork and divide in quadrants
saved_up = None
saved_up_right = None
saved_up_left = None
saved_down = None
saved_down_right = None
saved_down_left = None
with cs as cs_up:
cs_up.add(y.uge(0x80))
self.assertItemsEqual(solver.get_all_values(cs_up, x), range(0x0, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_up, y), range(0x80, 0x100))
saved_up = pickle_dumps((x, y, cs_up))
self.assertItemsEqual(solver.get_all_values(cs_up, x), range(0x0, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_up, y), range(0x80, 0x100))
with cs_up as cs_up_right:
cs_up_right.add(x.uge(0x80))
saved_up_right = pickle_dumps((x, y, cs_up_right))
self.assertItemsEqual(solver.get_all_values(cs_up_right, x), range(0x80, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_up_right, y), range(0x80, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_up, x), range(0x0, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_up, y), range(0x80, 0x100))
with cs_up as cs_up_left:
cs_up_left.add(x.ult(0x80))
saved_up_left = pickle_dumps((x, y, cs_up_left))
self.assertItemsEqual(solver.get_all_values(cs_up_left, x), range(0, 0x80))
self.assertItemsEqual(solver.get_all_values(cs_up_left, y), range(0x80, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_up, x), range(0x0, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_up, y), range(0x80, 0x100))
with cs as cs_down:
cs_down.add(y.ult(0x80))
self.assertItemsEqual(solver.get_all_values(cs_down, x), range(0x0, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_down, y), range(0, 0x80))
saved_down = pickle_dumps((x, y, cs_down))
self.assertItemsEqual(solver.get_all_values(cs_down, x), range(0x0, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_down, y), range(0, 0x80))
with cs_down as cs_down_right:
cs_down_right.add(x.uge(0x80))
saved_down_right = pickle_dumps((x, y, cs_down_right))
self.assertItemsEqual(solver.get_all_values(cs_down_right, x), range(0x80, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_down_right, y), range(0, 0x80))
self.assertItemsEqual(solver.get_all_values(cs_down, x), range(0x0, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_down, y), range(0, 0x80))
with cs_down as cs_down_left:
cs_down_left.add(x.ult(0x80))
saved_down_left = pickle_dumps((x, y, cs_down_left))
self.assertItemsEqual(solver.get_all_values(cs_down_left, x), range(0, 0x80))
self.assertItemsEqual(solver.get_all_values(cs_down_left, y), range(0, 0x80))
self.assertItemsEqual(solver.get_all_values(cs_down, x), range(0x0, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_down, y), range(0, 0x80))
x, y, cs_up = pickle.loads(saved_up)
self.assertItemsEqual(solver.get_all_values(cs_up, x), range(0x0, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_up, y), range(0x80, 0x100))
x, y, cs_up_right = pickle.loads(saved_up_right)
self.assertItemsEqual(solver.get_all_values(cs_up_right, x), range(0x80, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_up_right, y), range(0x80, 0x100))
x, y, cs_up_left = pickle.loads(saved_up_left)
self.assertItemsEqual(solver.get_all_values(cs_up_left, x), range(0x00, 0x80))
self.assertItemsEqual(solver.get_all_values(cs_up_left, y), range(0x80, 0x100))
x, y, cs_down = pickle.loads(saved_down)
self.assertItemsEqual(solver.get_all_values(cs_down, x), range(0x0, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_down, y), range(0x0, 0x80))
x, y, cs_down_right = pickle.loads(saved_down_right)
self.assertItemsEqual(solver.get_all_values(cs_down_right, x), range(0x80, 0x100))
self.assertItemsEqual(solver.get_all_values(cs_down_right, y), range(0x00, 0x80))
x, y, cs_down_left = pickle.loads(saved_down_left)
self.assertItemsEqual(solver.get_all_values(cs_down_left, x), range(0x00, 0x80))
self.assertItemsEqual(solver.get_all_values(cs_down_left, y), range(0x00, 0x80))
