debugpy 1.8.5__zip → 1.8.6__zip

{debugpy-1.8.5 → debugpy-1.8.6}/src/debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/crash.py

@@ -45,22 +45,18 @@ Crash dump support.
 __revision__ = "$Id$"
 
 __all__ = [
-
     # Object that represents a crash in the debugee.
-    'Crash',
-
+    "Crash",
     # Crash storage.
-    'CrashDictionary',
-
+    "CrashDictionary",
     # Warnings.
-    'CrashWarning',
-
+    "CrashWarning",
     # Backwards compatibility with WinAppDbg 1.4 and before.
-    'CrashContainer',
-    'CrashTable',
-    'CrashTableMSSQL',
-    'VolatileCrashContainer',
-    'DummyCrashContainer',
+    "CrashContainer",
+    "CrashTable",
+    "CrashTableMSSQL",
+    "VolatileCrashContainer",
+    "DummyCrashContainer",
 ]
 
 from winappdbg import win32
@@ -79,11 +75,12 @@ import warnings
 sql = None
 anydbm = None
 
-#==============================================================================
+# ==============================================================================
 
 # Secure alternative to pickle, use it if present.
 try:
     import cerealizer
+
     pickle = cerealizer
 
     # There is no optimization function for cerealized objects.
@@ -102,7 +99,6 @@ try:
 
 # If cerealizer is not present fallback to the insecure pickle module.
 except ImportError:
-
     # Faster implementation of the pickle module as a C extension.
     try:
         import cPickle as pickle
@@ -118,10 +114,12 @@ except ImportError:
     try:
         from pickletools import optimize
     except ImportError:
+
         def optimize(picklestring):
             return picklestring
 
-class Marshaller (StaticClass):
+
+class Marshaller(StaticClass):
     """
     Custom pickler for L{Crash} objects. Optimizes the pickled data when using
     the standard C{pickle} (or C{cPickle}) module. The pickled data is then
@@ -136,18 +134,22 @@ class Marshaller (StaticClass):
     def loads(data):
         return pickle.loads(zlib.decompress(data))
 
-#==============================================================================
 
-class CrashWarning (Warning):
+# ==============================================================================
+
+
+class CrashWarning(Warning):
     """
     An error occurred while gathering crash data.
     Some data may be incomplete or missing.
     """
 
-#==============================================================================
+
+# ==============================================================================
+
 
 # Crash object. Must be serializable.
-class Crash (object):
+class Crash(object):
     """
     Represents a crash, bug, or another interesting event in the debugee.
 
