예제 #1
0
    def test_longpath_basic(self):
        g = vs_graphcore.HierGraph()
        g.addHierRootNode('A')
        for i in range(ord('B'), ord('M')):
            g.addNode(chr(i))

        g.addEdgeByNids('A', 'B')
        g.addEdgeByNids('A', 'C')
        g.addEdgeByNids('B', 'D')
        g.addEdgeByNids('B', 'E')
        g.addEdgeByNids('C', 'F')
        g.addEdgeByNids('C', 'G')
        g.addEdgeByNids('D', 'H')
        g.addEdgeByNids('E', 'H')
        g.addEdgeByNids('F', 'I')
        g.addEdgeByNids('G', 'I')
        g.addEdgeByNids('H', 'J')
        g.addEdgeByNids('H', 'K')
        g.addEdgeByNids('I', 'L')
        g.addEdgeByNids('J', 'L')
        g.addEdgeByNids('K', 'L')

        pathgenr = viv_graph.getLongPath(g)
        longpath = next(pathgenr)
        self.assertEqual(len(longpath), 6)
예제 #2
0
    def test_graphutil_getopsfrompath(self):
        vw = self.gcc_vw
        g = v_t_graphutil.buildFunctionGraph(vw, 0x414a2a)
        path = next(v_t_graphutil.getLongPath(g))

        ops = [
            'push r14',
            'push r13',
            'mov r13,rdx',
            'push r12',
            'push rbp',
            'mov r12,rsi',
            'push rbx',
            'mov rbx,rdi',
            'sar r12,3',
            'mov rbp,rsi',
            'mov edx,r12d',
            'mov r14d,ecx',
            'sub rsp,16',
            'mov rdi,qword [rdi + 48]',
            'mov qword [rsp + 8],rsi',
            'lea rsi,qword [rsp + 8]',
            'call 0x00414962',
            'cmp qword [rax],0',
            'jz 0x00414abc',
            'mov rdx,qword [rax + 8]',
            'mov rax,qword [rdx]',
            'cmp r13,rax',
            'jbe 0x00414a85',
            'mov edx,0x004d76b0',
            'mov esi,151',
            'mov edi,0x004d7534',
            'call 0x0041806c',
            'sub rax,r13',
            'test r14l,r14l',
            'mov qword [rdx],rax',
            'jz 0x00414abc',
            'mov rbx,qword [rbx + 48]',
            'lea rsi,qword [rsp + 8]',
            'xor ecx,ecx',
            'mov edx,r12d',
            'mov qword [rsp + 8],rbp',
            'mov rdi,rbx',
            'call 0x004154ec',
            'cmp qword [rax],0',
            'jz 0x00414abc',
            'mov qword [rax],1',
            'inc qword [rbx + 24]',
            'add rsp,16',
            'pop rbx',
            'pop rbp',
            'pop r12',
            'pop r13',
            'pop r14',
            'ret '
        ]
        self.assertEqual(ops, map(str, v_t_graphutil.getOpsFromPath(vw, g, path)))
예제 #3
0
 def test_graphutil_longpath(self):
     '''
     order matters
     '''
     vw = self.firefox_vw
     g = v_t_graphutil.buildFunctionGraph(vw, 0x1400037c0)
     longpath = []
     longpath = [0x1400037c0, 0x14000382d, 0x1400038a4, 0x140003964, 0x140003994, 0x1400039cc, 0x1400039f6, 0x140003a29, 0x140003a59, 0x140003a83, 0x140003ab3, 0x140003b3b, 0x140003b3e, 0x140003ccd, 0x140003c3c, 0x140003c3f, 0x140003c4c, 0x140003c52, 0x140003c5f, 0x140003c65, 0x140003c72, 0x140003c78, 0x140003c85, 0x140003c8b, 0x140003c98, 0x140003c9e, 0x140003cab, 0x140003cb1, 0x140003cc2, 0x1400038fd, 0x14000390a, 0x140003910, 0x14000392b, 0x140003938, 0x14000393e]
     path = next(v_t_graphutil.getLongPath(g))
     path = [k[0] for k in path]
     self.assertEqual(path, longpath)
예제 #4
0
    def test_graphutil_longpath(self):
        '''
        order matters
        '''
        vw = self.gcc_vw
        # TODO: symbolik switchcase
        # g = v_t_graphutil.buildFunctionGraph(vw, 0x445db6)
        # longpath = [0x445db6, 0x445dc3, 0x445dd7, 0x445deb, 0x445dfc, 0x445e01, 0x445e0b, 0x445ddc, 0x445e11, 0x445e20, 0x445e2c, 0x445e30, 0x445e4b, 0x445e5b, 0x445e72, 0x445e85, 0x445e85, 0x445ea1, 0x445ea3, 0x445eae, 0x445ebb, 0x445df5, 0x445ec2]
        # path = next(v_t_graphutil.getLongPath(g))
        # self.assertEqual(longpath, map(lambda k: k[0], path))

        g = v_t_graphutil.buildFunctionGraph(vw, 0x405c10)
        longpath=[0x405c10, 0x405c48, 0x405ca6, 0x405cb0, 0x405cc3, 0x405c4e, 0x405c57, 0x405c5c, 0x405c6b, 0x405cd4, 0x405ce4, 0x405c80, 0x405c8c, 0x405cf6, 0x405c92]
        path = next(v_t_graphutil.getLongPath(g))
        path = map(lambda k: k[0], path)
        self.assertEqual(path, longpath)
