From Collaborative RCE Tool Library
Ring 3 Debuggers
| Tool name: | IDA Pro |
| ||
|---|---|---|---|---|
| Author: | Ilfak Guilfanov | |||
| Website: | http://www.hex-rays.com/idapro | |||
| Current version: | 5.2 | |||
| Last updated: | November 26, 2007 | |||
| Direct D/L link: | N/A | |||
| License type: | Commercial | |||
| Description: | The IDA Pro Disassembler and Debugger is an interactive, programmable, extendible, multi-processor disassembler hosted on Windows or on Linux. IDA Pro has become the de-facto standard for the analysis of hostile code, vulnerability research and COTS validation. There is also a free (crippled) version available (IDA Pro Free). See its own entry in the library for more info. As of January 7, 2007, the official IDA Pro website moved from the old URL (http://www.datarescue.com/idabase) to the one listed above. | |||
| Also listed in: | .NET Disassemblers, Disassemblers, Linux Debuggers, Linux Disassemblers, Mobile Platform Debuggers, Mobile Platform Disassemblers | |||
| More details: | Click here for more details, screenshots, related URLs & comments for this tool! (or to update its entry) | |||
| Tool name: | OllyDbg |
| ||
|---|---|---|---|---|
| Author: | Oleh Yuschuk | |||
| Website: | http://www.ollydbg.de | |||
| Current version: | 1.10 (and 2.0 pre-alpha) | |||
| Last updated: | ||||
| Direct D/L link: | http://www.ollydbg.de/odbg110.zip | |||
| License type: | Free | |||
| Description: | The world's most famous ring 3 debugger. The first public (pre-alpha) version of OllyDbg 2.0 was released on December 25, 2007, so you can now test it yourself if you want! | |||
| Also listed in: | (Not listed in any other category) | |||
| More details: | Click here for more details, screenshots, related URLs & comments for this tool! (or to update its entry) | |||
| Tool name: | IDA Pro Free |
| ||
|---|---|---|---|---|
| Author: | DataRescue | |||
| Website: | http://www.datarescue.com/idabase/idadownfreeware.htm | |||
| Current version: | 4.9 | |||
| Last updated: | November 2, 2007 | |||
| Direct D/L link: | http://tiarater.datarescue.be/freefiles/idafree49.exe | |||
| License type: | Free | |||
| Description: | This is the (crippled) freeware edition of the IDA Pro debugger (see its own entry in the library for more info). Differences from the commercial version is, among others: * No remote debugging * No Linux debugging (disassembling only) * No other OS support at all (Mac OSX, WinCE) * Only PE, COFF, OMF, ELF and Dos is supported (not NE) * No console version (idaw.exe) * No graphical view (5.0+) * Only x86 family processor module included (metapc) * No x64 support at all * Some FLIRT signatures are out-dated * Fewer included plugins * Difficulty identifying parameters in some cases (no PIT) * Buggy WINE support * Incompatible with plugins for commercial versions (plugins can be patched with another tool available in this library to work with the free version though!) The previous free version (4.3) is available at the following URL, if you for some reason wouldn't like the latest free version 4.9: http://www.datarescue.be/idafreeware/freeida43.exe | |||
| Also listed in: | Disassemblers | |||
| More details: | Click here for more details, screenshots, related URLs & comments for this tool! (or to update its entry) | |||
| Tool name: | WinDbg |
| ||
|---|---|---|---|---|
| Author: | Microsoft | |||
| Website: | http://www.microsoft.com/whdc/devtools/debugging/default.mspx | |||
| Current version: | 6.8.4.0 | |||
| Last updated: | October 18, 2007 | |||
| Direct D/L link: | N/A | |||
| License type: | Free | |||
| Description: | Microsoft's own ring 0 debugger. Quite unfriendly to use, but one of the remaining stable options since the discontinuation of SoftICE. You will find some extensions that make it at least somewhat easier to use, in the WinDbg extensions category. | |||
| Also listed in: | Ring 0 Debuggers | |||
| More details: | Click here for more details, screenshots, related URLs & comments for this tool! (or to update its entry) | |||
| Tool name: | Immunity Debugger |
| ||
|---|---|---|---|---|
| Author: | Immunity Inc / Oleh Yuschuk | |||
| Website: | http://debugger.immunityinc.com | |||
| Current version: | 1.5 | |||
| Last updated: | March 27, 2008 | |||
| Direct D/L link: | N/A | |||
| License type: | Free | |||
| Description: | Immunity Debugger is based on OllyDbg. Immunity Debugger is a powerful new way to write exploits, analyze malware, and reverse engineer binary files. It builds on a solid user interface with function graphing, the industry's first heap analysis tool built specifically for heap creation, and a large and well supported Python API for easy extensibility. * A debugger with functionality designed specifically for the security industry * Cuts exploit development time by 50% * Simple, understandable interfaces * Robust and powerful scripting language for automating intelligent debugging * Lightweight and fast debugging to prevent corruption during complex analysis * Connectivity to fuzzers and exploit development tools | |||
| Also listed in: | OllyDbg Custom Versions | |||
| More details: | Click here for more details, screenshots, related URLs & comments for this tool! (or to update its entry) | |||
| Tool name: | Obsidian |
| ||
|---|---|---|---|---|
| Author: | deneke | |||
| Website: | http://www.deneke.biz/obsidian | |||
| Current version: | ||||
| Last updated: | October 21, 2006 | |||
| Direct D/L link: | Locally archived copy | |||
| License type: | Free / Open Source | |||
| Description: | Obsidian is a non-intrusive debugger, which means that it doesn't change the targets process as a normal debugger would. Being in beta state there can be some minor issues but it should be mostly stable. The main advantage would be that you don't have to care anymore about those anti-debugger-tricks like: * IsDebuggerPresent() which boils down to checking the debugger-flag in the PEB * self-debugging: creating another thread or process which attaches itself to the target in order to keep other debuggers from doing so and probably doing some code 'corrections' during runtime. * timing checks to recognize delays due to an attached debugger. * Windows API The debugging functions are implemented by using standard Win32-API calls like: * CreateProcess * SuspendThread / ResumeThread * ReadProcessMemory / WriteProcessMemory * GetThreadContext / SetThreadContext * Breakpoints To implement breakpoints I used a trick I learned from a very interesting paper in Codebreakers Journal. Its name is "Guide on How to Play with Processes Memory, Write Loaders and Oraculumns" and was written by Shub Nigurrath. Shub Nigurrath references the trick itself to yates and his paper "Creating Loaders & Dumpers - Crackers Guide to Program Flow Control", so kudos to him too. The trick is to place the opcode EB FE at the address you want to stop. This code stands for "jmp -2" which is the shortest way to code a while(1); loop I know of. * Dis-/Assembling To dis-/assemble the opcodes, I used the awesome code of the disasm zip-file Oleh Yuschuk, creator of OllyDbg, has put on his site. OllyDbg has rightfully gained a reputation for being intuitive and a real alternative to SoftICE when it comes to ring 3 applications. * File-information To extract some information about code and data segments and other stuff about the process I used the information gained from the paper "Portable Executable File Format – A Reverse Engineer View" written by Goppit. This paper can also be found at Codebreakers Journal. * Singlestep and stepping into calls Since I couldn't use debug-events, I chose the simple way out and "just" set a breakpoint on the instruction which would be executed next. This involved checking for jumps, calls and returns to make sure to get the right instruction. Checking for conditional jumps was easy since the disasm files (mentioned above) could already do this for me with the Checkcondition function. The same applies for calls. With the exception of calls that got their destination from a register. After searching for a while I found that the lower nibble of the call-opcode gave away the register that should be used. Last time I wrote about StackWalk-function and I have to admit that I was wrong about using it for returns since intel-documentation states that ret in any case uses the first element form the stack. So there's nothing to be done except reading the DWORD pointed to by the ESP. * Thread Local Storage (TLS) The first piece of code that will be executed when a new process is started isn't at the address pointed to by AddressOfEntryPoint. Actually DataDirectory[IMAGE_DIRECTORY_ENTRY_TLS] in the optional header points to a IMAGE_TLS_DIRECTORY32 structure which contains a pointer to a list of functions executed before going to the AddressOfEntryPoint. * Process dumping When I started writing the code, I was wondering why there didn't seem to be any tutorial about dumping a running process with your own program. Most tutorials I found used existing tools for it. There are some really good papers about rebuilding the IAT by the way. Which I will keep in mind for one of the next releases. As I began to reread the PE documentation it occurred to me that this is about all you need to dump an unprotected process. You can get the headers directly from the imagebase of the module and from them you can gather all the other parts. So the job is reassembling the parts scattered through process space by the loader and writing them into a file. Just keep boundaries and offsets in mind. * Symbols Working with symbols is much easier than I first thought. Most work is done by the Sym*-functions provided by the imagehlp library (for example use SymGetSymFromAddr to get a symbols name by its address). So the only part which requires a bit of work, is to determine the levels of indirection so calls via a jumptable could be resolved correctly. The same goes for applying the IDA map file. Once it is parsed, it's back to analysing references again. By the way, IDA is a very impressive disassembler by Ilfak Guilfanov (DataRescue). It provides a deeper analysis and another view to an executable than most debuggers do. Plus, as the name implies, you don't need to actually execute the target, which is pretty cool, especially for malware analysis. * Basic block analysis After the construction of the (more or less) needed basics I decided to take a shot at improving the code analysis. A short research yielded the magical words 'basic block', which is a term that originated from optimization concepts of compilers. But perhaps it's better to first explain what basic blocks are. A basic block is, generally spoken, a sequence of commands that doesn't contain any jumps and isn't jumped into. Where jump doesn't mean the jmp instruction but generally everything that explicitly moves the eip anywhere. The commands I used the determine the end of a basic block are: * all jumps, conditional and unconditional (e.g. jmp, je...) * call * ret How are blocks and addresses handled? The Analyser contains two lists, where one holds all addresses not analysed yet and the other contains the generated blocks. By doing this there is a clean separation between unknown and known blocks. To avoid an infinite loop e.g. when dealing with backward jumps the analyser only processes addresses that do not lie on the beginning of an already processed code-block. Also no processing of addresses out of the modules scope will be performed. This is done to keep the processing-time at an acceptable level. The analysis of the code starts at the entrypoint and moves onward from there on. Calls and conditional jumps both yield at best two addresses where the analysis of a new block could be started. The 'at best' results from the fact that at the time of analysis indirect addressing with register can't be resolved, so this is a path that can't analysed. When an address points into a known block this means that the block needs to be split, since an address can only come from a jump to this location which means the former block ends there and a new one begins. At the moment the analyser doesn't make any assumptions about what could be meant but only cares for definate information. Thus there are blocks of code which haven't been recognized and therefore are treated as filling. This affects the readability of the disassembled code. Since any opcode not flagged as code will be disassembled in byte steps. For example an opcode like 74 53 at address 00403F52 will result in the following output: 00403F52 74 53 JE 403FA7 00403F53 53 PUSH EBX Mind the addresses, that is what was meant by 'in byte steps'. This can be fixed by telling the analyser to process the code from the current selection onwards. * Modular approach After starting with a single executable, I decided to break it up into the GUI which in itself still contains a lot of intelligence and the basic obsidian class which contains all of the debugger- like functions. The main reason for this was to be able to pass the obsidian class to a plugin. But this way you can also easily use the obsidian class in other programs. * Plugin interface At the moment there is only a by call interface available, which means that the plugin will only be called when the user selects the plugin from the list. To write a working plugin for obsidian you need to export the following two functions from a dll. extern "C" void EXPORT GetName(char* p, unsigned int len); extern "C" DWORD EXPORT Go(Obsidian* p); As the name of the first function implies its only purpose is to store the name of the plugin in the supplied buffer. The second function gets called when the user clicks on the menu entry. This is the place where your plugin can do its work. The paramer you receive is a valid class pointer which should be used by you instead of the singleton construct. To make Obsidian recognize a plugin you need to create a folder called "PlugIns" in the Obsidian-directory and put the dlls into that folder. | |||
| Also listed in: | Non-Intrusive Debuggers | |||
| More details: | Click here for more details, screenshots, related URLs & comments for this tool! (or to update its entry) | |||
| Tool name: | Poke |
| ||
|---|---|---|---|---|
| Author: | Toolcrypt Group | |||
| Website: | http://www.toolcrypt.org/tools/poke/index.html | |||
| Current version: | ||||
| Last updated: | ||||
| Direct D/L link: | http://www.toolcrypt.org/tools/poke/poke.zip | |||
| License type: | Free | |||
| Description: | Poke is a run-time process examination tool. It reminds slightly of a debugger, but is injected into a running process and does not use the Debug API. This tool can give you some valuable help if the process you want to examine has some heavy anti-debugging features. Poke is under development and is tested and works on Win2K. | |||
| Also listed in: | Non-Intrusive Debuggers | |||
| More details: | Click here for more details, screenshots, related URLs & comments for this tool! (or to update its entry) | |||
| Tool name: | radare |
| ||
|---|---|---|---|---|
| Author: | pancake | |||
| Website: | http://radare.nopcode.org | |||
| Current version: | 0.9.3 | |||
| Last updated: | February 19, 2008 | |||
| Direct D/L link: | http://radare.nopcode.org/get/radare-0.9.3.tar.gz | |||
| License type: | GPL | |||
| Description: | The radare project aims to provide a complete unix-like toolchain for working with binary files. It currently provides a set of tools to work with x86, arm and java with some ones powerpc. The core is a raw hexadecimal editor for commandline with scripting features and perl/python extensions that gets extended with IO plugins that hooks the open/read/write/close/system calls. The debugger and disassembler has a code analysis module for x86, arm and java. This way it's possible to draw graphs using Cairo on a GTK window or store the flow execution of a program on a log file and use the information to diff't against another trace or binary. The toolchain provides assemblers and disasemblers for x86, arm and java. The disassembler has been enhaced to handle inline comments, code block detections and flag references (data pointers or so). The debugger currently works on linux,*bsd x86-32 but it has initial support for x86-64 and linux-ARM, and w32 support is in mind too. But there are IO plugins for debugging windows and DOS applications via wine and dosemu. Initial gxemul support gives us the possibility to also debug ARM, MIPS, SPARC, .. binaries. There are some internal commands to handle memory maps, mount a syscall proxy, inject code, patch data, dump user data sections, step-back, syscall tracing, hardware DRx register manipulation, conditional watchpoints with expressions, signalling manipulation, syscall injection and very early threading support.. Data structures can be parsed with hand-written C programs called as extensions from radare. So the hexadecimal editor comes with a set of views for different bases and print formats like URL-encoding, binary, octal, shellcode, C string-like, which is really useful for developing shellcodes. There's a minimal GUI frontend written in C that interacts directly with an VTE running radare. But I plan to write a new native frontend written in Vala. Current development plugins are: * ewf: EnCase (R) forensic disk images * winedbg: WineDebugger interface ( winedbg://./program.exe ) * haret: Remotely read WindowsCE memory ( haret://host:port ) * ptrace: Debugs or attach to a process ( dbg://file or pid://PID ) * sysproxy: Connects to a remote syscallproxy server * remote: TCP IO ( listen://:port or connect://host:port ) * gdb: Debugs or attach to a process using gdb (gdb://file, gdb://PID, gdb://host:port) * w32: posix to native w32 api io * posix: plain posix file access The tools provided around the core are: * radare: command line hexadecimal editor with IO plugin extensions * rabin: get info from ELF/MZ/PE/CLASS files * rasc: shellcode generator and tester (outputs in raw, hexpairs or C) * bindiff: binary diffing utilities for raw files, binaries, data blocks, etc * xrefs: find crossed references on raw images for ppc, arm and x86 * hasher: calculate different algorithms over data blocks of a file or stream * rsc: command line helpers written in shellscript or perl * javasm: minimalistic java assembler/disassembler/classdumper * armasm: minimalistic arm assembler * xc: converts between multiple radix numeric bases FMI see the mailing list Have fun! | |||
| Also listed in: | Assemblers, Binary Diff Tools, Code Injection Tools, Disassemblers, Hex Editors, Java Disassembler Libraries, Linux Debuggers, Linux Disassemblers, Linux Tools, Memory Dumpers, Memory Patchers, Process Dumpers, Reverse Engineering Frameworks, String Finders, Symbol Retrievers, SysCall Monitoring Tools, Tracers | |||
| More details: | Click here for more details, screenshots, related URLs & comments for this tool! (or to update its entry) | |||
| Tool name: | W32DASM |
| ||
|---|---|---|---|---|
| Author: | URsoftware | |||
| Website: | N/A | |||
| Current version: | 8.94 | |||
| Last updated: | March 11, 2003 | |||
| Direct D/L link: | N/A | |||
| License type: | Commercial | |||
| Description: | Before IDA Pro, W32DASM was the king of Windows 32 bit executable disassemblers. It also has a ring 3 debugger built-in. | |||
| Also listed in: | Disassemblers | |||
| More details: | Click here for more details, screenshots, related URLs & comments for this tool! (or to update its entry) | |||
| Tool name: | Whiskey Kon Tequilla VB P-Code Debugger |
| ||
|---|---|---|---|---|
| Author: | WKT Team | |||
| Website: | N/A | |||
| Current version: | 1.3e | |||
| Last updated: | Around 2001 | |||
| Direct D/L link: | Locally archived copy | |||
| License type: | Free | |||
| Description: | At the time it showed up, the one and only P-Code disassembler / debugger mankind was able to use. Before it, debugging of the P-Code (Runtime interpreted Pseudo-VB code) with ordinary disassemblers / debuggers was really pain in your neck. This one saved me a lot of time, and probably helped postpone my deportation to the psychiatric research facility. | |||
| Also listed in: | Disassemblers, Visual Basic Decompilers | |||
| More details: | Click here for more details, screenshots, related URLs & comments for this tool! (or to update its entry) | |||
Feed containing all updates and additions for this category.
Feed containing all updates and additions for this category, including sub-categories.
