Free fast md5 implementation java 2.6.1 software for linux

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.

Inline::Java lets you write Perl classes in Java and wrap/use existing Java classes. The project is an ILSM (Inline Language Support Module) for Java 2, and is part of the Inline family of modules.

Pluto is the Reference Implementation of the Java Portlet Specfication. The current version of this specification is JSR 168.
Portlets are designed to run in the context of a portal. They are written to the Portlet API which are similar to the Servlet API.
In contrast to servlets, portlets may not do things like sending redirects or errors to browsers directly, forwarding requests or writing arbitrary markup to the output stream to assure that they don?t distract the portal web application which uses them.
Another difference compared to servlets is that portlets rely on portal specific infrastructure functions such as access to user profile information, standard interface for storing/retrieving persistent settings, getting client information, etc. Generally,
portlets are administrated more dynamically than servlets typically are.
A portlet container provides a runtime environment for portlets implemented according to the Portlet API. In this environment portlets can be instantiated, used and finally destroyed. The portlet container is not a stand-alone container like the servlet container; instead it is implemented as a thin layer on top of the servlet container and reuses the functionality provided by the servlet container.
Pluto serves as portlet container that implements the Portlet API and offers developers a working example platform from which they can test their portlets. However, its cumbersome to execute and test the portlet container without a driver, in this case, the portal.
Plutos simple portal component is built only on the portlet containers and the JSR 168s requirements. (In contrast, the more sophisticated, Jetspeed project concentrates on the portal itself rather than the portlet container, and considers requirements from other groups.)
Enhancements:
- Added Pluto 1.1 index page and basic documentation
- PLUTO 164: response contentType can change after getWriter()
- PLUTO 155: URL encoding in pluto 1.0.1-RC4 issue when using apache with jk2
- PLUTO 157: portlet.tld taglib is using jsp version 1.1. JSR168 spec requires JSP version 1.2
- PLUTO 152: Support maven deployment to a remote repository
- PLUTO 130: portlet:namespace fails inside JSTL c:set
- PLUTO-107: Admin portlet fails to add page. Hot deployment now supported.
- PLUTO-92: Deployer strips elements from web.xml (Deploy War Portlet)

JDOInstruments is an embedded object oriented database programmed in java, it is also an implementation of Suns Java Data Objects (JDO) specification for the transparent persistence of Java objects.
Because of this, it doesnt need a JDBC driver or a relational database. JDOInstruments uses its own object store thus it allows storage and retrieval of persistent data with little work from you.
It is integrated with Netbeans IDE (via Plugin module) allowing developers to build pure object-oriented systems.
It is free and Our license is GNU LGPL providing the code and executables (JARs) free of charge. You are free to use JDOInstruments in your projects.
Main features:
- Byte-Code Enhancement of classes
- Byte-Code Compatibility
- Datastore identity
- Optimistic Transaction
- Nontransactional Read
- Retain values
- Restore values
- Second Class PersistenceCapable objects
- J2EE Integration
- Query (JDOQL)
- Index
- Schema Evolution

Ganymed SSH2 for Java is a library which implements the SSH-2 protocol in pure Java (tested on J2SE 1.4.2 and 5.0).
Ganymed SSH2 for Java allows one to connect to SSH servers from within Java programs. It supports SSH sessions (remote command execution and shell access), local and remote port forwarding, local stream forwarding, X11 forwarding and SCP.
There are no dependencies on any JCE provider, as all crypto functionality is included.
Ganymed SSH2 for Java is used in the Ganymed replication project and a couple of other projects here at the IKS group.
Main features:
- 100% Java implementation of the SSH-2 protocol (tested on J2SE 1.4.2 and 5.0)
- No dependency on any JCE provider, all crypto functionality is included in the Ganymed SSH2 for Java library.
- Supports SSH sessions (remote command execution and shell access), X11 forwarding, local and remote port forwarding, local stream forwarding and SCP.
- Thread safe, multiple threads can concurrently execute commands, open shells etc. on the same SSH connection.
- Available ciphers: aes256-ctr, aes192-ctr, aes128-ctr, blowfish-ctr, aes256-cbc, aes192-cbc, aes128-cbc, blowfish-cbc, 3des-ctr and 3des-cbc.
- Supports DSA and RSA server keys (ssh-dss and ssh-rsa). Extensive support for known_hosts file handling.
- Key exchange methods: diffie-hellman-group-exchange-sha1 (parameters configurable), diffie-hellman-group14-sha1 and diffie-hellman-group1-sha1.
- Supported MAC algorithms: hmac-sha1-96, hmac-sha1, hmac-md5-96 and hmac-md5.
- User authentication: password, keyboard-interactive and public-key with DSA and RSA keys (client-side private keys (PEM format) may also be 3DES, DES or AES encrypted).
Enhancements:
- This release has support for SFTP v3, HTTP proxies, connection monitoring, improved port forwarding, better compatibility for the Diffie-Hellman group exchange, and enhancements in the SCP code.

Welcome to the SFI website. The Simple Forth Interpreter (SFI in short) is a Java implementation of a little subset of the ANS Forth language.
The goal of SFI is to develop a small interpreter to be embedded in any application and provide scripting functionality with low resources.
SFI follows the ANS Forth standard where reasonably possible, provides a simple way by inheritance to customize and integrate the interpreter in any existing application and a simple interface to play with the Forth code.
Why Forth? The interpreter its pretty simple and small, its an easy to learn language and the extend with user defined words fits quite well the idea of a language for scripting purposes.
Enhancements:
- Bug fix into TOK_NWORD parsing strings and comments.

Ristretto is the mail API that is used by Columba, a Java mail client.
It is available as a stand-alone API, and it provides a well-tested, slim, and fast Java implementation of all relevant mail protocols and features.
It is licensed under a MPL/LGPL/GPL tri-license.
Enhancements:
- Added CramMD5 Authentication
- Separate packages for each protocol
Bugs fixed:
- Zeros padding in server response while authenticaion fixed.
- Java 1.5 import problems for Sasl fixed.

JXTA platform is an open network computing platform designed for peer-to-peer (P2P) computing. The JXTA platform standardizes the manner in which peers:
- Discover other peers
- Advertise Peer resources (Peer, PeerGroup, Service and Pipe Advertisements)
- Communicate with each other (Pipes)
- Cooperate with each other to form secure peer groups (group membership)
The Platform project is a Java Standard Edition reference implementation of the JXTA protocols.
The Platform project was the original JXTA implementation and was built in Java, because Java enabled us to rapidly prototype and test new ideas and develop a more robust implementation.
Java is available on most client platforms (Unix, Windows, MacOS X, etc.) and allows us to reach the maximum number of potential users.