Лабораторная работа №21 / serpent.tar / serpent-as-submitted / floppy3 / src / Serpent / Serpent_Algorithm

// $Id: $
//
// $Log: $
// Revision 1.1.1 1998/04/10 raif
// + added code to generate Intermediate Values KAT.
// + cosmetics.
//
// Revision 1.1 1998/04/07 Serpent authors
// + revised slightly (endianness, and key schedule for variable lengths)
//
// Revision 1.0 1998/04/06 raif
// + original version.
//
// $Endlog$
/*
* Copyright (c) 1997, 1998 Systemics Ltd on behalf of
* the Cryptix Development Team. All rights reserved.
*/
package Serpent;

import java.io.PrintWriter;
import java.security.InvalidKeyException;

//...........................................................................
/**
* Serpent is a 128-bit 32-round block cipher with variable key lengths,
* including 128-, 192- and 256-bit
* keys conjectured to be at least as secure as three-key triple-DES.<p>
*
* Serpent was designed by Ross Anderson, Eli Biham and Lars Knudsen as a
* candidate algorithm for the NIST AES Quest.<p>
*
* References:<ol>
* <li>Serpent: A New Block Cipher Proposal. This paper was published in the
* proceedings of the "Fast Software Encryption Workshop No. 5" held in
* Paris in March 1998. LNCS, Springer Verlag.<p>
* <li>Reference implementation of the standard Serpent cipher written in C
* by <a href="http://www.cl.cam.ac.uk/~fms/">Frank Stajano</a>.</ol><p>
*
* <b>Copyright</b> &copy; 1997, 1998
* <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: $</b>
* @author Raif S. Naffah
* @author Serpent authors (Ross Anderson, Eli Biham and Lars Knudsen)
*/
public final class Serpent_Algorithm // implicit no-argument constructor
{
// Debugging methods and variables
//...........................................................................

static final String NAME = "Serpent_Algorithm";
static final boolean IN = true, OUT = false;

static final boolean DEBUG = Serpent_Properties.GLOBAL_DEBUG;
static final int debuglevel = DEBUG ? Serpent_Properties.getLevel(NAME) : 0;
static final PrintWriter err = DEBUG ? Serpent_Properties.getOutput() : null;

static final boolean TRACE = Serpent_Properties.isTraceable(NAME);

static void debug (String s) { err.println(">>> "+NAME+": "+s); }
static void trace (boolean in, String s) {
if (TRACE) err.println((in?"==> ":"<== ")+NAME+"."+s);
}
static void trace (String s) { if (TRACE) err.println("<=> "+NAME+"."+s); }


// Constants and variables
//...........................................................................

/**
* This variable acts as a selector to allow the user to choose between
* a bit-slice implementation (Serpent_BitSlice) and a standard one
* (Serpent_Standard). When set to true the bit-slice implementation
* code is used, otherwise it's the standard implementation code.<p>
*
* IMPORTANT: When you change the value of this variable, make sure
* you re-compile all the classes in the Serpent package.
*/
static final boolean USE_BIT_SLICE_IMPLEMENTATION = true;

static final int BLOCK_SIZE = 16; // bytes in a Serpent data-block

private static final char[] HEX_DIGITS = {
'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
};


// Basic API methods
//...........................................................................

/**
* Expand a user-supplied key material into a session key.
*
* @param key The user-key bytes (multiples of 4) to use.
* @exception InvalidKeyException If the key is invalid.
*/
public static synchronized Object makeKey (byte[] key)
throws InvalidKeyException {
if (key == null)
throw new InvalidKeyException("Empty key");
/*
if (!(key.length == 16 || key.length == 24 || key.length == 32))
throw new InvalidKeyException("Incorrect key length");

// Although it checks for size of 16, 24 or 32, it really
// supports all multiples of 4 up to 32 in the code of makeKey.
*/
if ((key.length % 4) != 0 || (key.length / 4) > 8)
throw new InvalidKeyException("Incorrect key length");

return USE_BIT_SLICE_IMPLEMENTATION ?
Serpent_BitSlice.makeKey(key) :
Serpent_Standard.makeKey(key);
}

/**
* Encrypt exactly one block of plaintext.
*
* @param in The plaintext.
* @param inOffset Index of in from which to start considering data.
* @param sessionKey The session key to use for encryption.
* @return The ciphertext generated from a plaintext using the session key.
*/
public static byte[]
blockEncrypt (byte[] in, int inOffset, Object sessionKey) {
return USE_BIT_SLICE_IMPLEMENTATION ?
Serpent_BitSlice.blockEncrypt(in, inOffset, sessionKey) :
Serpent_Standard.blockEncrypt(in, inOffset, sessionKey);
}

/**
* Decrypt exactly one block of ciphertext.
*
* @param in The ciphertext.
* @param inOffset Index of in from which to start considering data.
* @param sessionKey The session key to use for decryption.
* @return The plaintext generated from a ciphertext using the session key.
*/
public static byte[]
blockDecrypt (byte[] in, int inOffset, Object sessionKey) {
return USE_BIT_SLICE_IMPLEMENTATION ?
Serpent_BitSlice.blockDecrypt(in, inOffset, sessionKey) :
Serpent_Standard.blockDecrypt(in, inOffset, sessionKey);
}

/** A basic symmetric encryption/decryption test. */
public static boolean self_test() {
if (DEBUG) trace(IN, "self_test()");
boolean ok = false;
try {
byte[] kb = new byte[BLOCK_SIZE*2]; // all zeroes
// kb=fromString("0000000000000000000000000000000000000000000000000000000000000000");
byte[] pt = fromEvenLengthString("00000003000000020000000100000000");
int i;

Object key = makeKey(kb);

byte[] ct = blockEncrypt(pt, 0, key);
byte[] cpt = blockDecrypt(ct, 0, key);

ok = areEqual(pt, cpt);
if (!ok) {
if (DEBUG && debuglevel > 7) {
debug(" plain: "+toReversedString(pt));
debug(" cipher: "+toReversedString(ct));
debug(" plain2: "+toReversedString(cpt));
}
throw new RuntimeException("Symmetric operation failed");
}
ok = self_test(BLOCK_SIZE);
} catch (Exception x) {
if (DEBUG && debuglevel > 0) {
debug("Exception encountered during self-test: " + x.getMessage());
x.printStackTrace();
}
}
if (DEBUG && debuglevel > 0) debug("Self-test OK? " + ok);
if (DEBUG) trace(OUT, "self_test()");
return ok;
}


// Serpent own methods
//...........................................................................

/** @return The length in bytes of the Algorithm input block. */
public static int blockSize() { return BLOCK_SIZE; }

/** A basic symmetric encryption/decryption test for a given key size. */
private static boolean self_test (int keysize) {
if (DEBUG) trace(IN, "self_test("+keysize+")");
boolean ok = false;
try {
byte[] kb = new byte[keysize];
byte[] pt = new byte[BLOCK_SIZE];
int i;

for (i = 0; i < keysize; i++)
kb[i] = (byte) i;
for (i = 0; i < BLOCK_SIZE; i++)
pt[i] = (byte) i;

if (DEBUG && debuglevel > 6) {
System.out.println("==========");
System.out.println();
System.out.println("KEYSIZE="+(8*keysize));
System.out.println("KEY="+toString(kb));
System.out.println();
}
Object key = makeKey(kb);

if (DEBUG && debuglevel > 6) {
System.out.println("Intermediate Ciphertext Values (Encryption)");
System.out.println();
System.out.println("PT="+toString(pt));
}
byte[] ct = blockEncrypt(pt, 0, key);

if (DEBUG && debuglevel > 6) {
System.out.println("Intermediate Plaintext Values (Decryption)");
System.out.println();
System.out.println("CT="+toString(ct));
}
byte[] cpt = blockDecrypt(ct, 0, key);

ok = areEqual(pt, cpt);
if (!ok)
throw new RuntimeException("Symmetric operation failed");
} catch (Exception x) {
if (DEBUG && debuglevel > 0) {
debug("Exception encountered during self-test: " + x.getMessage());
x.printStackTrace();
}
}
if (DEBUG && debuglevel > 0) debug("Self-test OK? " + ok);
if (DEBUG) trace(OUT, "self_test()");
return ok;
}


// utility static methods (from cryptix.util.core ArrayUtil and Hex classes)
//...........................................................................

/**
* Compares two byte arrays for equality.
*
* @return true if the arrays have identical contents
*/
private static boolean areEqual (byte[] a, byte[] b) {
int aLength = a.length;
if (aLength != b.length)
return false;
for (int i = 0; i < aLength; i++)
if (a[i] != b[i])
return false;
return true;
}

/**
* Returns a number from 0 to 15 corresponding to the hex
* digit <i>ch</i>.
*/
public static int fromDigit (char ch) {
if (ch >= '0' && ch <= '9')
return ch - '0';
if (ch >= 'A' && ch <= 'F')
return ch - 'A' + 10;
if (ch >= 'a' && ch <= 'f')
return ch - 'a' + 10;
throw new IllegalArgumentException("Invalid hex digit '"+ch+"'");
}

/**
* Returns a string of hexadecimal digits from a byte array. Each
* byte is converted to 2 hex symbols.
*/
private static String toString (byte[] ba) {
int length = ba.length;
char[] buf = new char[length * 2];
for (int i = 0, j = 0, k; i < length; ) {
k = ba[i++];
buf[j++] = HEX_DIGITS[(k >>> 4) & 0x0F];
buf[j++] = HEX_DIGITS[ k & 0x0F];
}
return new String(buf);
}


// other utility static methods
//...........................................................................

/**
* Returns an hexadecimal number (respresented as a string of hexadecimal
* digits from a byte array). Each byte is converted to 2 hex symbols.
* The order is however, as of printing a number from a little-endian
* internal representation (i.e., reverse order).
*/
public static String toReversedString (byte[] ba) {
int length = ba.length;
char[] buf = new char[length * 2];
for (int i = length-1, j = 0, k; i >=0; ) {
k = ba[i--];
buf[j++] = HEX_DIGITS[(k >>> 4) & 0x0F];
buf[j++] = HEX_DIGITS[ k & 0x0F];
}
return new String(buf);
}

/**
* Returns a byte array from an hexadecimal number.
*/
public static byte[] fromEvenLengthString (String hex) {
int len = hex.length();
byte[] buf = new byte[((len + 1) / 2)];

int j = 0;
if ((len % 2) == 1) throw new IllegalArgumentException(
"string must have an even number of digits");

while (len > 0) {
buf[j++] = (byte) (fromDigit(hex.charAt(--len)) |
(fromDigit(hex.charAt(--len)) << 4));
}
return buf;
}


// main(): use to generate the Intermediate Values KAT
//...........................................................................

public static void main (String[] args) {
if (DEBUG && debuglevel > 6) {
System.out.println("Algorithm Name: "+Serpent_Properties.FULL_NAME);
System.out.println("Electronic Codebook (ECB) Mode");
System.out.println();
}
self_test(16);
self_test(24);
self_test(32);
}
}