예제 #5
0
    def test_longpath_med(self):
        g = vs_graphcore.HierGraph()
        g.addHierRootNode('A')
        for i in range(ord('B'), ord('U')):
            g.addNode(chr(i))

        g.addEdgeByNids('A', 'B')
        g.addEdgeByNids('A', 'C')

        g.addEdgeByNids('B', 'D')
        g.addEdgeByNids('B', 'E')

        g.addEdgeByNids('D', 'F')
        g.addEdgeByNids('E', 'F')

        g.addEdgeByNids('C', 'G')
        g.addEdgeByNids('F', 'G')

        g.addEdgeByNids('G', 'H')
        g.addEdgeByNids('G', 'I')

        g.addEdgeByNids('H', 'J')
        g.addEdgeByNids('H', 'K')

        g.addEdgeByNids('J', 'L')
        g.addEdgeByNids('K', 'L')
        g.addEdgeByNids('I', 'L')

        g.addEdgeByNids('L', 'M')

        g.addEdgeByNids('L', 'Q')
        g.addEdgeByNids('Q', 'R')
        g.addEdgeByNids('Q', 'S')
        g.addEdgeByNids('R', 'T')
        g.addEdgeByNids('S', 'T')
        g.addEdgeByNids('T', 'G')

        g.addEdgeByNids('M', 'N')
        g.addEdgeByNids('M', 'O')

        g.addEdgeByNids('N', 'P')
        g.addEdgeByNids('O', 'P')

        pathgenr = viv_graph.getLongPath(g)
        longpath = next(pathgenr)
        self.assertEqual(len(longpath), 11)
예제 #6
0
 def SKIPtest_longpath_backedge(self):
     # TODO: We need to answer whether or not we support weird backedges in the
     # longpath stuff
     longpath = [
         'Rooty',
         'Lefty',
         'SonOfLefty',
         'LeftysRevenge',
         'LeftyTheReboot',
         'Backtracker',
         'RightyStrikesBack',
         'TheEnd',
         'OrIsIt',
         'TheReboot',
         'Nobody',
         'Wanted',
     ]
     pathgenr = viv_graph.getLongPath(self.graph)
     path = [k[0] for k in next(pathgenr)]
     self.assertEqual(longpath, path)
예제 #7
0
    def test_graphutil_getopsfrompath(self):
        vw = self.firefox_vw
        g = v_t_graphutil.buildFunctionGraph(vw, 0x140048b84)
        path = next(v_t_graphutil.getLongPath(g))

        ops = [
            'push rbx', 'push rsi', 'push rdi', 'sub rsp,64', 'mov rbx,rcx',
            'call qword [rip + 36451]', 'mov rsi,qword [rbx + 248]',
            'xor edi,edi', 'xor r8d,r8d', 'lea rdx,qword [rsp + 96]',
            'mov rcx,rsi', 'call qword [rip + 36505]', 'test rax,rax',
            'jz 0x140048bed', 'and qword [rsp + 56],0',
            'lea rcx,qword [rsp + 104]', 'mov rdx,qword [rsp + 96]',
            'mov r9,rax', 'mov qword [rsp + 48],rcx', 'mov r8,rsi',
            'lea rcx,qword [rsp + 112]', 'mov qword [rsp + 40],rcx',
            'xor ecx,ecx', 'mov qword [rsp + 32],rbx',
            'call qword [rip + 36514]', 'inc edi', 'cmp edi,2',
            'jl 0x140048b9e', 'add rsp,64', 'pop rdi', 'pop rsi', 'pop rbx',
            'ret '
        ]
        self.assertEqual(
            ops, [str(op) for op in v_t_graphutil.getOpsFromPath(vw, g, path)])
예제 #8
0
    def SKIPtest_symbolik_gcc_subchildren(self):
        '''
        So before intify in vivisect/symboliks/common.py, this would bomb out on int has no
        attribute "kids" because the dellocate callspace function wasn't properly marshalling
        argc dellocation as Const() (and instead as raw ints)

        This is here mostly for codification purposes, since actually running this consumes
        more RAM than CI can handle.
        '''
        vw = self.gcc_vw
        fva = 0x00406ad6
        sctx = v_s_analysis.getSymbolikAnalysisContext(vw, consolve=True)
        graph = sctx.getSymbolikGraph(fva)
        for path in v_t_graph.getLongPath(graph):
            for emu, effects in sctx.getSymbolikPaths(fva,
                                                      paths=[
                                                          path,
                                                      ],
                                                      graph=graph):
                break

        calls = [x for x in effects if x.efftype == v_const.EFFTYPE_CALLFUNC]
        self.assertEqual(len(calls), 26)
예제 #9
0
 def checkGetLongPath(self, vw, fva):
     graph = viv_graph.buildFunctionGraph(vw, fva)
     paths = [path for path in viv_graph.getLongPath(graph)]
     self.codepaths = paths
     self.assertGreater(len(self.codepaths), 150)
예제 #10
0
 def checkGetLongPath(self, vw, fva):
     graph = viv_graph.buildFunctionGraph(vw, fva)
     paths = [ path for path in viv_graph.getLongPath(graph) ]
     self.codepaths = paths
     self.assertGreater(len(self.codepaths), 150)