| #!/usr/bin/env python |
| |
| #---------------------------------------------------------------------- |
| # Be sure to add the python path that points to the LLDB shared library. |
| # |
| # # To use this in the embedded python interpreter using "lldb" just |
| # import it with the full path using the "command script import" |
| # command |
| # (lldb) command script import /path/to/cmdtemplate.py |
| #---------------------------------------------------------------------- |
| |
| from __future__ import print_function |
| |
| import platform |
| import os |
| import re |
| import sys |
| import subprocess |
| |
| try: |
| # Just try for LLDB in case PYTHONPATH is already correctly setup |
| import lldb |
| except ImportError: |
| lldb_python_dirs = list() |
| # lldb is not in the PYTHONPATH, try some defaults for the current platform |
| platform_system = platform.system() |
| if platform_system == 'Darwin': |
| # On Darwin, try the currently selected Xcode directory |
| xcode_dir = subprocess.check_output("xcode-select --print-path", shell=True) |
| if xcode_dir: |
| lldb_python_dirs.append( |
| os.path.realpath( |
| xcode_dir + |
| '/../SharedFrameworks/LLDB.framework/Resources/Python')) |
| lldb_python_dirs.append( |
| xcode_dir + '/Library/PrivateFrameworks/LLDB.framework/Resources/Python') |
| lldb_python_dirs.append( |
| '/System/Library/PrivateFrameworks/LLDB.framework/Resources/Python') |
| success = False |
| for lldb_python_dir in lldb_python_dirs: |
| if os.path.exists(lldb_python_dir): |
| if not (sys.path.__contains__(lldb_python_dir)): |
| sys.path.append(lldb_python_dir) |
| try: |
| import lldb |
| except ImportError: |
| pass |
| else: |
| print('imported lldb from: "%s"' % (lldb_python_dir)) |
| success = True |
| break |
| if not success: |
| print("error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly") |
| sys.exit(1) |
| |
| import optparse |
| import shlex |
| import string |
| import struct |
| import time |
| |
| |
| def append_data_callback(option, opt_str, value, parser): |
| if opt_str == "--uint8": |
| int8 = int(value, 0) |
| parser.values.data += struct.pack('1B', int8) |
| if opt_str == "--uint16": |
| int16 = int(value, 0) |
| parser.values.data += struct.pack('1H', int16) |
| if opt_str == "--uint32": |
| int32 = int(value, 0) |
| parser.values.data += struct.pack('1I', int32) |
| if opt_str == "--uint64": |
| int64 = int(value, 0) |
| parser.values.data += struct.pack('1Q', int64) |
| if opt_str == "--int8": |
| int8 = int(value, 0) |
| parser.values.data += struct.pack('1b', int8) |
| if opt_str == "--int16": |
| int16 = int(value, 0) |
| parser.values.data += struct.pack('1h', int16) |
| if opt_str == "--int32": |
| int32 = int(value, 0) |
| parser.values.data += struct.pack('1i', int32) |
| if opt_str == "--int64": |
| int64 = int(value, 0) |
| parser.values.data += struct.pack('1q', int64) |
| |
| |
| def create_memfind_options(): |
| usage = "usage: %prog [options] STARTADDR [ENDADDR]" |
| description = '''This command can find data in a specified address range. |
| Options are used to specify the data that is to be looked for and the options |
| can be specified multiple times to look for longer streams of data. |
| ''' |
| parser = optparse.OptionParser( |
| description=description, |
| prog='memfind', |
| usage=usage) |
| parser.add_option( |
| '-s', |
| '--size', |
| type='int', |
| metavar='BYTESIZE', |
| dest='size', |
| help='Specify the byte size to search.', |
| default=0) |
| parser.add_option( |
| '--int8', |
| action="callback", |
| callback=append_data_callback, |
| type='string', |
| metavar='INT', |
| dest='data', |
| help='Specify a 8 bit signed integer value to search for in memory.', |
| default='') |
| parser.add_option( |
| '--int16', |
| action="callback", |
| callback=append_data_callback, |
| type='string', |
| metavar='INT', |
| dest='data', |
| help='Specify a 16 bit signed integer value to search for in memory.', |
| default='') |
| parser.add_option( |
| '--int32', |
| action="callback", |
| callback=append_data_callback, |
| type='string', |
| metavar='INT', |
| dest='data', |
| help='Specify a 32 bit signed integer value to search for in memory.', |
| default='') |
| parser.add_option( |
| '--int64', |
| action="callback", |
| callback=append_data_callback, |
| type='string', |
| metavar='INT', |
| dest='data', |
| help='Specify a 64 bit signed integer value to search for in memory.', |
| default='') |
| parser.add_option( |
| '--uint8', |
| action="callback", |
| callback=append_data_callback, |
| type='string', |
| metavar='INT', |
| dest='data', |
| help='Specify a 8 bit unsigned integer value to search for in memory.', |
| default='') |
| parser.add_option( |
| '--uint16', |
| action="callback", |
| callback=append_data_callback, |
| type='string', |
| metavar='INT', |
| dest='data', |
| help='Specify a 16 bit unsigned integer value to search for in memory.', |
| default='') |
| parser.add_option( |
| '--uint32', |
| action="callback", |
| callback=append_data_callback, |
| type='string', |
| metavar='INT', |
| dest='data', |
| help='Specify a 32 bit unsigned integer value to search for in memory.', |
| default='') |
| parser.add_option( |
| '--uint64', |
| action="callback", |
| callback=append_data_callback, |
| type='string', |
| metavar='INT', |
| dest='data', |
| help='Specify a 64 bit unsigned integer value to search for in memory.', |
| default='') |
| return parser |
| |
| |
| def memfind_command(debugger, command, result, dict): |
| # Use the Shell Lexer to properly parse up command options just like a |
| # shell would |
| command_args = shlex.split(command) |
| parser = create_memfind_options() |
| (options, args) = parser.parse_args(command_args) |
| # try: |
| # (options, args) = parser.parse_args(command_args) |
| # except: |
| # # if you don't handle exceptions, passing an incorrect argument to the OptionParser will cause LLDB to exit |
| # # (courtesy of OptParse dealing with argument errors by throwing SystemExit) |
| # result.SetStatus (lldb.eReturnStatusFailed) |
| # print >>result, "error: option parsing failed" # returning a string is the same as returning an error whose description is the string |
| # return |
| memfind(debugger.GetSelectedTarget(), options, args, result) |
| |
| |
| def print_error(str, show_usage, result): |
| print(str, file=result) |
| if show_usage: |
| print(create_memfind_options().format_help(), file=result) |
| |
| |
| def memfind(target, options, args, result): |
| num_args = len(args) |
| start_addr = 0 |
| if num_args == 1: |
| if options.size > 0: |
| print_error( |
| "error: --size must be specified if there is no ENDADDR argument", |
| True, |
| result) |
| return |
| start_addr = int(args[0], 0) |
| elif num_args == 2: |
| if options.size != 0: |
| print_error( |
| "error: --size can't be specified with an ENDADDR argument", |
| True, |
| result) |
| return |
| start_addr = int(args[0], 0) |
| end_addr = int(args[1], 0) |
| if start_addr >= end_addr: |
| print_error( |
| "error: inavlid memory range [%#x - %#x)" % |
| (start_addr, end_addr), True, result) |
| return |
| options.size = end_addr - start_addr |
| else: |
| print_error("error: memfind takes 1 or 2 arguments", True, result) |
| return |
| |
| if not options.data: |
| print('error: no data specified to search for', file=result) |
| return |
| |
| if not target: |
| print('error: invalid target', file=result) |
| return |
| process = target.process |
| if not process: |
| print('error: invalid process', file=result) |
| return |
| |
| error = lldb.SBError() |
| bytes = process.ReadMemory(start_addr, options.size, error) |
| if error.Success(): |
| num_matches = 0 |
| print("Searching memory range [%#x - %#x) for" % ( |
| start_addr, end_addr), end=' ', file=result) |
| for byte in options.data: |
| print('%2.2x' % ord(byte), end=' ', file=result) |
| print(file=result) |
| |
| match_index = string.find(bytes, options.data) |
| while match_index != -1: |
| num_matches = num_matches + 1 |
| print('%#x: %#x + %u' % (start_addr + |
| match_index, start_addr, match_index), file=result) |
| match_index = string.find(bytes, options.data, match_index + 1) |
| |
| if num_matches == 0: |
| print("error: no matches found", file=result) |
| else: |
| print('error: %s' % (error.GetCString()), file=result) |
| |
| |
| if __name__ == '__main__': |
| print('error: this script is designed to be used within the embedded script interpreter in LLDB') |
| elif getattr(lldb, 'debugger', None): |
| memfind_command.__doc__ = create_memfind_options().format_help() |
| lldb.debugger.HandleCommand( |
| 'command script add -f memory.memfind_command memfind') |
| print('"memfind" command installed, use the "--help" option for detailed help') |