@@ -427,59 +429,59 @@ class Crash (object):
         """
 
         # First of all, take the timestamp.
-        self.timeStamp          = time.time()
+        self.timeStamp = time.time()
 
         # Notes are initially empty.
-        self.notes              = list()
+        self.notes = list()
 
         # Get the process and thread, but dont't store them in the DB.
         process = event.get_process()
-        thread  = event.get_thread()
+        thread = event.get_thread()
 
         # Determine the architecture.
-        self.os                 = System.os
-        self.arch               = process.get_arch()
-        self.bits               = process.get_bits()
+        self.os = System.os
+        self.arch = process.get_arch()
+        self.bits = process.get_bits()
 
         # The following properties are always retrieved for all events.
-        self.eventCode          = event.get_event_code()
-        self.eventName          = event.get_event_name()
-        self.pid                = event.get_pid()
-        self.tid                = event.get_tid()
-        self.registers          = dict(thread.get_context())
-        self.labelPC            = process.get_label_at_address(self.pc)
+        self.eventCode = event.get_event_code()
+        self.eventName = event.get_event_name()
+        self.pid = event.get_pid()
+        self.tid = event.get_tid()
+        self.registers = dict(thread.get_context())
+        self.labelPC = process.get_label_at_address(self.pc)
 
         # The following properties are only retrieved for some events.
-        self.commandLine        = None
-        self.environment        = None
-        self.environmentData    = None
-        self.registersPeek      = None
-        self.debugString        = None
-        self.modFileName        = None
-        self.lpBaseOfDll        = None
-        self.exceptionCode      = None
-        self.exceptionName      = None
+        self.commandLine = None
+        self.environment = None
+        self.environmentData = None
+        self.registersPeek = None
+        self.debugString = None
+        self.modFileName = None
+        self.lpBaseOfDll = None
+        self.exceptionCode = None
+        self.exceptionName = None
         self.exceptionDescription = None
-        self.exceptionAddress   = None
-        self.exceptionLabel     = None
-        self.firstChance        = None
-        self.faultType          = None
-        self.faultAddress       = None
-        self.faultLabel         = None
-        self.isOurBreakpoint    = None
+        self.exceptionAddress = None
+        self.exceptionLabel = None
+        self.firstChance = None
+        self.faultType = None
+        self.faultAddress = None
+        self.faultLabel = None
+        self.isOurBreakpoint = None
         self.isSystemBreakpoint = None
-        self.stackTrace         = None
-        self.stackTracePC       = None
-        self.stackTraceLabels   = None
-        self.stackTracePretty   = None
-        self.stackRange         = None
-        self.stackFrame         = None
-        self.stackPeek          = None
-        self.faultCode          = None
-        self.faultMem           = None
-        self.faultPeek          = None
-        self.faultDisasm        = None
-        self.memoryMap          = None
+        self.stackTrace = None
+        self.stackTracePC = None
+        self.stackTraceLabels = None
+        self.stackTracePretty = None
+        self.stackRange = None
+        self.stackFrame = None
+        self.stackPeek = None
+        self.faultCode = None
+        self.faultMem = None
+        self.faultPeek = None
+        self.faultDisasm = None
+        self.memoryMap = None
 
         # Get information for debug string events.
         if self.eventCode == win32.OUTPUT_DEBUG_STRING_EVENT:
@@ -488,10 +490,12 @@ class Crash (object):
         # Get information for module load and unload events.
         # For create and exit process events, get the information
         # for the main module.
-        elif self.eventCode in (win32.CREATE_PROCESS_DEBUG_EVENT,
-                                win32.EXIT_PROCESS_DEBUG_EVENT,
-                                win32.LOAD_DLL_DEBUG_EVENT,
-                                win32.UNLOAD_DLL_DEBUG_EVENT):
+        elif self.eventCode in (
+            win32.CREATE_PROCESS_DEBUG_EVENT,
+            win32.EXIT_PROCESS_DEBUG_EVENT,
+            win32.LOAD_DLL_DEBUG_EVENT,
+            win32.UNLOAD_DLL_DEBUG_EVENT,
+        ):
             aModule = event.get_module()
             self.modFileName = event.get_filename()
             if not self.modFileName:
@@ -503,50 +507,38 @@ class Crash (object):
         # Get some information for exception events.
         # To get the remaining information call fetch_extra_data().
         elif self.eventCode == win32.EXCEPTION_DEBUG_EVENT:
-
             # Exception information.
-            self.exceptionCode          = event.get_exception_code()
-            self.exceptionName          = event.get_exception_name()
-            self.exceptionDescription   = event.get_exception_description()
-            self.exceptionAddress       = event.get_exception_address()
-            self.firstChance            = event.is_first_chance()
-            self.exceptionLabel         = process.get_label_at_address(
-                                                         self.exceptionAddress)
-            if self.exceptionCode in (win32.EXCEPTION_ACCESS_VIOLATION,
-                                      win32.EXCEPTION_GUARD_PAGE,
-                                      win32.EXCEPTION_IN_PAGE_ERROR):
-                self.faultType    = event.get_fault_type()
+            self.exceptionCode = event.get_exception_code()
+            self.exceptionName = event.get_exception_name()
+            self.exceptionDescription = event.get_exception_description()
+            self.exceptionAddress = event.get_exception_address()
+            self.firstChance = event.is_first_chance()
+            self.exceptionLabel = process.get_label_at_address(self.exceptionAddress)
+            if self.exceptionCode in (win32.EXCEPTION_ACCESS_VIOLATION, win32.EXCEPTION_GUARD_PAGE, win32.EXCEPTION_IN_PAGE_ERROR):
+                self.faultType = event.get_fault_type()
                 self.faultAddress = event.get_fault_address()
-                self.faultLabel   = process.get_label_at_address(
-                                                            self.faultAddress)
-            elif self.exceptionCode in (win32.EXCEPTION_BREAKPOINT,
-                                        win32.EXCEPTION_SINGLE_STEP):
-                self.isOurBreakpoint = hasattr(event, 'breakpoint') \
-                                       and event.breakpoint
-                self.isSystemBreakpoint = \
-                    process.is_system_defined_breakpoint(self.exceptionAddress)
+                self.faultLabel = process.get_label_at_address(self.faultAddress)
+            elif self.exceptionCode in (win32.EXCEPTION_BREAKPOINT, win32.EXCEPTION_SINGLE_STEP):
+                self.isOurBreakpoint = hasattr(event, "breakpoint") and event.breakpoint
+                self.isSystemBreakpoint = process.is_system_defined_breakpoint(self.exceptionAddress)
 
             # Stack trace.
             try:
                 self.stackTracePretty = thread.get_stack_trace_with_labels()
             except Exception:
                 e = sys.exc_info()[1]
-                warnings.warn(
-                    "Cannot get stack trace with labels, reason: %s" % str(e),
-                    CrashWarning)
+                warnings.warn("Cannot get stack trace with labels, reason: %s" % str(e), CrashWarning)
             try:
-                self.stackTrace     = thread.get_stack_trace()
-                stackTracePC        = [ ra for (_,ra,_) in self.stackTrace ]
-                self.stackTracePC   = tuple(stackTracePC)
-                stackTraceLabels    = [ process.get_label_at_address(ra) \
-                                             for ra in self.stackTracePC ]
+                self.stackTrace = thread.get_stack_trace()
+                stackTracePC = [ra for (_, ra, _) in self.stackTrace]
+                self.stackTracePC = tuple(stackTracePC)
+                stackTraceLabels = [process.get_label_at_address(ra) for ra in self.stackTracePC]
                 self.stackTraceLabels = tuple(stackTraceLabels)
             except Exception:
                 e = sys.exc_info()[1]
-                warnings.warn("Cannot get stack trace, reason: %s" % str(e),
-                              CrashWarning)
+                warnings.warn("Cannot get stack trace, reason: %s" % str(e), CrashWarning)
 
-    def fetch_extra_data(self, event, takeMemorySnapshot = 0):
+    def fetch_extra_data(self, event, takeMemorySnapshot=0):
         """
         Fetch extra data from the L{Event} object.
 
@@ -571,25 +563,22 @@ class Crash (object):
 
         # Get the process and thread, we'll use them below.
         process = event.get_process()
-        thread  = event.get_thread()
+        thread = event.get_thread()
 
         # Get the command line for the target process.
         try:
             self.commandLine = process.get_command_line()
         except Exception:
             e = sys.exc_info()[1]
-            warnings.warn("Cannot get command line, reason: %s" % str(e),
-                          CrashWarning)
+            warnings.warn("Cannot get command line, reason: %s" % str(e), CrashWarning)
 
         # Get the environment variables for the target process.
         try:
             self.environmentData = process.get_environment_data()
-            self.environment     = process.parse_environment_data(
-                                                        self.environmentData)
+            self.environment = process.parse_environment_data(self.environmentData)
         except Exception:
             e = sys.exc_info()[1]
-            warnings.warn("Cannot get environment, reason: %s" % str(e),
-                          CrashWarning)
+            warnings.warn("Cannot get environment, reason: %s" % str(e), CrashWarning)
 
         # Data pointed to by registers.
         self.registersPeek = thread.peek_pointers_in_registers()
