// $Id: IDEA.java,v 1.1.1.1 2002/08/27 12:32:09 grosbois Exp $//// $Log: IDEA.java,v $// Revision 1.1.1.1  2002/08/27 12:32:09  grosbois// Add cryptix 3.2//// Revision 1.4  2000/08/17 11:40:51  edwin// java.* -> xjava.*//// Revision 1.3  1997/11/29 04:42:55  hopwood// + Changes to engineUpdate method.//// + Fixed invertKey to do the right thing (i.e. nothing) when the native//   library is being used.// + Formatting changes.//// Revision 1.2  1997/11/20 19:31:39  hopwood// + cryptix.util.* name changes.//// Revision 1.1.1.1  1997/11/03 22:36:56  hopwood// + Imported to CVS (tagged as 'start').//// Revision 0.3.2.0  1997/08/21  David Hopwood// + Removed all deprecated methods and fields. Cryptix 2.2 compatibility//   is now handled by the separate cryptix.security.IDEA class.// + Tightened some of the access specifiers (e.g. SPI methods were public,//   and are now protected).// + Ensured that this class is final, and added a comment that this is for//   security reasons.//   If it were not final, some VMs have a bug that would allow a subclass//   that implements Cloneable to call Object's or Cipher's clone() method//   using invokenonvirtual, which would duplicate the pointer to the native//   state. Then calling finalize() on the original and using the clone (for//   example) would result in freed memory being written to :-(.// + Required native code version is 2.3.//// Revision 0.3.1.0  1997/07/14  David Hopwood// + Blowfish, DES, IDEA, and Square 3.1.0 are now at the same API//   level and in the same style.// + Fixed security bug (out-of-bounds read) introduced in 3.0.1 -//   same bug as for Blowfish 3.0.5.// + Renamed outs variable in engineUpdate to temp, to avoid similarity//   with out.//// Revision 0.3.0.1  1997/07/09  R. Naffah// + Fully IJCE-compliant!// + Tested OK with and without IDEA.DLL.// + Re-wrote the JNI code to conform with modifs;// + Changed method signatures to follow same style/params as the other//   ciphers in the library;// + Changed methods mul and inv to return shorts;// + Now use one short[] as the session key;// + Brought it to the same API level as Blowfish 3.0.5 and DES 3.0.2;//// Revision 0.3.0.0  1997/07/0?  David Hopwood// + JCE, native linking, debugging, etc...//// Revision 0.2.5.2  1997/04/03  Systemics// + Documentation.  Deprecated public variables and made methods private.//// Revision 0.2.5.1  1997/03/15  Jill Baker// + Moved this file here from old namespace.//// Revision 0.2.5.0  1997/02/24  Systemics// + Original version.//// $Endlog$/* * Copyright (c) 1995-97 Systemics Ltd * on behalf of the Cryptix Development Team.  All rights reserved. */ package cryptix.provider.cipher;import cryptix.util.core.Debug;import cryptix.CryptixException;import cryptix.util.core.ArrayUtil;import cryptix.util.core.Hex;import cryptix.provider.key.RawSecretKey;import java.io.PrintWriter;import xjava.security.Cipher;import java.security.Key;import java.security.InvalidKeyException;import xjava.security.SymmetricCipher;/** * IDEA is a block cipher with a key length of 16 bytes and a block length of * 8 bytes. It is highly popular, being the original cipher in PGP, and has * received a lot of cryptanalytic attention. * <p> * IDEA was written by Dr. X. Lai and Prof. J. Massey. * <p> * <b>References:</b> * <ol> *   <li> See the <a href="http://www.ascom.ch/Web/systec/security/idea.htm">IDEA page</a> *        for more details. *        <p> *   <li> The algorithm is subject to patent claims by *        <a href="http://www.ascom.ch/systec/">Ascom Systec Ltd</a> *        (applied for May 1991), and is *        <a href="http://www.ascom.ch/Web/systec/policy/normal/policy.html">licensable</a>. * </ol> * <p> * * <b>Copyright</b> &copy; 1995-1997 * <a href="http://www.systemics.com/">Systemics Ltd</a> on behalf of the * <a href="http://www.systemics.com/docs/cryptix/">Cryptix Development Team</a>. * <br>All rights reserved. * * <p><b>$Revision: 1.1.1.1 $</b> * @author  Systemics Ltd * @author  David Hopwood * @author  Raif S. Naffah * @since   Cryptix 2.2.2 */public final class IDEA // must be final for security reasonsextends Cipherimplements SymmetricCipher{// Debugging methods and vars.//...........................................................................    private static final boolean DEBUG = Debug.GLOBAL_DEBUG;    private static final boolean DEBUG_SLOW = Debug.GLOBAL_DEBUG_SLOW;    private static final int debuglevel = DEBUG ? Debug.getLevel("IDEA") : 0;    private static final PrintWriter err = DEBUG ? Debug.getOutput() : null;    private static void debug(String s) { err.println("IDEA: " + s); }// Native library linking methods and vars.//...........................................................................    private static NativeLink linkStatus = new NativeLink("IDEA", 2, 3);    /**     * Gets an object representing the native linking status of this class.     */    public static cryptix.util.core.LinkStatus getLinkStatus() { return linkStatus; }    /**     * The native reference to the current native key schedule     * structure. Defaults to 0 but is set by native code after a     * successful call to native_init().     * <p>     * IMPORTANT: Do not change the name of this variable without     * duplicating the same in the native code.     */    private long native_cookie;    /**     * This object must be synchronized on while calling any native instance     * method. It is null if the native code is not being used (e.g. the     * library did not load successfully, or the user disabled its use in     * the properties file).     */    private Object native_lock; // defaults to null    private void link() {        synchronized(linkStatus) {            try {                if (linkStatus.attemptLoad()) {                    linkStatus.checkVersion(getLibMajorVersion(), getLibMinorVersion());                    linkStatus.check(native_clinit());                }                if (linkStatus.useNative()) {                    linkStatus.check(native_init());                    native_lock = new Object();                }            } catch (UnsatisfiedLinkError e) {                linkStatus.fail(e);if (DEBUG && debuglevel > 2) debug(e.getMessage());            }if (DEBUG && debuglevel > 2) debug("Using native library? " + (native_lock != null));        }    }// Native support API//...........................................................................    // The methods that get the library version.    private native static int getLibMajorVersion();    private native static int getLibMinorVersion();    /**     * Static initialization and self-test method for the native code.     *     * @return a string if an error occurred or null otherwise.     */    private native String native_clinit();    /**     * Initializes the native state for this cipher object and allocates     * needed native storage for the internal key schedule. A reference     * to the newly allocated space, if successful, is stored in the     * instance variable <code>native_cookie</code>.     *     * @return a string if an error occurred or null otherwise.     */    private native String native_init();    /**     * This function expands the user key to an internal form.     *     * @param  cookie   a valid reference to the native key structure. This     *                  value is set by the native library upon return from     *                  native_init() (see link() method at the top).     * @param  userKey  a byte array representing the user key     * @return an error String, or null if there was no error     */    private native String native_ks(long cookie, byte[] userKey);    /**     * Encrypts/decrypts a data block.     * <p>     * FUTURE: possibly change this to be able to process more than one block,     * to reduce native method call overhead.     * <p>     * SECURITY: the caller <strong>must</strong> ensure that:     * <ul>     *   <li> <code>in != null</code>     *   <li> <code>out != null</code>     *   <li> <code>inOffset >= 0</code>     *   <li> <code>(long)inOffset + BLOCK_SIZE <= in.length</code>     *   <li> <code>outOffset >= 0</code>     *   <li> <code>(long)outOffset + BLOCK_SIZE <= out.length</code>     * </ul>     *     * @param  cookie       a valid reference to the native key structure. This     *                      value is set by the native library upon return from     *                      native_init() (see link() method at the top).     * @param  in           input array containing data to encrypt or decrypt     *                      depending on the value of the encrypt boolean parameter.     * @param  inOffset     index of where we should start reading from input.     * @param  out          output array containing data decrypted or encrypted     *                      depending on the value of the encrypt boolean parameter.     * @param  outOffset    index of where we should start writing to output.     * @param  encrypt      if true then encrypt, otherwise decrypt.     * @return the number of bytes crypted (always BLOCK_SIZE) or 0 if an error     *                      occurred.     */    private native int native_crypt(long cookie, byte[] in, int inOffset,                                    byte[] out, int outOffset, boolean encrypt);    /**     * Finalizes the native state for this object.     *     * @return a string if an error occurred or null otherwise.     */    private native String native_finalize();// IDEA constants and variables//............................................................................    private static final int        ROUNDS = 8,        BLOCK_SIZE = 8,        KEY_LENGTH = 16;    /**     * The number of array elements in the expanded key schedule, i.e. both     * encryption and decryption keys.     * <p>     * For IDEA this is <code>6 * ROUNDS + 4 = 52</code>.     */    private static final int INTERNAL_KEY_LENGTH = 52;    /**     * The key schedule.     */    private short[] ks = new short[INTERNAL_KEY_LENGTH];// Constructor, finalizer, and clone()//............................................................................    /**     * Constructs an IDEA cipher object, in the UNINITIALIZED state.     * This calls the Cipher constructor with <i>implBuffering</i> false,     * <i>implPadding</i> false and the provider set to "Cryptix".     */    public IDEA() {        super(false, false, "Cryptix");        link();    }    /**     * Cleans up resources used by this instance, if necessary.     */    protected final void finalize() {        if (native_lock != null) {            synchronized(native_lock) {                String error = native_finalize(); // may be called more than once                if (error != null)                    debug(error + " in native_finalize");            }        }    }    /**     * Always throws a CloneNotSupportedException (cloning of ciphers is not     * supported for security reasons).     */    public final Object clone() throws CloneNotSupportedException {        throw new CloneNotSupportedException();    }// Implementation of JCE methods//............................................................................        /**     * <b>SPI</b>: Returns the length of an input block, in bytes.     *     * @return the length in bytes of an input block for this cipher.     */    protected int engineBlockSize () { return BLOCK_SIZE; }    /**     * <b>SPI</b>: Initializes this cipher for encryption, using the     * specified key.     *     * @param  key  the key to use for encryption.     * @exception InvalidKeyException if one of the following occurs: <ul>     *                <li> key.getEncoded() == null;     *                <li> The length of the user key array is not KEY_LENGTH.     *              </ul>     */    protected void engineInitEncrypt (Key key)    throws InvalidKeyException, CryptixException {        makeKey(key);    }    /**     * <b>SPI</b>: Initializes this cipher for decryption, using the     * specified key.     *     * @param  key  the key to use for encryption.     * @exception InvalidKeyException if one of the following occurs: <ul>     *                <li> key.getEncoded() == null;     *                <li> The length of the user key array is not KEY_LENGTH.     *              </ul>     */    protected void engineInitDecrypt (Key key)    throws InvalidKeyException, CryptixException {        makeKey(key);