zynamics BinNavi 3.0 Manual

About BinNavi

Information about BinNavi
Third-Party Software
Change Log
License

Information about BinNavi

Third-Party Software

Many icons used in BinNavi were taken from FamFamFam and are licensed under the Creative Commons Attribution 2.5 License.

Change Log

Changes in BinNavi 3.0.0 (August 1st 2010)

Feature: Added support for the analysis of 32 bit MIPS code. You can now use BinNavi to analyze code from embedded MIPS devices like Cisco routers.
Feature: Local variables can now be renamed. This helps you to annotate the disassembled code with more information.
Feature: Global variables can now be renamed (through a context menu). This helps you annotate the code with more information.
Feature: Cross-references to global variables are now accessible in the main window. You can use this feature to quickly find out what functions access what global variables.
Feature: Views, modules, and other elements of BinNavi can now be starred to highlight them as particularly important or interesting. This is very useful to quickly get back to functions you previously considered interesting.
Feature: Added support for a faster C++ based exporter. This allows you to import IDB files into the BinNavi database much faster than the old Python exporter did.
Feature: Multiple IDB files can now be imported simultaneously. This speeds up IDB importing significantly.
Feature: Made it easier to select multiple IDB files from different directories for one batch import process. You can now easily import modules from different directories in one step.
Feature: Added support for conditional breakpoints. You can now decide exactly when program execution should be stopped on breakpoint hits.
Feature: The memory of the debugged target process can now be edited. This allows you to make quick patches to the target process memory.
Feature: Instruction operands like integer literals, registers, and even complex formulas can now be followed in memory during debugging.
Feature: When recording debug traces, the modules where the trace events happened, the register values at the time of the events and important memory sections are now recorded for each debug event.
Feature: It is now possible to apply set operations (union, intersection, difference) on recorded debug traces to quickly isolate important debug events.
Feature: It is now possible to specify how often breakpoints can be hit before they are removed during trace mode. This allows users to record more complete traces than before.
Feature: Modified the semantics of trace mode to allow the user to create new traces from the currently active breakpoints.
Feature: Instructions that use local or global variables can now be highlighted in the disassembled code.
Feature: Special instructions like function calls or memory access instructions can now be highlighted in the disassembled code.
Feature: Optional statistical information about functions is shown in call graph nodes to quickly give users an idea about the size of functions.
Feature: Added a way to step to the end of a function during debugging. This is a quick way to leave the current function and continue debugging in the calling function.
Feature: Modules can now be sorted by name. This makes it easier to find modules in large databases.
Feature: Removed the separation between raw modules and modules to smoothen the BinNavi workflow.
Feature: Unsaved changes are now highlighted in the GUI to show the user what he changed since he saved the last time.
Feature: Added non-blocking progress dialogs to allow the user to continue working while long running tasks run in the background.
Feature: Added more hotkeys to make working with the keyboard more comfortable.
Feature: The password to databases can now be shown in plain text to remind the user of forgotten passwords.
Feature: Added a context menu to the tabs in graph windows to close all graph views but the current one.
Feature: When debugging, the memory view now shows the memory address at the position of the caret. This makes it easier to navigate through the target process memory.
Feature: Added a context menu to the registers view that allows the user to follow register pointers in the target process memory.
Feature: The output of the scripting console can now be saved to a file.
Feature: Previously created Debug by Criteria expressions are now available in a menu of the graph window for quick access.
Feature: New improved code editor for writing scripts.
Feature: Renamed functions can have their name reverted to the original name.
Feature: The hierarchy of existing node tags and view tags can now be reorganized.
Feature: The correct thread IDs are now recorded for debug events in trace mode.
Feature: Trace events can now be filtered to show only those traces with a given register value or whose memory contains specific values.
Feature: The Select by Criteria dialog can now be extended by plugins.
Feature: Breakpoints are now tied to a module. This makes it possible to relocate breakpoints automatically when the debugged module is relocated.
Feature: The speed of echo breakpoint setting and removal was improved drastically.
Feature: It is now possible to quickly set breakpoints on the addresses of trace mode debug events.
Feature: It is now possible to quickly jump to the instruction for which a trace mode debug event was recorded.
Feature: The user can split one basic blocks into two basic blocks now. This is useful in combination with stepping to the next basic block while debugging.
Feature: Information about the threads of the debugged target process is now shown in BinNavi.
Feature: The threads of the debugged target process can now be suspended and resumed.
Feature: ALT+Right-Click on local or global comments now pops up a dialog to edit those comments.
Feature: Inlined functions can now be un-inlined.
Feature: During debugging the user can now access a panel that shows the log of the debug events of the current debugging session.
Feature: The addresses of instructions can now be copied to the clipboard quickly (context menu of instructions in disassembled code).
Feature: When functions references in disassembled code have their name changed, the disassembled code is updated to reflect this change.
Feature: It is now possible to change the name of referenced functions in disassembled code through a context menu.
Feature: Memory addresses referenced in disassembled code are now correctly rebased if the module itself is rebased.
Feature: Instruction operands in disassembled code can now be shown as decimal numbers, hexadecimal numbers, or their symbolic name.
Feature: Added context-sensitive help to many elements of the BinNavi GUI.
Feature: Added a way to quickly show the REIL code of a native instruction (context menu of the instruction).
Feature: Added a way to quickly find out what views contain a given instructions (part of the table filter of views).
Feature: The views whose nodes are tagged with node tags are now shown in the main window.
Feature: Stack values can now be copied to the clipboard.
Feature: Added more colors to distinguish between different types of instruction operands.
Feature: BinNavi can now check whether exporters are correctly installed and configured.
Feature: Added a way to quickly find views that share instructions with any given view.
Feature: Really long function names are now displayed more gracefully in the GUI.
Feature: Write access to the database has been improved.
Feature: Added a way to quickly select all nodes on the paths between two graph nodes.
Bugfix: Open graph views are now notified about changing debugger configurations.
REIL: Added support for 32 bit MIPS
Plugin API: The registers of the debugged target process can now be edited.
Plugin API: The memory of the debugged target process can now be edited.
Plugin API: The Select by Criteria dialog can now be extended using plugins.
Plugin API: Debug trace events are now tied to modules.
Plugin API: For each recorded debug trace event, the register values and the recorded memory can be accessed.
Plugin API: Changed the semantics of CodeNode::addInstruction. Instructions that are being inserted are now cloned before being added. The cloned instruction is returned by the function.
Plugin API: The IOperandExpression listener now receives information about changing operand expressions.
Plugin API: Removed raw modules from the plugin API.
Plugin API: Added the ModuleHelpers class which provides a few functions for working with modules.
Plugin API: Added Module::getId which returns the database ID of the module.
Plugin API: The BreakpointManager::setBreakpoint functions now return a Breakpoint object.
Plugin API: Added a Settings class where global BinNavi settings can be changed.
Plugin API: Added Debugger::toImagebase and Debugger::toFilebase to convert between relocated and non-relocated addresses.
Plugin API: Added AddressSpace::getProject which returns the project a address space belongs to.
Plugin API: Added Function::getModule which returns the module a function belongs to.