@@ -605,8 +594,7 @@ class Crash (object):
             self.stackRange = thread.get_stack_range()
         except Exception:
             e = sys.exc_info()[1]
-            warnings.warn("Cannot get stack range, reason: %s" % str(e),
-                          CrashWarning)
+            warnings.warn("Cannot get stack range, reason: %s" % str(e), CrashWarning)
         try:
             self.stackFrame = thread.get_stack_frame()
             stackFrame = self.stackFrame
@@ -617,29 +605,27 @@ class Crash (object):
             self.stackPeek = process.peek_pointers_in_data(stackFrame)
 
         # Code being executed.
-        self.faultCode   = thread.peek_code_bytes()
+        self.faultCode = thread.peek_code_bytes()
         try:
             self.faultDisasm = thread.disassemble_around_pc(32)
         except Exception:
             e = sys.exc_info()[1]
-            warnings.warn("Cannot disassemble, reason: %s" % str(e),
-                          CrashWarning)
+            warnings.warn("Cannot disassemble, reason: %s" % str(e), CrashWarning)
 
         # For memory related exceptions, get the memory contents
         # of the location that caused the exception to be raised.
         if self.eventCode == win32.EXCEPTION_DEBUG_EVENT:
             if self.pc != self.exceptionAddress and self.exceptionCode in (
-                        win32.EXCEPTION_ACCESS_VIOLATION,
-                        win32.EXCEPTION_ARRAY_BOUNDS_EXCEEDED,
-                        win32.EXCEPTION_DATATYPE_MISALIGNMENT,
-                        win32.EXCEPTION_IN_PAGE_ERROR,
-                        win32.EXCEPTION_STACK_OVERFLOW,
-                        win32.EXCEPTION_GUARD_PAGE,
-                        ):
+                win32.EXCEPTION_ACCESS_VIOLATION,
+                win32.EXCEPTION_ARRAY_BOUNDS_EXCEEDED,
+                win32.EXCEPTION_DATATYPE_MISALIGNMENT,
+                win32.EXCEPTION_IN_PAGE_ERROR,
+                win32.EXCEPTION_STACK_OVERFLOW,
+                win32.EXCEPTION_GUARD_PAGE,
+            ):
                 self.faultMem = process.peek(self.exceptionAddress, 64)
                 if self.faultMem:
-                    self.faultPeek = process.peek_pointers_in_data(
-                                                                 self.faultMem)
+                    self.faultPeek = process.peek_pointers_in_data(self.faultMem)
 
         # TODO: maybe add names and versions of DLLs and EXE?
 
@@ -650,7 +636,7 @@ class Crash (object):
             mappedFilenames = process.get_mapped_filenames(self.memoryMap)
             for mbi in self.memoryMap:
                 mbi.filename = mappedFilenames.get(mbi.BaseAddress, None)
-                mbi.content  = None
+                mbi.content = None
         elif takeMemorySnapshot == 2:
             self.memoryMap = process.take_memory_snapshot()
         elif takeMemorySnapshot == 3:
@@ -664,9 +650,9 @@ class Crash (object):
         @rtype:  int
         """
         try:
-            return self.registers['Eip']        # i386
+            return self.registers["Eip"]  # i386
         except KeyError:
-            return self.registers['Rip']        # amd64
+            return self.registers["Rip"]  # amd64
 
     @property
     def sp(self):
@@ -676,9 +662,9 @@ class Crash (object):
         @rtype:  int
         """
         try:
-            return self.registers['Esp']        # i386
+            return self.registers["Esp"]  # i386
         except KeyError:
-            return self.registers['Rsp']        # amd64
+            return self.registers["Rsp"]  # amd64
 
     @property
     def fp(self):
