コード例 #1
0
ファイル: tags.py プロジェクト: arizvisa/idascripts
    def content(cls, F, *tags, **location):
        '''Iterate through the specified `tags` belonging to the contents of the function at `ea` using the cache.'''
        identity = lambda res: res
        translate = addressToLocation if location.get('location', False) else identity

        iterable = func.select(F, Or=tags) if tags else func.select(F)
        for ea, res in iterable:
            ui.navigation.set(ea)
            if res: yield translate(ea), res
        return
コード例 #2
0
ファイル: tags.py プロジェクト: xcode2010/ida-minsc
    def content(cls, F, *tags, **location):
        '''Iterate through the specified `tags` belonging to the contents of the function at `ea` using the cache.'''
        identity = lambda res: res
        translate = addressToLocation if location.get('location',
                                                      False) else identity

        iterable = func.select(F, Or=tags) if tags else func.select(F)
        for ea, res in iterable:
            ui.navigation.set(ea)
            if res: yield translate(ea), res
        return
コード例 #3
0
ファイル: helper.py プロジェクト: IDA-RE-things/idascripts
def recovermarks():
    '''Utilizing any tag information found in the database, recreate all the database marks.'''
    # collect
    result = []
    for fn,l in database.select('marks'):
        m = set( (l['marks']) if hasattr(l['marks'],'__iter__') else [int(x,16) for x in l['marks'].split(',')] if type(l['marks']) is str else [l['marks']])
        res = [(ea,d['mark']) for ea,d in function.select(fn,'mark')]
        if m != set(a for a,_ in res):
            logging.warning("%x: ignoring cached version of marks due to being out-of-sync with real values : %r : %r", fn, map(hex,m), map(hex,set(a for a,_ in res)))
        result.extend(res)
    result.sort(cmp=lambda x,y: cmp(x[1],y[1]))

    # discovered marks versus database marks
    result = dict(result)
    current = {ea:descr for ea,descr in database.marks()}

    # create tags
    for x,y in result.items():
        if (x not in current) or (current[x] != result[x]):
            if current[x] != result[x]:
                logging.info('%x: database tag is newer than mark description : %r', x, result[x])
            database.mark(x, y)
            continue
        logging.warning('%x: skipping already existing mark : %r', x, current[x])

    # marks that aren't reachable in the database
    for ea in set(current.viewkeys()).difference(result.viewkeys()):
        logging.warning('%x: unreachable mark (global) : %r', ea, current[ea])

    # color them
    colormarks()
コード例 #4
0
def dump_labels(func, statement="g"):
    Escape = lambda s: s.replace('"', '\\"')
    for ea, t in fn.select(func, 'name'):
        print 'bp {:s} ".printf \\"label {:s}:{:s}\\\\n\\";{:s}"'.format(
            eaToReference(ea), fn.name(func), Escape(t['name']),
            Escape(statement))
    return
コード例 #5
0
ファイル: tools.py プロジェクト: xcode2010/ida-minsc
def recovermarks():
    """Walk through the tags made by ``colormarks`` and re-create the marks that were found.

    This is useful if any marks were accidentally deleted and can be used for
    recovering them as long as they were initally tagged properly.
    """
    # collect
    result = []
    for fn, l in database.select('marks'):
        m = {item
             for item in l['marks']} if hasattr(l['marks'], '__iter__') else {
                 int(item, 16)
                 for item in l['marks'].split(',')
             } if isinstance(l['marks'], six.string_types) else {l['marks']}
        res = [(ea, d['mark']) for ea, d in func.select(fn, 'mark')]
        if m != {ea for ea, _ in res}:
            logging.warning(
                "{:s} : Ignoring the function tag \"{:s}\" for function {:#x} due to its value being out-of-sync with the contents values ({!s} <> {!s})."
                .format('.'.join([__name__, 'recovermarks']), fn,
                        builtins.map("{:#x}".format, m),
                        builtins.map("{:#x}".format, {ea
                                                      for ea, _ in res})))
        result.extend(res)
    result.sort(key=lambda item: item[1])

    # discovered marks versus database marks
    result = {ea: item for ea, item in result.items()}
    current = {ea: descr for ea, descr in database.marks()}

    # create tags
    for x, y in result.items():
        if x in current:
            logging.warning(
                "{:#x}: skipping already existing mark : {!r}".format(
                    x, current[x]))
            continue

        # x not in current
        if x not in current:
            logging.info("{:#x}: adding missing mark due to tag : {!r}".format(
                x, result[x]))
        elif current[x] != result[x]:
            logging.info(
                "{:#x}: database tag is different than mark description : {!r}"
                .format(x, result[x]))
        else:
            assert current[x] == result[x]
        database.mark(x, y)

    # marks that aren't reachable in the database
    for ea in {item
               for item in current.keys()
               }.difference({item
                             for item in result.keys()}):
        logging.warning("{:#x}: unreachable mark (global) : {!r}".format(
            ea, current[ea]))

    # color them
    colormarks()
