Esempio n. 1
0
def test_dir():
    ana.dl = ana.DirDataLayer(pickle_dir="/tmp/test_ana")
    one = A(1)
    nose.tools.assert_is(one, A.ana_load(one.ana_store()))
    nose.tools.assert_true(os.path.exists("/tmp/test_ana/%s.p" % one.ana_uuid))

    uuid = one.ana_uuid
    old_id = id(one)
    del one
    gc.collect()
    ana.dl = ana.DirDataLayer(pickle_dir="/tmp/test_ana")
    two = A.ana_load(uuid)
    nose.tools.assert_equals(uuid, two.ana_uuid)
    nose.tools.assert_not_equals(old_id, id(two))

    # reset the datalayer to make sure we handle it properly
    ana.set_dl(ana.DictDataLayer())
    try:
        two = A.ana_load(uuid)
        assert False
    except KeyError:
        pass
    two.ana_store()
    del two
    three = A.ana_load(uuid)
    assert uuid, three.ana_uuid
Esempio n. 2
0
def test_datalayer():
    l.info("Running test_datalayer")

    pickle_dir = tempfile.mkdtemp()
    ana.set_dl(ana.DirDataLayer(pickle_dir))
    l.debug("Pickling to %s", pickle_dir)

    a = claripy.BVV(1, 32)
    b = claripy.BVS("x", 32)
    c = a + b
    d = a + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b + b

    l.debug("Storing!")
    a.ana_store()
    c_info = c.ana_store()
    d_info = d.ana_store()

    l.debug("Loading!")
    ana.set_dl(ana.DirDataLayer(pickle_dir))
    #nose.tools.assert_equal(len(claripy.dl._cache), 0)

    cc = claripy.ast.BV.ana_load(c_info)
    nose.tools.assert_equal(str(cc), str(c))
    cd = claripy.ast.BV.ana_load(d_info)
    nose.tools.assert_equal(str(cd), str(d))

    l.debug("Time to test some solvers!")
    s = claripy.Solver()
    x = claripy.BVS("x", 32)
    s.add(x == 3)
    s.finalize()
    ss = claripy.Solver.ana_load(s.ana_store())
    nose.tools.assert_equal(str(s.constraints), str(ss.constraints))
    nose.tools.assert_equal(str(s.variables), str(ss.variables))

    s = claripy.SolverComposite()
    x = claripy.BVS("x", 32)
    s.add(x == 3)
    s.finalize()
    ss = claripy.SolverComposite.ana_load(s.ana_store())
    old_constraint_sets = [[hash(j) for j in k.constraints]
                           for k in s._solver_list]
    new_constraint_sets = [[hash(j) for j in k.constraints]
                           for k in ss._solver_list]
    nose.tools.assert_equal(old_constraint_sets, new_constraint_sets)
    nose.tools.assert_equal(str(s.variables), str(ss.variables))
Esempio n. 3
0
def test_pickling():
    # set up ANA and make the pickles
    ana.set_dl(ana.DirDataLayer('pickletest'))
    make_pickles()

    # make sure the pickles work in the same "session"
    load_pickles()

    # reset ANA, and load the pickles
    ana.set_dl(ana.DirDataLayer('pickletest'))
    gc.collect()
    load_pickles()

    # purposefully set the wrong directory to make sure this excepts out
    ana.set_dl(ana.DirDataLayer('pickletest2'))
    gc.collect()
    #load_pickles()
    nose.tools.assert_raises(Exception, load_pickles)
Esempio n. 4
0
def test_serialization():
    ana.set_dl(ana.DirDataLayer('/tmp/ana'))

    for d in internaltest_arch:
        for f in internaltest_files:
            fpath = os.path.join(internaltest_location, d,f)
            if os.path.isfile(fpath) and os.access(fpath, os.X_OK):
                p = angr.Project(fpath)
                internaltest_project(p)

    p = angr.Project(os.path.join(internaltest_location, 'i386/fauxware'), load_options={'auto_load_libs': False})
    cfg = internaltest_cfg(p)
    internaltest_vfg(p, cfg)
Esempio n. 5
0
def test_pickling():
    try:
        # set up ANA and make the pickles
        ana.set_dl(ana.DirDataLayer('pickletest'))
        make_pickles()

        # make sure the pickles work in the same "session"
        load_pickles()

        # reset ANA, and load the pickles
        ana.set_dl(ana.DirDataLayer('pickletest'))
        gc.collect()
        load_pickles()

        # purposefully set the wrong directory to make sure this excepts out
        ana.set_dl(ana.DirDataLayer('pickletest2'))
        gc.collect()
        #load_pickles()
        nose.tools.assert_raises(Exception, load_pickles)
    finally:
        try:
            shutil.rmtree('pickletest')
        except:
            pass
        try:
            shutil.rmtree('pickletest2')
        except:
            pass
        try:
            os.remove('pickletest_good')
        except:
            pass
        try:
            os.remove('pickletest_bad')
        except:
            pass
Esempio n. 6
0
def test_state_pickle():
    old_dl = ana.dl
    ana.set_dl(ana.DirDataLayer('/tmp/picklez'))
    try:
        s = SimState(arch="AMD64")
        s.memory.store(100, s.se.BVV(0x4141414241414241424300, 88), endness='Iend_BE')
        s.regs.rax = 100

        sp = pickle.dumps(s)
        del s
        gc.collect()
        s = pickle.loads(sp)
        nose.tools.assert_equals(s.se.any_str(s.memory.load(100, 10)), "AAABAABABC")
    finally:
        ana.dl = old_dl
def setup():
    ana.set_dl(ana.DirDataLayer('/tmp/picklez'))
Esempio n. 8
0
def setup():
    tmp_dir = tempfile.mkdtemp(prefix='test_serialization_ana')
    ana.set_dl(ana.DirDataLayer(tmp_dir))
Esempio n. 9
0
def setup():
    tmp_dir = tempfile.mkdtemp(prefix='test_state_picklez')
    ana.set_dl(ana.DirDataLayer(tmp_dir))
def setup():
    ana.set_dl(ana.DirDataLayer('/tmp/ana'))