@@ -688,9 +674,9 @@ class Crash (object):
         @rtype:  int
         """
         try:
-            return self.registers['Ebp']        # i386
+            return self.registers["Ebp"]  # i386
         except KeyError:
-            return self.registers['Rbp']        # amd64
+            return self.registers["Rbp"]  # amd64
 
     def __str__(self):
         return self.fullReport()
@@ -699,8 +685,7 @@ class Crash (object):
         """
         Alias of L{signature}. Deprecated since WinAppDbg 1.5.
         """
-        warnings.warn("Crash.key() method was deprecated in WinAppDbg 1.5",
-                      DeprecationWarning)
+        warnings.warn("Crash.key() method was deprecated in WinAppDbg 1.5", DeprecationWarning)
         return self.signature
 
     @property
@@ -713,14 +698,14 @@ class Crash (object):
             trace = self.stackTraceLabels
         else:
             trace = self.stackTracePC
-        return  (
-                self.arch,
-                self.eventCode,
-                self.exceptionCode,
-                pc,
-                trace,
-                self.debugString,
-                )
+        return (
+            self.arch,
+            self.eventCode,
+            self.exceptionCode,
+            pc,
+            trace,
+            self.debugString,
+        )
         # TODO
         # add the name and version of the binary where the crash happened?
 
@@ -770,47 +755,95 @@ class Crash (object):
             return ("Exploitable", "StackPointerCorruption", "Stack pointer corruption is considered exploitable.")
 
         if self.exceptionCode == win32.EXCEPTION_ILLEGAL_INSTRUCTION:
-            return ("Exploitable", "IllegalInstruction", "An illegal instruction exception indicates that the attacker controls execution flow.")
+            return (
+                "Exploitable",
+                "IllegalInstruction",
+                "An illegal instruction exception indicates that the attacker controls execution flow.",
+            )
 
         if self.exceptionCode == win32.EXCEPTION_PRIV_INSTRUCTION:
-            return ("Exploitable", "PrivilegedInstruction", "A privileged instruction exception indicates that the attacker controls execution flow.")
+            return (
+                "Exploitable",
+                "PrivilegedInstruction",
+                "A privileged instruction exception indicates that the attacker controls execution flow.",
+            )
 
         if self.exceptionCode == win32.EXCEPTION_GUARD_PAGE:
-            return ("Exploitable", "GuardPage", "A guard page violation indicates a stack overflow has occured, and the stack of another thread was reached (possibly the overflow length is not controlled by the attacker).")
+            return (
+                "Exploitable",
+                "GuardPage",
+                "A guard page violation indicates a stack overflow has occured, and the stack of another thread was reached (possibly the overflow length is not controlled by the attacker).",
+            )
 
         if self.exceptionCode == win32.STATUS_STACK_BUFFER_OVERRUN:
-            return ("Exploitable", "GSViolation", "An overrun of a protected stack buffer has been detected. This is considered exploitable, and must be fixed.")
+            return (
+                "Exploitable",
+                "GSViolation",
+                "An overrun of a protected stack buffer has been detected. This is considered exploitable, and must be fixed.",
+            )
 
         if self.exceptionCode == win32.STATUS_HEAP_CORRUPTION:
-            return ("Exploitable", "HeapCorruption", "Heap Corruption has been detected. This is considered exploitable, and must be fixed.")
+            return (
+                "Exploitable",
+                "HeapCorruption",
+                "Heap Corruption has been detected. This is considered exploitable, and must be fixed.",
+            )
 
         if self.exceptionCode == win32.EXCEPTION_ACCESS_VIOLATION:
-            nearNull      = self.faultAddress is None or MemoryAddresses.align_address_to_page_start(self.faultAddress) == 0
-            controlFlow   = self.__is_control_flow()
+            nearNull = self.faultAddress is None or MemoryAddresses.align_address_to_page_start(self.faultAddress) == 0
+            controlFlow = self.__is_control_flow()
             blockDataMove = self.__is_block_data_move()
             if self.faultType == win32.EXCEPTION_EXECUTE_FAULT:
                 if nearNull:
-                    return ("Probably exploitable", "DEPViolation", "User mode DEP access violations are probably exploitable if near NULL.")
+                    return (
+                        "Probably exploitable",
+                        "DEPViolation",
+                        "User mode DEP access violations are probably exploitable if near NULL.",
+                    )
                 else:
                     return ("Exploitable", "DEPViolation", "User mode DEP access violations are exploitable.")
             elif self.faultType == win32.EXCEPTION_WRITE_FAULT:
                 if nearNull:
-                    return ("Probably exploitable", "WriteAV", "User mode write access violations that are near NULL are probably exploitable.")
+                    return (
+                        "Probably exploitable",
+                        "WriteAV",
+                        "User mode write access violations that are near NULL are probably exploitable.",
+                    )
                 else:
                     return ("Exploitable", "WriteAV", "User mode write access violations that are not near NULL are exploitable.")
             elif self.faultType == win32.EXCEPTION_READ_FAULT:
                 if self.faultAddress == self.pc:
                     if nearNull:
-                        return ("Probably exploitable", "ReadAVonIP", "Access violations at the instruction pointer are probably exploitable if near NULL.")
+                        return (
+                            "Probably exploitable",
+                            "ReadAVonIP",
+                            "Access violations at the instruction pointer are probably exploitable if near NULL.",
+                        )
                     else:
-                        return ("Exploitable", "ReadAVonIP", "Access violations at the instruction pointer are exploitable if not near NULL.")
+                        return (
+                            "Exploitable",
+                            "ReadAVonIP",
+                            "Access violations at the instruction pointer are exploitable if not near NULL.",
+                        )
                 if controlFlow:
                     if nearNull:
-                        return ("Probably exploitable", "ReadAVonControlFlow", "Access violations near null in control flow instructions are considered probably exploitable.")
+                        return (
+                            "Probably exploitable",
+                            "ReadAVonControlFlow",
+                            "Access violations near null in control flow instructions are considered probably exploitable.",
+                        )
                     else:
-                        return ("Exploitable", "ReadAVonControlFlow", "Access violations not near null in control flow instructions are considered exploitable.")
+                        return (
+                            "Exploitable",
+                            "ReadAVonControlFlow",
+                            "Access violations not near null in control flow instructions are considered exploitable.",
+                        )
                 if blockDataMove:
-                    return ("Probably exploitable", "ReadAVonBlockMove", "This is a read access violation in a block data move, and is therefore classified as probably exploitable.")
+                    return (
+                        "Probably exploitable",
+                        "ReadAVonBlockMove",
+                        "This is a read access violation in a block data move, and is therefore classified as probably exploitable.",
+                    )
 
                 # Rule: Tainted information used to control branch addresses is considered probably exploitable
                 # Rule: Tainted information used to control the target of a later write is probably exploitable
@@ -826,7 +859,11 @@ class Crash (object):
         if self.exceptionCode == win32.EXCEPTION_ACCESS_VIOLATION:
             if self.faultType == win32.EXCEPTION_READ_FAULT:
                 if nearNull:
-                    result = ("Not likely exploitable", "ReadAVNearNull", "This is a user mode read access violation near null, and is probably not exploitable.")
+                    result = (
+                        "Not likely exploitable",
+                        "ReadAVNearNull",
+                        "This is a user mode read access violation near null, and is probably not exploitable.",
+                    )
 
         elif self.exceptionCode == win32.EXCEPTION_INT_DIVIDE_BY_ZERO:
             result = ("Not likely exploitable", "DivideByZero", "This is an integer divide by zero, and is probably not exploitable.")
@@ -835,7 +872,11 @@ class Crash (object):
             result = ("Not likely exploitable", "DivideByZero", "This is a floating point divide by zero, and is probably not exploitable.")
 
         elif self.exceptionCode in (win32.EXCEPTION_BREAKPOINT, win32.STATUS_WX86_BREAKPOINT):
-            result = ("Unknown", "Breakpoint", "While a breakpoint itself is probably not exploitable, it may also be an indication that an attacker is testing a target. In either case breakpoints should not exist in production code.")
+            result = (
+                "Unknown",
+                "Breakpoint",
+                "While a breakpoint itself is probably not exploitable, it may also be an indication that an attacker is testing a target. In either case breakpoints should not exist in production code.",
+            )
 
         # Rule: If the stack contains unknown symbols in user mode, call that out
         # Rule: Tainted information used to control the source of a later block move unknown, but called out explicitly
@@ -852,15 +893,43 @@ class Crash (object):
         Currently only works for x86 and amd64 architectures.
         """
         jump_instructions = (
-            'jmp', 'jecxz', 'jcxz',
-            'ja', 'jnbe', 'jae', 'jnb', 'jb', 'jnae', 'jbe', 'jna', 'jc', 'je',
-            'jz', 'jnc', 'jne', 'jnz', 'jnp', 'jpo', 'jp', 'jpe', 'jg', 'jnle',
-            'jge', 'jnl', 'jl', 'jnge', 'jle', 'jng', 'jno', 'jns', 'jo', 'js'
+            "jmp",
+            "jecxz",
+            "jcxz",
+            "ja",
+            "jnbe",
+            "jae",
+            "jnb",
+            "jb",
+            "jnae",
+            "jbe",
+            "jna",
+            "jc",
+            "je",
+            "jz",
+            "jnc",
+            "jne",
+            "jnz",
+            "jnp",
+            "jpo",
+            "jp",
+            "jpe",
+            "jg",
+            "jnle",
+            "jge",
+            "jnl",
+            "jl",
+            "jnge",
+            "jle",
+            "jng",
+            "jno",
+            "jns",
+            "jo",
+            "js",
         )