Changes in BinNavi 2.2.0 (October 1st 2009)

Feature: Incoming call-references are now shown in the graph window. This makes it very easy to find out what functions are calling the function users are currently analyzing.
Feature: Added interactive tutorials for learning how to use BinNavi. This makes it easier for new users of BinNavi to learn about the most important BinNavi concepts.
Feature: Added the option to select from running processes when selecting a debug target. This feature allows users to select running processes of remote platforms from the BinNavi GUI instead of the console of the remote system.
Feature: Added the option to use the BinNavi GUI to select a file from the remote system for debugging. This allows users to select a file from the remote system through the BinNavi GUI instead of the console of the remote system.
Feature: REIL code can now be displayed as graphs just like regular code. This is very useful for people who want to work with REIL code.
Feature: Added the option to turn a normal control flow graph into a data flow graph
Feature: Added the option to connect a file with a module. This makes it possible to display the data of the file in a hex viewer.
Feature: Previously recorded debug traces are now shown in the main window. This feature allows users to quickly see all recorded debug traces for their modules and to see what views contain nodes that were hit by previously recorded debug traces.
Feature: Made several major improvements to our Windows Mobile debugger
Feature: The debugger now collects information about loaded modules and displays name, base address, and size of all active modules of a process. This allows users to keep track of dynamically loaded and unloaded libraries.
Feature: Relocated image bases of modules are automatically corrected while debugging. It is not necessary anymore to specify the relocated image bases of modules and dynamically loaded libraries manually.
Feature: Function breakpoints can now be set from the functions table of the main window. This is quicker than opening a function or the call graph of a module first.
Feature: Added a way to filter the content of larger tables to make it easier and quicker to find things. Using these filters users can reduce the lines shown in tables to those lines that are relevant for them.
Feature: Visual feedback is given if searching through a graph produces no results. This makes it more obvious whether a search operation produced results or not.
Feature: When searching through graphs, previous search strings are now cached so that the user can easily search for them again at a later point in time
Feature: Added the option to display a dialog that shows all search results when searching through graphs. This dialog shows all search results in a list which makes it easy to navigate between interesting search results.
Feature: Addresses the user recently searched for in graphs are now kept for later reuse. This is useful because users often want to go back to addresses they previously visited.
Feature: Visual feedback is given if the user wants to jump to an address that does not exist in a graph. This makes it more obvious whether an instruction address exists in a graph or not.
Feature: Function nodes now display additional information about the function they represent. This allows users to get an idea how large the functions represented by function nodes are.
Feature: The module names of functions are now shown in call graph function nodes. Previously it was unclear to which module a function belongs to if function nodes of multiple modules were shown in one view.
Feature: The original function of a code node can now be opened from the context menu of the code node. This allows users to quickly open the original function of a code node from heavily modified views.
Feature: Added the option to review the available debugger options. Previously this information was only shown once when first connecting to a debugger. Now it is possible to display the information again from the BinNavi GUI.
Feature: Graph windows can now be switched between a default perspective and a debug perspective. This reduces clutter and makes the GUI less complex.
Feature: Added the option to create non-existing databases right from BinNavi. This makes it easier to get started with new databases because it is not necessary to create new databases with external tools anymore.
Feature: Added popup-descriptions to all settings options in the settings dialog. It is now easier to modify settings without having to consult the manual.
Feature: Using the zynamics GDB Agent it is now possible to debug Mac OS applications.
Feature: The zynamics GDB Agent can now be used from Linux and Mac OS in addition to Windows.
Feature: Added a quick information label that displays information about the last debug events during debugging.
Feature: Size information about sections is now shown in the memory section box. This allows users to get an idea how large individual memory sections of the target process are while debugging.
Feature: Added the option to stop waiting while section memory is loaded
Feature: Added the option to inline all called functions of a graph in one step. This is useful for quickly determining all possible control flow paths between two nodes including all control flow paths in subfunctions.
Feature: Improved error messages throughout the program. This allows user to get a better understanding of what went wrong and how to fix the problem.
Feature: The database format can now support multiple instructions per address. This makes it much easier to experiment with instruction creation, for example while deobfuscating code.
Feature: Freshly created views are now now saved automatically anymore. This makes it much less tedious to experiment with automatic view creation because it is not necessary anymore to delete previously created views.
Features: Error messages now have unique error IDs. This makes it easier for us to find out what went wrong when users come across bugs and report them to us.
Feature: Errors can now be reported using a single button click in the error dialog. The error description is automatically sent to our bug tracker and users will receive feedback through the email address configured in their BinNavi settings.
Feature: Added a Python sample script that can be used to export comments to IDA Pro. While this serves mainly as a demonstration script for using the plugin API, it is also useful for users that want to continue working with IDA Pro.
Feature: Added a new sample code coverage plugin that demonstrates how to script the debugger. This plugin keeps track of what nodes of a view are hit during a debug session and changes their background color depending on how often they were hit.
Feature: Added a way to select function nodes of graphs by function type.
Feature: Added a way to tag all nodes of a debug event trace with a tag.
Feature: The font used in all comment dialogs was changed to monospace.
Feature: The Trace Events table now has a context menu that provides useful functions.
Feature: All comment dialogs can now be closed using CTRL-ENTER.
Feature: The DEL key can now be used to delete node tags in the node tags tree.
Feature: The DEL key can now be used to delete traces in the traces table.
Feature: The traces table now has a context menu that provides useful functions.
Feature: Added the option to create combined callgraphs of all modules of a project.
Feature: Memory Reload button now reloads memory shown in the stack window too.
Feature: Improved the Pathfinder example plugin that is shipped with source.
Bugfix: Fixed an issue that led to crashes when thread IDs >= 0x80000000 were seen during debugging
Bugfix: Fixed a thread leak that occurred when many modules were assigned debuggers
Bugfix: Fixed an issue that led to problems when loading projects that included modules that were loaded and other modules that were not loaded
Bugfix: Fixed an issue that led to problems when views for traces with zero events were requested
Bugfix: Fixed an issue that caused breakpoints not to be removed when clicking the "Remove all breakpoints" button
Bugfix: Fixed an issue that led to incorrect register information shown during debugging for threads that did not cause the last debug event
Bugfix: Fixed a bug that made the Save button of projects misbehave when project debuggers were configured
Bugfix: Fixed a bug that led to incorrect behavior when saving/loading edge colors
Bugfix: Fixed an error that led to incorrect results of the backtracking algorithm when encountering certain XOR instructions
Bugfix: Fixed issues in the REIL translation of the x86 instructions RCL, IMUL, and PUSHF
Plugin API: Added the option to execute SQL queries from the plugin API. This makes it possible for users to query the SQL database directly if necessary data is not easily available from the plugin API.
Plugin API: Added the option to change the background color of instructions code nodes. With this feature users can highlight important instructions programmatically from plugins and scripts. This improves the visualization of analysis algorithms.
Plugin API: Added the ability to create Instruction objects. This is useful for users that need to create new instructions, for example when they write analysis algorithms that modify existing code.
Plugin API: Added the option to change the color of edges. This feature allows users to give edge colors semantic meaning in the context of their analysis algorithms.
Plugin API: Made the frame of GraphWindow objects available. This frame object can be used by plugins as the parent frame of dialogs and message boxes.
Plugin API: Improved the design of the Breakpoint API
Plugin API: Improved the design of the MemoryBookmark API
Plugin API: Harmonized the naming scheme of enumerations
Plugin API: Harmonized the functions of the MessageBox class
Plugin API: Many new methods added to the plugin API
Plugin API: Added the option to remove instructions from code nodes to the plugin API
Plugin API: Added the option to remove databases from the plugin API
Plugin API: Added the option to listen to changes in DebuggerTemplate API objects
Plugin API: Added the option to add debuggers to projects
Plugin API: Added the option to remove debuggers from projects
Plugin API: Added the option to retrieve all project debuggers
Plugin API: Added the option to delete address spaces
Plugin API: Fixed various bugs that left data loaded when projects were closed
Plugin API: Added the option to listen on project debugger events
Plugin API: Changed the behavior of Project::getFunctions to return the functions of all loaded modules
Plugin API: Added a way to close View objects from the plugin API
Plugin API: Text nodes can now be cloned
Plugin API: Added the option to determine the tags of a View
Plugin API: Added the option to untag views
Plugin API: Fixed a bug in View::setDescription
Plugin API: Added the opportunity to listen on view edges
Plugin API: View Node object listeners now notify about parent group changes
Plugin API: View Node object listeners now notify about visibility changes
Plugin API: Fixed issues in ViewGraphHelpers that led to internal objects included in signatures
Plugin API: Added a way to find instructions by long-address to ViewGraphHelpers
Plugin API: Added a way to get all tags associated with a view node
Plugin API: Added a way to get the debugger template of a module
Plugin API: Module listeners are now notified about changing module debugger templates
Plugin API: It is now possible to add listeners to Instruction objects
Plugin API: Changes in Instruction comments are now sent to listener objects
Plugin API: Made the API graph algorithms more generic and made graph algorithms available to more API graph types
Plugin API: The view of a function can now be retrieved from the plugin API
Plugin API: Fixed an issue in TreeNode::getChildren() that led to internal objects being exposed to the plugin API
Plugin API: Fixed a bug in the InstructionGraphNode class that caused edges that were removed from the graph to remain in the children/parents set of instruction graph nodes
Plugin API: CodeNode objects do not required a parent function anymore. This makes it much less tedious to create new graphs.
Feature: Added the option to copy the value of registers to the clipboard
Plugin API: Added the option to set the meta-data of a ReilInstruction object
Plugin API: Instructions that cause exceptions when translating code to REIL are now accessible from the plugin API
Plugin API: Added the option to process raw debug events received from debug clients.
Plugin API: Added a global output console that can be used by plugins to output information.
Plugin API: Added a few REIL helper functions
Plugin API: Added some helper functions for creating REIL instructions
Plugin API: Fixed various bugs that led to crashes
Plugin API: Fixed a bug that led to incorrect parents/children of nodes
Plugin API: Added helper functions for function inlining
Plugin API: Added a way to get the incoming and outgoing edges of nodes
Plugin API: ProgressDialog now returns potential exceptions thrown while the progress dialog is active
Plugin API: Added the ViewGenerator class that makes it very simple to create new views from REIL code
REIL: Fixed a few REIL translation issues for various ARM instructions
REIL: Fixed an issue that led to incorrect edge types in REIL graphs
REIL: Added REIL support for the x86 instructions SHRD, SHLD, XADD, SETALC, BT, BTC, BTR, BTS, SAL, JCXZ, BSR, BSL
REIL: Fixed a REIL translation issue for the x86 instruction XLAT

