Free tool software for linux

The Java Binary Enhancement Tool (JBET) is a general Java program analysis and manipulation tool. Existing class files can be disassembled, reassembled, or edited programmatically through the JBET API. JBET can also be used to create new Java class files from scratch. JBET uses a convenient internal representation of all the contents of Java binary (.class) files, allowing the user to edit the classes easily, in a structured manner.

JBET was developed as part of the DARPA Self-Protecting Mobile Agents project under the OASIS and Active Networks programs (contract number N66001-00-C-8602) in order to study automated software obfuscation.

The Java language was chosen for this project because of the (relative) ease of constructing binary editing tools provided by the large amount of type information present in the class files. Our two reports, the Obfuscation Techniques Evaluation Report, and the Obfuscation Report, are available from the download area. The obfuscation tool developed is not part of this release.

JBET was also used in the DARPA/AFRL Survivable Server project (contract number F30602-00-C-0183) to add additional security checks to the Java Standard Library. (The Java SecurityManager API does not support many desirable security checks, such as continued authorization of file accesses after opening.)

JBET was used to replace the native method references in the Java standard library with stubs that call a pluggable security policy. This tool, called Jpolicy, is also available for download at this website. Jpolicy is very incomplete at this time, but may be interesting to those working in Java security or changing the standard library themselves.

The internal representation of Java class files used by JBET is intented to make it easy for programmers to write Java binary code transforms. Each element of Java class files has a corresponding internal data structure: ClassInfo for entire classes, MethodInfo for methods, FieldInfo for fields, Snippit for code blocks, and Instruction for individual instructions. Snippit and Instruction understand Java opcode syntax and semantics, allowing automated creation of valid Java programs. A Java-compatible class verifier is also included.

Some code transforms are difficult to program directly by manipulating Java instructions. For those transforms, a directed acyclic graph (DAG) representation of code is available. In the DAG representation, each basic block has a corresponding DAG, with a set of input and output nodes. Edges in the graph connect "producer" nodes (such as constants, or the result of calculations) to "user" nodes (such as method calls or other calculations). Methods are divided into basic blocks and control flow is stored at the basic block level (possible because Java has only fixed jump targets)

JBET requires a Java 1.4 virtual machine to run, although it can operate on class files from earlier Java versions. The packaging and build environment supplied supports Linux and Windows with Cygwin; however, the build process is simple and could be performed manually on other platforms. Perl is required for regression testing.

Jpolicy requires a Java 1.4 virtual machine to build, either Linux or Windows NT/XP with Cygwin. gcc is required for building on Windows (supplied with Cygwin). The runtime system can be either Java 1.3 or 1.4 (with Suns JVM only), running on Linux or Windows NT/XP. Windows 9x and Windows 2000 may work as well, but have not been tested.

Installation

1. Install jdk 1.4.1.
2. Set CLASSPATH to jdk1.4.1/jre/lib/rt.jar
3. cd src; make
4. If that didnt work, examine the makefile. java or javac may not be in the path.
5. To build a jar file that can be used with "java -jar jbet.jar", run "make jar".
6. If you have perl installed, run the tests with "make test".
Optionally, run "make regen; make test".

Make a symbolic link from jbet3/bin/jbet to somewhere in your path.

Usage

JBET uses the JNI format for class names, and JNI type and method descriptors. For a summary of this syntax, use jbet help syntax. Suns JVM specification may also be helpful.

To look at a class disassembly, use jbet print. Try disassembling a class you have source for, and was built with debug info (-g): jbet -P < classpath > print < classname >. Suns JVM specification has an instruction reference.

WebInject is a free tool for automated testing of web applications and services. It can be used to test individual system components that have HTTP interfaces (JSP, ASP, CGI, PHP, Servlets, HTML Forms, etc), and can be used as a test harness to create a suite of [HTTP level] automated functional, acceptance, and regression tests. A test harness, also referred to as a test driver or a test framework, allows you to run many test cases and collect/report your results. WebInject offers real-time results display and may also be used for monitoring system response times.

WebInject can be used as a complete test framework that is controlled by the WebInject User Interface (GUI). Optionally, it can be used as a standalone test runner (text/console application) which can be integrated and called from other test frameworks or applications.

WebInject uses an XML API (interface). This means you can use WebInject without ever seeing its internal implementation (no scripting or programming necessary to use it).

WebInject is written in Perl and can run on any platform that a Perl interpreter can be installed on (MS Windows, GNU/Linux, BSD, Solaris, MAC OS, and many more). Currently, binary executables of WebInject are only available for MS Windows. If you would like to run on other platforms, you must have a Perl interpreter and run it from the Perl source code.

Test cases are written in XML files, using XML tags and attributes, and passed to the WebInject engine for execution against the application/service under test. This abstracts the internals of WebInjects implementation away from the non-technical tester, while using an open architecture [written in Perl] for those that require more customization or modifications.

Result reports are generated in HTML (for viewing) and XML (for tranformation by external programs). These detailed results include pass/fail status, errors, response times, etc. Results are also displayed in a window on the User Interface if you are running the WebInject GUI, and are sent to the STDOUT channel if you are running the WebInject Engine as a standalone (console) application.

HTTP response times can be collected and monitored in real-time during test execution. Timer statistics are calculated and displayed in a monitor window during runtime. When used along with gnuplot (a plotting utility), a response time graph is generated and updated in real-time as the test runs. This is used to verify responses from the application/service under test are within an acceptable range (to meet your SLA or quality of service criteria). This also enables WebInject to be run as a performance probe for application/service monitoring.