-        call_instructions = ( 'call', 'ret', 'retn' )
-        loop_instructions = ( 'loop', 'loopz', 'loopnz', 'loope', 'loopne' )
-        control_flow_instructions = call_instructions + loop_instructions + \
-                                    jump_instructions
+        call_instructions = ("call", "ret", "retn")
+        loop_instructions = ("loop", "loopz", "loopnz", "loope", "loopne")
+        control_flow_instructions = call_instructions + loop_instructions + jump_instructions
         isControlFlow = False
         instruction = None
         if self.pc is not None and self.faultDisasm:
@@ -882,7 +951,7 @@ class Crash (object):
 
         Currently only works for x86 and amd64 architectures.
         """
-        block_data_move_instructions = ('movs', 'stos', 'lods')
+        block_data_move_instructions = ("movs", "stos", "lods")
         isBlockDataMove = False
         instruction = None
         if self.pc is not None and self.faultDisasm:
@@ -915,12 +984,11 @@ class Crash (object):
             elif self.exceptionName:
                 what = self.exceptionName
             else:
-                what = "Exception %s" % \
-                            HexDump.integer(self.exceptionCode, self.bits)
+                what = "Exception %s" % HexDump.integer(self.exceptionCode, self.bits)
             if self.firstChance:
-                chance = 'first'
+                chance = "first"
             else:
-                chance = 'second'
+                chance = "second"
             if self.exceptionLabel:
                 where = self.exceptionLabel
             elif self.exceptionAddress:
@@ -941,14 +1009,10 @@ class Crash (object):
                 where = self.labelPC
             else:
                 where = HexDump.address(self.pc, self.bits)
-            msg = "%s (%s) at %s" % (
-                        self.eventName,
-                        HexDump.integer(self.eventCode, self.bits),
-                        where
-                       )
+            msg = "%s (%s) at %s" % (self.eventName, HexDump.integer(self.eventCode, self.bits), where)
         return msg
 
-    def fullReport(self, bShowNotes = True):
+    def fullReport(self, bShowNotes=True):
         """
         @type  bShowNotes: bool
         @param bShowNotes: C{True} to show the user notes, C{False} otherwise.
