Free java to native 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.

SJPT is parsing toolkit that supports both top-down (LL(1) and Simple Precedence) and bottom-up parsing (LR(0), SLR(1), LR(1) and LALR(1)).

The toolkit also supports generating Java parsers for all the bottom-up parsing methods, based on a CUP definition (similar to Yacc and CUP, but not restricted to LALR parsers only). I worked alone on this project for the laboratory on Compilers.

SJPT is free software under the terms of the GNU GPL.

Asm2class is a java assembly to class file compiler.

Asm2class is release under the terms of the GPL License. The current version of asm2class (0.1.2) is a beta version and allow generating class file from java assembly file that contains class definition, field definition, method definition and constructor definition.

This release support also abstract class, abstract method and native method definition.

Asm2class know more thatn 90% of the java assembly language. Asm2class can do dead code detection, uninitialized register detection.

Vexi is a Visual, Extensible, XML Interfaces.

Vexi is written in Java, but compiled into native binaries using GCJ and are combined with launchers that work natively in popular web browsers.

Java for C++ is a tool to generate C++-wrapper-classes for existing Java-classes. This tool reads a list of Java class names and creates source code for C++-classes to wrap them.
The implementation of the wrapper classes uses JNI (Java Native Interface) to call the "real" Java classes.
The C++-API to use these wrapper classes is very close to the API of the original Java classes. So developers of C++-software can use Java-classes as if they have been implemented in C++.
Enhancements:
- A problem where null values for method arguments, method return values, or field values caused some generated code to crash was fixed.
- Updating is strongly encouraged.

JD4X project is a basic GUI Windowing Environment developed to support the Java Programming Language based on top of the X Window system. It was developed with the intention of providing a Java environment that allows Java programmers to build and extend a windowing system purely in Java. However, the project itself is not pure Java and uses a mixture of Java and C.

JD4X is targeted at the hobbyist programmers who desire to put their skills to the test by customizing a desktop of their own. To do this, the JD4X project sets out to provide a native structural foundation that gives them a greater degree of control over their desktop, JVMs and Java classes that runs on the Linux X Window system, thereby giving the Java programmer full control of their desktop environment.

The project also targets Java users who may desire a Java enabled and component based desktop without excluding other native applications already found on their Linux distribution. It does this by also providing a default windowing desktop to cater to the end users who can select a mixture of native and Java applications that they like on their desktop without having to differentiate between them and the way they are executed.

In general, JD4X aims to isolate the underlying platform system to the background and provide a fully Java GUI front end. JD4X is not about a Java only desktop. It is about empowering the Java user and programmer such that the Java desktop will meet their particular needs.

Fast MD5 Implementation in Java is a heavily optimized implementation of the MD5 hashing algorithm written in Java.
Fast MD5 Implementation in Java includes an optional native method for even greater speed improvements.
How Fast Is It?
Short answer:Much faster than any other Java implementation that I have tested and (surprisingly) even faster than the native, non-Java MD5 implementation on some systems.
Long answer:First of all, it is important to note that the term "fast" is used here in relative terms. The implementation of the MD5 message digest algorithm available on this page is written in Java and is fast compared with other implementations written in Java, both because it is heavily optimized by itself and because there is an optional native method that makes it even faster when the platform supports it. How it compares to a sensible implementation written in a language, such as C, that is compiled directly to machine code, is heavily dependent upon how good of a job the JIT compiler in your JVM does in compiling the code or whether you are able to use the optional native method.
Enhancements:
- Martin West contributed a bug fix and some code refactoring to make all targets work out of the box in the Ant build file. Previously, the "dist" target did not work if the "docs" directory was not present.

JSON-RPC-Java provides an RPC implementation that allows JavaScript DHTML Web applications to call remote methods in a Java Application Server (AJAX functionality) without the need for page reloading.
JSON-RPC-Java library is an enabler for the next generation of fast and highly dynamic enterprise Java Web applications. Minimal changes (if any) are necessary to existing server-side Java code to allow calling from JavaScript (such as the marshalling and unmarshalling of special types), as JSON-RPC-Java dynamically maps JavaScript objects to and from Java objects using Java reflection.
Enhancements:
- The license has changed from the LGPL to the Apache License, Version 2.0.
- New object registration, lookup, and unregister APIs have been added to JSONRPCBridge.