Example #1
0
    def tag_cyclomatic_complexity():
        import function
        import idc
        import idautils
        import symath.graph.signatures as sigs

        fns = set(idautils.Functions())
        rv = {}

        for f in fns:
            fg = FunctionGraph(f)
            #c = fg.cyclomatic_complexity()
            c = sigs.complexity(fg)[1]
            if c < 0:
                c = 0
            function.tag(fg.start_addr, 'cyclomatic complexity', c)
            rv[f] = c

        return rv
Example #2
0
    def tag_aggregate_complexity():
        import function
        import idc
        import idautils
        import callgraph
        import symath.graph.signatures as sigs

        cg = callgraph.CallGraph(includeImports=False)

        graphs = {}
        _reversed = {}
        rv = {}

        fns = set(idautils.Functions())
        cc = {}

        for f in fns:
            graphs[f] = FunctionGraph(f)
            _reversed[f] = FunctionGraph._tag_val(f, 'reversed') != None
            if _reversed[f]:
                cg.strip_edges_to(idc.GetTrueName(f))

        for i in fns:
            ac = symbolic(0)
            for j,l in cg.walk(idc.GetTrueName(i), direction='outgoing'):
                loc = idc.LocByName(j)
                if loc not in graphs:
                  continue
                if loc not in cc:
                    cc[loc] = sigs.complexity(graphs[loc])[1]
                ac += cc[loc] if cc[loc] > 0 else 0

            ac = ac.simplify()
            function.tag(i, 'aggregate complexity', ac)
            rv[i] = ac

        return rv