@@ -956,8 +1020,8 @@ class Crash (object):
         @rtype:  str
         @return: Long description of the event.
         """
-        msg  = self.briefReport()
-        msg += '\n'
+        msg = self.briefReport()
+        msg += "\n"
 
         if self.bits == 32:
             width = 16
@@ -966,89 +1030,76 @@ class Crash (object):
 
         if self.eventCode == win32.EXCEPTION_DEBUG_EVENT:
             (exploitability, expcode, expdescription) = self.isExploitable()
-            msg += '\nSecurity risk level: %s\n' % exploitability
-            msg += '  %s\n' % expdescription
+            msg += "\nSecurity risk level: %s\n" % exploitability
+            msg += "  %s\n" % expdescription
 
         if bShowNotes and self.notes:
-            msg += '\nNotes:\n'
+            msg += "\nNotes:\n"
             msg += self.notesReport()
 
         if self.commandLine:
-            msg += '\nCommand line: %s\n' % self.commandLine
+            msg += "\nCommand line: %s\n" % self.commandLine
 
         if self.environment:
-            msg += '\nEnvironment:\n'
+            msg += "\nEnvironment:\n"
             msg += self.environmentReport()
 
         if not self.labelPC:
             base = HexDump.address(self.lpBaseOfDll, self.bits)
             if self.modFileName:
-                fn   = PathOperations.pathname_to_filename(self.modFileName)
-                msg += '\nRunning in %s (%s)\n' % (fn, base)
+                fn = PathOperations.pathname_to_filename(self.modFileName)
+                msg += "\nRunning in %s (%s)\n" % (fn, base)
             else:
-                msg += '\nRunning in module at %s\n' % base
+                msg += "\nRunning in module at %s\n" % base
 
         if self.registers:
-            msg += '\nRegisters:\n'
+            msg += "\nRegisters:\n"
             msg += CrashDump.dump_registers(self.registers)
             if self.registersPeek:
-                msg += '\n'
-                msg += CrashDump.dump_registers_peek(self.registers,
-                                                     self.registersPeek,
-                                                     width = width)
+                msg += "\n"
+                msg += CrashDump.dump_registers_peek(self.registers, self.registersPeek, width=width)
 
         if self.faultDisasm:
-            msg += '\nCode disassembly:\n'
-            msg += CrashDump.dump_code(self.faultDisasm, self.pc,
-                                       bits = self.bits)
+            msg += "\nCode disassembly:\n"
+            msg += CrashDump.dump_code(self.faultDisasm, self.pc, bits=self.bits)
 
         if self.stackTrace:
-            msg += '\nStack trace:\n'
+            msg += "\nStack trace:\n"
             if self.stackTracePretty:
-                msg += CrashDump.dump_stack_trace_with_labels(
-                                        self.stackTracePretty,
-                                        bits = self.bits)
+                msg += CrashDump.dump_stack_trace_with_labels(self.stackTracePretty, bits=self.bits)
             else:
-                msg += CrashDump.dump_stack_trace(self.stackTrace,
-                                                  bits = self.bits)
+                msg += CrashDump.dump_stack_trace(self.stackTrace, bits=self.bits)
 
         if self.stackFrame:
             if self.stackPeek:
-                msg += '\nStack pointers:\n'
-                msg += CrashDump.dump_stack_peek(self.stackPeek, width = width)
-            msg += '\nStack dump:\n'
-            msg += HexDump.hexblock(self.stackFrame, self.sp,
-                                    bits = self.bits, width = width)
+                msg += "\nStack pointers:\n"
+                msg += CrashDump.dump_stack_peek(self.stackPeek, width=width)
+            msg += "\nStack dump:\n"
+            msg += HexDump.hexblock(self.stackFrame, self.sp, bits=self.bits, width=width)
 
         if self.faultCode and not self.modFileName:
-            msg += '\nCode dump:\n'
-            msg += HexDump.hexblock(self.faultCode, self.pc,
-                                    bits = self.bits, width = width)
+            msg += "\nCode dump:\n"
+            msg += HexDump.hexblock(self.faultCode, self.pc, bits=self.bits, width=width)
 
         if self.faultMem:
             if self.faultPeek:
-                msg += '\nException address pointers:\n'
-                msg += CrashDump.dump_data_peek(self.faultPeek,
-                                                self.exceptionAddress,
-                                                bits  = self.bits,
-                                                width = width)
-            msg += '\nException address dump:\n'
-            msg += HexDump.hexblock(self.faultMem, self.exceptionAddress,
-                                    bits = self.bits, width = width)
+                msg += "\nException address pointers:\n"
+                msg += CrashDump.dump_data_peek(self.faultPeek, self.exceptionAddress, bits=self.bits, width=width)
+            msg += "\nException address dump:\n"
+            msg += HexDump.hexblock(self.faultMem, self.exceptionAddress, bits=self.bits, width=width)
 
         if self.memoryMap:
-            msg += '\nMemory map:\n'
+            msg += "\nMemory map:\n"
             mappedFileNames = dict()
             for mbi in self.memoryMap:
-                if hasattr(mbi, 'filename') and mbi.filename:
+                if hasattr(mbi, "filename") and mbi.filename:
                     mappedFileNames[mbi.BaseAddress] = mbi.filename
-            msg += CrashDump.dump_memory_map(self.memoryMap, mappedFileNames,
-                                             bits = self.bits)
+            msg += CrashDump.dump_memory_map(self.memoryMap, mappedFileNames, bits=self.bits)
 
-        if not msg.endswith('\n\n'):
-            if not msg.endswith('\n'):
-                msg += '\n'
-            msg += '\n'
+        if not msg.endswith("\n\n"):
+            if not msg.endswith("\n"):
+                msg += "\n"
+            msg += "\n"
         return msg
 
     def environmentReport(self):
@@ -1057,10 +1108,10 @@ class Crash (object):
         @return: The process environment variables,
             merged and formatted for a report.
         """
-        msg = ''
+        msg = ""
         if self.environment:
             for key, value in compat.iteritems(self.environment):
-                msg += '  %s=%s\n' % (key, value)
+                msg += "  %s=%s\n" % (key, value)
         return msg
 
     def notesReport(self):
@@ -1068,17 +1119,17 @@ class Crash (object):
         @rtype:  str
         @return: All notes, merged and formatted for a report.
         """
-        msg = ''
+        msg = ""
         if self.notes:
             for n in self.notes:
-                n = n.strip('\n')
-                if '\n' in n:
-                    n = n.strip('\n')
-                    msg += ' * %s\n' % n.pop(0)
+                n = n.strip("\n")
+                if "\n" in n:
+                    n = n.strip("\n")
+                    msg += " * %s\n" % n.pop(0)
                     for x in n:
-                        msg += '   %s\n' % x
+                        msg += "   %s\n" % x
                 else:
-                    msg += ' * %s\n' % n
+                    msg += " * %s\n" % n
         return msg
 
     def addNote(self, msg):
@@ -1119,11 +1170,13 @@ class Crash (object):
         @rtype:  bool
         @return: C{True} if there are notes for this crash event.
         """
-        return bool( self.notes )
+        return bool(self.notes)
+
 
-#==============================================================================
+# ==============================================================================
 
-class CrashContainer (object):
+
+class CrashContainer(object):
     """
     Old crash dump persistencer using a DBM database.
     Doesn't support duplicate crashes.
@@ -1181,16 +1234,16 @@ class CrashContainer (object):
         C{buffer} type), C{False} to use text marshalled values (C{str} type).
     """
 
-    optimizeKeys    = False
-    optimizeValues  = True
-    compressKeys    = False
-    compressValues  = True
-    escapeKeys      = False
-    escapeValues    = False
-    binaryKeys      = False
-    binaryValues    = False
+    optimizeKeys = False
+    optimizeValues = True
+    compressKeys = False
+    compressValues = True
+    escapeKeys = False
+    escapeValues = False
+    binaryKeys = False
+    binaryValues = False
 