The mii-tool command provides an tool for checking and setting ethernet cabling parameters.
It is normally included in Bernd Eckenfels net-tools package, but this is an single distribution which only contains mii-tool. This package also comes with cleaned makefile and allows build-time relocation and cross/sysroot-compiling.
Enhancements:
- removed evrything whats not mii-tool
- removed I18N stuff
- added support for specifying an installation root via the DESTDIR environment variable
- removed the config stuff (not needed for mii-tool)

cdp-tools is a software that provides tools to work with the Cisco Discovery Protocol (CDP).
They were written because of a particular hosting center that insisted on learning routes using CDP, and thusly required Cisco Switches for doing their dirty work.
cdp-listen/cdp-routemgr are proof-of-concepts that may be useful if you want to implement a similarly brain-damaged proposal.
cdp-send is a must-have tool if you are in that situation. It can pretend to be just about any kind of Cisco hardware you can imagine.
The source is a bit difficult to follow as a requirement was that it build under both the ancient libnet and the new libnet code. hence, much nasty macro-ing.
Enhancements:
- DESCRIPTION, README: More docs...

Database Fishing Tool is short DaFT is a front-end to any database that can be connected to with an ODBC driver. DaFT allows you to browse the database objects, view data in tables and views, and create and execute SQL statements, also as a script, including variable scanning.
DaFT contains a database objects list (tables and views), list of columns and column properties, a table for data snapshots, detailed data view, a notepad, a table for viewing the outcome of select statements, T-SQL or PL/SQL statements, a SQL statement editor with syntax highlighting, and a screen to follow all ODBC driver messages (errors etc.).
All selected data can be saved into a file. The supported file formats are HTML, XLS, CSV, SyLK, and DIF. The SQL statements can be saved into a text file.
Enhancements:
- Handle Tables, Views, and colums with names (partly) in capitals with surrounding quotes.
- Some bug fixes...

MIME-tool is a little mime encoding tool I slapped together when I needed something on a production box at work (productions = no C development environment, only the ancient K&R compiler required for god-knows-what sys-admin task).
The resulting program will compile happilly on both the crippled C compilers bundled with some commercial *nix distributions, and on full ANSI/ISO C compilers like gcc.
I wrote this program when I needed a tool to construct MIME encoded emails with file attachments in job scripts on a production box. Being a production box it didnt have any development tools installed. However, the box DID have a K&R C compiler that appears to be necessary for some administrative task or another (configuring the kernel?). If you tried to compile even fairly simple ANSI/ISO C source the compiler bitched and moaned about all the stuff it didnt support, which will stop most folk (at least those who dont know anything about the history of the C programming language) from building their own binaries.
Since Im old enough to actually have written C code back before we had the ANSI/ISO standard and all the accompanying niceties, I was not stymied by a the lack of ANSI/ISO support. Its really not all that hard to write K&R compliant code, so long as you dont need the compiler to check your function calls for you. For a program this small, however, thats not much of a concern.
Since the program is meant to be compiled on systems with minimal support (there is no telling what unrestrained IT staff will decide must be removed in the interest of system security) I didnt bother to include a makefile. On every system I have tried, however, the program compiled with the simple incantation
cc -o mime mime.c
but your selected target system may require extra special magics.
The program supports the basic MIME standard: The caller can select the content type (application/octet-stream, text/plain, or user specified), content type encoding (7bit, 8bit, binary, base64 or auto-detected) and the boundry string (defaults to "=_MIME_CONTENT_BREAK_="). Further, the caller may specify the e-mail subject, to address, from address, carbon copy address and text for a prolog and epilog. The content type and encoding may be specified separately for each attached file.
The programs calling format is:
mime [-dDvV] [-S subject] [-F from-address] [-T to-address]
[-C carbon-copy address] [-P prolog-text] [-E epiplogue-text]
[-B boundry] {[-78abqux] [-t content-type] filename}
-d low detail debugging
-D high detail debugging
-v verbose messages
-V very verbose messages
-7 7-bit ASCII encoding
-8 8-bit ASCII encoding
-a application/octet-stream content type
-b binary encoding
-q quoted-printable encoding
-t text/plain content type
-u unknown encoding, auto-detect
-x base64 encoding
Theres really not much to this program. Once you know how the MIME messages are constructed you could do most of it manually (except for the base64 encoding, which would require a program like this), but if there are any problems with it, I would like to know about them.
Enhancements:
- A typo in the online help message was fixed.
- A known bugs section was added to the manpage.
- Proper quoting and folding were added to the filename header.

IPsec-Tools is a port of KAMEs IPsec utilities to the Linux-2.6 IPsec implementation. IPsec-Tools supports NetBSD and FreeBSD as well.
Contents:
libipsec
Library with PF_KEY implementation.
setkey
Tool to manipulate and dump the kernel Security Policy Database (SPD) and Security Association Database (SAD).
racoon
Internet Key Exchange (IKE) daemon for automatically keying IPsec connections.
racoonctl
A shell-based control tool for racoon
Enhancements:
- Some various bugfixes

Cimon is Perl program wich monitors the load (memory and CPU) on Cisco routers using SNMP, and generates graphics with statistics using rrdtool. Its good for information about your routers health.

It monitors and displays the cpu 5 minutes utilization in percents and free+used Processor memory. The I/O memory(usualy 2 MB) or Fast on high end routers is being monitored too, but there isnt graphic for it. Cimon is good source for information about your routers health. From version 0.2 cimon can do ip accounting using the cisco ip accounting feature.
The logfiles that it generates as the rrd files needed for the graphics are fully compatible with those produced by sasacct (SASs accounting statistics). So you can use its cgi interface also its posibility to generate graphics on demand or on a user defined interval (via crontab and -g option).