Changes in BinNavi 2.1.1 (June 5th 2009)

Bugfix: Removed excessive debug output in some situations
Bugfix: Improved input behavior for hex number fields
Bugfix: Improved text copy speed when copying from tables
Bugfix: Fixed a bug in the Lengauer-Tarjan algorithm that led to incorrect dominator trees
Bugfix: Clicks on the project debugger control now have an effect on the status of the Save button
Bugfix: Fixed a bug that led to incorrect behavior of the Save button when module debuggers were selected
Bugfix: Special characters like German Umlauts can now be used in instruction comments
Bugfix: The NOT operator now works in the Select by Criteria
Bugfix: Fixed a bug that led to incorrect register tracking results for "call register" instructions
Bugfix: Fixed a bug that led to incorrectly displayed trace data when debug traces were reordered
Bugfix: Less "Do you want to Save?" dialogs are shown when closing the main window of BinNavi while graphs are open
Bugfix: Fixed a slight layouting issue that cut off information about selected module debuggers
Bugfix: Fixed a bug that caused breakpoints not be removed when pressing the "Remove All Breakpoints" button
Bugfix: Fixed a bug that led to closed threads not being removed from the plugin API
Plugin API: REIL instructions and REIL graphs can now be easily created from the plugin API

Changes in BinNavi 2.1 (April 1st 2009)