-    def __init__(self, filename = None, allowRepeatedKeys = False):
+    def __init__(self, filename=None, allowRepeatedKeys=False):
         """
         @type  filename: str
         @param filename: (Optional) File name for crash database.
@@ -1210,9 +1263,8 @@ class CrashContainer (object):
             global anydbm
             if not anydbm:
                 import anydbm
-            self.__db = anydbm.open(filename, 'c')
-            self.__keys = dict([ (self.unmarshall_key(mk), mk)
-                                                  for mk in self.__db.keys() ])
+            self.__db = anydbm.open(filename, "c")
+            self.__keys = dict([(self.unmarshall_key(mk), mk) for mk in self.__db.keys()])
         else:
             self.__db = dict()
             self.__keys = dict()
@@ -1240,11 +1292,11 @@ class CrashContainer (object):
         """
         if key in self.__keys:
             return self.__keys[key]
-        skey = pickle.dumps(key, protocol = 0)
+        skey = pickle.dumps(key, protocol=0)
         if self.compressKeys:
             skey = zlib.compress(skey, zlib.Z_BEST_COMPRESSION)
         if self.escapeKeys:
-            skey = skey.encode('hex')
+            skey = skey.encode("hex")
         if self.binaryKeys:
             skey = buffer(skey)
         self.__keys[key] = skey
@@ -1262,13 +1314,13 @@ class CrashContainer (object):
         """
         key = str(key)
         if self.escapeKeys:
-            key = key.decode('hex')
+            key = key.decode("hex")
         if self.compressKeys:
             key = zlib.decompress(key)
         key = pickle.loads(key)
         return key
 
-    def marshall_value(self, value, storeMemoryMap = False):
+    def marshall_value(self, value, storeMemoryMap=False):
         """
         Marshalls a Crash object to be used in the database.
         By default the C{memoryMap} member is B{NOT} stored here.
@@ -1286,7 +1338,7 @@ class CrashContainer (object):
         @rtype:  str
         @return: Converted object.
         """
-        if hasattr(value, 'memoryMap'):
+        if hasattr(value, "memoryMap"):
             crash = value
             memoryMap = crash.memoryMap
             try:
@@ -1295,10 +1347,10 @@ class CrashContainer (object):
                     # convert the generator to a list
                     crash.memoryMap = list(memoryMap)
                 if self.optimizeValues:
-                    value = pickle.dumps(crash, protocol = HIGHEST_PROTOCOL)
+                    value = pickle.dumps(crash, protocol=HIGHEST_PROTOCOL)
                     value = optimize(value)
                 else:
-                    value = pickle.dumps(crash, protocol = 0)
+                    value = pickle.dumps(crash, protocol=0)
             finally:
                 crash.memoryMap = memoryMap
                 del memoryMap
@@ -1306,7 +1358,7 @@ class CrashContainer (object):
         if self.compressValues:
             value = zlib.compress(value, zlib.Z_BEST_COMPRESSION)
         if self.escapeValues:
-            value = value.encode('hex')
+            value = value.encode("hex")
         if self.binaryValues:
             value = buffer(value)
         return value
@@ -1323,7 +1375,7 @@ class CrashContainer (object):
         """
         value = str(value)
         if self.escapeValues:
-            value = value.decode('hex')
+            value = value.decode("hex")
         if self.compressValues:
             value = zlib.decompress(value)
         value = pickle.loads(value)
@@ -1357,7 +1409,7 @@ class CrashContainer (object):
         @return:
             C{True} if a Crash object with the same key is in the container.
         """
-        return self.has_key( crash.key() )
+        return self.has_key(crash.key())
 
     def has_key(self, key):
         """
@@ -1376,7 +1428,7 @@ class CrashContainer (object):
         """
         return compat.iterkeys(self.__keys)
 
-    class __CrashContainerIterator (object):
+    class __CrashContainerIterator(object):
         """
         Iterator of Crash objects. Returned by L{CrashContainer.__iter__}.
         """
@@ -1402,7 +1454,7 @@ class CrashContainer (object):
             @return: A B{copy} of a Crash object in the L{CrashContainer}.
             @raise StopIteration: No more items left.
             """
-            key  = self.__keys_iter.next()
+            key = self.__keys_iter.next()
             return self.__container.get(key)
 
     def __del__(self):
@@ -1447,9 +1499,9 @@ class CrashContainer (object):
         @param crash: Crash object to add.
         """
         if crash not in self:
-            key  = crash.key()
+            key = crash.key()
             skey = self.marshall_key(key)
-            data = self.marshall_value(crash, storeMemoryMap = True)
+            data = self.marshall_value(crash, storeMemoryMap=True)
             self.__db[skey] = data
 
     def __delitem__(self, key):
@@ -1470,7 +1522,7 @@ class CrashContainer (object):
         @type  crash: L{Crash}
         @param crash: Crash object to remove.
         """
-        del self[ crash.key() ]
+        del self[crash.key()]
 
     def get(self, key):
         """
@@ -1491,8 +1543,8 @@ class CrashContainer (object):
                 2. Delete the object from the set.
                 3. Modify the object and add it again.
         """
-        skey  = self.marshall_key(key)
-        data  = self.__db[skey]
+        skey = self.marshall_key(key)
+        data = self.__db[skey]
         crash = self.unmarshall_value(data)
         return crash
 
@@ -1517,7 +1569,9 @@ class CrashContainer (object):
         """
         return self.get(key)
 
-#==============================================================================
+
+# ==============================================================================
+
 
 class CrashDictionary(object):
     """
@@ -1526,7 +1580,7 @@ class CrashDictionary(object):
     Currently the only implementation is through L{sql.CrashDAO}.
     """
 
-    def __init__(self, url, creator = None, allowRepeatedKeys = True):
+    def __init__(self, url, creator=None, allowRepeatedKeys=True):
         """
         @type  url: str
         @param url: Connection URL of the crash database.