コード例 #6
0
ファイル: windbg.py プロジェクト: xcode2010/ida-minsc
def breakpoints(f=None, **kwargs):
    """Query the function `f` for the "break" tag, and use it to emit a list of breakpoints for windbg.

    If the string `module` is specified, then use it instead of the current filename when emitting the location.
    If the string `tagname` is provided, then use it to query instead of "break".
    """
    tagname = kwargs.get('tagname', 'break')

    # if no function was provided, then recurse into ourself for all of them
    if f is None:
        for f, _ in db.selectcontents(tagname):
            breakpoints(f, **kwargs)
        return

    #entry, exit = func.top(f), func.bottom(f)
    #funcname = func.name(f)
    #[(entry,{tagname:'.printf "Entering {:s} %x,%x\\n",poi(@esp),@esp'.format(funcname)})], [(x,{tagname:'.printf "Exiting {:s} %x,%x\\n",poi(@esp),@esp'.format(funcname)}) for x in exit],

    # query the given function for the requested tagname
    tags, select = {}, itertools.chain(func.select(f, And=(tagname,), Or=('',)))
    for ea, t in select:
        h = tags.setdefault(ea, {})
        for k in t.keys():
            if k == tagname:
                h.setdefault(k, []).extend(t[k] if isinstance(t[k], builtins.list) else t[k].split(';'))

            elif operator.contains(h, k):
                logging.warning(u"{:s}.breakpoints({:#x}{:s}) : The specified key \"{:s}\" already exists in dictionary for address {:#x}.".format(__name__, func.addr(f), u", {:s}".format(utils.strings.kwargs(kwargs)) if kwargs else '', utils.string.escape(k, '"'), ea))

            else:
                h[k] = t[k]
            continue
        continue

    # aggregate all of the discovered tags into a list of breakpoints
    for ea, t in tags.items():
        ofs, commands = db.offset(ea), []

        # create the command that emits the current label
        label_t = string.Template(r'.printf "$label -- $note\n"' if operator.contains(t, '') else r'.printf "$label\n"')
        commands.append(label_t.safe_substitute(label=label(ea), note=t.get('', '')))

        # append the commands to execute when encountering the given breakpoint
        res = t.get(tagname, ['g'])
        if isinstance(res, builtins.list):
            commands.extend(res)
        else:
            commands.append(res)

        # escape all of the commands since we're going to join them together
        commands = (escape(cmd) for cmd in commands)

        six.print_('bp {:s} "{:s}"'.format(reference(ea, **kwargs), escape(';'.join(commands), depth=1)))
    return