Feature: Added a stack window that displays the stack while debugging
Feature: Added the option to group nodes in graphs
Feature: Added the option to statically track register usage
Feature: Improved settings dialogs to make it easier to select settings
Feature: ALT-RightClick on instructions pops up the instruction comment dialog
Feature: Double-clicking a node zooms to the node
Feature: CPU flags are now shown individually while debugging
Feature: Added a quick overview over the available hotkeys in graph windows
Feature: Improved zoom behavior during debugging
Feature: When selecting the content of a node, a special context menu is now shown to work with the selected content
Feature: Added a sample Python script that creates the dominator tree of a graph
Feature: Added the option to select the log level in the settings dialog
Feature: Improved the GUI of the main window to make the Save button only clickable if data was modified
Feature: Added the option to delete nodes from a graph while connecting the parents of the nodes with their children
Feature: Added the option to remove instructions from nodes
Feature: Added the option to select all nodes of a graph which belong to the same function
Feature: Added the option to follow memory pointers in the memory view while debugging
Feature: Added the options to remove, deactivate, and activate all active breakpoints
Feature: Improved the GUI of the scripting dialog
Feature: Added the option to set a preferred scripting language which is selected by default in scripting dialogs
Feature: Added the option to create a copy of a view
Feature: Added the option to add bookmarks to instructions
Feature: Changed the behavior of proximity browsing to make sure that comment nodes are always visible when the nodes they are attached to are visible
Feature: Added the option to flip endianness in the memory viewer while debugging
Feature: When closing a window, the user is now asked about saving in one dialog, instead of having one dialog per open graph
Feature: Added a "Report a Bug" menu
Feature: Added the option to choose default basic block colors
Feature: The appearance of the graph window is now saved between sessions
Feature: Added the option execute arbitrary scripts without loading them into the script editor first
Feature: Added the option to automatically execute a startup script when opening script dialogs
Feature: Improved the way graph windows are brought to the front while debugging
Feature: Added the option to import raw modules to a database without first establishing a connection to the database
Feature: Added the option to delete multiple debug traces in one step
Feature: Edges that belong to loops are now displayed differently than edges that don't
Feature: Build Numbers are now shown properly in the About dialog
Feature: Added PowerPC and ARM support to REIL
Feature: Improved REIL support for x86 assembly
Feature: Improved the exporting of ARM code from IDA Pro
Feature: Relocated addresses are now shown in callgraphs too
Feature: Edges that jump from the end of a loop to its start are now painted different from normal edges
Bugfix: Fixed a bug that caused x86 functions with SIDT/SGDT/SLDT/LIDT/LGDT/LLDT instructions to fail
Bugfix: Fixed a bug that caused useless graph layouting when settings changed that do not influence the graph layout
Bugfix: Fixed some issues that caused minor problems with graph layouting when loading saved graphs
Bugfix: Global comments are now properly synchronized between open views
Bugfix: The border color of blocks split during function inlining is set correctly now.
Bugfix: Fixed a bug that caused debugging highlighting to disappear from nodes when comments were added to the node
Bugfix: Fixed a bug that caused the option to display multiple edges between two blocks as one to misbehave
Bugfix: Fixed a bug that failed to update the scripting dialog output panel when printing from registered callback objects
Plugin API: Added a static analysis framework (MonoREIL) to the plugin API
Plugin API: Added a sample script that shows how to use MonoREIL
Plugin API: Fixed an issue that caused node tagging to fail
Plugin API: Added Lengauer-Tarjan algorithm to determine the dominator tree of graphs
Plugin API: Added the option to open graphs
Plugin API: Added the option to access graph windows
Plugin API: Added the option to access the module/project a view belongs to
Plugin API: Made it easier to convert native assembly code to REIL code
Plugin API: Added the option to get the edge type of edges in REIL graphs
Plugin API: Added the option to access REIL instruction meta-data
Plugin API: Added implementations for common module-related functions
Plugin API: Added implementations for common view-related functions
Plugin API: Made it possible to get the function objects represented by function nodes
Plugin API: Added the option to be notified about changes in code nodes
Plugin API: Enumerations are now properly documented in the API documentation
Plugin API: Address objects can now be treated like longs in Python scripts
Plugin API: Added the option to access the BinNavi start path
Plugin API: Added the option to access comment nodes from the plugin API
Plugin API: Added the option to access group nodes from the plugin API
Plugin API: Added the option to get the image base of a module inside an address space
Plugin API: Added implementations for common breakpoint-related functions
Plugin API: Added access to the binary data of instructions
Plugin API: Improved access to debug traces
Plugin API: Added the option to create debug traces from the plugin API
Plugin API: For increased convenience, objects accessed from the plugin API are not loaded automatically
Plugin-API: Added the option to reload plugins without restarting BinNavi
Plugin-API: Improved the convenience of working with BinNavi objects from Python scripts
Plugin API: Fixed a bug that caused an exception when removing a debugger from a module
Plugin API: Made it significantly easier to convert functions and other code objects to REIL code.
Plugin API: Added new example scripts
Plugin API: Added the option to add and remove code and data references to/from instructions
Plugin API: Made it possible to write stand-alone scripts that run from the shell without running BinNavi in the background
Plugin API: Added a way to determine the type of a function (normal, library, imported, ...)
Plugin API: Fixed a bug that led to incorrect removal of breakpoints
Plugin API: Added the option to create new REIL instruction
Plugin API: Added the option to modify instruction graphs

Changes in BinNavi 2.0 (October 15th 2008)

Added the option to bundle multiple modules into address spaces and projects
Added the option to analyze and debug dynamically linked modules
Added the option to load and analyze multiple modules at the same time
Improved the Python scripting API
Added support for Ruby and ECMAScript scripts
Added a full-featured plugin API
Added the option to tag views
Added the option to tag nodes
Added comment nodes which can be used to store larger comments in graphs
Improved the graph overview panel
Added the option to copy disassembly data to the clipboard
Added the option to export graphs in SVG format
Improved graph loading and rendering speed
Added the option to associate imported functions with real functions in other modules
Added better support for debugger configurations
Added support for multiple interface languages (English and German are supported in this version)
Improved manual
Improved proximity browsing with nodes that give information about hidden nodes
New Select by Criteria dialog allows node selection with complicated criteria
Added tabbed browsing in graph windows
Added better REIL integration

Changes in BinNavi 1.5 (March 1st 2008)

Improved debugger interface
Single stepping, stepping over calls, and stepping to the next basic block are now possible
Improved display for registers and memory
Debugger support for multi-threaded programs
Memory bookmarks
Improved breakpoint handling
Improved graph layout
Improved graph loading and rendering speed
Additional layout options
Support for line comments
Distinction between local comments and global comments
Search for functions by address
Improved search functionality in graphs
Mousewheel support to zoom graphs
Improved graph tooltips
Improved function inlining
Added magnifying glass mode

License

BinNavi License Agreement

In the following, the term zynamics is used interchangeably with "zynamics GmbH".

The BinNavi computer programs, hereafter described as "the software" are licensed, not sold, to you by zynamics pursuant to the terms and conditions of this Agreement. zynamics reserves any right not expressly granted to you. You own the media on which the software is delivered but zynamics retains ownership of all copies of the software itself. The software is protected by copyright law.

The software is licensed on a "per user" basis. Each copy of the software can only be used by a single user at a time. This user may install the software on his office workstation, personal laptop and home computer, provided that no other user uses the software on those computers.

In case you obtained an "enterprise license", any regular full-time employee of your organization is granted a "per user" license. The organization and it's exact limits have to be defined upon purchase of an enterprise license.

In case you obtained an "evaluation license", one single employee can use the software until the granted evaluation period expires, for the sole purpose of evaluating the software.

The "per user" and "enterprise" license also allows you to

make as many copies of the installation media as you need for backup or installation purposes.
reverse-engineer the software (with the exception of y.jar and all components that belong to yFiles)
with the written agreement of zynamics, transfer the software and all rights under this license to an other party together with a copy of this license and all material, written or electronic, accompanying the software, provided that the other party reads and accepts the terms and conditions of this license. You lose the right to use the software and all other rights under this license when transferring the software.

Restrictions

You may not distribute copies of the software to another party or electronically transfer the software from one computer to another if one computer is also used by another party.

You may not modify, adapt, translate, rent, lease, resell, distribute, or create derivative works based upon the software or any part thereof.

Limited Warranty and Disclaimers

The software is provided "as is" without warranty of any kind. zynamics expressly disclaims all implied warranties, included but not limited to the implied warranties of merchantability and fitness for a particular purpose. zynamics does not guarantee the software or any accompanying materials in terms of their correctness, accuracy, reliability, or otherwise. The entire risk as to the results and performance of the software and written materials is assumed by you.

Complete Statement of Warranty

The limited warranty provided in preceding paragraphs are the only warranties of any kind made by zynamics on this product. No oral or written information or advice given by zynamics, its dealers, distributors, agents or employees shall create a warranty or in any way increase the scope of this warranty, and you may not rely on any such information or advice. This warranty gives you specific legal rights. Your statutory rights, which may vary from country to country, are not affected.

Limitation of Liability.

In no event will zynamics or his employees be liable to you for any consequential, incidental, or indirect damages arising out of the use or the inability to use the software or accompanying written material. This includes damages for loss of business profits, business interruption and loss of business information. The liability of zynamics for actual damages for any cause whatsoever is limited to the money paid for the software that caused the damages.

Termination

This license is effective until terminated. It will terminate immediately without notice if you fail to comply with any of its provisions. Upon termination you must destroy the software and all copies thereof. You may terminate this license at any time by destroying the software and all copies thereof.

Disputes

This agreement is subject to German law. The courts at Essen/Germany shall have exclusive jurisdiction.