@@ -1599,7 +1653,7 @@ class CrashDictionary(object):
         @return: Iterator of the contained L{Crash} objects.
         """
         offset = 0
-        limit  = 10
+        limit = 10
         while 1:
             found = self._dao.find(offset=offset, limit=limit)
             if not found:
@@ -1621,7 +1675,7 @@ class CrashDictionary(object):
         @return: Iterator of the contained L{Crash} heuristic signatures.
         """
         for crash in self:
-            yield crash.signature       # FIXME this gives repeated results!
+            yield crash.signature  # FIXME this gives repeated results!
 
     def __contains__(self, crash):
         """
@@ -1655,7 +1709,8 @@ class CrashDictionary(object):
         @rtype:  bool
         @return: C{False} if the container is empty.
         """
-        return bool( len(self) )
+        return bool(len(self))
+
 
 class CrashTable(CrashDictionary):
     """
@@ -1666,7 +1721,7 @@ class CrashTable(CrashDictionary):
         New applications should not use this class.
     """
 
-    def __init__(self, location = None, allowRepeatedKeys = True):
+    def __init__(self, location=None, allowRepeatedKeys=True):
         """
         @type  location: str
         @param location: (Optional) Location of the crash database.
@@ -1683,16 +1738,15 @@ class CrashTable(CrashDictionary):
             If C{False} any L{Crash} object with the same signature as a
             previously existing object will be ignored.
         """
-        warnings.warn(
-            "The %s class is deprecated since WinAppDbg 1.5." % self.__class__,
-            DeprecationWarning)
+        warnings.warn("The %s class is deprecated since WinAppDbg 1.5." % self.__class__, DeprecationWarning)
         if location:
             url = "sqlite:///%s" % location
         else:
             url = "sqlite://"
         super(CrashTable, self).__init__(url, allowRepeatedKeys)
 
-class CrashTableMSSQL (CrashDictionary):
+
+class CrashTableMSSQL(CrashDictionary):
     """
     Old crash dump persistencer using a Microsoft SQL Server database.
 
@@ -1701,7 +1755,7 @@ class CrashTableMSSQL (CrashDictionary):
         New applications should not use this class.
     """
 
-    def __init__(self, location = None, allowRepeatedKeys = True):
+    def __init__(self, location=None, allowRepeatedKeys=True):
         """
         @type  location: str
         @param location: Location of the crash database.
@@ -1714,14 +1768,14 @@ class CrashTableMSSQL (CrashDictionary):
             If C{False} any L{Crash} object with the same signature as a
             previously existing object will be ignored.
         """
-        warnings.warn(
-            "The %s class is deprecated since WinAppDbg 1.5." % self.__class__,
-            DeprecationWarning)
+        warnings.warn("The %s class is deprecated since WinAppDbg 1.5." % self.__class__, DeprecationWarning)
         import urllib
+
         url = "mssql+pyodbc:///?odbc_connect=" + urllib.quote_plus(location)
         super(CrashTableMSSQL, self).__init__(url, allowRepeatedKeys)
 
-class VolatileCrashContainer (CrashTable):
+
+class VolatileCrashContainer(CrashTable):
     """
     Old in-memory crash dump storage.
 
@@ -1730,7 +1784,7 @@ class VolatileCrashContainer (CrashTable):
         New applications should not use this class.
     """
 
-    def __init__(self, allowRepeatedKeys = True):
+    def __init__(self, allowRepeatedKeys=True):
         """
         Volatile containers are stored only in memory and
         destroyed when they go out of scope.
@@ -1742,8 +1796,8 @@ class VolatileCrashContainer (CrashTable):
             If C{False} any L{Crash} object with the same key as a
             previously existing object will be ignored.
         """
-        super(VolatileCrashContainer, self).__init__(
-            allowRepeatedKeys=allowRepeatedKeys)
+        super(VolatileCrashContainer, self).__init__(allowRepeatedKeys=allowRepeatedKeys)
+
 
 class DummyCrashContainer(object):
     """
@@ -1756,7 +1810,7 @@ class DummyCrashContainer(object):
     @see: L{CrashDictionary}
     """
 
-    def __init__(self, allowRepeatedKeys = True):
+    def __init__(self, allowRepeatedKeys=True):
         """
         Fake containers don't store L{Crash} objects, but they implement the
         interface properly.
@@ -1765,7 +1819,7 @@ class DummyCrashContainer(object):
         @param allowRepeatedKeys:
             Mimics the duplicate filter behavior found in real containers.
         """
-        self.__keys  = set()
+        self.__keys = set()
         self.__count = 0
         self.__allowRepeatedKeys = allowRepeatedKeys
 
@@ -1786,14 +1840,14 @@ class DummyCrashContainer(object):
         """
         if self.__allowRepeatedKeys:
             return self.__count
-        return len( self.__keys )
+        return len(self.__keys)
 
     def __bool__(self):
         """
         @rtype:  bool
         @return: C{False} if the container is empty.
         """
-        return bool( len(self) )
+        return bool(len(self))
 
     def add(self, crash):
         """
@@ -1808,7 +1862,7 @@ class DummyCrashContainer(object):
         @type  crash: L{Crash}
         @param crash: Crash object to add.
         """
-        self.__keys.add( crash.signature )
+        self.__keys.add(crash.signature)
         self.__count += 1
 
     def get(self, key):
@@ -1825,7 +1879,7 @@ class DummyCrashContainer(object):
         @rtype:  bool
         @return: C{True} if a matching L{Crash} object is in the container.
         """
-        return self.__keys.has_key( key )
+        return self.__keys.has_key(key)
 
     def iterkeys(self):
         """
@@ -1843,7 +1897,8 @@ class DummyCrashContainer(object):
         """
         return iter(self.__keys)
 
-#==============================================================================
+
+# ==============================================================================
 # Register the Crash class with the secure serializer.
 
 try: