Free java cryptography api software for linux

The Legion of the Bouncy Castle Java Cryptography API provides a lightweight cryptography API in Java. A provider for the JCE and JCA, a clean-room implementation of the JCE 1.2.1, generators for Version 1 and Version 3 X.509 certificates, generators for Version 2 X.509 attribute certificates, PKCS12 support, and APIs for dealing with S/MIME, CMS, OCSP, TSP, and OpenPGP. Versions are provided for the J2ME, and JDK 1.0-1.5.
Main features:
- A lightweight cryptography API in Java.
- A provider for the JCE and JCA.
- A clean room implementation of the JCE 1.2.1.
- A library for reading and writing encoded ASN.1 objects.
- Generators for Version 1 and Version 3 X.509 certificates, Version 2 CRLs, and PKCS12 files.
- Generators for Version 2 X.509 attribute certificates.
- Generators/Processors for S/MIME and CMS (PKCS7).
- Generators/Processors for OCSP (RFC 2560).
- Generators/Processors for TSP (RFC 3161).
- Generators/Processors for OpenPGP (RFC 2440).
- A signed jar version suitable for JDK 1.4/1.5 and the Sun JCE.

Java Network Stack provides a Java library for research oriented network programming.

Java Network Stack is a library used by the DIMES project to create new internet measurements. It provides a clean API for packet manipulation, send, receive, filter, and analysis. It is a unification of raw socket capabilities, MAC level networkingm, and IPv6 capabilities.

Java Tools is a lightweight integrated development environment for creating, compiling, and executing Java applications and applets.
Java Tools includes point and click access to the Java files, commands, and documents. It also includes a built-in text editor and user interface for the Java debugger.
It is intended for the new Java user who needs help getting started. Its also for the more experienced Java user who wants easy access to the Java commands and a text editor.
Main features:
- GUI with built-in help and small footprint.
- Point and click access to all files (Java, manifest, HTML, image and sound) and directories (package).
- Point and click access to all commands for compiling (javac), archiving (jar), documenting (javadoc), executing (java), debugging (jdb) and disassembling (javap).
- Point and click access to all documents (Java API Specification, Java Tools and Utilities, Java Features and Java Tutorial).
- Point and click creation of all files (Java, manifest and HTML) and directories (package).
- Point and click installation of distribution archive files (Java document, Java source code, Java Tutorial and Sun Tools).
- Automatic determination of class file dependencies for archiving (jar) and documenting (javadoc) Java files.
- Checking for unused, redundant and missing imports.
- Logging of all commands invoked by GUI.
- Code metrics for Java files.
- Built-in text editor (see Edit for details).
- Built-in user interface for the Java debugger with command-line editing and history.
- Self-installing executable (Java archive file).
- Comprehensive installation and user documentation for Java and Java Tools.

Java Bomberman project is a multiplayer game for Java.

Instructions

First of all start a bomberman server by typing...

# java BombermanServer [-port 1033 -speed 3 -timeout 300]

You can use the -port option to change the default port number.

You the -speed option to change the player speed at game start (default 3). The option -timeout changes the timeout (default 300).

After the server has started successfully you can start several clients by typing...

# java BombermanClient [-name nickname -port 1034
-host 127.0.0.1 -serverport 1033
-quiet
-music
-theme ice
-x 0 -y 0
-c1 16756655 -c2 16776960
-ai BombermanDefaultAI
-i]

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.

Java Properties provides an efficient way to access bean-like properties of Java objects.

In a nutshell, provides an efficient way to access bean-like properties of java objects. Unlike java bean properties, a chain of properties can be specified efficiently, allowing convenient access to properties of nested domain objects.

Runtime class-generation and caching can be used very easily to obviate the need for reflection, without losing the flexibility it provides.

Class Properties It also provides classes which manipulate objects at runtime by using strings to address conceptual variables (think bean properties) in a similar fashion to the java reflection mechanisms.

Class Property example Say we have the following classes:

public class Order {
...
public Customer getCustomer() { ... }
...
}
public class Customer {
...
public Address getAddress() { ... }
...
}
public class Address {
...
public String getLine1() { ... }
public String getLine2() { ... }
...
}

Now, we could do this to access line 1 of the address:

result = order.getCustomer().getAddress().getLine1();

But what if there are nulls? What if we want to compare the first line of the address from two different orders? Whith properties this is really simple:

ClassProperty p = PropertyManager.getProperty(Order.class,"Customer:Address:Line1",true);
result = p.getValue(order);

The idea is simple enough - you use the string "Customer:Address:Line1" to specify a series of getXXX calls. Importantly, it the library handles nulls for you, returning null if any of the objects in the chain are null.

Note, this is not simply a wrapper around java reflection, since it includes non-reflective optimizations by making use of the cojen library to generate class files at runtime to acces these properties.

The real benefit lies in being able to specify which properties you wish to access at runtime. You can even pass this ability on to the users of your library or application. Unlike reflection, class files are generated for the properties, and these files are cached - which means once you have specified a property once, further uses of the same property dont use reflection and are very fast.

Property API vs Java Bean Properties. The property API models accessor/mutator method pairs as conceptual variables called properties. The approach used is similar to, but more flexible than java bean properties, and more performant than reflection if runtime class generation is used. Unlike java bean properties, a chain or path of properties can be specified (and more importantly, turned into bytecode using runtime generation) to traverse a complex tree of objects.
It is simple to create applications portable between different security environments - using runtime generation where allowed, and falling back to reflection where security is tighter.

Dynamic Class Management. The properties package also provides classes to handle the loading (and unloading/reloading) of classes at runtime. It provides a framework useful for dynamically loading runtime-generated classes, for example.
While the property API can happily ignore the dynamic loading framework, it can also make use of it to enable runtime class generation.

Jeffs Java Scanf Library is an implementation of the C-Runtime scanf, fscanf, and sscanf functions.

The syntax of format strings is very similar (%*s, %3d, etc.) to that of the standard C implementation of scanf.

Instead of taking wrapper objects, all scanf functions return an Object[], whose types can be inferred from the format string.