add commands

Author: xialu

commands.py renamed to commands/dt.py

@@ -4,20 +4,6 @@
 except ImportError as e:
     raise ImportError("This script must be run in GDB: ", str(e))
 
-
-class SampleCommand(gdb.Command):
-    '''
-       Your custom gdb command
-       '''
-    _command = "sample_command"
-
-    def __init__(self):
-        gdb.Command.__init__(self, self._command, gdb.COMMAND_STACK)
-
-    def invoke(self, argument, from_tty):
-        print('command is called.')
-
-
 class DTCommand(gdb.Command):
     def __init__(self):
         # This registers our class as "simple_command"

commands/stackfold.py

@@ -0,0 +1,74 @@
+# From https://fy.blackhats.net.au/blog/html/2017/08/04/so_you_want_to_script_gdb_with_python.html
+#####################################################
+#
+# Usage: to load this to gdb run:
+# (gdb) source ..../path/to/debug_naughty.py
+#
+# To have this automatically load, you need to put the script
+# in a path related to your binary. If you make /usr/sbin/foo,
+# You can ship this script as:
+# /usr/share/gdb/auto-load/ <PATH TO BINARY>
+# /usr/share/gdb/auto-load/usr/sbin/foo
+#
+# This will trigger gdb to autoload the script when you start
+# to acces a core or the live binary from this location.
+#
+
+import gdb
+
+
+class StackFold(gdb.Command):
+    def __init__(self):
+        super(StackFold, self).__init__("stackfold", gdb.COMMAND_DATA)
+
+    def invoke(self, arg, from_tty):
+        # An inferior is the 'currently running applications'. In this case we only
+        # have one.
+        stack_maps = {}
+        # This creates a dict where each element is keyed by backtrace.
+        # Then each backtrace contains an array of "frames"
+        #
+        inferiors = gdb.inferiors()
+        for inferior in inferiors:
+            for thread in inferior.threads():
+                try:
+                    # Change to our threads context
+                    thread.switch()
+                    # Get the thread IDS
+                    (tpid, lwpid, tid) = thread.ptid
+                    gtid = thread.num
+                    # Take a human readable copy of the backtrace, we'll need this for display later.
+                    o = gdb.execute('bt', to_string=True)
+                    # Build the backtrace for comparison
+                    backtrace = []
+                    gdb.newest_frame()
+                    cur_frame = gdb.selected_frame()
+                    while cur_frame is not None:
+                        if cur_frame.name() is not None:
+                            backtrace.append(cur_frame.name())
+
+                        cur_frame = cur_frame.older()
+                    # Now we have a backtrace like ['pthread_cond_wait@@GLIBC_2.3.2', 'lazy_thread', 'start_thread', 'clone']
+                    # dicts can't use lists as keys because they are non-hashable, so we turn this into a string.
+                    # Remember, C functions can't have spaces in them ...
+                    s_backtrace = ' '.join(backtrace)
+                    # Let's see if it exists in the stack_maps
+                    if s_backtrace not in stack_maps:
+                        stack_maps[s_backtrace] = []
+                    # Now lets add this thread to the map.
+                    stack_maps[s_backtrace].append(
+                        {'gtid': gtid, 'tpid': tpid, 'bt': o})
+                except Exception as e:
+                    print(e)
+        # Now at this point we have a dict of traces, and each trace has a "list" of pids that match. Let's display them
+        for smap in stack_maps:
+            # Get our human readable form out.
+            o = stack_maps[smap][0]['bt']
+            for t in stack_maps[smap]:
+                # For each thread we recorded
+                print("Thread %s (LWP %s))" % (t['gtid'], t['tpid']))
+            print(o)
+
+
+# This registers our class to the gdb runtime at "source" time.
+StackFold()

commands/stackwalk.py

@@ -0,0 +1,44 @@
+
+# Usage: to load this to gdb run:
+# (gdb) source ..../path/to/debug_naughty.py
+#
+# To have this automatically load, you need to put the script
+# in a path related to your binary. If you make /usr/sbin/foo,
+# You can ship this script as:
+# /usr/share/gdb/auto-load/ <PATH TO BINARY>
+# /usr/share/gdb/auto-load/usr/sbin/foo
+#
+# This will trigger gdb to autoload the script when you start
+# to acces a core or the live binary from this location.
+#
+
+import gdb
+
+
+class StackWalkWCharCommand(gdb.Command):
+    def __init__(self):
+        # This registers our class as "simple_command"
+        super(StackWalkWCharCommand, self).__init__("stackwalk", gdb.COMMAND_DATA)
+
+    def invoke(self, arg, from_tty):
+        # When we call "simple_command" from gdb, this is the method
+        # that will be called.
+        print("Hello from simple_command!")
+        # get the register
+        rbp = gdb.parse_and_eval('$rbp')
+        rsp = gdb.parse_and_eval('$rsp')
+        ptr = rsp
+        ppwc = gdb.lookup_type('wchar_t').pointer().pointer()
+        while ptr < rbp:
+            try:
+                print('pointer is {}'.format(ptr))
+                print(gdb.execute('wc_print {}'.format(
+                    ptr.cast(ppwc).dereference())))
+                print('===')
+            except:
+                pass
+            ptr += 4
+
+
+# This registers our class to the gdb runtime at "source" time.
+StackWalkWCharCommand()

common.py

@@ -15,3 +15,41 @@ def not_handle_SIGSEGV():
 def enable_logging(logging_file):
     gdb.execute('set logging file ' + logging_file)
     gdb.execute('set logging on')
+
+
+def dynamic_value(val):
+    '''val must be pointer or a reference'''
+    return val.cast(val.dynamic_type)
+
+
+def norm_type(tp):
+    '''return the pointee type if the type is pointter'''
+    if tp.code == gdb.TYPE_CODE_PTR:
+        pointee_type = tp.target()
+        if pointee_type.code == gdb.TYPE_CODE_PTR:
+            return norm_type(pointee_type)
+        return pointee_type
+    return tp
+
+
+def is_null(val):
+    if val.type.code == gdb.TYPE_CODE_PTR:
+        return int(val) == 0
+    return False
+
+
+def deref(pointer):
+    '''dereference pointer to get value'''
+    val = pointer
+    if val.type.code == gdb.TYPE_CODE_PTR:
+        if is_null(val):
+            raise Exception("nullptr")
+        val = dynamic_value(val)
+        val = val.referenced_value()
+        if val.type.code == gdb.TYPE_CODE_PTR:
+            if is_null(val):
+                raise Exception("nullptr")
+            val = dynamic_value(val)
+            val = val.referenced_value()
+    return val
+

prelude.py

@@ -7,6 +7,6 @@ def add_paths():
     scripts_folder = os.path.dirname(__file__)
 
     print('add to the python sys.path: '+ scripts_folder)
-    sys.path.append(scripts_folder)
+    sys.path.insert(0, scripts_folder)
 
 add_paths()

pretty_printers/pointer.py

@@ -0,0 +1,32 @@
+# # printer is to pretty print the variable
+# # 1 create a printer with to_string method
+# # 2 create a printer matcher
+# # 3 register the printer to the gdb.
+
+import re
+import gdb.printing
+import gdb
+import traceback
+import common
+gPrinters = {}
+
+def lookup_pretty_printer(val):
+    try:
+        tp = val.type
+        if val.type.code == gdb.TYPE_CODE_PTR:
+            tp = common.norm_type(val.type)
+            if int(val) == 0:
+                return None
+        for k, v in gPrinters.items():
+            if k.search(str(tp)):
+                return v(val)
+    except Exception as e:
+        print(traceback.format_exc())
+    return None
+
+
+print('register disptacher for pointer.')
+gdb.printing.register_pretty_printer(
+    gdb.current_objfile(),
+    lookup_pretty_printer, replace=True
+)

process.py

@@ -0,0 +1,27 @@
+
+try:
+    import gdb
+except ImportError as e:
+    raise ImportError("This script must be run in GDB: ", str(e))
+
+gProcess = None
+class Process:
+    def __init__(self):
+        self._inferior = gdb.selected_inferior()
+        self.types = {}
+
+    def read_memory(self, addr, size):
+        return self._inferior.read_memory(addr, size)
+
+    def lookup_type(self, tp):
+        if tp in self.types:
+            return self.types[tp]
+        _tp = gdb.lookup_type(tp)
+        self.types[tp] = _tp
+        return _tp
+
+def get_process():
+    global gProcess
+    if not gProcess:
+        gProcess = Process()
+    return gProcess

util.py

@@ -2,28 +2,14 @@
     import gdb
 except ImportError as e:
     raise ImportError("This script must be run in GDB: ", str(e))
-    
+
 from libstdcxx.v6.printers import StdMapPrinter, StdVectorPrinter, StdListPrinter
 import re
 
 
 def print_stack_trace():
     gdb.execute('bt')
 
-def dynamic_type(val):
-    '''val must be pointer or a reference'''
-    return val.cast(val.dynamic_type)
-
-
-def norm_type(tp):
-    '''return the pointee type if the type is pointter'''
-    if tp.code == gdb.TYPE_CODE_PTR:
-        pointee_type = tp.target()
-        if pointee_type.code == gdb.TYPE_CODE_PTR:
-            return norm_type(pointee_type)
-        return pointee_type
-    return tp
-
 
 def StdMapToDict(iMap):
     it = StdMapPrinter('map', iMap).children()