HcryptoJ Files

This directory contains version 0.5a of the HCryptoJ API. 

Features

HCryptoJ is a Java Application Programming Interface (API) for
historical cryptography. It is modelled after the Java Cryptography
Extension (JCE).

* Encryption/Decryption --  Supports the encryption of strings (Java String objects) or ASCII files. 

* Ciphers -- Can be used to implement any historical cipher that can
  be defined as a function from a String to a String.

* Default Ciphers -- Default Provider classes are supplied which
  contain implementations of Caesar, Simple Substitution (passphrase),
  Vigenere, Playfair, Affine, RailFence, and Transposition ciphers.

* Keys -- All Cipher objects are defined with a Key class which can
  accomodate a wide range of key types.

* Alphabets -- Supports a wide range of alphabets including: az, AZ,
  azAZ, azAZ09, printable ASCII and the full ASCII character set.

* Analyzers -- The hcrypto.analyzer package contains a variety of
  classes to analyze historical ciphers, including:

 - AffineAnalyzer -- automatically solves cryptograms created with an Affine cipher.
 - CaesarAnalyzer -- automatically solves cryptograms created with a Caesar cipher.
 - CryptogramAnalyzer -- automatically solves cryptograms created with simple substitution cipher.
 - Histogram -- computes a frequency histogram for a message.
 - IndexOfCoincidence -- computes the Index of Coincidence for a message.
 - VigenereAnalyzer -- automatically solves Vigenere ciphers. 

* Applications -- HcryptoJ comes with a couple of very simple
  applications that illustrate how to use it. 
  - TestCipher is a command-line test program which encrypts or decrypts a string entered on the command line. 
  - FileCipher is a command-line programthat encrypts or decrypts a file named on the command  line. 

  - CryptoToolJ is a GUI program that encrypts and decrypts text entered interactively or via File I/O. 
  - CryptoAppletJ is a Java applet that supports interactive encryption/decryption of text for Java enabled browsers.

* Service Providers --Like the JCE, HcryptoJ enables cryptographic
  service providers to develop their own implementations of a new or
  existing cipher. A service provider can install a cipher algorithm
  by defining a Cipher subclass, a HistoricalKey subclass and a
  Provider subclass.

* Object Oriented Design -- HcryptoJ is modeled after the JCE and is
  organized into three packages. For details on the design, see the
  online documentation.

To Compile the Source:

To compile all the files in ./source and store the classes in the
./classes, which must already exist, use the following command. This
assumes that you are presently in this directory.

    javac -d classes -classpath src src/hcrypto/cipher/*.java \
         src/hcrypto/provider/*.java src/hcrypto/engines/*.java \
	 src/hcrypto/analyzer/*.java src/applications/*.java \
	 src/applications/cryptotoolj/*.java src/pluginproviders/*.java

This command will create the following package structure within classes:

classes
 |
 -- applications
 |
 -- hcrypto
    |
    -- analyzer
    |
    -- cipher
    | 
    -- engines
    |
    -- provider
 |
 -- pluginanalyzers
 
To run from the jar file:
	java -classpath <path/to/your.jar> applications.TestCipher
	java -classpath <path/to/your.jar> applications.FileCipher <args>
	java -classpath <path/to/your.jar> applications.cryptotoolj.CryptoToolJ
     
To Create a JAR (Java ARchive) file containing all the classes within
the proper package structure from with the ./classes directory:

    jar cvf <path/to/your.jar> hcrypto

To generate the JAVADOC documentation from the sourcecode:

 javadoc -d docs -sourcepath src hcrypto.cipher hcrypto.engines \
     hcrypto.provider hcrypto.analyzer pluginanalyzers applications