コード例 #7
0
def dump_breaks(func=None, tagname='break', stdout=True):
    if func is None:
        for func, _ in db.selectcontents(tagname):
            dump_breaks(func, tagname=tagname)
        return
    Escape = lambda s: s.replace('"', '\\"')

    entry, exit = fn.top(func), fn.bottom(func)
    funcname = fn.name(func)

    #[(entry,{tagname:'.printf "Entering {:s} %x,%x\\n",poi(@esp),@esp'.format(funcname)})], [(x,{tagname:'.printf "Exiting {:s} %x,%x\\n",poi(@esp),@esp'.format(funcname)}) for x in exit],
    select = itertools.chain(fn.select(func, And=(tagname, ), Or=('', )))

    res = {}
    for ea, t in select:
        h = res.setdefault(ea, {})
        for k in t.keys():
            if k == tagname:
                h.setdefault(k, []).extend(t[k].split(';'))
            else:
                assert k not in h
                h[k] = t[k]
        continue

    output = []
    for ea, t in res.iteritems():
        ofs = db.offset(ea)

        commands = []
        label = Template('.printf "$label -- $note\\n"' if t.
                         has_key('') else '.printf "$label\\n"')
        commands.append(
            label.safe_substitute(label=eaToLabel(ea), note=t.get('', '')))
        commands.extend(t.get(tagname, ['g']))
        commands = map(windbgescape, commands)

        breakpoint = 'bp {:s} "{:s}"'.format(eaToReference(ea),
                                             Escape(';'.join(commands)))
        if stdout:
            print(breakpoint)

        output.append(breakpoint)

    if len(output) == 1:
        return output[0] + '\n'

    return '\n'.join(output)
コード例 #8
0
ファイル: tools.py プロジェクト: k273811702/idascripts
def recovermarks():
    '''Utilizing any tag information found in the database, recreate all the database marks.'''
    # collect
    result = []
    for fn, l in database.select('marks'):
        m = set((l['marks']) if hasattr(l['marks'], '__iter__') else
                [int(x, 16) for x in l['marks'].
                 split(',')] if type(l['marks']) is str else [l['marks']])
        res = [(ea, d['mark']) for ea, d in function.select(fn, 'mark')]
        if m != set(a for a, _ in res):
            logging.warning(
                "{:x}: ignoring cached version of marks due to being out-of-sync with real values : {!r} : {!r}"
                .format(fn, map(hex, m), map(hex, set(a for a, _ in res))))
        result.extend(res)
    result.sort(cmp=lambda x, y: cmp(x[1], y[1]))

    # discovered marks versus database marks
    result = dict(result)
    current = {ea: descr for ea, descr in database.marks()}

    # create tags
    for x, y in result.items():
        if x in current:
            logging.warning(
                "{:x}: skipping already existing mark : {!r}".format(
                    x, current[x]))
            continue

        # x not in current
        if x not in current:
            logging.info("{:x}: adding missing mark due to tag : {!r}".format(
                x, result[x]))
        elif current[x] != result[x]:
            logging.info(
                "{:x}: database tag is different than mark description : {!r}".
                format(x, result[x]))
        else:
            assert current[x] == result[x]
        database.mark(x, y)

    # marks that aren't reachable in the database
    for ea in set(current.viewkeys()).difference(result.viewkeys()):
        logging.warning("{:x}: unreachable mark (global) : {!r}".format(
            ea, current[ea]))

    # color them
    colormarks()
コード例 #9
0
ファイル: tools.py プロジェクト: PeterG75/ida-minsc
def recovermarks():
    """Walk through the tags made by `colormarks` and re-create the marks that were found.

    This is useful if any marks were accidentally deleted and can be used for
    recovering them as long as they were initally tagged properly.
    """
    # collect
    result = []
    for fn, l in database.select('marks'):
        m = set( (l['marks']) if hasattr(l['marks'], '__iter__') else [int(x, 16) for x in l['marks'].split(',')] if type(l['marks']) is str else [l['marks']])
        res = [(ea, d['mark']) for ea, d in func.select(fn, 'mark')]
        if m != set(a for a, _ in res):
            logging.warning("{:#x}: ignoring cached version of marks due to being out-of-sync with real values : {!r} : {!r}".format(fn, builtins.map(hex, m), builtins.map(hex, set(a for a, _ in res))))
        result.extend(res)
    result.sort(cmp=lambda x, y: cmp(x[1], y[1]))

    # discovered marks versus database marks
    result = dict(result)
    current = {ea : descr for ea, descr in database.marks()}

    # create tags
    for x, y in result.items():
        if x in current:
            logging.warning("{:#x}: skipping already existing mark : {!r}".format(x, current[x]))
            continue

        # x not in current
        if x not in current:
            logging.info("{:#x}: adding missing mark due to tag : {!r}".format(x, result[x]))
        elif current[x] != result[x]:
            logging.info("{:#x}: database tag is different than mark description : {!r}".format(x, result[x]))
        else:
            assert current[x] == result[x]
        database.mark(x, y)

    # marks that aren't reachable in the database
    for ea in set(current.viewkeys()).difference(result.viewkeys()):
        logging.warning("{:#x}: unreachable mark (global) : {!r}".format(ea, current[ea]))

    # color them
    colormarks()
