IO Ninja 

Scriptable Terminal/Sniffer

IO Ninja

 

Introducing IO Ninja

IO Ninja is an all-in-one scriptable terminal, sniffer and monitor. It is aimed at system administrators, network security experts and developers of communication software, firmware and hardware.

All-in-One

Programmability with Jancy language is what really takes IO Ninja to another level. But it is an extremely useful all-in-one tool even without writing a single line of Jancy code. IO Ninja can be used out-of-the-box as:

  • Serial terminal;
  • TCP terminal (both TCP client and TCP listener/server);
  • UDP terminal with support for UDP broadcasts (both UDP client and UDP server);
  • SSH terminal (SSH client channel);
  • Windows named pipe terminal (listener/server);
  • Generic file terminal (for working with custom device drivers, named pipes or FIFOs);
  • Serial monitor;
  • Network sniffer with support for sending/injecting user-defined frames;
  • TCP proxy (combination of TCP server and TCP client designed to work as a man-in-the-middle and replace Network Sniffer in certain situations).

Binary Data Support

IO Ninja is probably the best tool to transmit binary packets -- in fact, the lack of good hex editors in existing terminal emulators was one of our motivations in creating the first IO Ninja prototype many years ago. The latest version of IO Ninja has excellent support for editing binary packets before sending:

  • Text editor with support for escape sequences like \n, \e \xFF, \u2661 etc;
  • Hex editor with support for copy/paste/undo/redo etc;
  • Support for all UTF encodings (UTF-8, UTF-16, UTF-32, including variations with inverted/bigendian byte order);
  • Template packet editor -- find a definition of protocol header in C language, copy and paste it in IO Ninja (it might need a few cosmetic touches to get Jancy-compatible). Then fill in the fields using property grid!

IO Ninja has equally good support for displaying both incoming and outgouing (RX/TX) binary data in a communication log:

  • Binary data is interleaved with informational textual messages thus creating a clean single-sheet log;
  • Merge incoming (as well as outgoing) binary packets together:
    • Always;
    • Never;
    • If time interval is less than user-defined threshold.
  • Merged packet boundaries are (optionally) highlighted in a checker pattern;
  • Display binary data as:
    • Hex-view (with user-defined line size);
    • Plain text (with user-defined line size and tab size).
  • Support for all UTF encodings (UTF-8, UTF-16, UTF-32, including variations with inverted/bigendian byte order);
  • Whenever you select binary data range, offset and length of selection is displayed in the status bar;
  • Multiple modes of binary data copy:
    • Copy as text;
    • Copy as hex;
    • Copy as C-literal, e.g. "abc\ndef\x01\x02";
    • Copy as C-array, e.g. { 0x01, 0x02, 0x03 };
    • Copy as Jancy hex-literal, e.g. 0x"01 02 03";
    • Save as file.

Redirect Anything-to-Anything

IO Ninja features Session Linking which turns it to a universal redirector. Create two sessions (possibly, of completely different nature), configure them and then link them together. All the data will be passed-through from one end to another and vice versa.

For example, you may have a certain device connected to PC with a serial cable. Run IO Ninja on this PC, create Serial and TCP Listener sessions, link these sessions -- and voila! You can now connect to this device from any other computer via TCP!

Programmable

Alright, we've saved the best for the last. IO Ninja is programmable with Jancy scripting and it means that IO Ninja is basically a universal IO debugger. It will do whatever you tell it to with any of its supported IO interfaces (the list of which will get even bigger in future releases). In fact, IO Ninja executables merely provide a framework of IO classes, GUI widgets and log engine objects while the actual logic of a particular session (be it TCP Listener, Network Sniffer or Serial Monitor) is all written in Jancy -- that's how every built-in IO Ninja session works.

Just to give you a hint of what's possible with Jancy scripting in IO Ninja:

  • Change any existing session provider -- from modification of a single line of text in log to a complete redesign of UI or connection logic;
  • Create derivative sessions (for example, use Serial session as a basis for a serial tap-cable sniffer);
  • Write custom protocol analyzers, be it a transport-level protocol or an application-level protocol...
  • ...or write your own implementation of any protocol (including, yes, transport- or link-level layers);
  • Write filters to hide or colorize data based on user-defined logic;
  • Write any testing utilities imaginable, like: wait for incoming packets, analyze them and send something in return.

The list can go on and on, we'll leave the rest up to your imagination. Whatever piece of utility you write, it gets automatically powered by IO Ninja remarkable logging and transmitting capabilities. And -- dig this! -- we have an IO Ninja IDE (Integrated Development Environment) to assist you in exploring and making use of IO Ninja scripting!

Free For Personal Use

IO Ninja is free for non-commercial usage. However, if you plan to use IO Ninja for work-related purposes, you have to purchase a license. If you already have a license for IO Ninja version 2.x.x, you can upgrade it to a commercial license for IO Ninja version 3.x.x free of charge. Contact our sales department for details at sales@tibbo.com


Proceed to the detailed discussion of IO Ninja feature list