コード例 #10
0
ファイル: tools.py プロジェクト: arizvisa/idascripts
def recovermarks():
    """Walk through the tags made by ``colormarks`` and re-create the marks that were found.

    This is useful if any marks were accidentally deleted and can be used for
    recovering them as long as they were initally tagged properly.
    """
    # collect
    result = []
    for fn, l in database.select('marks'):
        m = set( (l['marks']) if hasattr(l['marks'], '__iter__') else [int(x, 16) for x in l['marks'].split(',')] if type(l['marks']) is str else [l['marks']])
        res = [(ea, d['mark']) for ea, d in func.select(fn, 'mark')]
        if m != { a for a, _ in res }:
            logging.warning("{:s} : Ignoring the function tag \"{:s}\" for function {:#x} due to its value being out-of-sync with the contents values ({!s} <> {!s}).".format('.'.join((__name__, 'recovermarks')), fn, builtins.map(hex, m), builtins.map(hex, set(a for a, _ in res))))
        result.extend(res)
    result.sort(cmp=lambda x, y: cmp(x[1], y[1]))

    # discovered marks versus database marks
    result = dict(result)
    current = {ea : descr for ea, descr in database.marks()}

    # create tags
    for x, y in result.items():
        if x in current:
            logging.warning("{:#x}: skipping already existing mark : {!r}".format(x, current[x]))
            continue

        # x not in current
        if x not in current:
            logging.info("{:#x}: adding missing mark due to tag : {!r}".format(x, result[x]))
        elif current[x] != result[x]:
            logging.info("{:#x}: database tag is different than mark description : {!r}".format(x, result[x]))
        else:
            assert current[x] == result[x]
        database.mark(x, y)

    # marks that aren't reachable in the database
    for ea in set(current.viewkeys()).difference(result.viewkeys()):
        logging.warning("{:#x}: unreachable mark (global) : {!r}".format(ea, current[ea]))

    # color them
    colormarks()
コード例 #11
0
ファイル: main.py プロジェクト: nonsene/training-path
            '\nUser not found!\n\n\nCreating the new list of repositories.\n\n'
        )
        print(
            "Here's a list of repositories that you're saving in your DB:\n\n")
        for i in web_page_json:
            insert_values(username, i['name'])
            print('->' + i['name'])

    count = 0

    while count == 0:
        ans = input(
            '\n\nDo you want to show your repositories list saved on your DB? (y/n)'
        )
        if ans.lower() == 'y':
            lista = select()
            for r in lista:
                print(f'{r[0]}:{r[1]}')
            count = 1
            print('\n\nThanks for using!\n\n...Shuting down...')
            sleep(2)

        elif ans.lower() == 'n':
            print('\n\nThanks for using!\n\n...Shuting down...')
            sleep(2)
            exit()
        else:
            print('\n\nInvalid insert.\n\nTry again')

else:
    print('\nUser not available.')
コード例 #12
0
 def contents(*tags, **boolean):
     for res in db.selectcontents(*tags, **boolean):
         for ea, res in fn.select(*res):
             yield ea, res
         continue
     return
コード例 #13
0
def search(func, *tags):
    print '\n'.join(map(db.disasm, fn.select(func, Or=tags)))