Imported GNU Classpath 0.90
Imported GNU Classpath 0.90
* scripts/makemake.tcl: Set gnu/java/awt/peer/swing to ignore.
* gnu/classpath/jdwp/VMFrame.java (SIZE): New constant.
* java/lang/VMCompiler.java: Use gnu.java.security.hash.MD5.
* java/lang/Math.java: New override file.
* java/lang/Character.java: Merged from Classpath.
(start, end): Now 'int's.
(canonicalName): New field.
(CANONICAL_NAME, NO_SPACES_NAME, CONSTANT_NAME): New constants.
(UnicodeBlock): Added argument.
(of): New overload.
(forName): New method.
Updated unicode blocks.
(sets): Updated.
* sources.am: Regenerated.
* Makefile.in: Likewise.
From-SVN: r111942
This commit is contained in:
Mark Wielaard
@@ -0,0 +1,206 @@
|
||||
/* BaseHash.java --
|
||||
Copyright (C) 2001, 2002, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
/**
|
||||
* <p>A base abstract class to facilitate hash implementations.</p>
|
||||
*/
|
||||
public abstract class BaseHash implements IMessageDigest
|
||||
{
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** The canonical name prefix of the hash. */
|
||||
protected String name;
|
||||
|
||||
/** The hash (output) size in bytes. */
|
||||
protected int hashSize;
|
||||
|
||||
/** The hash (inner) block size in bytes. */
|
||||
protected int blockSize;
|
||||
|
||||
/** Number of bytes processed so far. */
|
||||
protected long count;
|
||||
|
||||
/** Temporary input buffer. */
|
||||
protected byte[] buffer;
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* <p>Trivial constructor for use by concrete subclasses.</p>
|
||||
*
|
||||
* @param name the canonical name prefix of this instance.
|
||||
* @param hashSize the block size of the output in bytes.
|
||||
* @param blockSize the block size of the internal transform.
|
||||
*/
|
||||
protected BaseHash(String name, int hashSize, int blockSize)
|
||||
{
|
||||
super();
|
||||
|
||||
this.name = name;
|
||||
this.hashSize = hashSize;
|
||||
this.blockSize = blockSize;
|
||||
this.buffer = new byte[blockSize];
|
||||
|
||||
resetContext();
|
||||
}
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// IMessageDigest interface implementation ---------------------------------
|
||||
|
||||
public String name()
|
||||
{
|
||||
return name;
|
||||
}
|
||||
|
||||
public int hashSize()
|
||||
{
|
||||
return hashSize;
|
||||
}
|
||||
|
||||
public int blockSize()
|
||||
{
|
||||
return blockSize;
|
||||
}
|
||||
|
||||
public void update(byte b)
|
||||
{
|
||||
// compute number of bytes still unhashed; ie. present in buffer
|
||||
int i = (int) (count % blockSize);
|
||||
count++;
|
||||
buffer[i] = b;
|
||||
if (i == (blockSize - 1))
|
||||
{
|
||||
transform(buffer, 0);
|
||||
}
|
||||
}
|
||||
|
||||
public void update(byte[] b)
|
||||
{
|
||||
update(b, 0, b.length);
|
||||
}
|
||||
|
||||
public void update(byte[] b, int offset, int len)
|
||||
{
|
||||
int n = (int) (count % blockSize);
|
||||
count += len;
|
||||
int partLen = blockSize - n;
|
||||
int i = 0;
|
||||
|
||||
if (len >= partLen)
|
||||
{
|
||||
System.arraycopy(b, offset, buffer, n, partLen);
|
||||
transform(buffer, 0);
|
||||
for (i = partLen; i + blockSize - 1 < len; i += blockSize)
|
||||
{
|
||||
transform(b, offset + i);
|
||||
}
|
||||
n = 0;
|
||||
}
|
||||
|
||||
if (i < len)
|
||||
{
|
||||
System.arraycopy(b, offset + i, buffer, n, len - i);
|
||||
}
|
||||
}
|
||||
|
||||
public byte[] digest()
|
||||
{
|
||||
byte[] tail = padBuffer(); // pad remaining bytes in buffer
|
||||
update(tail, 0, tail.length); // last transform of a message
|
||||
byte[] result = getResult(); // make a result out of context
|
||||
|
||||
reset(); // reset this instance for future re-use
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
public void reset()
|
||||
{ // reset this instance for future re-use
|
||||
count = 0L;
|
||||
for (int i = 0; i < blockSize;)
|
||||
{
|
||||
buffer[i++] = 0;
|
||||
}
|
||||
|
||||
resetContext();
|
||||
}
|
||||
|
||||
// methods to be implemented by concrete subclasses ------------------------
|
||||
|
||||
public abstract Object clone();
|
||||
|
||||
public abstract boolean selfTest();
|
||||
|
||||
/**
|
||||
* <p>Returns the byte array to use as padding before completing a hash
|
||||
* operation.</p>
|
||||
*
|
||||
* @return the bytes to pad the remaining bytes in the buffer before
|
||||
* completing a hash operation.
|
||||
*/
|
||||
protected abstract byte[] padBuffer();
|
||||
|
||||
/**
|
||||
* <p>Constructs the result from the contents of the current context.</p>
|
||||
*
|
||||
* @return the output of the completed hash operation.
|
||||
*/
|
||||
protected abstract byte[] getResult();
|
||||
|
||||
/** Resets the instance for future re-use. */
|
||||
protected abstract void resetContext();
|
||||
|
||||
/**
|
||||
* <p>The block digest transformation per se.</p>
|
||||
*
|
||||
* @param in the <i>blockSize</i> long block, as an array of bytes to digest.
|
||||
* @param offset the index where the data to digest is located within the
|
||||
* input buffer.
|
||||
*/
|
||||
protected abstract void transform(byte[] in, int offset);
|
||||
}
|
||||
@@ -0,0 +1,178 @@
|
||||
/* HashFactory.java --
|
||||
Copyright (C) 2001, 2002, 2003, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
/**
|
||||
* <p>A <i>Factory</i> to instantiate message digest algorithm instances.</p>
|
||||
*/
|
||||
public class HashFactory
|
||||
{
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** Trivial constructor to enforce <i>Singleton</i> pattern. */
|
||||
private HashFactory()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* <p>Return an instance of a hash algorithm given its name.</p>
|
||||
*
|
||||
* @param name the name of the hash algorithm.
|
||||
* @return an instance of the hash algorithm, or null if none found.
|
||||
* @exception InternalError if the implementation does not pass its self-
|
||||
* test.
|
||||
*/
|
||||
public static IMessageDigest getInstance(String name)
|
||||
{
|
||||
if (name == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
name = name.trim();
|
||||
IMessageDigest result = null;
|
||||
if (name.equalsIgnoreCase(Registry.WHIRLPOOL_HASH))
|
||||
{
|
||||
result = new Whirlpool();
|
||||
}
|
||||
else if (name.equalsIgnoreCase(Registry.RIPEMD128_HASH)
|
||||
|| name.equalsIgnoreCase(Registry.RIPEMD_128_HASH))
|
||||
{
|
||||
result = new RipeMD128();
|
||||
}
|
||||
else if (name.equalsIgnoreCase(Registry.RIPEMD160_HASH)
|
||||
|| name.equalsIgnoreCase(Registry.RIPEMD_160_HASH))
|
||||
{
|
||||
result = new RipeMD160();
|
||||
}
|
||||
else if (name.equalsIgnoreCase(Registry.SHA160_HASH)
|
||||
|| name.equalsIgnoreCase(Registry.SHA_1_HASH)
|
||||
|| name.equalsIgnoreCase(Registry.SHA1_HASH)
|
||||
|| name.equalsIgnoreCase(Registry.SHA_HASH))
|
||||
{
|
||||
result = new Sha160();
|
||||
}
|
||||
else if (name.equalsIgnoreCase(Registry.SHA256_HASH))
|
||||
{
|
||||
result = new Sha256();
|
||||
}
|
||||
else if (name.equalsIgnoreCase(Registry.SHA384_HASH))
|
||||
{
|
||||
result = new Sha384();
|
||||
}
|
||||
else if (name.equalsIgnoreCase(Registry.SHA512_HASH))
|
||||
{
|
||||
result = new Sha512();
|
||||
}
|
||||
else if (name.equalsIgnoreCase(Registry.TIGER_HASH))
|
||||
{
|
||||
result = new Tiger();
|
||||
}
|
||||
else if (name.equalsIgnoreCase(Registry.HAVAL_HASH))
|
||||
{
|
||||
result = new Haval();
|
||||
}
|
||||
else if (name.equalsIgnoreCase(Registry.MD5_HASH))
|
||||
{
|
||||
result = new MD5();
|
||||
}
|
||||
else if (name.equalsIgnoreCase(Registry.MD4_HASH))
|
||||
{
|
||||
result = new MD4();
|
||||
}
|
||||
else if (name.equalsIgnoreCase(Registry.MD2_HASH))
|
||||
{
|
||||
result = new MD2();
|
||||
}
|
||||
else if (name.equalsIgnoreCase(Registry.HAVAL_HASH))
|
||||
{
|
||||
result = new Haval();
|
||||
}
|
||||
|
||||
if (result != null && !result.selfTest())
|
||||
{
|
||||
throw new InternalError(result.name());
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Returns a {@link Set} of names of hash algorithms supported by this
|
||||
* <i>Factory</i>.</p>
|
||||
*
|
||||
* @return a {@link Set} of hash names (Strings).
|
||||
*/
|
||||
public static final Set getNames()
|
||||
{
|
||||
HashSet hs = new HashSet();
|
||||
hs.add(Registry.WHIRLPOOL_HASH);
|
||||
hs.add(Registry.RIPEMD128_HASH);
|
||||
hs.add(Registry.RIPEMD160_HASH);
|
||||
hs.add(Registry.SHA160_HASH);
|
||||
hs.add(Registry.SHA256_HASH);
|
||||
hs.add(Registry.SHA384_HASH);
|
||||
hs.add(Registry.SHA512_HASH);
|
||||
hs.add(Registry.TIGER_HASH);
|
||||
hs.add(Registry.HAVAL_HASH);
|
||||
hs.add(Registry.MD5_HASH);
|
||||
hs.add(Registry.MD4_HASH);
|
||||
hs.add(Registry.MD2_HASH);
|
||||
|
||||
return Collections.unmodifiableSet(hs);
|
||||
}
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
}
|
||||
@@ -0,0 +1,759 @@
|
||||
/* Haval.java --
|
||||
Copyright (C) 2003, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
import gnu.java.security.util.Util;
|
||||
|
||||
/**
|
||||
* <p>The <i>HAVAL</i> message-digest algorithm is a variable output length,
|
||||
* with variable number of rounds. By default, this implementation allows
|
||||
* <i>HAVAL</i> to be used as a drop-in replacement for <i>MD5</i>.</p>
|
||||
*
|
||||
* <p>References:</p>
|
||||
*
|
||||
* <ol>
|
||||
* <li>HAVAL - A One-Way Hashing Algorithm with Variable Length of Output<br>
|
||||
* Advances in Cryptology - AUSCRYPT'92, Lecture Notes in Computer Science,<br>
|
||||
* Springer-Verlag, 1993; <br>
|
||||
* Y. Zheng, J. Pieprzyk and J. Seberry.</li>
|
||||
* </ol>
|
||||
*/
|
||||
public class Haval extends BaseHash
|
||||
{
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
public static final int HAVAL_VERSION = 1;
|
||||
|
||||
public static final int HAVAL_128_BIT = 16;
|
||||
|
||||
public static final int HAVAL_160_BIT = 20;
|
||||
|
||||
public static final int HAVAL_192_BIT = 24;
|
||||
|
||||
public static final int HAVAL_224_BIT = 28;
|
||||
|
||||
public static final int HAVAL_256_BIT = 32;
|
||||
|
||||
public static final int HAVAL_3_ROUND = 3;
|
||||
|
||||
public static final int HAVAL_4_ROUND = 4;
|
||||
|
||||
public static final int HAVAL_5_ROUND = 5;
|
||||
|
||||
private static final int BLOCK_SIZE = 128; // inner block size in bytes
|
||||
|
||||
private static final String DIGEST0 = "C68F39913F901F3DDF44C707357A7D70";
|
||||
|
||||
/** caches the result of the correctness test, once executed. */
|
||||
private static Boolean valid;
|
||||
|
||||
/**
|
||||
* Number of HAVAL rounds. Allowed values are integers in the range <code>3
|
||||
* .. 5</code>. The default is <code>3</code>.
|
||||
*/
|
||||
private int rounds = HAVAL_3_ROUND;
|
||||
|
||||
/** 128-bit interim result. */
|
||||
private int h0, h1, h2, h3, h4, h5, h6, h7;
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* <p>Calls the constructor with two argument using {@link #HAVAL_128_BIT} as
|
||||
* the value for the output size (i.e. <code>128</code> bits, and
|
||||
* {@link #HAVAL_3_ROUND} for the value of number of rounds.</p>
|
||||
*/
|
||||
public Haval()
|
||||
{
|
||||
this(HAVAL_128_BIT, HAVAL_3_ROUND);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Calls the constructor with two arguments using the designated output
|
||||
* size, and {@link #HAVAL_3_ROUND} for the value of number of rounds.</p>
|
||||
*
|
||||
* @param size the output size in bytes of this instance.
|
||||
* @throws IllegalArgumentException if the designated output size is invalid.
|
||||
* @see #HAVAL_128_BIT
|
||||
* @see #HAVAL_160_BIT
|
||||
* @see #HAVAL_192_BIT
|
||||
* @see #HAVAL_224_BIT
|
||||
* @see #HAVAL_256_BIT
|
||||
*/
|
||||
public Haval(int size)
|
||||
{
|
||||
this(size, HAVAL_3_ROUND);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Constructs a <code>Haval</code> instance with the designated output
|
||||
* size (in bytes). Valid output <code>size</code> values are <code>16</code>,
|
||||
* <code>20</code>, <code>24</code>, <code>28</code> and <code>32</code>.
|
||||
* Valid values for <code>rounds</code> are in the range <code>3..5</code>
|
||||
* inclusive.</p>
|
||||
*
|
||||
* @param size the output size in bytes of this instance.
|
||||
* @param rounds the number of rounds to apply when transforming data.
|
||||
* @throws IllegalArgumentException if the designated output size is invalid,
|
||||
* or if the number of rounds is invalid.
|
||||
* @see #HAVAL_128_BIT
|
||||
* @see #HAVAL_160_BIT
|
||||
* @see #HAVAL_192_BIT
|
||||
* @see #HAVAL_224_BIT
|
||||
* @see #HAVAL_256_BIT
|
||||
* @see #HAVAL_3_ROUND
|
||||
* @see #HAVAL_4_ROUND
|
||||
* @see #HAVAL_5_ROUND
|
||||
*/
|
||||
public Haval(int size, int rounds)
|
||||
{
|
||||
super(Registry.HAVAL_HASH, size, BLOCK_SIZE);
|
||||
|
||||
if (size != HAVAL_128_BIT && size != HAVAL_160_BIT && size != HAVAL_192_BIT
|
||||
&& size != HAVAL_224_BIT && size != HAVAL_256_BIT)
|
||||
{
|
||||
throw new IllegalArgumentException("Invalid HAVAL output size");
|
||||
}
|
||||
|
||||
if (rounds != HAVAL_3_ROUND && rounds != HAVAL_4_ROUND
|
||||
&& rounds != HAVAL_5_ROUND)
|
||||
{
|
||||
throw new IllegalArgumentException("Invalid HAVAL number of rounds");
|
||||
}
|
||||
|
||||
this.rounds = rounds;
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Private constructor for cloning purposes.</p>
|
||||
*
|
||||
* @param md the instance to clone.
|
||||
*/
|
||||
private Haval(Haval md)
|
||||
{
|
||||
this(md.hashSize, md.rounds);
|
||||
|
||||
this.h0 = md.h0;
|
||||
this.h1 = md.h1;
|
||||
this.h2 = md.h2;
|
||||
this.h3 = md.h3;
|
||||
this.h4 = md.h4;
|
||||
this.h5 = md.h5;
|
||||
this.h6 = md.h6;
|
||||
this.h7 = md.h7;
|
||||
this.count = md.count;
|
||||
this.buffer = (byte[]) md.buffer.clone();
|
||||
}
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// java.lang.Cloneable interface implementation ----------------------------
|
||||
|
||||
public Object clone()
|
||||
{
|
||||
return new Haval(this);
|
||||
}
|
||||
|
||||
// Implementation of concrete methods in BaseHash --------------------------
|
||||
|
||||
protected synchronized void transform(byte[] in, int i)
|
||||
{
|
||||
int X0 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X1 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X2 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X3 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X4 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X5 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X6 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X7 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X8 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X9 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X10 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X11 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X12 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X13 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X14 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X15 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X16 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X17 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X18 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X19 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X20 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X21 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X22 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X23 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X24 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X25 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X26 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X27 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X28 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X29 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X30 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
int X31 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| (in[i++] & 0xFF) << 24;
|
||||
|
||||
int t0 = h0, t1 = h1, t2 = h2, t3 = h3, t4 = h4, t5 = h5, t6 = h6, t7 = h7;
|
||||
|
||||
// Pass 1
|
||||
t7 = FF1(t7, t6, t5, t4, t3, t2, t1, t0, X0);
|
||||
t6 = FF1(t6, t5, t4, t3, t2, t1, t0, t7, X1);
|
||||
t5 = FF1(t5, t4, t3, t2, t1, t0, t7, t6, X2);
|
||||
t4 = FF1(t4, t3, t2, t1, t0, t7, t6, t5, X3);
|
||||
t3 = FF1(t3, t2, t1, t0, t7, t6, t5, t4, X4);
|
||||
t2 = FF1(t2, t1, t0, t7, t6, t5, t4, t3, X5);
|
||||
t1 = FF1(t1, t0, t7, t6, t5, t4, t3, t2, X6);
|
||||
t0 = FF1(t0, t7, t6, t5, t4, t3, t2, t1, X7);
|
||||
|
||||
t7 = FF1(t7, t6, t5, t4, t3, t2, t1, t0, X8);
|
||||
t6 = FF1(t6, t5, t4, t3, t2, t1, t0, t7, X9);
|
||||
t5 = FF1(t5, t4, t3, t2, t1, t0, t7, t6, X10);
|
||||
t4 = FF1(t4, t3, t2, t1, t0, t7, t6, t5, X11);
|
||||
t3 = FF1(t3, t2, t1, t0, t7, t6, t5, t4, X12);
|
||||
t2 = FF1(t2, t1, t0, t7, t6, t5, t4, t3, X13);
|
||||
t1 = FF1(t1, t0, t7, t6, t5, t4, t3, t2, X14);
|
||||
t0 = FF1(t0, t7, t6, t5, t4, t3, t2, t1, X15);
|
||||
|
||||
t7 = FF1(t7, t6, t5, t4, t3, t2, t1, t0, X16);
|
||||
t6 = FF1(t6, t5, t4, t3, t2, t1, t0, t7, X17);
|
||||
t5 = FF1(t5, t4, t3, t2, t1, t0, t7, t6, X18);
|
||||
t4 = FF1(t4, t3, t2, t1, t0, t7, t6, t5, X19);
|
||||
t3 = FF1(t3, t2, t1, t0, t7, t6, t5, t4, X20);
|
||||
t2 = FF1(t2, t1, t0, t7, t6, t5, t4, t3, X21);
|
||||
t1 = FF1(t1, t0, t7, t6, t5, t4, t3, t2, X22);
|
||||
t0 = FF1(t0, t7, t6, t5, t4, t3, t2, t1, X23);
|
||||
|
||||
t7 = FF1(t7, t6, t5, t4, t3, t2, t1, t0, X24);
|
||||
t6 = FF1(t6, t5, t4, t3, t2, t1, t0, t7, X25);
|
||||
t5 = FF1(t5, t4, t3, t2, t1, t0, t7, t6, X26);
|
||||
t4 = FF1(t4, t3, t2, t1, t0, t7, t6, t5, X27);
|
||||
t3 = FF1(t3, t2, t1, t0, t7, t6, t5, t4, X28);
|
||||
t2 = FF1(t2, t1, t0, t7, t6, t5, t4, t3, X29);
|
||||
t1 = FF1(t1, t0, t7, t6, t5, t4, t3, t2, X30);
|
||||
t0 = FF1(t0, t7, t6, t5, t4, t3, t2, t1, X31);
|
||||
|
||||
// Pass 2
|
||||
t7 = FF2(t7, t6, t5, t4, t3, t2, t1, t0, X5, 0x452821E6);
|
||||
t6 = FF2(t6, t5, t4, t3, t2, t1, t0, t7, X14, 0x38D01377);
|
||||
t5 = FF2(t5, t4, t3, t2, t1, t0, t7, t6, X26, 0xBE5466CF);
|
||||
t4 = FF2(t4, t3, t2, t1, t0, t7, t6, t5, X18, 0x34E90C6C);
|
||||
t3 = FF2(t3, t2, t1, t0, t7, t6, t5, t4, X11, 0xC0AC29B7);
|
||||
t2 = FF2(t2, t1, t0, t7, t6, t5, t4, t3, X28, 0xC97C50DD);
|
||||
t1 = FF2(t1, t0, t7, t6, t5, t4, t3, t2, X7, 0x3F84D5B5);
|
||||
t0 = FF2(t0, t7, t6, t5, t4, t3, t2, t1, X16, 0xB5470917);
|
||||
|
||||
t7 = FF2(t7, t6, t5, t4, t3, t2, t1, t0, X0, 0x9216D5D9);
|
||||
t6 = FF2(t6, t5, t4, t3, t2, t1, t0, t7, X23, 0x8979FB1B);
|
||||
t5 = FF2(t5, t4, t3, t2, t1, t0, t7, t6, X20, 0xD1310BA6);
|
||||
t4 = FF2(t4, t3, t2, t1, t0, t7, t6, t5, X22, 0x98DFB5AC);
|
||||
t3 = FF2(t3, t2, t1, t0, t7, t6, t5, t4, X1, 0x2FFD72DB);
|
||||
t2 = FF2(t2, t1, t0, t7, t6, t5, t4, t3, X10, 0xD01ADFB7);
|
||||
t1 = FF2(t1, t0, t7, t6, t5, t4, t3, t2, X4, 0xB8E1AFED);
|
||||
t0 = FF2(t0, t7, t6, t5, t4, t3, t2, t1, X8, 0x6A267E96);
|
||||
|
||||
t7 = FF2(t7, t6, t5, t4, t3, t2, t1, t0, X30, 0xBA7C9045);
|
||||
t6 = FF2(t6, t5, t4, t3, t2, t1, t0, t7, X3, 0xF12C7F99);
|
||||
t5 = FF2(t5, t4, t3, t2, t1, t0, t7, t6, X21, 0x24A19947);
|
||||
t4 = FF2(t4, t3, t2, t1, t0, t7, t6, t5, X9, 0xB3916CF7);
|
||||
t3 = FF2(t3, t2, t1, t0, t7, t6, t5, t4, X17, 0x0801F2E2);
|
||||
t2 = FF2(t2, t1, t0, t7, t6, t5, t4, t3, X24, 0x858EFC16);
|
||||
t1 = FF2(t1, t0, t7, t6, t5, t4, t3, t2, X29, 0x636920D8);
|
||||
t0 = FF2(t0, t7, t6, t5, t4, t3, t2, t1, X6, 0x71574E69);
|
||||
|
||||
t7 = FF2(t7, t6, t5, t4, t3, t2, t1, t0, X19, 0xA458FEA3);
|
||||
t6 = FF2(t6, t5, t4, t3, t2, t1, t0, t7, X12, 0xF4933D7E);
|
||||
t5 = FF2(t5, t4, t3, t2, t1, t0, t7, t6, X15, 0x0D95748F);
|
||||
t4 = FF2(t4, t3, t2, t1, t0, t7, t6, t5, X13, 0x728EB658);
|
||||
t3 = FF2(t3, t2, t1, t0, t7, t6, t5, t4, X2, 0x718BCD58);
|
||||
t2 = FF2(t2, t1, t0, t7, t6, t5, t4, t3, X25, 0x82154AEE);
|
||||
t1 = FF2(t1, t0, t7, t6, t5, t4, t3, t2, X31, 0x7B54A41D);
|
||||
t0 = FF2(t0, t7, t6, t5, t4, t3, t2, t1, X27, 0xC25A59B5);
|
||||
|
||||
// Pass 3
|
||||
t7 = FF3(t7, t6, t5, t4, t3, t2, t1, t0, X19, 0x9C30D539);
|
||||
t6 = FF3(t6, t5, t4, t3, t2, t1, t0, t7, X9, 0x2AF26013);
|
||||
t5 = FF3(t5, t4, t3, t2, t1, t0, t7, t6, X4, 0xC5D1B023);
|
||||
t4 = FF3(t4, t3, t2, t1, t0, t7, t6, t5, X20, 0x286085F0);
|
||||
t3 = FF3(t3, t2, t1, t0, t7, t6, t5, t4, X28, 0xCA417918);
|
||||
t2 = FF3(t2, t1, t0, t7, t6, t5, t4, t3, X17, 0xB8DB38EF);
|
||||
t1 = FF3(t1, t0, t7, t6, t5, t4, t3, t2, X8, 0x8E79DCB0);
|
||||
t0 = FF3(t0, t7, t6, t5, t4, t3, t2, t1, X22, 0x603A180E);
|
||||
|
||||
t7 = FF3(t7, t6, t5, t4, t3, t2, t1, t0, X29, 0x6C9E0E8B);
|
||||
t6 = FF3(t6, t5, t4, t3, t2, t1, t0, t7, X14, 0xB01E8A3E);
|
||||
t5 = FF3(t5, t4, t3, t2, t1, t0, t7, t6, X25, 0xD71577C1);
|
||||
t4 = FF3(t4, t3, t2, t1, t0, t7, t6, t5, X12, 0xBD314B27);
|
||||
t3 = FF3(t3, t2, t1, t0, t7, t6, t5, t4, X24, 0x78AF2FDA);
|
||||
t2 = FF3(t2, t1, t0, t7, t6, t5, t4, t3, X30, 0x55605C60);
|
||||
t1 = FF3(t1, t0, t7, t6, t5, t4, t3, t2, X16, 0xE65525F3);
|
||||
t0 = FF3(t0, t7, t6, t5, t4, t3, t2, t1, X26, 0xAA55AB94);
|
||||
|
||||
t7 = FF3(t7, t6, t5, t4, t3, t2, t1, t0, X31, 0x57489862);
|
||||
t6 = FF3(t6, t5, t4, t3, t2, t1, t0, t7, X15, 0x63E81440);
|
||||
t5 = FF3(t5, t4, t3, t2, t1, t0, t7, t6, X7, 0x55CA396A);
|
||||
t4 = FF3(t4, t3, t2, t1, t0, t7, t6, t5, X3, 0x2AAB10B6);
|
||||
t3 = FF3(t3, t2, t1, t0, t7, t6, t5, t4, X1, 0xB4CC5C34);
|
||||
t2 = FF3(t2, t1, t0, t7, t6, t5, t4, t3, X0, 0x1141E8CE);
|
||||
t1 = FF3(t1, t0, t7, t6, t5, t4, t3, t2, X18, 0xA15486AF);
|
||||
t0 = FF3(t0, t7, t6, t5, t4, t3, t2, t1, X27, 0x7C72E993);
|
||||
|
||||
t7 = FF3(t7, t6, t5, t4, t3, t2, t1, t0, X13, 0xB3EE1411);
|
||||
t6 = FF3(t6, t5, t4, t3, t2, t1, t0, t7, X6, 0x636FBC2A);
|
||||
t5 = FF3(t5, t4, t3, t2, t1, t0, t7, t6, X21, 0x2BA9C55D);
|
||||
t4 = FF3(t4, t3, t2, t1, t0, t7, t6, t5, X10, 0x741831F6);
|
||||
t3 = FF3(t3, t2, t1, t0, t7, t6, t5, t4, X23, 0xCE5C3E16);
|
||||
t2 = FF3(t2, t1, t0, t7, t6, t5, t4, t3, X11, 0x9B87931E);
|
||||
t1 = FF3(t1, t0, t7, t6, t5, t4, t3, t2, X5, 0xAFD6BA33);
|
||||
t0 = FF3(t0, t7, t6, t5, t4, t3, t2, t1, X2, 0x6C24CF5C);
|
||||
|
||||
if (rounds >= 4)
|
||||
{
|
||||
t7 = FF4(t7, t6, t5, t4, t3, t2, t1, t0, X24, 0x7A325381);
|
||||
t6 = FF4(t6, t5, t4, t3, t2, t1, t0, t7, X4, 0x28958677);
|
||||
t5 = FF4(t5, t4, t3, t2, t1, t0, t7, t6, X0, 0x3B8F4898);
|
||||
t4 = FF4(t4, t3, t2, t1, t0, t7, t6, t5, X14, 0x6B4BB9AF);
|
||||
t3 = FF4(t3, t2, t1, t0, t7, t6, t5, t4, X2, 0xC4BFE81B);
|
||||
t2 = FF4(t2, t1, t0, t7, t6, t5, t4, t3, X7, 0x66282193);
|
||||
t1 = FF4(t1, t0, t7, t6, t5, t4, t3, t2, X28, 0x61D809CC);
|
||||
t0 = FF4(t0, t7, t6, t5, t4, t3, t2, t1, X23, 0xFB21A991);
|
||||
t7 = FF4(t7, t6, t5, t4, t3, t2, t1, t0, X26, 0x487CAC60);
|
||||
t6 = FF4(t6, t5, t4, t3, t2, t1, t0, t7, X6, 0x5DEC8032);
|
||||
t5 = FF4(t5, t4, t3, t2, t1, t0, t7, t6, X30, 0xEF845D5D);
|
||||
t4 = FF4(t4, t3, t2, t1, t0, t7, t6, t5, X20, 0xE98575B1);
|
||||
t3 = FF4(t3, t2, t1, t0, t7, t6, t5, t4, X18, 0xDC262302);
|
||||
t2 = FF4(t2, t1, t0, t7, t6, t5, t4, t3, X25, 0xEB651B88);
|
||||
t1 = FF4(t1, t0, t7, t6, t5, t4, t3, t2, X19, 0x23893E81);
|
||||
t0 = FF4(t0, t7, t6, t5, t4, t3, t2, t1, X3, 0xD396ACC5);
|
||||
|
||||
t7 = FF4(t7, t6, t5, t4, t3, t2, t1, t0, X22, 0x0F6D6FF3);
|
||||
t6 = FF4(t6, t5, t4, t3, t2, t1, t0, t7, X11, 0x83F44239);
|
||||
t5 = FF4(t5, t4, t3, t2, t1, t0, t7, t6, X31, 0x2E0B4482);
|
||||
t4 = FF4(t4, t3, t2, t1, t0, t7, t6, t5, X21, 0xA4842004);
|
||||
t3 = FF4(t3, t2, t1, t0, t7, t6, t5, t4, X8, 0x69C8F04A);
|
||||
t2 = FF4(t2, t1, t0, t7, t6, t5, t4, t3, X27, 0x9E1F9B5E);
|
||||
t1 = FF4(t1, t0, t7, t6, t5, t4, t3, t2, X12, 0x21C66842);
|
||||
t0 = FF4(t0, t7, t6, t5, t4, t3, t2, t1, X9, 0xF6E96C9A);
|
||||
t7 = FF4(t7, t6, t5, t4, t3, t2, t1, t0, X1, 0x670C9C61);
|
||||
t6 = FF4(t6, t5, t4, t3, t2, t1, t0, t7, X29, 0xABD388F0);
|
||||
t5 = FF4(t5, t4, t3, t2, t1, t0, t7, t6, X5, 0x6A51A0D2);
|
||||
t4 = FF4(t4, t3, t2, t1, t0, t7, t6, t5, X15, 0xD8542F68);
|
||||
t3 = FF4(t3, t2, t1, t0, t7, t6, t5, t4, X17, 0x960FA728);
|
||||
t2 = FF4(t2, t1, t0, t7, t6, t5, t4, t3, X10, 0xAB5133A3);
|
||||
t1 = FF4(t1, t0, t7, t6, t5, t4, t3, t2, X16, 0x6EEF0B6C);
|
||||
t0 = FF4(t0, t7, t6, t5, t4, t3, t2, t1, X13, 0x137A3BE4);
|
||||
|
||||
if (rounds == 5)
|
||||
{
|
||||
t7 = FF5(t7, t6, t5, t4, t3, t2, t1, t0, X27, 0xBA3BF050);
|
||||
t6 = FF5(t6, t5, t4, t3, t2, t1, t0, t7, X3, 0x7EFB2A98);
|
||||
t5 = FF5(t5, t4, t3, t2, t1, t0, t7, t6, X21, 0xA1F1651D);
|
||||
t4 = FF5(t4, t3, t2, t1, t0, t7, t6, t5, X26, 0x39AF0176);
|
||||
t3 = FF5(t3, t2, t1, t0, t7, t6, t5, t4, X17, 0x66CA593E);
|
||||
t2 = FF5(t2, t1, t0, t7, t6, t5, t4, t3, X11, 0x82430E88);
|
||||
t1 = FF5(t1, t0, t7, t6, t5, t4, t3, t2, X20, 0x8CEE8619);
|
||||
t0 = FF5(t0, t7, t6, t5, t4, t3, t2, t1, X29, 0x456F9FB4);
|
||||
|
||||
t7 = FF5(t7, t6, t5, t4, t3, t2, t1, t0, X19, 0x7D84A5C3);
|
||||
t6 = FF5(t6, t5, t4, t3, t2, t1, t0, t7, X0, 0x3B8B5EBE);
|
||||
t5 = FF5(t5, t4, t3, t2, t1, t0, t7, t6, X12, 0xE06F75D8);
|
||||
t4 = FF5(t4, t3, t2, t1, t0, t7, t6, t5, X7, 0x85C12073);
|
||||
t3 = FF5(t3, t2, t1, t0, t7, t6, t5, t4, X13, 0x401A449F);
|
||||
t2 = FF5(t2, t1, t0, t7, t6, t5, t4, t3, X8, 0x56C16AA6);
|
||||
t1 = FF5(t1, t0, t7, t6, t5, t4, t3, t2, X31, 0x4ED3AA62);
|
||||
t0 = FF5(t0, t7, t6, t5, t4, t3, t2, t1, X10, 0x363F7706);
|
||||
|
||||
t7 = FF5(t7, t6, t5, t4, t3, t2, t1, t0, X5, 0x1BFEDF72);
|
||||
t6 = FF5(t6, t5, t4, t3, t2, t1, t0, t7, X9, 0x429B023D);
|
||||
t5 = FF5(t5, t4, t3, t2, t1, t0, t7, t6, X14, 0x37D0D724);
|
||||
t4 = FF5(t4, t3, t2, t1, t0, t7, t6, t5, X30, 0xD00A1248);
|
||||
t3 = FF5(t3, t2, t1, t0, t7, t6, t5, t4, X18, 0xDB0FEAD3);
|
||||
t2 = FF5(t2, t1, t0, t7, t6, t5, t4, t3, X6, 0x49F1C09B);
|
||||
t1 = FF5(t1, t0, t7, t6, t5, t4, t3, t2, X28, 0x075372C9);
|
||||
t0 = FF5(t0, t7, t6, t5, t4, t3, t2, t1, X24, 0x80991B7B);
|
||||
|
||||
t7 = FF5(t7, t6, t5, t4, t3, t2, t1, t0, X2, 0x25D479D8);
|
||||
t6 = FF5(t6, t5, t4, t3, t2, t1, t0, t7, X23, 0xF6E8DEF7);
|
||||
t5 = FF5(t5, t4, t3, t2, t1, t0, t7, t6, X16, 0xE3FE501A);
|
||||
t4 = FF5(t4, t3, t2, t1, t0, t7, t6, t5, X22, 0xB6794C3B);
|
||||
t3 = FF5(t3, t2, t1, t0, t7, t6, t5, t4, X4, 0x976CE0BD);
|
||||
t2 = FF5(t2, t1, t0, t7, t6, t5, t4, t3, X1, 0x04C006BA);
|
||||
t1 = FF5(t1, t0, t7, t6, t5, t4, t3, t2, X25, 0xC1A94FB6);
|
||||
t0 = FF5(t0, t7, t6, t5, t4, t3, t2, t1, X15, 0x409F60C4);
|
||||
}
|
||||
}
|
||||
|
||||
h7 += t7;
|
||||
h6 += t6;
|
||||
h5 += t5;
|
||||
h4 += t4;
|
||||
h3 += t3;
|
||||
h2 += t2;
|
||||
h1 += t1;
|
||||
h0 += t0;
|
||||
}
|
||||
|
||||
protected byte[] padBuffer()
|
||||
{
|
||||
// pad out to 118 mod 128. other 10 bytes have special use.
|
||||
int n = (int) (count % BLOCK_SIZE);
|
||||
int padding = (n < 118) ? (118 - n) : (246 - n);
|
||||
byte[] result = new byte[padding + 10];
|
||||
result[0] = (byte) 0x01;
|
||||
|
||||
// save the version number (LSB 3), the number of rounds (3 bits in the
|
||||
// middle), the fingerprint length (MSB 2 bits and next byte) and the
|
||||
// number of bits in the unpadded message.
|
||||
int bl = hashSize * 8;
|
||||
result[padding++] = (byte) (((bl & 0x03) << 6) | ((rounds & 0x07) << 3) | (HAVAL_VERSION & 0x07));
|
||||
result[padding++] = (byte) (bl >>> 2);
|
||||
|
||||
// save number of bits, casting the long to an array of 8 bytes
|
||||
long bits = count << 3;
|
||||
result[padding++] = (byte) bits;
|
||||
result[padding++] = (byte) (bits >>> 8);
|
||||
result[padding++] = (byte) (bits >>> 16);
|
||||
result[padding++] = (byte) (bits >>> 24);
|
||||
result[padding++] = (byte) (bits >>> 32);
|
||||
result[padding++] = (byte) (bits >>> 40);
|
||||
result[padding++] = (byte) (bits >>> 48);
|
||||
result[padding] = (byte) (bits >>> 56);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected byte[] getResult()
|
||||
{
|
||||
tailorDigestBits(); // tailor context for the designated output size
|
||||
// cast enough top context values into an array of hashSize bytes
|
||||
byte[] result = new byte[hashSize];
|
||||
if (hashSize >= HAVAL_256_BIT)
|
||||
{
|
||||
result[31] = (byte) (h7 >>> 24);
|
||||
result[30] = (byte) (h7 >>> 16);
|
||||
result[29] = (byte) (h7 >>> 8);
|
||||
result[28] = (byte) h7;
|
||||
}
|
||||
if (hashSize >= HAVAL_224_BIT)
|
||||
{
|
||||
result[27] = (byte) (h6 >>> 24);
|
||||
result[26] = (byte) (h6 >>> 16);
|
||||
result[25] = (byte) (h6 >>> 8);
|
||||
result[24] = (byte) h6;
|
||||
}
|
||||
if (hashSize >= HAVAL_192_BIT)
|
||||
{
|
||||
result[23] = (byte) (h5 >>> 24);
|
||||
result[22] = (byte) (h5 >>> 16);
|
||||
result[21] = (byte) (h5 >>> 8);
|
||||
result[20] = (byte) h5;
|
||||
}
|
||||
if (hashSize >= HAVAL_160_BIT)
|
||||
{
|
||||
result[19] = (byte) (h4 >>> 24);
|
||||
result[18] = (byte) (h4 >>> 16);
|
||||
result[17] = (byte) (h4 >>> 8);
|
||||
result[16] = (byte) h4;
|
||||
}
|
||||
result[15] = (byte) (h3 >>> 24);
|
||||
result[14] = (byte) (h3 >>> 16);
|
||||
result[13] = (byte) (h3 >>> 8);
|
||||
result[12] = (byte) h3;
|
||||
result[11] = (byte) (h2 >>> 24);
|
||||
result[10] = (byte) (h2 >>> 16);
|
||||
result[9] = (byte) (h2 >>> 8);
|
||||
result[8] = (byte) h2;
|
||||
result[7] = (byte) (h1 >>> 24);
|
||||
result[6] = (byte) (h1 >>> 16);
|
||||
result[5] = (byte) (h1 >>> 8);
|
||||
result[4] = (byte) h1;
|
||||
result[3] = (byte) (h0 >>> 24);
|
||||
result[2] = (byte) (h0 >>> 16);
|
||||
result[1] = (byte) (h0 >>> 8);
|
||||
result[0] = (byte) h0;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected void resetContext()
|
||||
{
|
||||
h0 = 0x243F6A88;
|
||||
h1 = 0x85A308D3;
|
||||
h2 = 0x13198A2E;
|
||||
h3 = 0x03707344;
|
||||
h4 = 0xA4093822;
|
||||
h5 = 0x299F31D0;
|
||||
h6 = 0x082EFA98;
|
||||
h7 = 0xEC4E6C89;
|
||||
}
|
||||
|
||||
public boolean selfTest()
|
||||
{
|
||||
if (valid == null)
|
||||
{
|
||||
valid = new Boolean(DIGEST0.equals(Util.toString(new Haval().digest())));
|
||||
}
|
||||
return valid.booleanValue();
|
||||
}
|
||||
|
||||
// helper methods ----------------------------------------------------------
|
||||
|
||||
/** Tailors the last output. */
|
||||
private void tailorDigestBits()
|
||||
{
|
||||
int t;
|
||||
switch (hashSize)
|
||||
{
|
||||
case HAVAL_128_BIT:
|
||||
t = (h7 & 0x000000FF) | (h6 & 0xFF000000) | (h5 & 0x00FF0000)
|
||||
| (h4 & 0x0000FF00);
|
||||
h0 += t >>> 8 | t << 24;
|
||||
t = (h7 & 0x0000FF00) | (h6 & 0x000000FF) | (h5 & 0xFF000000)
|
||||
| (h4 & 0x00FF0000);
|
||||
h1 += t >>> 16 | t << 16;
|
||||
t = (h7 & 0x00FF0000) | (h6 & 0x0000FF00) | (h5 & 0x000000FF)
|
||||
| (h4 & 0xFF000000);
|
||||
h2 += t >>> 24 | t << 8;
|
||||
t = (h7 & 0xFF000000) | (h6 & 0x00FF0000) | (h5 & 0x0000FF00)
|
||||
| (h4 & 0x000000FF);
|
||||
h3 += t;
|
||||
break;
|
||||
case HAVAL_160_BIT:
|
||||
t = (h7 & 0x3F) | (h6 & (0x7F << 25)) | (h5 & (0x3F << 19));
|
||||
h0 += t >>> 19 | t << 13;
|
||||
t = (h7 & (0x3F << 6)) | (h6 & 0x3F) | (h5 & (0x7F << 25));
|
||||
h1 += t >>> 25 | t << 7;
|
||||
t = (h7 & (0x7F << 12)) | (h6 & (0x3F << 6)) | (h5 & 0x3F);
|
||||
h2 += t;
|
||||
t = (h7 & (0x3F << 19)) | (h6 & (0x7F << 12)) | (h5 & (0x3F << 6));
|
||||
h3 += (t >>> 6);
|
||||
t = (h7 & (0x7F << 25)) | (h6 & (0x3F << 19)) | (h5 & (0x7F << 12));
|
||||
h4 += (t >>> 12);
|
||||
break;
|
||||
case HAVAL_192_BIT:
|
||||
t = (h7 & 0x1F) | (h6 & (0x3F << 26));
|
||||
h0 += t >>> 26 | t << 6;
|
||||
t = (h7 & (0x1F << 5)) | (h6 & 0x1F);
|
||||
h1 += t;
|
||||
t = (h7 & (0x3F << 10)) | (h6 & (0x1F << 5));
|
||||
h2 += (t >>> 5);
|
||||
t = (h7 & (0x1F << 16)) | (h6 & (0x3F << 10));
|
||||
h3 += (t >>> 10);
|
||||
t = (h7 & (0x1F << 21)) | (h6 & (0x1F << 16));
|
||||
h4 += (t >>> 16);
|
||||
t = (h7 & (0x3F << 26)) | (h6 & (0x1F << 21));
|
||||
h5 += (t >>> 21);
|
||||
break;
|
||||
case HAVAL_224_BIT:
|
||||
h0 += ((h7 >>> 27) & 0x1F);
|
||||
h1 += ((h7 >>> 22) & 0x1F);
|
||||
h2 += ((h7 >>> 18) & 0x0F);
|
||||
h3 += ((h7 >>> 13) & 0x1F);
|
||||
h4 += ((h7 >>> 9) & 0x0F);
|
||||
h5 += ((h7 >>> 4) & 0x1F);
|
||||
h6 += (h7 & 0x0F);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Permutations phi_{i,j}, i=3,4,5, j=1,...,i.
|
||||
*
|
||||
* rounds = 3: 6 5 4 3 2 1 0
|
||||
* | | | | | | | (replaced by)
|
||||
* phi_{3,1}: 1 0 3 5 6 2 4
|
||||
* phi_{3,2}: 4 2 1 0 5 3 6
|
||||
* phi_{3,3}: 6 1 2 3 4 5 0
|
||||
*
|
||||
* rounds = 4: 6 5 4 3 2 1 0
|
||||
* | | | | | | | (replaced by)
|
||||
* phi_{4,1}: 2 6 1 4 5 3 0
|
||||
* phi_{4,2}: 3 5 2 0 1 6 4
|
||||
* phi_{4,3}: 1 4 3 6 0 2 5
|
||||
* phi_{4,4}: 6 4 0 5 2 1 3
|
||||
*
|
||||
* rounds = 5: 6 5 4 3 2 1 0
|
||||
* | | | | | | | (replaced by)
|
||||
* phi_{5,1}: 3 4 1 0 5 2 6
|
||||
* phi_{5,2}: 6 2 1 0 3 4 5
|
||||
* phi_{5,3}: 2 6 0 4 3 1 5
|
||||
* phi_{5,4}: 1 5 3 2 0 4 6
|
||||
* phi_{5,5}: 2 5 0 6 4 3 1
|
||||
*/
|
||||
private int FF1(int x7, int x6, int x5, int x4, int x3, int x2, int x1,
|
||||
int x0, int w)
|
||||
{
|
||||
int t;
|
||||
switch (rounds)
|
||||
{
|
||||
case 3:
|
||||
t = f1(x1, x0, x3, x5, x6, x2, x4);
|
||||
break;
|
||||
case 4:
|
||||
t = f1(x2, x6, x1, x4, x5, x3, x0);
|
||||
break;
|
||||
default:
|
||||
t = f1(x3, x4, x1, x0, x5, x2, x6);
|
||||
}
|
||||
return (t >>> 7 | t << 25) + (x7 >>> 11 | x7 << 21) + w;
|
||||
}
|
||||
|
||||
private int FF2(int x7, int x6, int x5, int x4, int x3, int x2, int x1,
|
||||
int x0, int w, int c)
|
||||
{
|
||||
int t;
|
||||
switch (rounds)
|
||||
{
|
||||
case 3:
|
||||
t = f2(x4, x2, x1, x0, x5, x3, x6);
|
||||
break;
|
||||
case 4:
|
||||
t = f2(x3, x5, x2, x0, x1, x6, x4);
|
||||
break;
|
||||
default:
|
||||
t = f2(x6, x2, x1, x0, x3, x4, x5);
|
||||
}
|
||||
return (t >>> 7 | t << 25) + (x7 >>> 11 | x7 << 21) + w + c;
|
||||
}
|
||||
|
||||
private int FF3(int x7, int x6, int x5, int x4, int x3, int x2, int x1,
|
||||
int x0, int w, int c)
|
||||
{
|
||||
int t;
|
||||
switch (rounds)
|
||||
{
|
||||
case 3:
|
||||
t = f3(x6, x1, x2, x3, x4, x5, x0);
|
||||
break;
|
||||
case 4:
|
||||
t = f3(x1, x4, x3, x6, x0, x2, x5);
|
||||
break;
|
||||
default:
|
||||
t = f3(x2, x6, x0, x4, x3, x1, x5);
|
||||
}
|
||||
return (t >>> 7 | t << 25) + (x7 >>> 11 | x7 << 21) + w + c;
|
||||
}
|
||||
|
||||
private int FF4(int x7, int x6, int x5, int x4, int x3, int x2, int x1,
|
||||
int x0, int w, int c)
|
||||
{
|
||||
int t;
|
||||
switch (rounds)
|
||||
{
|
||||
case 4:
|
||||
t = f4(x6, x4, x0, x5, x2, x1, x3);
|
||||
break;
|
||||
default:
|
||||
t = f4(x1, x5, x3, x2, x0, x4, x6);
|
||||
}
|
||||
return (t >>> 7 | t << 25) + (x7 >>> 11 | x7 << 21) + w + c;
|
||||
}
|
||||
|
||||
private int FF5(int x7, int x6, int x5, int x4, int x3, int x2, int x1,
|
||||
int x0, int w, int c)
|
||||
{
|
||||
int t = f5(x2, x5, x0, x6, x4, x3, x1);
|
||||
return (t >>> 7 | t << 25) + (x7 >>> 11 | x7 << 21) + w + c;
|
||||
}
|
||||
|
||||
private int f1(int x6, int x5, int x4, int x3, int x2, int x1, int x0)
|
||||
{
|
||||
return x1 & (x0 ^ x4) ^ x2 & x5 ^ x3 & x6 ^ x0;
|
||||
}
|
||||
|
||||
private int f2(int x6, int x5, int x4, int x3, int x2, int x1, int x0)
|
||||
{
|
||||
return x2 & (x1 & ~x3 ^ x4 & x5 ^ x6 ^ x0) ^ x4 & (x1 ^ x5) ^ x3 & x5 ^ x0;
|
||||
}
|
||||
|
||||
private int f3(int x6, int x5, int x4, int x3, int x2, int x1, int x0)
|
||||
{
|
||||
return x3 & (x1 & x2 ^ x6 ^ x0) ^ x1 & x4 ^ x2 & x5 ^ x0;
|
||||
}
|
||||
|
||||
private int f4(int x6, int x5, int x4, int x3, int x2, int x1, int x0)
|
||||
{
|
||||
return x4 & (x5 & ~x2 ^ x3 & ~x6 ^ x1 ^ x6 ^ x0) ^ x3 & (x1 & x2 ^ x5 ^ x6)
|
||||
^ x2 & x6 ^ x0;
|
||||
}
|
||||
|
||||
private int f5(int x6, int x5, int x4, int x3, int x2, int x1, int x0)
|
||||
{
|
||||
return x0 & (x1 & x2 & x3 ^ ~x5) ^ x1 & x4 ^ x2 & x5 ^ x3 & x6;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
/* IMessageDigest.java --
|
||||
Copyright (C) 2001, 2002, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
/**
|
||||
* <p>The basic visible methods of any hash algorithm.</p>
|
||||
*
|
||||
* <p>A hash (or message digest) algorithm produces its output by iterating a
|
||||
* basic compression function on blocks of data.</p>
|
||||
*/
|
||||
public interface IMessageDigest extends Cloneable
|
||||
{
|
||||
|
||||
// Constants
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// Methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* <p>Returns the canonical name of this algorithm.</p>
|
||||
*
|
||||
* @return the canonical name of this instance.
|
||||
*/
|
||||
String name();
|
||||
|
||||
/**
|
||||
* <p>Returns the output length in bytes of this message digest algorithm.</p>
|
||||
*
|
||||
* @return the output length in bytes of this message digest algorithm.
|
||||
*/
|
||||
int hashSize();
|
||||
|
||||
/**
|
||||
* <p>Returns the algorithm's (inner) block size in bytes.</p>
|
||||
*
|
||||
* @return the algorithm's inner block size in bytes.
|
||||
*/
|
||||
int blockSize();
|
||||
|
||||
/**
|
||||
* <p>Continues a message digest operation using the input byte.</p>
|
||||
*
|
||||
* @param b the input byte to digest.
|
||||
*/
|
||||
void update(byte b);
|
||||
|
||||
/**
|
||||
* <p>Continues a message digest operation, by filling the buffer, processing
|
||||
* data in the algorithm's HASH_SIZE-bit block(s), updating the context and
|
||||
* count, and buffering the remaining bytes in buffer for the next
|
||||
* operation.</p>
|
||||
*
|
||||
* @param in the input block.
|
||||
*/
|
||||
void update(byte[] in);
|
||||
|
||||
/**
|
||||
* <p>Continues a message digest operation, by filling the buffer, processing
|
||||
* data in the algorithm's HASH_SIZE-bit block(s), updating the context and
|
||||
* count, and buffering the remaining bytes in buffer for the next
|
||||
* operation.</p>
|
||||
*
|
||||
* @param in the input block.
|
||||
* @param offset start of meaningful bytes in input block.
|
||||
* @param length number of bytes, in input block, to consider.
|
||||
*/
|
||||
void update(byte[] in, int offset, int length);
|
||||
|
||||
/**
|
||||
* <p>Completes the message digest by performing final operations such as
|
||||
* padding and resetting the instance.</p>
|
||||
*
|
||||
* @return the array of bytes representing the hash value.
|
||||
*/
|
||||
byte[] digest();
|
||||
|
||||
/**
|
||||
* <p>Resets the current context of this instance clearing any eventually cached
|
||||
* intermediary values.</p>
|
||||
*/
|
||||
void reset();
|
||||
|
||||
/**
|
||||
* <p>A basic test. Ensures that the digest of a pre-determined message is equal
|
||||
* to a known pre-computed value.</p>
|
||||
*
|
||||
* @return <tt>true</tt> if the implementation passes a basic self-test.
|
||||
* Returns <tt>false</tt> otherwise.
|
||||
*/
|
||||
boolean selfTest();
|
||||
|
||||
/**
|
||||
* <p>Returns a clone copy of this instance.</p>
|
||||
*
|
||||
* @return a clone copy of this instance.
|
||||
*/
|
||||
Object clone();
|
||||
}
|
||||
@@ -0,0 +1,301 @@
|
||||
/* MD2.java --
|
||||
Copyright (C) 2001, 2002, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
import gnu.java.security.util.Util;
|
||||
|
||||
/**
|
||||
* <p>An implementation of the MD2 message digest algorithm.</p>
|
||||
*
|
||||
* <p>MD2 is not widely used. Unless it is needed for compatibility with
|
||||
* existing systems, it is not recommended for use in new applications.</p>
|
||||
*
|
||||
* <p>References:</p>
|
||||
*
|
||||
* <ol>
|
||||
* <li>The <a href="http://www.ietf.org/rfc/rfc1319.txt">MD2</a>
|
||||
* Message-Digest Algorithm.<br>
|
||||
* B. Kaliski.</li>
|
||||
* <li>The <a href="http://www.rfc-editor.org/errata.html">RFC ERRATA PAGE</a>
|
||||
* under section RFC 1319.</li>
|
||||
* </ol>
|
||||
*/
|
||||
public class MD2 extends BaseHash
|
||||
{
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** An MD2 message digest is always 128-bits long, or 16 bytes. */
|
||||
private static final int DIGEST_LENGTH = 16;
|
||||
|
||||
/** The MD2 algorithm operates on 128-bit blocks, or 16 bytes. */
|
||||
private static final int BLOCK_LENGTH = 16;
|
||||
|
||||
/** 256 byte "random" permutation of the digits of pi. */
|
||||
private static final byte[] PI = { 41, 46, 67, -55, -94, -40, 124, 1, 61, 54,
|
||||
84, -95, -20, -16, 6, 19, 98, -89, 5, -13,
|
||||
-64, -57, 115, -116, -104, -109, 43, -39,
|
||||
-68, 76, -126, -54, 30, -101, 87, 60, -3,
|
||||
-44, -32, 22, 103, 66, 111, 24, -118, 23,
|
||||
-27, 18, -66, 78, -60, -42, -38, -98, -34,
|
||||
73, -96, -5, -11, -114, -69, 47, -18, 122,
|
||||
-87, 104, 121, -111, 21, -78, 7, 63, -108,
|
||||
-62, 16, -119, 11, 34, 95, 33, -128, 127,
|
||||
93, -102, 90, -112, 50, 39, 53, 62, -52,
|
||||
-25, -65, -9, -105, 3, -1, 25, 48, -77, 72,
|
||||
-91, -75, -47, -41, 94, -110, 42, -84, 86,
|
||||
-86, -58, 79, -72, 56, -46, -106, -92, 125,
|
||||
-74, 118, -4, 107, -30, -100, 116, 4, -15,
|
||||
69, -99, 112, 89, 100, 113, -121, 32, -122,
|
||||
91, -49, 101, -26, 45, -88, 2, 27, 96, 37,
|
||||
-83, -82, -80, -71, -10, 28, 70, 97, 105,
|
||||
52, 64, 126, 15, 85, 71, -93, 35, -35, 81,
|
||||
-81, 58, -61, 92, -7, -50, -70, -59, -22,
|
||||
38, 44, 83, 13, 110, -123, 40, -124, 9,
|
||||
-45, -33, -51, -12, 65, -127, 77, 82, 106,
|
||||
-36, 55, -56, 108, -63, -85, -6, 36, -31,
|
||||
123, 8, 12, -67, -79, 74, 120, -120, -107,
|
||||
-117, -29, 99, -24, 109, -23, -53, -43, -2,
|
||||
59, 0, 29, 57, -14, -17, -73, 14, 102, 88,
|
||||
-48, -28, -90, 119, 114, -8, -21, 117, 75,
|
||||
10, 49, 68, 80, -76, -113, -19, 31, 26,
|
||||
-37, -103, -115, 51, -97, 17, -125, 20 };
|
||||
|
||||
/** The output of this message digest when no data has been input. */
|
||||
private static final String DIGEST0 = "8350E5A3E24C153DF2275C9F80692773";
|
||||
|
||||
/** caches the result of the correctness test, once executed. */
|
||||
private static Boolean valid;
|
||||
|
||||
/** The checksum computed so far. */
|
||||
private byte[] checksum;
|
||||
|
||||
/**
|
||||
* Work array needed by encrypt method. First <code>BLOCK_LENGTH</code> bytes
|
||||
* are also used to store the running digest.
|
||||
*/
|
||||
private byte[] work;
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** Creates a new MD2 digest ready for use. */
|
||||
public MD2()
|
||||
{
|
||||
super(Registry.MD2_HASH, DIGEST_LENGTH, BLOCK_LENGTH);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Private constructor used for cloning.</p>
|
||||
*
|
||||
* @param md2 the instance to clone.
|
||||
*/
|
||||
private MD2(MD2 md2)
|
||||
{
|
||||
this();
|
||||
|
||||
// superclass field
|
||||
this.count = md2.count;
|
||||
this.buffer = (byte[]) md2.buffer.clone();
|
||||
|
||||
// private field
|
||||
this.checksum = (byte[]) md2.checksum.clone();
|
||||
this.work = (byte[]) md2.work.clone();
|
||||
}
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// java.lang.Cloneable interface implementation ----------------------------
|
||||
|
||||
public Object clone()
|
||||
{
|
||||
return new MD2(this);
|
||||
}
|
||||
|
||||
// Implementation of abstract methods in BaseHash --------------------------
|
||||
|
||||
protected byte[] getResult()
|
||||
{
|
||||
byte[] result = new byte[DIGEST_LENGTH];
|
||||
|
||||
// Encrypt checksum as last block.
|
||||
encryptBlock(checksum, 0);
|
||||
|
||||
for (int i = 0; i < BLOCK_LENGTH; i++)
|
||||
{
|
||||
result[i] = work[i];
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected void resetContext()
|
||||
{
|
||||
checksum = new byte[BLOCK_LENGTH];
|
||||
work = new byte[BLOCK_LENGTH * 3];
|
||||
}
|
||||
|
||||
public boolean selfTest()
|
||||
{
|
||||
if (valid == null)
|
||||
{
|
||||
valid = new Boolean(DIGEST0.equals(Util.toString(new MD2().digest())));
|
||||
}
|
||||
return valid.booleanValue();
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Generates an array of padding bytes. The padding is defined as
|
||||
* <code>i</code> bytes of value <code>i</code>, where <code>i</code> is the
|
||||
* number of bytes to fill the last block of the message to
|
||||
* <code>BLOCK_LENGTH</code> bytes (or <code>BLOCK_LENGTH</code> bytes when
|
||||
* the last block was completely full).</p>
|
||||
*
|
||||
* @return the bytes to pad the remaining bytes in the buffer before
|
||||
* completing a hash operation.
|
||||
*/
|
||||
protected byte[] padBuffer()
|
||||
{
|
||||
int length = BLOCK_LENGTH - (int) (count % BLOCK_LENGTH);
|
||||
if (length == 0)
|
||||
{
|
||||
length = BLOCK_LENGTH;
|
||||
}
|
||||
byte[] pad = new byte[length];
|
||||
for (int i = 0; i < length; i++)
|
||||
{
|
||||
pad[i] = (byte) length;
|
||||
}
|
||||
return pad;
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Adds <code>BLOCK_LENGTH</code> bytes to the running digest.</p>
|
||||
*
|
||||
* @param in the byte array to take the <code>BLOCK_LENGTH</code> bytes from.
|
||||
* @param off the offset to start from in the given byte array.
|
||||
*/
|
||||
protected void transform(byte[] in, int off)
|
||||
{
|
||||
// encryptBlock(in, off);
|
||||
// updateCheckSum(in, off);
|
||||
updateCheckSumAndEncryptBlock(in, off);
|
||||
}
|
||||
|
||||
// Private instance methods ------------------------------------------------
|
||||
|
||||
/**
|
||||
* Updates the checksum with the <code>BLOCK_LENGTH</code> bytes from the
|
||||
* given array starting at <code>off</code>.
|
||||
*/
|
||||
/*
|
||||
private void updateCheckSum(byte[] in, int off) {
|
||||
byte l = checksum[BLOCK_LENGTH-1];
|
||||
for (int i = 0; i < BLOCK_LENGTH; i++) {
|
||||
byte b = in[off+i];
|
||||
// l = (byte)((checksum[i] & 0xFF) ^ (PI[((b & 0xFF) ^ (l & 0xFF))] & 0xFF));
|
||||
l = (byte)(checksum[i] ^ PI[(b ^ l) & 0xFF]);
|
||||
checksum[i] = l;
|
||||
}
|
||||
}
|
||||
*/
|
||||
/**
|
||||
* Adds a new block (<code>BLOCK_LENGTH</code> bytes) to the running digest
|
||||
* from the given byte array starting from the given offset.
|
||||
*/
|
||||
private void encryptBlock(byte[] in, int off)
|
||||
{
|
||||
for (int i = 0; i < BLOCK_LENGTH; i++)
|
||||
{
|
||||
byte b = in[off + i];
|
||||
work[BLOCK_LENGTH + i] = b;
|
||||
work[BLOCK_LENGTH * 2 + i] = (byte) (work[i] ^ b);
|
||||
}
|
||||
|
||||
byte t = 0;
|
||||
for (int i = 0; i < 18; i++)
|
||||
{
|
||||
for (int j = 0; j < 3 * BLOCK_LENGTH; j++)
|
||||
{
|
||||
// t = (byte)((work[j] & 0xFF) ^ (PI[t & 0xFF] & 0xFF));
|
||||
t = (byte) (work[j] ^ PI[t & 0xFF]);
|
||||
work[j] = t;
|
||||
}
|
||||
// t = (byte)((t + i) & 0xFF);
|
||||
t = (byte) (t + i);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Optimized method that combines a checksum update and encrypt of a block.
|
||||
*/
|
||||
private void updateCheckSumAndEncryptBlock(byte[] in, int off)
|
||||
{
|
||||
byte l = checksum[BLOCK_LENGTH - 1];
|
||||
for (int i = 0; i < BLOCK_LENGTH; i++)
|
||||
{
|
||||
byte b = in[off + i];
|
||||
work[BLOCK_LENGTH + i] = b;
|
||||
// work[BLOCK_LENGTH*2+i] = (byte)((work[i] & 0xFF) ^ (b & 0xFF));
|
||||
work[BLOCK_LENGTH * 2 + i] = (byte) (work[i] ^ b);
|
||||
// l = (byte)((checksum[i] & 0xFF) ^ (PI[((b & 0xFF) ^ (l & 0xFF))] & 0xFF));
|
||||
l = (byte) (checksum[i] ^ PI[(b ^ l) & 0xFF]);
|
||||
checksum[i] = l;
|
||||
}
|
||||
|
||||
byte t = 0;
|
||||
for (int i = 0; i < 18; i++)
|
||||
{
|
||||
for (int j = 0; j < 3 * BLOCK_LENGTH; j++)
|
||||
{
|
||||
// t = (byte)((work[j] & 0xFF) ^ (PI[t & 0xFF] & 0xFF));
|
||||
t = (byte) (work[j] ^ PI[t & 0xFF]);
|
||||
work[j] = t;
|
||||
}
|
||||
// t = (byte)((t + i) & 0xFF);
|
||||
t = (byte) (t + i);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,328 @@
|
||||
/* MD4.java --
|
||||
Copyright (C) 2001, 2002, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
import gnu.java.security.util.Util;
|
||||
|
||||
/**
|
||||
* <p>An implementation of Ron Rivest's MD4 message digest algorithm.</p>
|
||||
*
|
||||
* <p>MD4 was the precursor to the stronger {@link gnu.crypto.hash.MD5}
|
||||
* algorithm, and while not considered cryptograpically secure itself, MD4 is
|
||||
* in use in various applications. It is slightly faster than MD5.</p>
|
||||
*
|
||||
* <p>References:</p>
|
||||
*
|
||||
* <ol>
|
||||
* <li>The <a href="http://www.ietf.org/rfc/rfc1320.txt">MD4</a>
|
||||
* Message-Digest Algorithm.<br>
|
||||
* R. Rivest.</li>
|
||||
* </ol>
|
||||
*
|
||||
* @author Casey Marshall (rsdio@metastatic.org)
|
||||
*/
|
||||
public class MD4 extends BaseHash
|
||||
{
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** An MD4 message digest is always 128-bits long, or 16 bytes. */
|
||||
private static final int DIGEST_LENGTH = 16;
|
||||
|
||||
/** The MD4 algorithm operates on 512-bit blocks, or 64 bytes. */
|
||||
private static final int BLOCK_LENGTH = 64;
|
||||
|
||||
private static final int A = 0x67452301;
|
||||
|
||||
private static final int B = 0xefcdab89;
|
||||
|
||||
private static final int C = 0x98badcfe;
|
||||
|
||||
private static final int D = 0x10325476;
|
||||
|
||||
/** The output of this message digest when no data has been input. */
|
||||
private static final String DIGEST0 = "31D6CFE0D16AE931B73C59D7E0C089C0";
|
||||
|
||||
/** caches the result of the correctness test, once executed. */
|
||||
private static Boolean valid;
|
||||
|
||||
private int a, b, c, d;
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* <p>Public constructor. Initializes the chaining variables, sets the byte
|
||||
* count to <code>0</code>, and creates a new block of <code>512</code> bits.
|
||||
* </p>
|
||||
*/
|
||||
public MD4()
|
||||
{
|
||||
super(Registry.MD4_HASH, DIGEST_LENGTH, BLOCK_LENGTH);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Trivial private constructor for cloning purposes.</p>
|
||||
*
|
||||
* @param that the instance to clone.
|
||||
*/
|
||||
private MD4(MD4 that)
|
||||
{
|
||||
this();
|
||||
|
||||
this.a = that.a;
|
||||
this.b = that.b;
|
||||
this.c = that.c;
|
||||
this.d = that.d;
|
||||
this.count = that.count;
|
||||
this.buffer = (byte[]) that.buffer.clone();
|
||||
}
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// java.lang.Cloneable interface implementation ----------------------------
|
||||
|
||||
public Object clone()
|
||||
{
|
||||
return new MD4(this);
|
||||
}
|
||||
|
||||
// Implementation of abstract methods in BashHash --------------------------
|
||||
|
||||
protected byte[] getResult()
|
||||
{
|
||||
byte[] digest = { (byte) a, (byte) (a >>> 8), (byte) (a >>> 16),
|
||||
(byte) (a >>> 24), (byte) b, (byte) (b >>> 8),
|
||||
(byte) (b >>> 16), (byte) (b >>> 24), (byte) c,
|
||||
(byte) (c >>> 8), (byte) (c >>> 16), (byte) (c >>> 24),
|
||||
(byte) d, (byte) (d >>> 8), (byte) (d >>> 16),
|
||||
(byte) (d >>> 24) };
|
||||
return digest;
|
||||
}
|
||||
|
||||
protected void resetContext()
|
||||
{
|
||||
a = A;
|
||||
b = B;
|
||||
c = C;
|
||||
d = D;
|
||||
}
|
||||
|
||||
public boolean selfTest()
|
||||
{
|
||||
if (valid == null)
|
||||
{
|
||||
valid = new Boolean(DIGEST0.equals(Util.toString(new MD4().digest())));
|
||||
}
|
||||
return valid.booleanValue();
|
||||
}
|
||||
|
||||
protected byte[] padBuffer()
|
||||
{
|
||||
int n = (int) (count % BLOCK_LENGTH);
|
||||
int padding = (n < 56) ? (56 - n) : (120 - n);
|
||||
byte[] pad = new byte[padding + 8];
|
||||
|
||||
pad[0] = (byte) 0x80;
|
||||
long bits = count << 3;
|
||||
pad[padding++] = (byte) bits;
|
||||
pad[padding++] = (byte) (bits >>> 8);
|
||||
pad[padding++] = (byte) (bits >>> 16);
|
||||
pad[padding++] = (byte) (bits >>> 24);
|
||||
pad[padding++] = (byte) (bits >>> 32);
|
||||
pad[padding++] = (byte) (bits >>> 40);
|
||||
pad[padding++] = (byte) (bits >>> 48);
|
||||
pad[padding] = (byte) (bits >>> 56);
|
||||
|
||||
return pad;
|
||||
}
|
||||
|
||||
protected void transform(byte[] in, int i)
|
||||
{
|
||||
int X0 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X1 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X2 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X3 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X4 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X5 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X6 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X7 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X8 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X9 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X10 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X11 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X12 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X13 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X14 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X15 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i] << 24;
|
||||
|
||||
int aa, bb, cc, dd;
|
||||
|
||||
aa = a;
|
||||
bb = b;
|
||||
cc = c;
|
||||
dd = d;
|
||||
|
||||
aa += ((bb & cc) | ((~bb) & dd)) + X0;
|
||||
aa = aa << 3 | aa >>> -3;
|
||||
dd += ((aa & bb) | ((~aa) & cc)) + X1;
|
||||
dd = dd << 7 | dd >>> -7;
|
||||
cc += ((dd & aa) | ((~dd) & bb)) + X2;
|
||||
cc = cc << 11 | cc >>> -11;
|
||||
bb += ((cc & dd) | ((~cc) & aa)) + X3;
|
||||
bb = bb << 19 | bb >>> -19;
|
||||
aa += ((bb & cc) | ((~bb) & dd)) + X4;
|
||||
aa = aa << 3 | aa >>> -3;
|
||||
dd += ((aa & bb) | ((~aa) & cc)) + X5;
|
||||
dd = dd << 7 | dd >>> -7;
|
||||
cc += ((dd & aa) | ((~dd) & bb)) + X6;
|
||||
cc = cc << 11 | cc >>> -11;
|
||||
bb += ((cc & dd) | ((~cc) & aa)) + X7;
|
||||
bb = bb << 19 | bb >>> -19;
|
||||
aa += ((bb & cc) | ((~bb) & dd)) + X8;
|
||||
aa = aa << 3 | aa >>> -3;
|
||||
dd += ((aa & bb) | ((~aa) & cc)) + X9;
|
||||
dd = dd << 7 | dd >>> -7;
|
||||
cc += ((dd & aa) | ((~dd) & bb)) + X10;
|
||||
cc = cc << 11 | cc >>> -11;
|
||||
bb += ((cc & dd) | ((~cc) & aa)) + X11;
|
||||
bb = bb << 19 | bb >>> -19;
|
||||
aa += ((bb & cc) | ((~bb) & dd)) + X12;
|
||||
aa = aa << 3 | aa >>> -3;
|
||||
dd += ((aa & bb) | ((~aa) & cc)) + X13;
|
||||
dd = dd << 7 | dd >>> -7;
|
||||
cc += ((dd & aa) | ((~dd) & bb)) + X14;
|
||||
cc = cc << 11 | cc >>> -11;
|
||||
bb += ((cc & dd) | ((~cc) & aa)) + X15;
|
||||
bb = bb << 19 | bb >>> -19;
|
||||
|
||||
aa += ((bb & (cc | dd)) | (cc & dd)) + X0 + 0x5a827999;
|
||||
aa = aa << 3 | aa >>> -3;
|
||||
dd += ((aa & (bb | cc)) | (bb & cc)) + X4 + 0x5a827999;
|
||||
dd = dd << 5 | dd >>> -5;
|
||||
cc += ((dd & (aa | bb)) | (aa & bb)) + X8 + 0x5a827999;
|
||||
cc = cc << 9 | cc >>> -9;
|
||||
bb += ((cc & (dd | aa)) | (dd & aa)) + X12 + 0x5a827999;
|
||||
bb = bb << 13 | bb >>> -13;
|
||||
aa += ((bb & (cc | dd)) | (cc & dd)) + X1 + 0x5a827999;
|
||||
aa = aa << 3 | aa >>> -3;
|
||||
dd += ((aa & (bb | cc)) | (bb & cc)) + X5 + 0x5a827999;
|
||||
dd = dd << 5 | dd >>> -5;
|
||||
cc += ((dd & (aa | bb)) | (aa & bb)) + X9 + 0x5a827999;
|
||||
cc = cc << 9 | cc >>> -9;
|
||||
bb += ((cc & (dd | aa)) | (dd & aa)) + X13 + 0x5a827999;
|
||||
bb = bb << 13 | bb >>> -13;
|
||||
aa += ((bb & (cc | dd)) | (cc & dd)) + X2 + 0x5a827999;
|
||||
aa = aa << 3 | aa >>> -3;
|
||||
dd += ((aa & (bb | cc)) | (bb & cc)) + X6 + 0x5a827999;
|
||||
dd = dd << 5 | dd >>> -5;
|
||||
cc += ((dd & (aa | bb)) | (aa & bb)) + X10 + 0x5a827999;
|
||||
cc = cc << 9 | cc >>> -9;
|
||||
bb += ((cc & (dd | aa)) | (dd & aa)) + X14 + 0x5a827999;
|
||||
bb = bb << 13 | bb >>> -13;
|
||||
aa += ((bb & (cc | dd)) | (cc & dd)) + X3 + 0x5a827999;
|
||||
aa = aa << 3 | aa >>> -3;
|
||||
dd += ((aa & (bb | cc)) | (bb & cc)) + X7 + 0x5a827999;
|
||||
dd = dd << 5 | dd >>> -5;
|
||||
cc += ((dd & (aa | bb)) | (aa & bb)) + X11 + 0x5a827999;
|
||||
cc = cc << 9 | cc >>> -9;
|
||||
bb += ((cc & (dd | aa)) | (dd & aa)) + X15 + 0x5a827999;
|
||||
bb = bb << 13 | bb >>> -13;
|
||||
|
||||
aa += (bb ^ cc ^ dd) + X0 + 0x6ed9eba1;
|
||||
aa = aa << 3 | aa >>> -3;
|
||||
dd += (aa ^ bb ^ cc) + X8 + 0x6ed9eba1;
|
||||
dd = dd << 9 | dd >>> -9;
|
||||
cc += (dd ^ aa ^ bb) + X4 + 0x6ed9eba1;
|
||||
cc = cc << 11 | cc >>> -11;
|
||||
bb += (cc ^ dd ^ aa) + X12 + 0x6ed9eba1;
|
||||
bb = bb << 15 | bb >>> -15;
|
||||
aa += (bb ^ cc ^ dd) + X2 + 0x6ed9eba1;
|
||||
aa = aa << 3 | aa >>> -3;
|
||||
dd += (aa ^ bb ^ cc) + X10 + 0x6ed9eba1;
|
||||
dd = dd << 9 | dd >>> -9;
|
||||
cc += (dd ^ aa ^ bb) + X6 + 0x6ed9eba1;
|
||||
cc = cc << 11 | cc >>> -11;
|
||||
bb += (cc ^ dd ^ aa) + X14 + 0x6ed9eba1;
|
||||
bb = bb << 15 | bb >>> -15;
|
||||
aa += (bb ^ cc ^ dd) + X1 + 0x6ed9eba1;
|
||||
aa = aa << 3 | aa >>> -3;
|
||||
dd += (aa ^ bb ^ cc) + X9 + 0x6ed9eba1;
|
||||
dd = dd << 9 | dd >>> -9;
|
||||
cc += (dd ^ aa ^ bb) + X5 + 0x6ed9eba1;
|
||||
cc = cc << 11 | cc >>> -11;
|
||||
bb += (cc ^ dd ^ aa) + X13 + 0x6ed9eba1;
|
||||
bb = bb << 15 | bb >>> -15;
|
||||
aa += (bb ^ cc ^ dd) + X3 + 0x6ed9eba1;
|
||||
aa = aa << 3 | aa >>> -3;
|
||||
dd += (aa ^ bb ^ cc) + X11 + 0x6ed9eba1;
|
||||
dd = dd << 9 | dd >>> -9;
|
||||
cc += (dd ^ aa ^ bb) + X7 + 0x6ed9eba1;
|
||||
cc = cc << 11 | cc >>> -11;
|
||||
bb += (cc ^ dd ^ aa) + X15 + 0x6ed9eba1;
|
||||
bb = bb << 15 | bb >>> -15;
|
||||
|
||||
a += aa;
|
||||
b += bb;
|
||||
c += cc;
|
||||
d += dd;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,365 @@
|
||||
/* MD5.java --
|
||||
Copyright (C) 2001, 2002, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
import gnu.java.security.util.Util;
|
||||
|
||||
/**
|
||||
* <p>The MD5 message-digest algorithm takes as input a message of arbitrary
|
||||
* length and produces as output a 128-bit "fingerprint" or "message digest" of
|
||||
* the input. It is conjectured that it is computationally infeasible to
|
||||
* produce two messages having the same message digest, or to produce any
|
||||
* message having a given prespecified target message digest.</p>
|
||||
*
|
||||
* <p>References:</p>
|
||||
*
|
||||
* <ol>
|
||||
* <li>The <a href="http://www.ietf.org/rfc/rfc1321.txt">MD5</a> Message-
|
||||
* Digest Algorithm.<br>
|
||||
* R. Rivest.</li>
|
||||
* </ol>
|
||||
*/
|
||||
public class MD5 extends BaseHash
|
||||
{
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private static final int BLOCK_SIZE = 64; // inner block size in bytes
|
||||
|
||||
private static final String DIGEST0 = "D41D8CD98F00B204E9800998ECF8427E";
|
||||
|
||||
/** caches the result of the correctness test, once executed. */
|
||||
private static Boolean valid;
|
||||
|
||||
/** 128-bit interim result. */
|
||||
private int h0, h1, h2, h3;
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** Trivial 0-arguments constructor. */
|
||||
public MD5()
|
||||
{
|
||||
super(Registry.MD5_HASH, 16, BLOCK_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Private constructor for cloning purposes.</p>
|
||||
*
|
||||
* @param md the instance to clone.
|
||||
*/
|
||||
private MD5(MD5 md)
|
||||
{
|
||||
this();
|
||||
|
||||
this.h0 = md.h0;
|
||||
this.h1 = md.h1;
|
||||
this.h2 = md.h2;
|
||||
this.h3 = md.h3;
|
||||
this.count = md.count;
|
||||
this.buffer = (byte[]) md.buffer.clone();
|
||||
}
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// java.lang.Cloneable interface implementation ----------------------------
|
||||
|
||||
public Object clone()
|
||||
{
|
||||
return new MD5(this);
|
||||
}
|
||||
|
||||
// Implementation of concrete methods in BaseHash --------------------------
|
||||
|
||||
protected synchronized void transform(byte[] in, int i)
|
||||
{
|
||||
int X0 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X1 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X2 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X3 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X4 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X5 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X6 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X7 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X8 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X9 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X10 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X11 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X12 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X13 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X14 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i++] << 24;
|
||||
int X15 = (in[i++] & 0xFF) | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF) << 16
|
||||
| in[i] << 24;
|
||||
|
||||
int A = h0;
|
||||
int B = h1;
|
||||
int C = h2;
|
||||
int D = h3;
|
||||
|
||||
// hex constants are from md5.c in FSF Gnu Privacy Guard 0.9.2
|
||||
// round 1
|
||||
A += ((B & C) | (~B & D)) + X0 + 0xD76AA478;
|
||||
A = B + (A << 7 | A >>> -7);
|
||||
D += ((A & B) | (~A & C)) + X1 + 0xE8C7B756;
|
||||
D = A + (D << 12 | D >>> -12);
|
||||
C += ((D & A) | (~D & B)) + X2 + 0x242070DB;
|
||||
C = D + (C << 17 | C >>> -17);
|
||||
B += ((C & D) | (~C & A)) + X3 + 0xC1BDCEEE;
|
||||
B = C + (B << 22 | B >>> -22);
|
||||
|
||||
A += ((B & C) | (~B & D)) + X4 + 0xF57C0FAF;
|
||||
A = B + (A << 7 | A >>> -7);
|
||||
D += ((A & B) | (~A & C)) + X5 + 0x4787C62A;
|
||||
D = A + (D << 12 | D >>> -12);
|
||||
C += ((D & A) | (~D & B)) + X6 + 0xA8304613;
|
||||
C = D + (C << 17 | C >>> -17);
|
||||
B += ((C & D) | (~C & A)) + X7 + 0xFD469501;
|
||||
B = C + (B << 22 | B >>> -22);
|
||||
|
||||
A += ((B & C) | (~B & D)) + X8 + 0x698098D8;
|
||||
A = B + (A << 7 | A >>> -7);
|
||||
D += ((A & B) | (~A & C)) + X9 + 0x8B44F7AF;
|
||||
D = A + (D << 12 | D >>> -12);
|
||||
C += ((D & A) | (~D & B)) + X10 + 0xFFFF5BB1;
|
||||
C = D + (C << 17 | C >>> -17);
|
||||
B += ((C & D) | (~C & A)) + X11 + 0x895CD7BE;
|
||||
B = C + (B << 22 | B >>> -22);
|
||||
|
||||
A += ((B & C) | (~B & D)) + X12 + 0x6B901122;
|
||||
A = B + (A << 7 | A >>> -7);
|
||||
D += ((A & B) | (~A & C)) + X13 + 0xFD987193;
|
||||
D = A + (D << 12 | D >>> -12);
|
||||
C += ((D & A) | (~D & B)) + X14 + 0xA679438E;
|
||||
C = D + (C << 17 | C >>> -17);
|
||||
B += ((C & D) | (~C & A)) + X15 + 0x49B40821;
|
||||
B = C + (B << 22 | B >>> -22);
|
||||
|
||||
// round 2
|
||||
A += ((B & D) | (C & ~D)) + X1 + 0xF61E2562;
|
||||
A = B + (A << 5 | A >>> -5);
|
||||
D += ((A & C) | (B & ~C)) + X6 + 0xC040B340;
|
||||
D = A + (D << 9 | D >>> -9);
|
||||
C += ((D & B) | (A & ~B)) + X11 + 0x265E5A51;
|
||||
C = D + (C << 14 | C >>> -14);
|
||||
B += ((C & A) | (D & ~A)) + X0 + 0xE9B6C7AA;
|
||||
B = C + (B << 20 | B >>> -20);
|
||||
|
||||
A += ((B & D) | (C & ~D)) + X5 + 0xD62F105D;
|
||||
A = B + (A << 5 | A >>> -5);
|
||||
D += ((A & C) | (B & ~C)) + X10 + 0x02441453;
|
||||
D = A + (D << 9 | D >>> -9);
|
||||
C += ((D & B) | (A & ~B)) + X15 + 0xD8A1E681;
|
||||
C = D + (C << 14 | C >>> -14);
|
||||
B += ((C & A) | (D & ~A)) + X4 + 0xE7D3FBC8;
|
||||
B = C + (B << 20 | B >>> -20);
|
||||
|
||||
A += ((B & D) | (C & ~D)) + X9 + 0x21E1CDE6;
|
||||
A = B + (A << 5 | A >>> -5);
|
||||
D += ((A & C) | (B & ~C)) + X14 + 0xC33707D6;
|
||||
D = A + (D << 9 | D >>> -9);
|
||||
C += ((D & B) | (A & ~B)) + X3 + 0xF4D50D87;
|
||||
C = D + (C << 14 | C >>> -14);
|
||||
B += ((C & A) | (D & ~A)) + X8 + 0x455A14ED;
|
||||
B = C + (B << 20 | B >>> -20);
|
||||
|
||||
A += ((B & D) | (C & ~D)) + X13 + 0xA9E3E905;
|
||||
A = B + (A << 5 | A >>> -5);
|
||||
D += ((A & C) | (B & ~C)) + X2 + 0xFCEFA3F8;
|
||||
D = A + (D << 9 | D >>> -9);
|
||||
C += ((D & B) | (A & ~B)) + X7 + 0x676F02D9;
|
||||
C = D + (C << 14 | C >>> -14);
|
||||
B += ((C & A) | (D & ~A)) + X12 + 0x8D2A4C8A;
|
||||
B = C + (B << 20 | B >>> -20);
|
||||
|
||||
// round 3
|
||||
A += (B ^ C ^ D) + X5 + 0xFFFA3942;
|
||||
A = B + (A << 4 | A >>> -4);
|
||||
D += (A ^ B ^ C) + X8 + 0x8771F681;
|
||||
D = A + (D << 11 | D >>> -11);
|
||||
C += (D ^ A ^ B) + X11 + 0x6D9D6122;
|
||||
C = D + (C << 16 | C >>> -16);
|
||||
B += (C ^ D ^ A) + X14 + 0xFDE5380C;
|
||||
B = C + (B << 23 | B >>> -23);
|
||||
|
||||
A += (B ^ C ^ D) + X1 + 0xA4BEEA44;
|
||||
A = B + (A << 4 | A >>> -4);
|
||||
D += (A ^ B ^ C) + X4 + 0x4BDECFA9;
|
||||
D = A + (D << 11 | D >>> -11);
|
||||
C += (D ^ A ^ B) + X7 + 0xF6BB4B60;
|
||||
C = D + (C << 16 | C >>> -16);
|
||||
B += (C ^ D ^ A) + X10 + 0xBEBFBC70;
|
||||
B = C + (B << 23 | B >>> -23);
|
||||
|
||||
A += (B ^ C ^ D) + X13 + 0x289B7EC6;
|
||||
A = B + (A << 4 | A >>> -4);
|
||||
D += (A ^ B ^ C) + X0 + 0xEAA127FA;
|
||||
D = A + (D << 11 | D >>> -11);
|
||||
C += (D ^ A ^ B) + X3 + 0xD4EF3085;
|
||||
C = D + (C << 16 | C >>> -16);
|
||||
B += (C ^ D ^ A) + X6 + 0x04881D05;
|
||||
B = C + (B << 23 | B >>> -23);
|
||||
|
||||
A += (B ^ C ^ D) + X9 + 0xD9D4D039;
|
||||
A = B + (A << 4 | A >>> -4);
|
||||
D += (A ^ B ^ C) + X12 + 0xE6DB99E5;
|
||||
D = A + (D << 11 | D >>> -11);
|
||||
C += (D ^ A ^ B) + X15 + 0x1FA27CF8;
|
||||
C = D + (C << 16 | C >>> -16);
|
||||
B += (C ^ D ^ A) + X2 + 0xC4AC5665;
|
||||
B = C + (B << 23 | B >>> -23);
|
||||
|
||||
// round 4
|
||||
A += (C ^ (B | ~D)) + X0 + 0xF4292244;
|
||||
A = B + (A << 6 | A >>> -6);
|
||||
D += (B ^ (A | ~C)) + X7 + 0x432AFF97;
|
||||
D = A + (D << 10 | D >>> -10);
|
||||
C += (A ^ (D | ~B)) + X14 + 0xAB9423A7;
|
||||
C = D + (C << 15 | C >>> -15);
|
||||
B += (D ^ (C | ~A)) + X5 + 0xFC93A039;
|
||||
B = C + (B << 21 | B >>> -21);
|
||||
|
||||
A += (C ^ (B | ~D)) + X12 + 0x655B59C3;
|
||||
A = B + (A << 6 | A >>> -6);
|
||||
D += (B ^ (A | ~C)) + X3 + 0x8F0CCC92;
|
||||
D = A + (D << 10 | D >>> -10);
|
||||
C += (A ^ (D | ~B)) + X10 + 0xFFEFF47D;
|
||||
C = D + (C << 15 | C >>> -15);
|
||||
B += (D ^ (C | ~A)) + X1 + 0x85845dd1;
|
||||
B = C + (B << 21 | B >>> -21);
|
||||
|
||||
A += (C ^ (B | ~D)) + X8 + 0x6FA87E4F;
|
||||
A = B + (A << 6 | A >>> -6);
|
||||
D += (B ^ (A | ~C)) + X15 + 0xFE2CE6E0;
|
||||
D = A + (D << 10 | D >>> -10);
|
||||
C += (A ^ (D | ~B)) + X6 + 0xA3014314;
|
||||
C = D + (C << 15 | C >>> -15);
|
||||
B += (D ^ (C | ~A)) + X13 + 0x4E0811A1;
|
||||
B = C + (B << 21 | B >>> -21);
|
||||
|
||||
A += (C ^ (B | ~D)) + X4 + 0xF7537E82;
|
||||
A = B + (A << 6 | A >>> -6);
|
||||
D += (B ^ (A | ~C)) + X11 + 0xBD3AF235;
|
||||
D = A + (D << 10 | D >>> -10);
|
||||
C += (A ^ (D | ~B)) + X2 + 0x2AD7D2BB;
|
||||
C = D + (C << 15 | C >>> -15);
|
||||
B += (D ^ (C | ~A)) + X9 + 0xEB86D391;
|
||||
B = C + (B << 21 | B >>> -21);
|
||||
|
||||
h0 += A;
|
||||
h1 += B;
|
||||
h2 += C;
|
||||
h3 += D;
|
||||
}
|
||||
|
||||
protected byte[] padBuffer()
|
||||
{
|
||||
int n = (int) (count % BLOCK_SIZE);
|
||||
int padding = (n < 56) ? (56 - n) : (120 - n);
|
||||
byte[] result = new byte[padding + 8];
|
||||
|
||||
// padding is always binary 1 followed by binary 0s
|
||||
result[0] = (byte) 0x80;
|
||||
|
||||
// save number of bits, casting the long to an array of 8 bytes
|
||||
long bits = count << 3;
|
||||
result[padding++] = (byte) bits;
|
||||
result[padding++] = (byte) (bits >>> 8);
|
||||
result[padding++] = (byte) (bits >>> 16);
|
||||
result[padding++] = (byte) (bits >>> 24);
|
||||
result[padding++] = (byte) (bits >>> 32);
|
||||
result[padding++] = (byte) (bits >>> 40);
|
||||
result[padding++] = (byte) (bits >>> 48);
|
||||
result[padding] = (byte) (bits >>> 56);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected byte[] getResult()
|
||||
{
|
||||
byte[] result = new byte[] { (byte) h0, (byte) (h0 >>> 8),
|
||||
(byte) (h0 >>> 16), (byte) (h0 >>> 24),
|
||||
(byte) h1, (byte) (h1 >>> 8),
|
||||
(byte) (h1 >>> 16), (byte) (h1 >>> 24),
|
||||
(byte) h2, (byte) (h2 >>> 8),
|
||||
(byte) (h2 >>> 16), (byte) (h2 >>> 24),
|
||||
(byte) h3, (byte) (h3 >>> 8),
|
||||
(byte) (h3 >>> 16), (byte) (h3 >>> 24) };
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected void resetContext()
|
||||
{
|
||||
// magic MD5/RIPEMD128 initialisation constants
|
||||
h0 = 0x67452301;
|
||||
h1 = 0xEFCDAB89;
|
||||
h2 = 0x98BADCFE;
|
||||
h3 = 0x10325476;
|
||||
}
|
||||
|
||||
public boolean selfTest()
|
||||
{
|
||||
if (valid == null)
|
||||
{
|
||||
valid = new Boolean(DIGEST0.equals(Util.toString(new MD5().digest())));
|
||||
}
|
||||
return valid.booleanValue();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,291 @@
|
||||
/* RipeMD128.java --
|
||||
Copyright (C) 2001, 2002, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
import gnu.java.security.util.Util;
|
||||
|
||||
/**
|
||||
* <p>RIPEMD-128 is a 128-bit message digest.</p>
|
||||
*
|
||||
* <p>References:</p>
|
||||
*
|
||||
* <ol>
|
||||
* <li><a href="http://www.esat.kuleuven.ac.be/~bosselae/ripemd160.html">
|
||||
* RIPEMD160</a>: A Strengthened Version of RIPEMD.<br>
|
||||
* Hans Dobbertin, Antoon Bosselaers and Bart Preneel.</li>
|
||||
* </ol>
|
||||
*/
|
||||
public class RipeMD128 extends BaseHash
|
||||
{
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private static final int BLOCK_SIZE = 64; // inner block size in bytes
|
||||
|
||||
private static final String DIGEST0 = "CDF26213A150DC3ECB610F18F6B38B46";
|
||||
|
||||
/** Constants for the transform method. */
|
||||
// selection of message word
|
||||
private static final int[] R = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
|
||||
13, 14, 15, 7, 4, 13, 1, 10, 6, 15, 3, 12, 0,
|
||||
9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8,
|
||||
1, 2, 7, 0, 6, 13, 11, 5, 12, 1, 9, 11, 10,
|
||||
0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2 };
|
||||
|
||||
private static final int[] Rp = { 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1,
|
||||
10, 3, 12, 6, 11, 3, 7, 0, 13, 5, 10, 14,
|
||||
15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14,
|
||||
6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 8, 6, 4,
|
||||
1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14 };
|
||||
|
||||
// amount for rotate left (rol)
|
||||
private static final int[] S = { 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15,
|
||||
6, 7, 9, 8, 7, 6, 8, 13, 11, 9, 7, 15, 7, 12,
|
||||
15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9,
|
||||
13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 11, 12,
|
||||
14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5,
|
||||
12 };
|
||||
|
||||
private static final int[] Sp = { 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11,
|
||||
14, 14, 12, 6, 9, 13, 15, 7, 12, 8, 9, 11,
|
||||
7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8,
|
||||
6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 15,
|
||||
5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5,
|
||||
15, 8 };
|
||||
|
||||
/** caches the result of the correctness test, once executed. */
|
||||
private static Boolean valid;
|
||||
|
||||
/** 128-bit h0, h1, h2, h3 (interim result) */
|
||||
private int h0, h1, h2, h3;
|
||||
|
||||
/** 512 bits work buffer = 16 x 32-bit words */
|
||||
private int[] X = new int[16];
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** Trivial 0-arguments constructor. */
|
||||
public RipeMD128()
|
||||
{
|
||||
super(Registry.RIPEMD128_HASH, 16, BLOCK_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Private constructor for cloning purposes.</p>
|
||||
*
|
||||
* @param md the instance to clone.
|
||||
*/
|
||||
private RipeMD128(RipeMD128 md)
|
||||
{
|
||||
this();
|
||||
|
||||
this.h0 = md.h0;
|
||||
this.h1 = md.h1;
|
||||
this.h2 = md.h2;
|
||||
this.h3 = md.h3;
|
||||
this.count = md.count;
|
||||
this.buffer = (byte[]) md.buffer.clone();
|
||||
}
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// java.lang.Cloneable interface implementation ----------------------------
|
||||
|
||||
public Object clone()
|
||||
{
|
||||
return new RipeMD128(this);
|
||||
}
|
||||
|
||||
// Implementation of concrete methods in BaseHash --------------------------
|
||||
|
||||
protected void transform(byte[] in, int offset)
|
||||
{
|
||||
int A, B, C, D, Ap, Bp, Cp, Dp, T, s, i;
|
||||
|
||||
// encode 64 bytes from input block into an array of 16 unsigned
|
||||
// integers.
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
X[i] = (in[offset++] & 0xFF) | (in[offset++] & 0xFF) << 8
|
||||
| (in[offset++] & 0xFF) << 16 | in[offset++] << 24;
|
||||
}
|
||||
|
||||
A = Ap = h0;
|
||||
B = Bp = h1;
|
||||
C = Cp = h2;
|
||||
D = Dp = h3;
|
||||
|
||||
for (i = 0; i < 16; i++)
|
||||
{ // rounds 0...15
|
||||
s = S[i];
|
||||
T = A + (B ^ C ^ D) + X[i];
|
||||
A = D;
|
||||
D = C;
|
||||
C = B;
|
||||
B = T << s | T >>> (32 - s);
|
||||
|
||||
s = Sp[i];
|
||||
T = Ap + ((Bp & Dp) | (Cp & ~Dp)) + X[Rp[i]] + 0x50A28BE6;
|
||||
Ap = Dp;
|
||||
Dp = Cp;
|
||||
Cp = Bp;
|
||||
Bp = T << s | T >>> (32 - s);
|
||||
}
|
||||
|
||||
for (; i < 32; i++)
|
||||
{ // rounds 16...31
|
||||
s = S[i];
|
||||
T = A + ((B & C) | (~B & D)) + X[R[i]] + 0x5A827999;
|
||||
A = D;
|
||||
D = C;
|
||||
C = B;
|
||||
B = T << s | T >>> (32 - s);
|
||||
|
||||
s = Sp[i];
|
||||
T = Ap + ((Bp | ~Cp) ^ Dp) + X[Rp[i]] + 0x5C4DD124;
|
||||
Ap = Dp;
|
||||
Dp = Cp;
|
||||
Cp = Bp;
|
||||
Bp = T << s | T >>> (32 - s);
|
||||
}
|
||||
|
||||
for (; i < 48; i++)
|
||||
{ // rounds 32...47
|
||||
s = S[i];
|
||||
T = A + ((B | ~C) ^ D) + X[R[i]] + 0x6ED9EBA1;
|
||||
A = D;
|
||||
D = C;
|
||||
C = B;
|
||||
B = T << s | T >>> (32 - s);
|
||||
|
||||
s = Sp[i];
|
||||
T = Ap + ((Bp & Cp) | (~Bp & Dp)) + X[Rp[i]] + 0x6D703EF3;
|
||||
Ap = Dp;
|
||||
Dp = Cp;
|
||||
Cp = Bp;
|
||||
Bp = T << s | T >>> (32 - s);
|
||||
}
|
||||
|
||||
for (; i < 64; i++)
|
||||
{ // rounds 48...63
|
||||
s = S[i];
|
||||
T = A + ((B & D) | (C & ~D)) + X[R[i]] + 0x8F1BBCDC;
|
||||
A = D;
|
||||
D = C;
|
||||
C = B;
|
||||
B = T << s | T >>> (32 - s);
|
||||
|
||||
s = Sp[i];
|
||||
T = Ap + (Bp ^ Cp ^ Dp) + X[Rp[i]];
|
||||
Ap = Dp;
|
||||
Dp = Cp;
|
||||
Cp = Bp;
|
||||
Bp = T << s | T >>> (32 - s);
|
||||
}
|
||||
|
||||
T = h1 + C + Dp;
|
||||
h1 = h2 + D + Ap;
|
||||
h2 = h3 + A + Bp;
|
||||
h3 = h0 + B + Cp;
|
||||
h0 = T;
|
||||
}
|
||||
|
||||
protected byte[] padBuffer()
|
||||
{
|
||||
int n = (int) (count % BLOCK_SIZE);
|
||||
int padding = (n < 56) ? (56 - n) : (120 - n);
|
||||
byte[] result = new byte[padding + 8];
|
||||
|
||||
// padding is always binary 1 followed by binary 0s
|
||||
result[0] = (byte) 0x80;
|
||||
|
||||
// save number of bits, casting the long to an array of 8 bytes
|
||||
long bits = count << 3;
|
||||
result[padding++] = (byte) bits;
|
||||
result[padding++] = (byte) (bits >>> 8);
|
||||
result[padding++] = (byte) (bits >>> 16);
|
||||
result[padding++] = (byte) (bits >>> 24);
|
||||
result[padding++] = (byte) (bits >>> 32);
|
||||
result[padding++] = (byte) (bits >>> 40);
|
||||
result[padding++] = (byte) (bits >>> 48);
|
||||
result[padding] = (byte) (bits >>> 56);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected byte[] getResult()
|
||||
{
|
||||
byte[] result = new byte[] { (byte) h0, (byte) (h0 >>> 8),
|
||||
(byte) (h0 >>> 16), (byte) (h0 >>> 24),
|
||||
(byte) h1, (byte) (h1 >>> 8),
|
||||
(byte) (h1 >>> 16), (byte) (h1 >>> 24),
|
||||
(byte) h2, (byte) (h2 >>> 8),
|
||||
(byte) (h2 >>> 16), (byte) (h2 >>> 24),
|
||||
(byte) h3, (byte) (h3 >>> 8),
|
||||
(byte) (h3 >>> 16), (byte) (h3 >>> 24) };
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected void resetContext()
|
||||
{
|
||||
// magic RIPEMD128 initialisation constants
|
||||
h0 = 0x67452301;
|
||||
h1 = 0xEFCDAB89;
|
||||
h2 = 0x98BADCFE;
|
||||
h3 = 0x10325476;
|
||||
}
|
||||
|
||||
public boolean selfTest()
|
||||
{
|
||||
if (valid == null)
|
||||
{
|
||||
valid = new Boolean
|
||||
(DIGEST0.equals(Util.toString(new RipeMD128().digest())));
|
||||
}
|
||||
return valid.booleanValue();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,328 @@
|
||||
/* RipeMD160.java --
|
||||
Copyright (C) 2001, 2002, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
import gnu.java.security.util.Util;
|
||||
|
||||
/**
|
||||
* <p>RIPEMD-160 is a 160-bit message digest.</p>
|
||||
*
|
||||
* <p>References:</p>
|
||||
*
|
||||
* <ol>
|
||||
* <li><a href="http://www.esat.kuleuven.ac.be/~bosselae/ripemd160.html">
|
||||
* RIPEMD160</a>: A Strengthened Version of RIPEMD.<br>
|
||||
* Hans Dobbertin, Antoon Bosselaers and Bart Preneel.</li>
|
||||
* </ol>
|
||||
*/
|
||||
public class RipeMD160 extends BaseHash
|
||||
{
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private static final int BLOCK_SIZE = 64; // inner block size in bytes
|
||||
|
||||
private static final String DIGEST0 = "9C1185A5C5E9FC54612808977EE8F548B2258D31";
|
||||
|
||||
// selection of message word
|
||||
private static final int[] R = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
|
||||
13, 14, 15, 7, 4, 13, 1, 10, 6, 15, 3, 12, 0,
|
||||
9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8,
|
||||
1, 2, 7, 0, 6, 13, 11, 5, 12, 1, 9, 11, 10,
|
||||
0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, 4, 0,
|
||||
5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15,
|
||||
13 };
|
||||
|
||||
private static final int[] Rp = { 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1,
|
||||
10, 3, 12, 6, 11, 3, 7, 0, 13, 5, 10, 14,
|
||||
15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14,
|
||||
6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 8, 6, 4,
|
||||
1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
|
||||
12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0,
|
||||
3, 9, 11 };
|
||||
|
||||
// amount for rotate left (rol)
|
||||
private static final int[] S = { 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15,
|
||||
6, 7, 9, 8, 7, 6, 8, 13, 11, 9, 7, 15, 7, 12,
|
||||
15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9,
|
||||
13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 11, 12,
|
||||
14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5,
|
||||
12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13,
|
||||
14, 11, 8, 5, 6 };
|
||||
|
||||
private static final int[] Sp = { 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11,
|
||||
14, 14, 12, 6, 9, 13, 15, 7, 12, 8, 9, 11,
|
||||
7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8,
|
||||
6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 15,
|
||||
5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5,
|
||||
15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6,
|
||||
5, 15, 13, 11, 11 };
|
||||
|
||||
/** caches the result of the correctness test, once executed. */
|
||||
private static Boolean valid;
|
||||
|
||||
/** 160-bit h0, h1, h2, h3, h4 (interim result) */
|
||||
private int h0, h1, h2, h3, h4;
|
||||
|
||||
/** 512 bits work buffer = 16 x 32-bit words */
|
||||
private int[] X = new int[16];
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** Trivial 0-arguments constructor. */
|
||||
public RipeMD160()
|
||||
{
|
||||
super(Registry.RIPEMD160_HASH, 20, BLOCK_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Private constructor for cloning purposes.</p>
|
||||
*
|
||||
* @param md the instance to clone.
|
||||
*/
|
||||
private RipeMD160(RipeMD160 md)
|
||||
{
|
||||
this();
|
||||
|
||||
this.h0 = md.h0;
|
||||
this.h1 = md.h1;
|
||||
this.h2 = md.h2;
|
||||
this.h3 = md.h3;
|
||||
this.h4 = md.h4;
|
||||
this.count = md.count;
|
||||
this.buffer = (byte[]) md.buffer.clone();
|
||||
}
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// java.lang.Cloneable interface implementation ----------------------------
|
||||
|
||||
public Object clone()
|
||||
{
|
||||
return (new RipeMD160(this));
|
||||
}
|
||||
|
||||
// Implementation of concrete methods in BaseHash --------------------------
|
||||
|
||||
protected void transform(byte[] in, int offset)
|
||||
{
|
||||
int A, B, C, D, E, Ap, Bp, Cp, Dp, Ep, T, s, i;
|
||||
|
||||
// encode 64 bytes from input block into an array of 16 unsigned integers
|
||||
for (i = 0; i < 16; i++)
|
||||
{
|
||||
X[i] = (in[offset++] & 0xFF) | (in[offset++] & 0xFF) << 8
|
||||
| (in[offset++] & 0xFF) << 16 | in[offset++] << 24;
|
||||
}
|
||||
|
||||
A = Ap = h0;
|
||||
B = Bp = h1;
|
||||
C = Cp = h2;
|
||||
D = Dp = h3;
|
||||
E = Ep = h4;
|
||||
|
||||
for (i = 0; i < 16; i++)
|
||||
{ // rounds 0...15
|
||||
s = S[i];
|
||||
T = A + (B ^ C ^ D) + X[i];
|
||||
A = E;
|
||||
E = D;
|
||||
D = C << 10 | C >>> 22;
|
||||
C = B;
|
||||
B = (T << s | T >>> (32 - s)) + A;
|
||||
|
||||
s = Sp[i];
|
||||
T = Ap + (Bp ^ (Cp | ~Dp)) + X[Rp[i]] + 0x50A28BE6;
|
||||
Ap = Ep;
|
||||
Ep = Dp;
|
||||
Dp = Cp << 10 | Cp >>> 22;
|
||||
Cp = Bp;
|
||||
Bp = (T << s | T >>> (32 - s)) + Ap;
|
||||
}
|
||||
|
||||
for (; i < 32; i++)
|
||||
{ // rounds 16...31
|
||||
s = S[i];
|
||||
T = A + ((B & C) | (~B & D)) + X[R[i]] + 0x5A827999;
|
||||
A = E;
|
||||
E = D;
|
||||
D = C << 10 | C >>> 22;
|
||||
C = B;
|
||||
B = (T << s | T >>> (32 - s)) + A;
|
||||
|
||||
s = Sp[i];
|
||||
T = Ap + ((Bp & Dp) | (Cp & ~Dp)) + X[Rp[i]] + 0x5C4DD124;
|
||||
Ap = Ep;
|
||||
Ep = Dp;
|
||||
Dp = Cp << 10 | Cp >>> 22;
|
||||
Cp = Bp;
|
||||
Bp = (T << s | T >>> (32 - s)) + Ap;
|
||||
}
|
||||
|
||||
for (; i < 48; i++)
|
||||
{ // rounds 32...47
|
||||
s = S[i];
|
||||
T = A + ((B | ~C) ^ D) + X[R[i]] + 0x6ED9EBA1;
|
||||
A = E;
|
||||
E = D;
|
||||
D = C << 10 | C >>> 22;
|
||||
C = B;
|
||||
B = (T << s | T >>> (32 - s)) + A;
|
||||
|
||||
s = Sp[i];
|
||||
T = Ap + ((Bp | ~Cp) ^ Dp) + X[Rp[i]] + 0x6D703EF3;
|
||||
Ap = Ep;
|
||||
Ep = Dp;
|
||||
Dp = Cp << 10 | Cp >>> 22;
|
||||
Cp = Bp;
|
||||
Bp = (T << s | T >>> (32 - s)) + Ap;
|
||||
}
|
||||
|
||||
for (; i < 64; i++)
|
||||
{ // rounds 48...63
|
||||
s = S[i];
|
||||
T = A + ((B & D) | (C & ~D)) + X[R[i]] + 0x8F1BBCDC;
|
||||
A = E;
|
||||
E = D;
|
||||
D = C << 10 | C >>> 22;
|
||||
C = B;
|
||||
B = (T << s | T >>> (32 - s)) + A;
|
||||
|
||||
s = Sp[i];
|
||||
T = Ap + ((Bp & Cp) | (~Bp & Dp)) + X[Rp[i]] + 0x7A6D76E9;
|
||||
Ap = Ep;
|
||||
Ep = Dp;
|
||||
Dp = Cp << 10 | Cp >>> 22;
|
||||
Cp = Bp;
|
||||
Bp = (T << s | T >>> (32 - s)) + Ap;
|
||||
}
|
||||
|
||||
for (; i < 80; i++)
|
||||
{ // rounds 64...79
|
||||
s = S[i];
|
||||
T = A + (B ^ (C | ~D)) + X[R[i]] + 0xA953FD4E;
|
||||
A = E;
|
||||
E = D;
|
||||
D = C << 10 | C >>> 22;
|
||||
C = B;
|
||||
B = (T << s | T >>> (32 - s)) + A;
|
||||
|
||||
s = Sp[i];
|
||||
T = Ap + (Bp ^ Cp ^ Dp) + X[Rp[i]];
|
||||
Ap = Ep;
|
||||
Ep = Dp;
|
||||
Dp = Cp << 10 | Cp >>> 22;
|
||||
Cp = Bp;
|
||||
Bp = (T << s | T >>> (32 - s)) + Ap;
|
||||
}
|
||||
|
||||
T = h1 + C + Dp;
|
||||
h1 = h2 + D + Ep;
|
||||
h2 = h3 + E + Ap;
|
||||
h3 = h4 + A + Bp;
|
||||
h4 = h0 + B + Cp;
|
||||
h0 = T;
|
||||
}
|
||||
|
||||
protected byte[] padBuffer()
|
||||
{
|
||||
int n = (int) (count % BLOCK_SIZE);
|
||||
int padding = (n < 56) ? (56 - n) : (120 - n);
|
||||
byte[] result = new byte[padding + 8];
|
||||
|
||||
// padding is always binary 1 followed by binary 0s
|
||||
result[0] = (byte) 0x80;
|
||||
|
||||
// save number of bits, casting the long to an array of 8 bytes
|
||||
long bits = count << 3;
|
||||
result[padding++] = (byte) bits;
|
||||
result[padding++] = (byte) (bits >>> 8);
|
||||
result[padding++] = (byte) (bits >>> 16);
|
||||
result[padding++] = (byte) (bits >>> 24);
|
||||
result[padding++] = (byte) (bits >>> 32);
|
||||
result[padding++] = (byte) (bits >>> 40);
|
||||
result[padding++] = (byte) (bits >>> 48);
|
||||
result[padding] = (byte) (bits >>> 56);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected byte[] getResult()
|
||||
{
|
||||
byte[] result = new byte[] { (byte) h0, (byte) (h0 >>> 8),
|
||||
(byte) (h0 >>> 16), (byte) (h0 >>> 24),
|
||||
(byte) h1, (byte) (h1 >>> 8),
|
||||
(byte) (h1 >>> 16), (byte) (h1 >>> 24),
|
||||
(byte) h2, (byte) (h2 >>> 8),
|
||||
(byte) (h2 >>> 16), (byte) (h2 >>> 24),
|
||||
(byte) h3, (byte) (h3 >>> 8),
|
||||
(byte) (h3 >>> 16), (byte) (h3 >>> 24),
|
||||
(byte) h4, (byte) (h4 >>> 8),
|
||||
(byte) (h4 >>> 16), (byte) (h4 >>> 24) };
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected void resetContext()
|
||||
{
|
||||
// magic RIPEMD160 initialisation constants
|
||||
h0 = 0x67452301;
|
||||
h1 = 0xEFCDAB89;
|
||||
h2 = 0x98BADCFE;
|
||||
h3 = 0x10325476;
|
||||
h4 = 0xC3D2E1F0;
|
||||
}
|
||||
|
||||
public boolean selfTest()
|
||||
{
|
||||
if (valid == null)
|
||||
{
|
||||
valid = new Boolean
|
||||
(DIGEST0.equals(Util.toString(new RipeMD160().digest())));
|
||||
}
|
||||
return valid.booleanValue();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,308 @@
|
||||
/* Sha160.java --
|
||||
Copyright (C) 2001, 2002, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
import gnu.java.security.util.Util;
|
||||
|
||||
/**
|
||||
* <p>The Secure Hash Algorithm (SHA-1) is required for use with the Digital
|
||||
* Signature Algorithm (DSA) as specified in the Digital Signature Standard
|
||||
* (DSS) and whenever a secure hash algorithm is required for federal
|
||||
* applications. For a message of length less than 2^64 bits, the SHA-1
|
||||
* produces a 160-bit condensed representation of the message called a message
|
||||
* digest. The message digest is used during generation of a signature for the
|
||||
* message. The SHA-1 is also used to compute a message digest for the received
|
||||
* version of the message during the process of verifying the signature. Any
|
||||
* change to the message in transit will, with very high probability, result in
|
||||
* a different message digest, and the signature will fail to verify.</p>
|
||||
*
|
||||
* <p>The SHA-1 is designed to have the following properties: it is
|
||||
* computationally infeasible to find a message which corresponds to a given
|
||||
* message digest, or to find two different messages which produce the same
|
||||
* message digest.</p>
|
||||
*
|
||||
* <p>References:</p>
|
||||
*
|
||||
* <ol>
|
||||
* <li><a href="http://www.itl.nist.gov/fipspubs/fip180-1.htm">SECURE HASH
|
||||
* STANDARD</a><br>
|
||||
* Federal Information, Processing Standards Publication 180-1, 1995 April 17.
|
||||
* </li>
|
||||
* </ol>
|
||||
*/
|
||||
public class Sha160 extends BaseHash
|
||||
{
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private static final int BLOCK_SIZE = 64; // inner block size in bytes
|
||||
|
||||
private static final String DIGEST0 = "A9993E364706816ABA3E25717850C26C9CD0D89D";
|
||||
|
||||
private static final int[] w = new int[80];
|
||||
|
||||
/** caches the result of the correctness test, once executed. */
|
||||
private static Boolean valid;
|
||||
|
||||
/** 160-bit interim result. */
|
||||
private int h0, h1, h2, h3, h4;
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** Trivial 0-arguments constructor. */
|
||||
public Sha160()
|
||||
{
|
||||
super(Registry.SHA160_HASH, 20, BLOCK_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Private constructor for cloning purposes.</p>
|
||||
*
|
||||
* @param md the instance to clone.
|
||||
*/
|
||||
private Sha160(Sha160 md)
|
||||
{
|
||||
this();
|
||||
|
||||
this.h0 = md.h0;
|
||||
this.h1 = md.h1;
|
||||
this.h2 = md.h2;
|
||||
this.h3 = md.h3;
|
||||
this.h4 = md.h4;
|
||||
this.count = md.count;
|
||||
this.buffer = (byte[]) md.buffer.clone();
|
||||
}
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
public static final int[] G(int hh0, int hh1, int hh2, int hh3, int hh4,
|
||||
byte[] in, int offset)
|
||||
{
|
||||
// int[] w = new int[80];
|
||||
// int i, T;
|
||||
// for (i = 0; i < 16; i++) {
|
||||
// w[i] = in[offset++] << 24 |
|
||||
// (in[offset++] & 0xFF) << 16 |
|
||||
// (in[offset++] & 0xFF) << 8 |
|
||||
// (in[offset++] & 0xFF);
|
||||
// }
|
||||
// for (i = 16; i < 80; i++) {
|
||||
// T = w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16];
|
||||
// w[i] = T << 1 | T >>> 31;
|
||||
// }
|
||||
|
||||
// return sha(hh0, hh1, hh2, hh3, hh4, in, offset, w);
|
||||
return sha(hh0, hh1, hh2, hh3, hh4, in, offset);
|
||||
}
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// java.lang.Cloneable interface implementation ----------------------------
|
||||
|
||||
public Object clone()
|
||||
{
|
||||
return new Sha160(this);
|
||||
}
|
||||
|
||||
// Implementation of concrete methods in BaseHash --------------------------
|
||||
|
||||
protected void transform(byte[] in, int offset)
|
||||
{
|
||||
// int i, T;
|
||||
// for (i = 0; i < 16; i++) {
|
||||
// W[i] = in[offset++] << 24 |
|
||||
// (in[offset++] & 0xFF) << 16 |
|
||||
// (in[offset++] & 0xFF) << 8 |
|
||||
// (in[offset++] & 0xFF);
|
||||
// }
|
||||
// for (i = 16; i < 80; i++) {
|
||||
// T = W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16];
|
||||
// W[i] = T << 1 | T >>> 31;
|
||||
// }
|
||||
|
||||
// int[] result = sha(h0, h1, h2, h3, h4, in, offset, W);
|
||||
int[] result = sha(h0, h1, h2, h3, h4, in, offset);
|
||||
|
||||
h0 = result[0];
|
||||
h1 = result[1];
|
||||
h2 = result[2];
|
||||
h3 = result[3];
|
||||
h4 = result[4];
|
||||
}
|
||||
|
||||
protected byte[] padBuffer()
|
||||
{
|
||||
int n = (int) (count % BLOCK_SIZE);
|
||||
int padding = (n < 56) ? (56 - n) : (120 - n);
|
||||
byte[] result = new byte[padding + 8];
|
||||
|
||||
// padding is always binary 1 followed by binary 0s
|
||||
result[0] = (byte) 0x80;
|
||||
|
||||
// save number of bits, casting the long to an array of 8 bytes
|
||||
long bits = count << 3;
|
||||
result[padding++] = (byte) (bits >>> 56);
|
||||
result[padding++] = (byte) (bits >>> 48);
|
||||
result[padding++] = (byte) (bits >>> 40);
|
||||
result[padding++] = (byte) (bits >>> 32);
|
||||
result[padding++] = (byte) (bits >>> 24);
|
||||
result[padding++] = (byte) (bits >>> 16);
|
||||
result[padding++] = (byte) (bits >>> 8);
|
||||
result[padding] = (byte) bits;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected byte[] getResult()
|
||||
{
|
||||
byte[] result = new byte[] { (byte) (h0 >>> 24), (byte) (h0 >>> 16),
|
||||
(byte) (h0 >>> 8), (byte) h0,
|
||||
(byte) (h1 >>> 24), (byte) (h1 >>> 16),
|
||||
(byte) (h1 >>> 8), (byte) h1,
|
||||
(byte) (h2 >>> 24), (byte) (h2 >>> 16),
|
||||
(byte) (h2 >>> 8), (byte) h2,
|
||||
(byte) (h3 >>> 24), (byte) (h3 >>> 16),
|
||||
(byte) (h3 >>> 8), (byte) h3,
|
||||
(byte) (h4 >>> 24), (byte) (h4 >>> 16),
|
||||
(byte) (h4 >>> 8), (byte) h4 };
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected void resetContext()
|
||||
{
|
||||
// magic SHA-1/RIPEMD160 initialisation constants
|
||||
h0 = 0x67452301;
|
||||
h1 = 0xEFCDAB89;
|
||||
h2 = 0x98BADCFE;
|
||||
h3 = 0x10325476;
|
||||
h4 = 0xC3D2E1F0;
|
||||
}
|
||||
|
||||
public boolean selfTest()
|
||||
{
|
||||
if (valid == null)
|
||||
{
|
||||
Sha160 md = new Sha160();
|
||||
md.update((byte) 0x61); // a
|
||||
md.update((byte) 0x62); // b
|
||||
md.update((byte) 0x63); // c
|
||||
String result = Util.toString(md.digest());
|
||||
valid = new Boolean(DIGEST0.equals(result));
|
||||
}
|
||||
return valid.booleanValue();
|
||||
}
|
||||
|
||||
// SHA specific methods ----------------------------------------------------
|
||||
|
||||
private static final synchronized int[]
|
||||
// sha(int hh0, int hh1, int hh2, int hh3, int hh4, byte[] in, int offset, int[] w) {
|
||||
sha(int hh0, int hh1, int hh2, int hh3, int hh4, byte[] in, int offset)
|
||||
{
|
||||
int A = hh0;
|
||||
int B = hh1;
|
||||
int C = hh2;
|
||||
int D = hh3;
|
||||
int E = hh4;
|
||||
int r, T;
|
||||
|
||||
for (r = 0; r < 16; r++)
|
||||
{
|
||||
w[r] = in[offset++] << 24 | (in[offset++] & 0xFF) << 16
|
||||
| (in[offset++] & 0xFF) << 8 | (in[offset++] & 0xFF);
|
||||
}
|
||||
for (r = 16; r < 80; r++)
|
||||
{
|
||||
T = w[r - 3] ^ w[r - 8] ^ w[r - 14] ^ w[r - 16];
|
||||
w[r] = T << 1 | T >>> 31;
|
||||
}
|
||||
|
||||
// rounds 0-19
|
||||
for (r = 0; r < 20; r++)
|
||||
{
|
||||
T = (A << 5 | A >>> 27) + ((B & C) | (~B & D)) + E + w[r] + 0x5A827999;
|
||||
E = D;
|
||||
D = C;
|
||||
C = B << 30 | B >>> 2;
|
||||
B = A;
|
||||
A = T;
|
||||
}
|
||||
|
||||
// rounds 20-39
|
||||
for (r = 20; r < 40; r++)
|
||||
{
|
||||
T = (A << 5 | A >>> 27) + (B ^ C ^ D) + E + w[r] + 0x6ED9EBA1;
|
||||
E = D;
|
||||
D = C;
|
||||
C = B << 30 | B >>> 2;
|
||||
B = A;
|
||||
A = T;
|
||||
}
|
||||
|
||||
// rounds 40-59
|
||||
for (r = 40; r < 60; r++)
|
||||
{
|
||||
T = (A << 5 | A >>> 27) + (B & C | B & D | C & D) + E + w[r]
|
||||
+ 0x8F1BBCDC;
|
||||
E = D;
|
||||
D = C;
|
||||
C = B << 30 | B >>> 2;
|
||||
B = A;
|
||||
A = T;
|
||||
}
|
||||
|
||||
// rounds 60-79
|
||||
for (r = 60; r < 80; r++)
|
||||
{
|
||||
T = (A << 5 | A >>> 27) + (B ^ C ^ D) + E + w[r] + 0xCA62C1D6;
|
||||
E = D;
|
||||
D = C;
|
||||
C = B << 30 | B >>> 2;
|
||||
B = A;
|
||||
A = T;
|
||||
}
|
||||
|
||||
return new int[] { hh0 + A, hh1 + B, hh2 + C, hh3 + D, hh4 + E };
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,278 @@
|
||||
/* Sha256.java --
|
||||
Copyright (C) 2003, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
import gnu.java.security.util.Util;
|
||||
|
||||
/**
|
||||
* <p>Implementation of SHA2-1 [SHA-256] per the IETF Draft Specification.</p>
|
||||
*
|
||||
* <p>References:</p>
|
||||
* <ol>
|
||||
* <li><a href="http://ftp.ipv4.heanet.ie/pub/ietf/internet-drafts/draft-ietf-ipsec-ciph-aes-cbc-03.txt">
|
||||
* Descriptions of SHA-256, SHA-384, and SHA-512</a>,</li>
|
||||
* <li>http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf</li>
|
||||
* </ol>
|
||||
*/
|
||||
public class Sha256 extends BaseHash
|
||||
{
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
private static final int[] k = { 0x428a2f98, 0x71374491, 0xb5c0fbcf,
|
||||
0xe9b5dba5, 0x3956c25b, 0x59f111f1,
|
||||
0x923f82a4, 0xab1c5ed5, 0xd807aa98,
|
||||
0x12835b01, 0x243185be, 0x550c7dc3,
|
||||
0x72be5d74, 0x80deb1fe, 0x9bdc06a7,
|
||||
0xc19bf174, 0xe49b69c1, 0xefbe4786,
|
||||
0x0fc19dc6, 0x240ca1cc, 0x2de92c6f,
|
||||
0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
|
||||
0x983e5152, 0xa831c66d, 0xb00327c8,
|
||||
0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
|
||||
0x06ca6351, 0x14292967, 0x27b70a85,
|
||||
0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
|
||||
0x650a7354, 0x766a0abb, 0x81c2c92e,
|
||||
0x92722c85, 0xa2bfe8a1, 0xa81a664b,
|
||||
0xc24b8b70, 0xc76c51a3, 0xd192e819,
|
||||
0xd6990624, 0xf40e3585, 0x106aa070,
|
||||
0x19a4c116, 0x1e376c08, 0x2748774c,
|
||||
0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
|
||||
0x5b9cca4f, 0x682e6ff3, 0x748f82ee,
|
||||
0x78a5636f, 0x84c87814, 0x8cc70208,
|
||||
0x90befffa, 0xa4506ceb, 0xbef9a3f7,
|
||||
0xc67178f2 };
|
||||
|
||||
private static final int BLOCK_SIZE = 64; // inner block size in bytes
|
||||
|
||||
private static final String DIGEST0 = "BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD";
|
||||
|
||||
private static final int[] w = new int[64];
|
||||
|
||||
/** caches the result of the correctness test, once executed. */
|
||||
private static Boolean valid;
|
||||
|
||||
/** 256-bit interim result. */
|
||||
private int h0, h1, h2, h3, h4, h5, h6, h7;
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** Trivial 0-arguments constructor. */
|
||||
public Sha256()
|
||||
{
|
||||
super(Registry.SHA256_HASH, 32, BLOCK_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Private constructor for cloning purposes.</p>
|
||||
*
|
||||
* @param md the instance to clone.
|
||||
*/
|
||||
private Sha256(Sha256 md)
|
||||
{
|
||||
this();
|
||||
|
||||
this.h0 = md.h0;
|
||||
this.h1 = md.h1;
|
||||
this.h2 = md.h2;
|
||||
this.h3 = md.h3;
|
||||
this.h4 = md.h4;
|
||||
this.h5 = md.h5;
|
||||
this.h6 = md.h6;
|
||||
this.h7 = md.h7;
|
||||
this.count = md.count;
|
||||
this.buffer = (byte[]) md.buffer.clone();
|
||||
}
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
public static final int[] G(int hh0, int hh1, int hh2, int hh3, int hh4,
|
||||
int hh5, int hh6, int hh7, byte[] in, int offset)
|
||||
{
|
||||
return sha(hh0, hh1, hh2, hh3, hh4, hh5, hh6, hh7, in, offset);
|
||||
}
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// java.lang.Cloneable interface implementation ----------------------------
|
||||
|
||||
public Object clone()
|
||||
{
|
||||
return new Sha256(this);
|
||||
}
|
||||
|
||||
// Implementation of concrete methods in BaseHash --------------------------
|
||||
|
||||
protected void transform(byte[] in, int offset)
|
||||
{
|
||||
int[] result = sha(h0, h1, h2, h3, h4, h5, h6, h7, in, offset);
|
||||
|
||||
h0 = result[0];
|
||||
h1 = result[1];
|
||||
h2 = result[2];
|
||||
h3 = result[3];
|
||||
h4 = result[4];
|
||||
h5 = result[5];
|
||||
h6 = result[6];
|
||||
h7 = result[7];
|
||||
}
|
||||
|
||||
protected byte[] padBuffer()
|
||||
{
|
||||
int n = (int) (count % BLOCK_SIZE);
|
||||
int padding = (n < 56) ? (56 - n) : (120 - n);
|
||||
byte[] result = new byte[padding + 8];
|
||||
|
||||
// padding is always binary 1 followed by binary 0s
|
||||
result[0] = (byte) 0x80;
|
||||
|
||||
// save number of bits, casting the long to an array of 8 bytes
|
||||
long bits = count << 3;
|
||||
result[padding++] = (byte) (bits >>> 56);
|
||||
result[padding++] = (byte) (bits >>> 48);
|
||||
result[padding++] = (byte) (bits >>> 40);
|
||||
result[padding++] = (byte) (bits >>> 32);
|
||||
result[padding++] = (byte) (bits >>> 24);
|
||||
result[padding++] = (byte) (bits >>> 16);
|
||||
result[padding++] = (byte) (bits >>> 8);
|
||||
result[padding] = (byte) bits;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected byte[] getResult()
|
||||
{
|
||||
return new byte[] { (byte) (h0 >>> 24), (byte) (h0 >>> 16),
|
||||
(byte) (h0 >>> 8), (byte) h0, (byte) (h1 >>> 24),
|
||||
(byte) (h1 >>> 16), (byte) (h1 >>> 8), (byte) h1,
|
||||
(byte) (h2 >>> 24), (byte) (h2 >>> 16),
|
||||
(byte) (h2 >>> 8), (byte) h2, (byte) (h3 >>> 24),
|
||||
(byte) (h3 >>> 16), (byte) (h3 >>> 8), (byte) h3,
|
||||
(byte) (h4 >>> 24), (byte) (h4 >>> 16),
|
||||
(byte) (h4 >>> 8), (byte) h4, (byte) (h5 >>> 24),
|
||||
(byte) (h5 >>> 16), (byte) (h5 >>> 8), (byte) h5,
|
||||
(byte) (h6 >>> 24), (byte) (h6 >>> 16),
|
||||
(byte) (h6 >>> 8), (byte) h6, (byte) (h7 >>> 24),
|
||||
(byte) (h7 >>> 16), (byte) (h7 >>> 8), (byte) h7 };
|
||||
}
|
||||
|
||||
protected void resetContext()
|
||||
{
|
||||
// magic SHA-256 initialisation constants
|
||||
h0 = 0x6a09e667;
|
||||
h1 = 0xbb67ae85;
|
||||
h2 = 0x3c6ef372;
|
||||
h3 = 0xa54ff53a;
|
||||
h4 = 0x510e527f;
|
||||
h5 = 0x9b05688c;
|
||||
h6 = 0x1f83d9ab;
|
||||
h7 = 0x5be0cd19;
|
||||
}
|
||||
|
||||
public boolean selfTest()
|
||||
{
|
||||
if (valid == null)
|
||||
{
|
||||
Sha256 md = new Sha256();
|
||||
md.update((byte) 0x61); // a
|
||||
md.update((byte) 0x62); // b
|
||||
md.update((byte) 0x63); // c
|
||||
String result = Util.toString(md.digest());
|
||||
valid = new Boolean(DIGEST0.equals(result));
|
||||
}
|
||||
|
||||
return valid.booleanValue();
|
||||
}
|
||||
|
||||
// SHA specific methods ----------------------------------------------------
|
||||
|
||||
private static final synchronized int[] sha(int hh0, int hh1, int hh2,
|
||||
int hh3, int hh4, int hh5,
|
||||
int hh6, int hh7, byte[] in,
|
||||
int offset)
|
||||
{
|
||||
int A = hh0;
|
||||
int B = hh1;
|
||||
int C = hh2;
|
||||
int D = hh3;
|
||||
int E = hh4;
|
||||
int F = hh5;
|
||||
int G = hh6;
|
||||
int H = hh7;
|
||||
int r, T, T2;
|
||||
|
||||
for (r = 0; r < 16; r++)
|
||||
{
|
||||
w[r] = (in[offset++] << 24 | (in[offset++] & 0xFF) << 16
|
||||
| (in[offset++] & 0xFF) << 8 | (in[offset++] & 0xFF));
|
||||
}
|
||||
for (r = 16; r < 64; r++)
|
||||
{
|
||||
T = w[r - 2];
|
||||
T2 = w[r - 15];
|
||||
w[r] = ((((T >>> 17) | (T << 15)) ^ ((T >>> 19) | (T << 13)) ^ (T >>> 10))
|
||||
+ w[r - 7]
|
||||
+ (((T2 >>> 7) | (T2 << 25)) ^ ((T2 >>> 18) | (T2 << 14)) ^ (T2 >>> 3))
|
||||
+ w[r - 16]);
|
||||
}
|
||||
|
||||
for (r = 0; r < 64; r++)
|
||||
{
|
||||
T = (H
|
||||
+ (((E >>> 6) | (E << 26)) ^ ((E >>> 11) | (E << 21)) ^ ((E >>> 25) | (E << 7)))
|
||||
+ ((E & F) ^ (~E & G)) + k[r] + w[r]);
|
||||
T2 = ((((A >>> 2) | (A << 30)) ^ ((A >>> 13) | (A << 19)) ^ ((A >>> 22) | (A << 10)))
|
||||
+ ((A & B) ^ (A & C) ^ (B & C)));
|
||||
H = G;
|
||||
G = F;
|
||||
F = E;
|
||||
E = D + T;
|
||||
D = C;
|
||||
C = B;
|
||||
B = A;
|
||||
A = T + T2;
|
||||
}
|
||||
|
||||
return new int[] { hh0 + A, hh1 + B, hh2 + C, hh3 + D, hh4 + E, hh5 + F,
|
||||
hh6 + G, hh7 + H };
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,322 @@
|
||||
/* Sha384.java --
|
||||
Copyright (C) 2003, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
import gnu.java.security.util.Util;
|
||||
|
||||
/**
|
||||
* <p>Implementation of SHA2-2 [SHA-384] per the IETF Draft Specification.</p>
|
||||
*
|
||||
* <p>References:</p>
|
||||
* <ol>
|
||||
* <li><a href="http://ftp.ipv4.heanet.ie/pub/ietf/internet-drafts/draft-ietf-ipsec-ciph-aes-cbc-03.txt">
|
||||
* Descriptions of SHA-256, SHA-384, and SHA-512</a>,</li>
|
||||
* <li>http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf</li>
|
||||
* </ol>
|
||||
*/
|
||||
public class Sha384 extends BaseHash
|
||||
{
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private static final long[] k = { 0x428a2f98d728ae22L, 0x7137449123ef65cdL,
|
||||
0xb5c0fbcfec4d3b2fL, 0xe9b5dba58189dbbcL,
|
||||
0x3956c25bf348b538L, 0x59f111f1b605d019L,
|
||||
0x923f82a4af194f9bL, 0xab1c5ed5da6d8118L,
|
||||
0xd807aa98a3030242L, 0x12835b0145706fbeL,
|
||||
0x243185be4ee4b28cL, 0x550c7dc3d5ffb4e2L,
|
||||
0x72be5d74f27b896fL, 0x80deb1fe3b1696b1L,
|
||||
0x9bdc06a725c71235L, 0xc19bf174cf692694L,
|
||||
0xe49b69c19ef14ad2L, 0xefbe4786384f25e3L,
|
||||
0x0fc19dc68b8cd5b5L, 0x240ca1cc77ac9c65L,
|
||||
0x2de92c6f592b0275L, 0x4a7484aa6ea6e483L,
|
||||
0x5cb0a9dcbd41fbd4L, 0x76f988da831153b5L,
|
||||
0x983e5152ee66dfabL, 0xa831c66d2db43210L,
|
||||
0xb00327c898fb213fL, 0xbf597fc7beef0ee4L,
|
||||
0xc6e00bf33da88fc2L, 0xd5a79147930aa725L,
|
||||
0x06ca6351e003826fL, 0x142929670a0e6e70L,
|
||||
0x27b70a8546d22ffcL, 0x2e1b21385c26c926L,
|
||||
0x4d2c6dfc5ac42aedL, 0x53380d139d95b3dfL,
|
||||
0x650a73548baf63deL, 0x766a0abb3c77b2a8L,
|
||||
0x81c2c92e47edaee6L, 0x92722c851482353bL,
|
||||
0xa2bfe8a14cf10364L, 0xa81a664bbc423001L,
|
||||
0xc24b8b70d0f89791L, 0xc76c51a30654be30L,
|
||||
0xd192e819d6ef5218L, 0xd69906245565a910L,
|
||||
0xf40e35855771202aL, 0x106aa07032bbd1b8L,
|
||||
0x19a4c116b8d2d0c8L, 0x1e376c085141ab53L,
|
||||
0x2748774cdf8eeb99L, 0x34b0bcb5e19b48a8L,
|
||||
0x391c0cb3c5c95a63L, 0x4ed8aa4ae3418acbL,
|
||||
0x5b9cca4f7763e373L, 0x682e6ff3d6b2b8a3L,
|
||||
0x748f82ee5defb2fcL, 0x78a5636f43172f60L,
|
||||
0x84c87814a1f0ab72L, 0x8cc702081a6439ecL,
|
||||
0x90befffa23631e28L, 0xa4506cebde82bde9L,
|
||||
0xbef9a3f7b2c67915L, 0xc67178f2e372532bL,
|
||||
0xca273eceea26619cL, 0xd186b8c721c0c207L,
|
||||
0xeada7dd6cde0eb1eL, 0xf57d4f7fee6ed178L,
|
||||
0x06f067aa72176fbaL, 0x0a637dc5a2c898a6L,
|
||||
0x113f9804bef90daeL, 0x1b710b35131c471bL,
|
||||
0x28db77f523047d84L, 0x32caab7b40c72493L,
|
||||
0x3c9ebe0a15c9bebcL, 0x431d67c49c100d4cL,
|
||||
0x4cc5d4becb3e42b6L, 0x597f299cfc657e2aL,
|
||||
0x5fcb6fab3ad6faecL, 0x6c44198c4a475817L };
|
||||
|
||||
private static final int BLOCK_SIZE = 128; // inner block size in bytes
|
||||
|
||||
private static final String DIGEST0 = "CB00753F45A35E8BB5A03D699AC65007272C32AB0EDED1631A8B605A43FF5BED"
|
||||
+ "8086072BA1E7CC2358BAECA134C825A7";
|
||||
|
||||
private static final long[] w = new long[80];
|
||||
|
||||
/** caches the result of the correctness test, once executed. */
|
||||
private static Boolean valid;
|
||||
|
||||
/** 512-bit interim result. */
|
||||
private long h0, h1, h2, h3, h4, h5, h6, h7;
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** Trivial 0-arguments constructor. */
|
||||
public Sha384()
|
||||
{
|
||||
super(Registry.SHA384_HASH, 48, BLOCK_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Private constructor for cloning purposes.</p>
|
||||
*
|
||||
* @param md the instance to clone.
|
||||
*/
|
||||
private Sha384(Sha384 md)
|
||||
{
|
||||
this();
|
||||
|
||||
this.h0 = md.h0;
|
||||
this.h1 = md.h1;
|
||||
this.h2 = md.h2;
|
||||
this.h3 = md.h3;
|
||||
this.h4 = md.h4;
|
||||
this.h5 = md.h5;
|
||||
this.h6 = md.h6;
|
||||
this.h7 = md.h7;
|
||||
this.count = md.count;
|
||||
this.buffer = (byte[]) md.buffer.clone();
|
||||
}
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
public static final long[] G(long hh0, long hh1, long hh2, long hh3,
|
||||
long hh4, long hh5, long hh6, long hh7,
|
||||
byte[] in, int offset)
|
||||
{
|
||||
return sha(hh0, hh1, hh2, hh3, hh4, hh5, hh6, hh7, in, offset);
|
||||
}
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// java.lang.Cloneable interface implementation ----------------------------
|
||||
|
||||
public Object clone()
|
||||
{
|
||||
return new Sha384(this);
|
||||
}
|
||||
|
||||
// Implementation of concrete methods in BaseHash --------------------------
|
||||
|
||||
protected void transform(byte[] in, int offset)
|
||||
{
|
||||
long[] result = sha(h0, h1, h2, h3, h4, h5, h6, h7, in, offset);
|
||||
|
||||
h0 = result[0];
|
||||
h1 = result[1];
|
||||
h2 = result[2];
|
||||
h3 = result[3];
|
||||
h4 = result[4];
|
||||
h5 = result[5];
|
||||
h6 = result[6];
|
||||
h7 = result[7];
|
||||
}
|
||||
|
||||
protected byte[] padBuffer()
|
||||
{
|
||||
int n = (int) (count % BLOCK_SIZE);
|
||||
int padding = (n < 112) ? (112 - n) : (240 - n);
|
||||
byte[] result = new byte[padding + 16];
|
||||
|
||||
// padding is always binary 1 followed by binary 0s
|
||||
result[0] = (byte) 0x80;
|
||||
|
||||
// save number of bits, casting the long to an array of 8 bytes
|
||||
// TODO: FIX Only ~35 bits of 128 bit counter usable this way
|
||||
long bits = count << 3;
|
||||
padding += 8;
|
||||
result[padding++] = (byte) (bits >>> 56);
|
||||
result[padding++] = (byte) (bits >>> 48);
|
||||
result[padding++] = (byte) (bits >>> 40);
|
||||
result[padding++] = (byte) (bits >>> 32);
|
||||
result[padding++] = (byte) (bits >>> 24);
|
||||
result[padding++] = (byte) (bits >>> 16);
|
||||
result[padding++] = (byte) (bits >>> 8);
|
||||
result[padding] = (byte) bits;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected byte[] getResult()
|
||||
{
|
||||
return new byte[] { (byte) (h0 >>> 56), (byte) (h0 >>> 48),
|
||||
(byte) (h0 >>> 40), (byte) (h0 >>> 32),
|
||||
(byte) (h0 >>> 24), (byte) (h0 >>> 16),
|
||||
(byte) (h0 >>> 8), (byte) h0, (byte) (h1 >>> 56),
|
||||
(byte) (h1 >>> 48), (byte) (h1 >>> 40),
|
||||
(byte) (h1 >>> 32), (byte) (h1 >>> 24),
|
||||
(byte) (h1 >>> 16), (byte) (h1 >>> 8), (byte) h1,
|
||||
(byte) (h2 >>> 56), (byte) (h2 >>> 48),
|
||||
(byte) (h2 >>> 40), (byte) (h2 >>> 32),
|
||||
(byte) (h2 >>> 24), (byte) (h2 >>> 16),
|
||||
(byte) (h2 >>> 8), (byte) h2, (byte) (h3 >>> 56),
|
||||
(byte) (h3 >>> 48), (byte) (h3 >>> 40),
|
||||
(byte) (h3 >>> 32), (byte) (h3 >>> 24),
|
||||
(byte) (h3 >>> 16), (byte) (h3 >>> 8), (byte) h3,
|
||||
(byte) (h4 >>> 56), (byte) (h4 >>> 48),
|
||||
(byte) (h4 >>> 40), (byte) (h4 >>> 32),
|
||||
(byte) (h4 >>> 24), (byte) (h4 >>> 16),
|
||||
(byte) (h4 >>> 8), (byte) h4, (byte) (h5 >>> 56),
|
||||
(byte) (h5 >>> 48), (byte) (h5 >>> 40),
|
||||
(byte) (h5 >>> 32), (byte) (h5 >>> 24),
|
||||
(byte) (h5 >>> 16), (byte) (h5 >>> 8), (byte) h5
|
||||
// (byte)(h6 >>> 56), (byte)(h6 >>> 48), (byte)(h6 >>> 40), (byte)(h6 >>> 32),
|
||||
// (byte)(h6 >>> 24), (byte)(h6 >>> 16), (byte)(h6 >>> 8), (byte) h6,
|
||||
// (byte)(h7 >>> 56), (byte)(h7 >>> 48), (byte)(h7 >>> 40), (byte)(h7 >>> 32),
|
||||
// (byte)(h7 >>> 24), (byte)(h7 >>> 16), (byte)(h7 >>> 8), (byte) h7
|
||||
};
|
||||
}
|
||||
|
||||
protected void resetContext()
|
||||
{
|
||||
// magic SHA-384 initialisation constants
|
||||
h0 = 0xcbbb9d5dc1059ed8L;
|
||||
h1 = 0x629a292a367cd507L;
|
||||
h2 = 0x9159015a3070dd17L;
|
||||
h3 = 0x152fecd8f70e5939L;
|
||||
h4 = 0x67332667ffc00b31L;
|
||||
h5 = 0x8eb44a8768581511L;
|
||||
h6 = 0xdb0c2e0d64f98fa7L;
|
||||
h7 = 0x47b5481dbefa4fa4L;
|
||||
}
|
||||
|
||||
public boolean selfTest()
|
||||
{
|
||||
if (valid == null)
|
||||
{
|
||||
Sha384 md = new Sha384();
|
||||
md.update((byte) 0x61); // a
|
||||
md.update((byte) 0x62); // b
|
||||
md.update((byte) 0x63); // c
|
||||
String result = Util.toString(md.digest());
|
||||
valid = new Boolean(DIGEST0.equals(result));
|
||||
}
|
||||
return valid.booleanValue();
|
||||
}
|
||||
|
||||
// SHA specific methods ----------------------------------------------------
|
||||
|
||||
private static final synchronized long[] sha(long hh0, long hh1, long hh2,
|
||||
long hh3, long hh4, long hh5,
|
||||
long hh6, long hh7, byte[] in,
|
||||
int offset)
|
||||
{
|
||||
long A = hh0;
|
||||
long B = hh1;
|
||||
long C = hh2;
|
||||
long D = hh3;
|
||||
long E = hh4;
|
||||
long F = hh5;
|
||||
long G = hh6;
|
||||
long H = hh7;
|
||||
long T, T2;
|
||||
int r;
|
||||
|
||||
for (r = 0; r < 16; r++)
|
||||
{
|
||||
w[r] = (long) in[offset++] << 56 | ((long) in[offset++] & 0xFF) << 48
|
||||
| ((long) in[offset++] & 0xFF) << 40
|
||||
| ((long) in[offset++] & 0xFF) << 32
|
||||
| ((long) in[offset++] & 0xFF) << 24
|
||||
| ((long) in[offset++] & 0xFF) << 16
|
||||
| ((long) in[offset++] & 0xFF) << 8
|
||||
| ((long) in[offset++] & 0xFF);
|
||||
}
|
||||
for (r = 16; r < 80; r++)
|
||||
{
|
||||
T = w[r - 2];
|
||||
T2 = w[r - 15];
|
||||
w[r] = (((T >>> 19) | (T << 45)) ^ ((T >>> 61) | (T << 3)) ^ (T >>> 6))
|
||||
+ w[r - 7]
|
||||
+ (((T2 >>> 1) | (T2 << 63)) ^ ((T2 >>> 8) | (T2 << 56)) ^ (T2 >>> 7))
|
||||
+ w[r - 16];
|
||||
}
|
||||
|
||||
for (r = 0; r < 80; r++)
|
||||
{
|
||||
|
||||
T = H
|
||||
+ (((E >>> 14) | (E << 50)) ^ ((E >>> 18) | (E << 46)) ^ ((E >>> 41) | (E << 23)))
|
||||
+ ((E & F) ^ ((~E) & G)) + k[r] + w[r];
|
||||
// T IS INCORRECT SOMEHOW
|
||||
T2 = (((A >>> 28) | (A << 36)) ^ ((A >>> 34) | (A << 30)) ^ ((A >>> 39) | (A << 25)))
|
||||
+ ((A & B) ^ (A & C) ^ (B & C));
|
||||
H = G;
|
||||
G = F;
|
||||
F = E;
|
||||
E = D + T;
|
||||
D = C;
|
||||
C = B;
|
||||
B = A;
|
||||
A = T + T2;
|
||||
}
|
||||
|
||||
return new long[] { hh0 + A, hh1 + B, hh2 + C, hh3 + D, hh4 + E, hh5 + F,
|
||||
hh6 + G, hh7 + H };
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,322 @@
|
||||
/* Sha512.java --
|
||||
Copyright (C) 2003, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
import gnu.java.security.util.Util;
|
||||
|
||||
/**
|
||||
* <p>Implementation of SHA2-3 [SHA-512] per the IETF Draft Specification.</p>
|
||||
*
|
||||
* <p>References:</p>
|
||||
* <ol>
|
||||
* <li><a href="http://ftp.ipv4.heanet.ie/pub/ietf/internet-drafts/draft-ietf-ipsec-ciph-aes-cbc-03.txt">
|
||||
* Descriptions of SHA-256, SHA-384, and SHA-512</a>,</li>
|
||||
* <li>http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf</li>
|
||||
* </ol>
|
||||
*/
|
||||
public class Sha512 extends BaseHash
|
||||
{
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private static final long[] k = { 0x428a2f98d728ae22L, 0x7137449123ef65cdL,
|
||||
0xb5c0fbcfec4d3b2fL, 0xe9b5dba58189dbbcL,
|
||||
0x3956c25bf348b538L, 0x59f111f1b605d019L,
|
||||
0x923f82a4af194f9bL, 0xab1c5ed5da6d8118L,
|
||||
0xd807aa98a3030242L, 0x12835b0145706fbeL,
|
||||
0x243185be4ee4b28cL, 0x550c7dc3d5ffb4e2L,
|
||||
0x72be5d74f27b896fL, 0x80deb1fe3b1696b1L,
|
||||
0x9bdc06a725c71235L, 0xc19bf174cf692694L,
|
||||
0xe49b69c19ef14ad2L, 0xefbe4786384f25e3L,
|
||||
0x0fc19dc68b8cd5b5L, 0x240ca1cc77ac9c65L,
|
||||
0x2de92c6f592b0275L, 0x4a7484aa6ea6e483L,
|
||||
0x5cb0a9dcbd41fbd4L, 0x76f988da831153b5L,
|
||||
0x983e5152ee66dfabL, 0xa831c66d2db43210L,
|
||||
0xb00327c898fb213fL, 0xbf597fc7beef0ee4L,
|
||||
0xc6e00bf33da88fc2L, 0xd5a79147930aa725L,
|
||||
0x06ca6351e003826fL, 0x142929670a0e6e70L,
|
||||
0x27b70a8546d22ffcL, 0x2e1b21385c26c926L,
|
||||
0x4d2c6dfc5ac42aedL, 0x53380d139d95b3dfL,
|
||||
0x650a73548baf63deL, 0x766a0abb3c77b2a8L,
|
||||
0x81c2c92e47edaee6L, 0x92722c851482353bL,
|
||||
0xa2bfe8a14cf10364L, 0xa81a664bbc423001L,
|
||||
0xc24b8b70d0f89791L, 0xc76c51a30654be30L,
|
||||
0xd192e819d6ef5218L, 0xd69906245565a910L,
|
||||
0xf40e35855771202aL, 0x106aa07032bbd1b8L,
|
||||
0x19a4c116b8d2d0c8L, 0x1e376c085141ab53L,
|
||||
0x2748774cdf8eeb99L, 0x34b0bcb5e19b48a8L,
|
||||
0x391c0cb3c5c95a63L, 0x4ed8aa4ae3418acbL,
|
||||
0x5b9cca4f7763e373L, 0x682e6ff3d6b2b8a3L,
|
||||
0x748f82ee5defb2fcL, 0x78a5636f43172f60L,
|
||||
0x84c87814a1f0ab72L, 0x8cc702081a6439ecL,
|
||||
0x90befffa23631e28L, 0xa4506cebde82bde9L,
|
||||
0xbef9a3f7b2c67915L, 0xc67178f2e372532bL,
|
||||
0xca273eceea26619cL, 0xd186b8c721c0c207L,
|
||||
0xeada7dd6cde0eb1eL, 0xf57d4f7fee6ed178L,
|
||||
0x06f067aa72176fbaL, 0x0a637dc5a2c898a6L,
|
||||
0x113f9804bef90daeL, 0x1b710b35131c471bL,
|
||||
0x28db77f523047d84L, 0x32caab7b40c72493L,
|
||||
0x3c9ebe0a15c9bebcL, 0x431d67c49c100d4cL,
|
||||
0x4cc5d4becb3e42b6L, 0x597f299cfc657e2aL,
|
||||
0x5fcb6fab3ad6faecL, 0x6c44198c4a475817L };
|
||||
|
||||
private static final int BLOCK_SIZE = 128; // inner block size in bytes
|
||||
|
||||
private static final String DIGEST0 = "DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA20A9EEEE64B55D39A"
|
||||
+ "2192992A274FC1A836BA3C23A3FEEBBD454D4423643CE80E2A9AC94FA54CA49F";
|
||||
|
||||
private static final long[] w = new long[80];
|
||||
|
||||
/** caches the result of the correctness test, once executed. */
|
||||
private static Boolean valid;
|
||||
|
||||
/** 512-bit interim result. */
|
||||
private long h0, h1, h2, h3, h4, h5, h6, h7;
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** Trivial 0-arguments constructor. */
|
||||
public Sha512()
|
||||
{
|
||||
super(Registry.SHA512_HASH, 64, BLOCK_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Private constructor for cloning purposes.</p>
|
||||
*
|
||||
* @param md the instance to clone.
|
||||
*/
|
||||
private Sha512(Sha512 md)
|
||||
{
|
||||
this();
|
||||
|
||||
this.h0 = md.h0;
|
||||
this.h1 = md.h1;
|
||||
this.h2 = md.h2;
|
||||
this.h3 = md.h3;
|
||||
this.h4 = md.h4;
|
||||
this.h5 = md.h5;
|
||||
this.h6 = md.h6;
|
||||
this.h7 = md.h7;
|
||||
this.count = md.count;
|
||||
this.buffer = (byte[]) md.buffer.clone();
|
||||
}
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
public static final long[] G(long hh0, long hh1, long hh2, long hh3,
|
||||
long hh4, long hh5, long hh6, long hh7,
|
||||
byte[] in, int offset)
|
||||
{
|
||||
return sha(hh0, hh1, hh2, hh3, hh4, hh5, hh6, hh7, in, offset);
|
||||
}
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// java.lang.Cloneable interface implementation ----------------------------
|
||||
|
||||
public Object clone()
|
||||
{
|
||||
return new Sha512(this);
|
||||
}
|
||||
|
||||
// Implementation of concrete methods in BaseHash --------------------------
|
||||
|
||||
protected void transform(byte[] in, int offset)
|
||||
{
|
||||
long[] result = sha(h0, h1, h2, h3, h4, h5, h6, h7, in, offset);
|
||||
|
||||
h0 = result[0];
|
||||
h1 = result[1];
|
||||
h2 = result[2];
|
||||
h3 = result[3];
|
||||
h4 = result[4];
|
||||
h5 = result[5];
|
||||
h6 = result[6];
|
||||
h7 = result[7];
|
||||
}
|
||||
|
||||
protected byte[] padBuffer()
|
||||
{
|
||||
int n = (int) (count % BLOCK_SIZE);
|
||||
int padding = (n < 112) ? (112 - n) : (240 - n);
|
||||
byte[] result = new byte[padding + 16];
|
||||
|
||||
// padding is always binary 1 followed by binary 0s
|
||||
result[0] = (byte) 0x80;
|
||||
|
||||
// save number of bits, casting the long to an array of 8 bytes
|
||||
// TODO: FIX Only ~35 bits of 128 bit counter usable this way
|
||||
long bits = count << 3;
|
||||
padding += 8;
|
||||
result[padding++] = (byte) (bits >>> 56);
|
||||
result[padding++] = (byte) (bits >>> 48);
|
||||
result[padding++] = (byte) (bits >>> 40);
|
||||
result[padding++] = (byte) (bits >>> 32);
|
||||
result[padding++] = (byte) (bits >>> 24);
|
||||
result[padding++] = (byte) (bits >>> 16);
|
||||
result[padding++] = (byte) (bits >>> 8);
|
||||
result[padding] = (byte) bits;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected byte[] getResult()
|
||||
{
|
||||
return new byte[] { (byte) (h0 >>> 56), (byte) (h0 >>> 48),
|
||||
(byte) (h0 >>> 40), (byte) (h0 >>> 32),
|
||||
(byte) (h0 >>> 24), (byte) (h0 >>> 16),
|
||||
(byte) (h0 >>> 8), (byte) h0, (byte) (h1 >>> 56),
|
||||
(byte) (h1 >>> 48), (byte) (h1 >>> 40),
|
||||
(byte) (h1 >>> 32), (byte) (h1 >>> 24),
|
||||
(byte) (h1 >>> 16), (byte) (h1 >>> 8), (byte) h1,
|
||||
(byte) (h2 >>> 56), (byte) (h2 >>> 48),
|
||||
(byte) (h2 >>> 40), (byte) (h2 >>> 32),
|
||||
(byte) (h2 >>> 24), (byte) (h2 >>> 16),
|
||||
(byte) (h2 >>> 8), (byte) h2, (byte) (h3 >>> 56),
|
||||
(byte) (h3 >>> 48), (byte) (h3 >>> 40),
|
||||
(byte) (h3 >>> 32), (byte) (h3 >>> 24),
|
||||
(byte) (h3 >>> 16), (byte) (h3 >>> 8), (byte) h3,
|
||||
(byte) (h4 >>> 56), (byte) (h4 >>> 48),
|
||||
(byte) (h4 >>> 40), (byte) (h4 >>> 32),
|
||||
(byte) (h4 >>> 24), (byte) (h4 >>> 16),
|
||||
(byte) (h4 >>> 8), (byte) h4, (byte) (h5 >>> 56),
|
||||
(byte) (h5 >>> 48), (byte) (h5 >>> 40),
|
||||
(byte) (h5 >>> 32), (byte) (h5 >>> 24),
|
||||
(byte) (h5 >>> 16), (byte) (h5 >>> 8), (byte) h5,
|
||||
(byte) (h6 >>> 56), (byte) (h6 >>> 48),
|
||||
(byte) (h6 >>> 40), (byte) (h6 >>> 32),
|
||||
(byte) (h6 >>> 24), (byte) (h6 >>> 16),
|
||||
(byte) (h6 >>> 8), (byte) h6, (byte) (h7 >>> 56),
|
||||
(byte) (h7 >>> 48), (byte) (h7 >>> 40),
|
||||
(byte) (h7 >>> 32), (byte) (h7 >>> 24),
|
||||
(byte) (h7 >>> 16), (byte) (h7 >>> 8), (byte) h7 };
|
||||
}
|
||||
|
||||
protected void resetContext()
|
||||
{
|
||||
// magic SHA-512 initialisation constants
|
||||
h0 = 0x6a09e667f3bcc908L;
|
||||
h1 = 0xbb67ae8584caa73bL;
|
||||
h2 = 0x3c6ef372fe94f82bL;
|
||||
h3 = 0xa54ff53a5f1d36f1L;
|
||||
h4 = 0x510e527fade682d1L;
|
||||
h5 = 0x9b05688c2b3e6c1fL;
|
||||
h6 = 0x1f83d9abfb41bd6bL;
|
||||
h7 = 0x5be0cd19137e2179L;
|
||||
}
|
||||
|
||||
public boolean selfTest()
|
||||
{
|
||||
if (valid == null)
|
||||
{
|
||||
Sha512 md = new Sha512();
|
||||
md.update((byte) 0x61); // a
|
||||
md.update((byte) 0x62); // b
|
||||
md.update((byte) 0x63); // c
|
||||
String result = Util.toString(md.digest());
|
||||
valid = new Boolean(DIGEST0.equals(result));
|
||||
}
|
||||
return valid.booleanValue();
|
||||
}
|
||||
|
||||
// SHA specific methods ----------------------------------------------------
|
||||
|
||||
private static final synchronized long[] sha(long hh0, long hh1, long hh2,
|
||||
long hh3, long hh4, long hh5,
|
||||
long hh6, long hh7, byte[] in,
|
||||
int offset)
|
||||
{
|
||||
long A = hh0;
|
||||
long B = hh1;
|
||||
long C = hh2;
|
||||
long D = hh3;
|
||||
long E = hh4;
|
||||
long F = hh5;
|
||||
long G = hh6;
|
||||
long H = hh7;
|
||||
long T, T2;
|
||||
int r;
|
||||
|
||||
for (r = 0; r < 16; r++)
|
||||
{
|
||||
w[r] = (long) in[offset++] << 56 | ((long) in[offset++] & 0xFF) << 48
|
||||
| ((long) in[offset++] & 0xFF) << 40
|
||||
| ((long) in[offset++] & 0xFF) << 32
|
||||
| ((long) in[offset++] & 0xFF) << 24
|
||||
| ((long) in[offset++] & 0xFF) << 16
|
||||
| ((long) in[offset++] & 0xFF) << 8
|
||||
| ((long) in[offset++] & 0xFF);
|
||||
}
|
||||
for (r = 16; r < 80; r++)
|
||||
{
|
||||
T = w[r - 2];
|
||||
T2 = w[r - 15];
|
||||
w[r] = (((T >>> 19) | (T << 45)) ^ ((T >>> 61) | (T << 3)) ^ (T >>> 6))
|
||||
+ w[r - 7]
|
||||
+ (((T2 >>> 1) | (T2 << 63)) ^ ((T2 >>> 8) | (T2 << 56)) ^ (T2 >>> 7))
|
||||
+ w[r - 16];
|
||||
}
|
||||
|
||||
for (r = 0; r < 80; r++)
|
||||
{
|
||||
T = H
|
||||
+ (((E >>> 14) | (E << 50)) ^ ((E >>> 18) | (E << 46)) ^ ((E >>> 41) | (E << 23)))
|
||||
+ ((E & F) ^ ((~E) & G)) + k[r] + w[r];
|
||||
T2 = (((A >>> 28) | (A << 36)) ^ ((A >>> 34) | (A << 30)) ^ ((A >>> 39) | (A << 25)))
|
||||
+ ((A & B) ^ (A & C) ^ (B & C));
|
||||
H = G;
|
||||
G = F;
|
||||
F = E;
|
||||
E = D + T;
|
||||
D = C;
|
||||
C = B;
|
||||
B = A;
|
||||
A = T + T2;
|
||||
}
|
||||
|
||||
return new long[] { hh0 + A, hh1 + B, hh2 + C, hh3 + D, hh4 + E, hh5 + F,
|
||||
hh6 + G, hh7 + H };
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,943 @@
|
||||
/* Tiger.java --
|
||||
Copyright (C) 2003, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
import gnu.java.security.util.Util;
|
||||
|
||||
/**
|
||||
* The Tiger message digest. Tiger was designed by Ross Anderson and Eli
|
||||
* Biham, with the goal of producing a secure, fast hash function that
|
||||
* performs especially well on next-generation 64-bit architectures, but
|
||||
* is still efficient on 32- and 16-bit architectures.
|
||||
*
|
||||
* <p>Tiger processes data in 512-bit blocks and produces a 192-bit
|
||||
* digest.</p>
|
||||
*
|
||||
* <p>References:</p>
|
||||
* <ol>
|
||||
* <li><a
|
||||
* href="http://www.cs.technion.ac.il/~biham/Reports/Tiger/">Tiger: A
|
||||
* Fast New Hash Function</a>, Ross Anderson and Eli Biham.</a></li>
|
||||
* </ol>
|
||||
*/
|
||||
public class Tiger extends BaseHash
|
||||
{
|
||||
|
||||
// Constants and variables.
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
private static final int HASH_SIZE = 24;
|
||||
|
||||
private static final int BLOCK_SIZE = 64;
|
||||
|
||||
/** Result when no data has been input. */
|
||||
private static final String DIGEST0 = "3293AC630C13F0245F92BBB1766E16167A4E58492DDE73F3";
|
||||
|
||||
private static final long A = 0x0123456789ABCDEFL;
|
||||
|
||||
private static final long B = 0xFEDCBA9876543210L;
|
||||
|
||||
private static final long C = 0xF096A5B4C3B2E187L;
|
||||
|
||||
/** S-Box T1. */
|
||||
private static final long[] T1 = { 0x02AAB17CF7E90C5EL, 0xAC424B03E243A8ECL,
|
||||
0x72CD5BE30DD5FCD3L, 0x6D019B93F6F97F3AL,
|
||||
0xCD9978FFD21F9193L, 0x7573A1C9708029E2L,
|
||||
0xB164326B922A83C3L, 0x46883EEE04915870L,
|
||||
0xEAACE3057103ECE6L, 0xC54169B808A3535CL,
|
||||
0x4CE754918DDEC47CL, 0x0AA2F4DFDC0DF40CL,
|
||||
0x10B76F18A74DBEFAL, 0xC6CCB6235AD1AB6AL,
|
||||
0x13726121572FE2FFL, 0x1A488C6F199D921EL,
|
||||
0x4BC9F9F4DA0007CAL, 0x26F5E6F6E85241C7L,
|
||||
0x859079DBEA5947B6L, 0x4F1885C5C99E8C92L,
|
||||
0xD78E761EA96F864BL, 0x8E36428C52B5C17DL,
|
||||
0x69CF6827373063C1L, 0xB607C93D9BB4C56EL,
|
||||
0x7D820E760E76B5EAL, 0x645C9CC6F07FDC42L,
|
||||
0xBF38A078243342E0L, 0x5F6B343C9D2E7D04L,
|
||||
0xF2C28AEB600B0EC6L, 0x6C0ED85F7254BCACL,
|
||||
0x71592281A4DB4FE5L, 0x1967FA69CE0FED9FL,
|
||||
0xFD5293F8B96545DBL, 0xC879E9D7F2A7600BL,
|
||||
0x860248920193194EL, 0xA4F9533B2D9CC0B3L,
|
||||
0x9053836C15957613L, 0xDB6DCF8AFC357BF1L,
|
||||
0x18BEEA7A7A370F57L, 0x037117CA50B99066L,
|
||||
0x6AB30A9774424A35L, 0xF4E92F02E325249BL,
|
||||
0x7739DB07061CCAE1L, 0xD8F3B49CECA42A05L,
|
||||
0xBD56BE3F51382F73L, 0x45FAED5843B0BB28L,
|
||||
0x1C813D5C11BF1F83L, 0x8AF0E4B6D75FA169L,
|
||||
0x33EE18A487AD9999L, 0x3C26E8EAB1C94410L,
|
||||
0xB510102BC0A822F9L, 0x141EEF310CE6123BL,
|
||||
0xFC65B90059DDB154L, 0xE0158640C5E0E607L,
|
||||
0x884E079826C3A3CFL, 0x930D0D9523C535FDL,
|
||||
0x35638D754E9A2B00L, 0x4085FCCF40469DD5L,
|
||||
0xC4B17AD28BE23A4CL, 0xCAB2F0FC6A3E6A2EL,
|
||||
0x2860971A6B943FCDL, 0x3DDE6EE212E30446L,
|
||||
0x6222F32AE01765AEL, 0x5D550BB5478308FEL,
|
||||
0xA9EFA98DA0EDA22AL, 0xC351A71686C40DA7L,
|
||||
0x1105586D9C867C84L, 0xDCFFEE85FDA22853L,
|
||||
0xCCFBD0262C5EEF76L, 0xBAF294CB8990D201L,
|
||||
0xE69464F52AFAD975L, 0x94B013AFDF133E14L,
|
||||
0x06A7D1A32823C958L, 0x6F95FE5130F61119L,
|
||||
0xD92AB34E462C06C0L, 0xED7BDE33887C71D2L,
|
||||
0x79746D6E6518393EL, 0x5BA419385D713329L,
|
||||
0x7C1BA6B948A97564L, 0x31987C197BFDAC67L,
|
||||
0xDE6C23C44B053D02L, 0x581C49FED002D64DL,
|
||||
0xDD474D6338261571L, 0xAA4546C3E473D062L,
|
||||
0x928FCE349455F860L, 0x48161BBACAAB94D9L,
|
||||
0x63912430770E6F68L, 0x6EC8A5E602C6641CL,
|
||||
0x87282515337DDD2BL, 0x2CDA6B42034B701BL,
|
||||
0xB03D37C181CB096DL, 0xE108438266C71C6FL,
|
||||
0x2B3180C7EB51B255L, 0xDF92B82F96C08BBCL,
|
||||
0x5C68C8C0A632F3BAL, 0x5504CC861C3D0556L,
|
||||
0xABBFA4E55FB26B8FL, 0x41848B0AB3BACEB4L,
|
||||
0xB334A273AA445D32L, 0xBCA696F0A85AD881L,
|
||||
0x24F6EC65B528D56CL, 0x0CE1512E90F4524AL,
|
||||
0x4E9DD79D5506D35AL, 0x258905FAC6CE9779L,
|
||||
0x2019295B3E109B33L, 0xF8A9478B73A054CCL,
|
||||
0x2924F2F934417EB0L, 0x3993357D536D1BC4L,
|
||||
0x38A81AC21DB6FF8BL, 0x47C4FBF17D6016BFL,
|
||||
0x1E0FAADD7667E3F5L, 0x7ABCFF62938BEB96L,
|
||||
0xA78DAD948FC179C9L, 0x8F1F98B72911E50DL,
|
||||
0x61E48EAE27121A91L, 0x4D62F7AD31859808L,
|
||||
0xECEBA345EF5CEAEBL, 0xF5CEB25EBC9684CEL,
|
||||
0xF633E20CB7F76221L, 0xA32CDF06AB8293E4L,
|
||||
0x985A202CA5EE2CA4L, 0xCF0B8447CC8A8FB1L,
|
||||
0x9F765244979859A3L, 0xA8D516B1A1240017L,
|
||||
0x0BD7BA3EBB5DC726L, 0xE54BCA55B86ADB39L,
|
||||
0x1D7A3AFD6C478063L, 0x519EC608E7669EDDL,
|
||||
0x0E5715A2D149AA23L, 0x177D4571848FF194L,
|
||||
0xEEB55F3241014C22L, 0x0F5E5CA13A6E2EC2L,
|
||||
0x8029927B75F5C361L, 0xAD139FABC3D6E436L,
|
||||
0x0D5DF1A94CCF402FL, 0x3E8BD948BEA5DFC8L,
|
||||
0xA5A0D357BD3FF77EL, 0xA2D12E251F74F645L,
|
||||
0x66FD9E525E81A082L, 0x2E0C90CE7F687A49L,
|
||||
0xC2E8BCBEBA973BC5L, 0x000001BCE509745FL,
|
||||
0x423777BBE6DAB3D6L, 0xD1661C7EAEF06EB5L,
|
||||
0xA1781F354DAACFD8L, 0x2D11284A2B16AFFCL,
|
||||
0xF1FC4F67FA891D1FL, 0x73ECC25DCB920ADAL,
|
||||
0xAE610C22C2A12651L, 0x96E0A810D356B78AL,
|
||||
0x5A9A381F2FE7870FL, 0xD5AD62EDE94E5530L,
|
||||
0xD225E5E8368D1427L, 0x65977B70C7AF4631L,
|
||||
0x99F889B2DE39D74FL, 0x233F30BF54E1D143L,
|
||||
0x9A9675D3D9A63C97L, 0x5470554FF334F9A8L,
|
||||
0x166ACB744A4F5688L, 0x70C74CAAB2E4AEADL,
|
||||
0xF0D091646F294D12L, 0x57B82A89684031D1L,
|
||||
0xEFD95A5A61BE0B6BL, 0x2FBD12E969F2F29AL,
|
||||
0x9BD37013FEFF9FE8L, 0x3F9B0404D6085A06L,
|
||||
0x4940C1F3166CFE15L, 0x09542C4DCDF3DEFBL,
|
||||
0xB4C5218385CD5CE3L, 0xC935B7DC4462A641L,
|
||||
0x3417F8A68ED3B63FL, 0xB80959295B215B40L,
|
||||
0xF99CDAEF3B8C8572L, 0x018C0614F8FCB95DL,
|
||||
0x1B14ACCD1A3ACDF3L, 0x84D471F200BB732DL,
|
||||
0xC1A3110E95E8DA16L, 0x430A7220BF1A82B8L,
|
||||
0xB77E090D39DF210EL, 0x5EF4BD9F3CD05E9DL,
|
||||
0x9D4FF6DA7E57A444L, 0xDA1D60E183D4A5F8L,
|
||||
0xB287C38417998E47L, 0xFE3EDC121BB31886L,
|
||||
0xC7FE3CCC980CCBEFL, 0xE46FB590189BFD03L,
|
||||
0x3732FD469A4C57DCL, 0x7EF700A07CF1AD65L,
|
||||
0x59C64468A31D8859L, 0x762FB0B4D45B61F6L,
|
||||
0x155BAED099047718L, 0x68755E4C3D50BAA6L,
|
||||
0xE9214E7F22D8B4DFL, 0x2ADDBF532EAC95F4L,
|
||||
0x32AE3909B4BD0109L, 0x834DF537B08E3450L,
|
||||
0xFA209DA84220728DL, 0x9E691D9B9EFE23F7L,
|
||||
0x0446D288C4AE8D7FL, 0x7B4CC524E169785BL,
|
||||
0x21D87F0135CA1385L, 0xCEBB400F137B8AA5L,
|
||||
0x272E2B66580796BEL, 0x3612264125C2B0DEL,
|
||||
0x057702BDAD1EFBB2L, 0xD4BABB8EACF84BE9L,
|
||||
0x91583139641BC67BL, 0x8BDC2DE08036E024L,
|
||||
0x603C8156F49F68EDL, 0xF7D236F7DBEF5111L,
|
||||
0x9727C4598AD21E80L, 0xA08A0896670A5FD7L,
|
||||
0xCB4A8F4309EBA9CBL, 0x81AF564B0F7036A1L,
|
||||
0xC0B99AA778199ABDL, 0x959F1EC83FC8E952L,
|
||||
0x8C505077794A81B9L, 0x3ACAAF8F056338F0L,
|
||||
0x07B43F50627A6778L, 0x4A44AB49F5ECCC77L,
|
||||
0x3BC3D6E4B679EE98L, 0x9CC0D4D1CF14108CL,
|
||||
0x4406C00B206BC8A0L, 0x82A18854C8D72D89L,
|
||||
0x67E366B35C3C432CL, 0xB923DD61102B37F2L,
|
||||
0x56AB2779D884271DL, 0xBE83E1B0FF1525AFL,
|
||||
0xFB7C65D4217E49A9L, 0x6BDBE0E76D48E7D4L,
|
||||
0x08DF828745D9179EL, 0x22EA6A9ADD53BD34L,
|
||||
0xE36E141C5622200AL, 0x7F805D1B8CB750EEL,
|
||||
0xAFE5C7A59F58E837L, 0xE27F996A4FB1C23CL,
|
||||
0xD3867DFB0775F0D0L, 0xD0E673DE6E88891AL,
|
||||
0x123AEB9EAFB86C25L, 0x30F1D5D5C145B895L,
|
||||
0xBB434A2DEE7269E7L, 0x78CB67ECF931FA38L,
|
||||
0xF33B0372323BBF9CL, 0x52D66336FB279C74L,
|
||||
0x505F33AC0AFB4EAAL, 0xE8A5CD99A2CCE187L,
|
||||
0x534974801E2D30BBL, 0x8D2D5711D5876D90L,
|
||||
0x1F1A412891BC038EL, 0xD6E2E71D82E56648L,
|
||||
0x74036C3A497732B7L, 0x89B67ED96361F5ABL,
|
||||
0xFFED95D8F1EA02A2L, 0xE72B3BD61464D43DL,
|
||||
0xA6300F170BDC4820L, 0xEBC18760ED78A77AL };
|
||||
|
||||
/** S-Box T2. */
|
||||
private static final long[] T2 = { 0xE6A6BE5A05A12138L, 0xB5A122A5B4F87C98L,
|
||||
0x563C6089140B6990L, 0x4C46CB2E391F5DD5L,
|
||||
0xD932ADDBC9B79434L, 0x08EA70E42015AFF5L,
|
||||
0xD765A6673E478CF1L, 0xC4FB757EAB278D99L,
|
||||
0xDF11C6862D6E0692L, 0xDDEB84F10D7F3B16L,
|
||||
0x6F2EF604A665EA04L, 0x4A8E0F0FF0E0DFB3L,
|
||||
0xA5EDEEF83DBCBA51L, 0xFC4F0A2A0EA4371EL,
|
||||
0xE83E1DA85CB38429L, 0xDC8FF882BA1B1CE2L,
|
||||
0xCD45505E8353E80DL, 0x18D19A00D4DB0717L,
|
||||
0x34A0CFEDA5F38101L, 0x0BE77E518887CAF2L,
|
||||
0x1E341438B3C45136L, 0xE05797F49089CCF9L,
|
||||
0xFFD23F9DF2591D14L, 0x543DDA228595C5CDL,
|
||||
0x661F81FD99052A33L, 0x8736E641DB0F7B76L,
|
||||
0x15227725418E5307L, 0xE25F7F46162EB2FAL,
|
||||
0x48A8B2126C13D9FEL, 0xAFDC541792E76EEAL,
|
||||
0x03D912BFC6D1898FL, 0x31B1AAFA1B83F51BL,
|
||||
0xF1AC2796E42AB7D9L, 0x40A3A7D7FCD2EBACL,
|
||||
0x1056136D0AFBBCC5L, 0x7889E1DD9A6D0C85L,
|
||||
0xD33525782A7974AAL, 0xA7E25D09078AC09BL,
|
||||
0xBD4138B3EAC6EDD0L, 0x920ABFBE71EB9E70L,
|
||||
0xA2A5D0F54FC2625CL, 0xC054E36B0B1290A3L,
|
||||
0xF6DD59FF62FE932BL, 0x3537354511A8AC7DL,
|
||||
0xCA845E9172FADCD4L, 0x84F82B60329D20DCL,
|
||||
0x79C62CE1CD672F18L, 0x8B09A2ADD124642CL,
|
||||
0xD0C1E96A19D9E726L, 0x5A786A9B4BA9500CL,
|
||||
0x0E020336634C43F3L, 0xC17B474AEB66D822L,
|
||||
0x6A731AE3EC9BAAC2L, 0x8226667AE0840258L,
|
||||
0x67D4567691CAECA5L, 0x1D94155C4875ADB5L,
|
||||
0x6D00FD985B813FDFL, 0x51286EFCB774CD06L,
|
||||
0x5E8834471FA744AFL, 0xF72CA0AEE761AE2EL,
|
||||
0xBE40E4CDAEE8E09AL, 0xE9970BBB5118F665L,
|
||||
0x726E4BEB33DF1964L, 0x703B000729199762L,
|
||||
0x4631D816F5EF30A7L, 0xB880B5B51504A6BEL,
|
||||
0x641793C37ED84B6CL, 0x7B21ED77F6E97D96L,
|
||||
0x776306312EF96B73L, 0xAE528948E86FF3F4L,
|
||||
0x53DBD7F286A3F8F8L, 0x16CADCE74CFC1063L,
|
||||
0x005C19BDFA52C6DDL, 0x68868F5D64D46AD3L,
|
||||
0x3A9D512CCF1E186AL, 0x367E62C2385660AEL,
|
||||
0xE359E7EA77DCB1D7L, 0x526C0773749ABE6EL,
|
||||
0x735AE5F9D09F734BL, 0x493FC7CC8A558BA8L,
|
||||
0xB0B9C1533041AB45L, 0x321958BA470A59BDL,
|
||||
0x852DB00B5F46C393L, 0x91209B2BD336B0E5L,
|
||||
0x6E604F7D659EF19FL, 0xB99A8AE2782CCB24L,
|
||||
0xCCF52AB6C814C4C7L, 0x4727D9AFBE11727BL,
|
||||
0x7E950D0C0121B34DL, 0x756F435670AD471FL,
|
||||
0xF5ADD442615A6849L, 0x4E87E09980B9957AL,
|
||||
0x2ACFA1DF50AEE355L, 0xD898263AFD2FD556L,
|
||||
0xC8F4924DD80C8FD6L, 0xCF99CA3D754A173AL,
|
||||
0xFE477BACAF91BF3CL, 0xED5371F6D690C12DL,
|
||||
0x831A5C285E687094L, 0xC5D3C90A3708A0A4L,
|
||||
0x0F7F903717D06580L, 0x19F9BB13B8FDF27FL,
|
||||
0xB1BD6F1B4D502843L, 0x1C761BA38FFF4012L,
|
||||
0x0D1530C4E2E21F3BL, 0x8943CE69A7372C8AL,
|
||||
0xE5184E11FEB5CE66L, 0x618BDB80BD736621L,
|
||||
0x7D29BAD68B574D0BL, 0x81BB613E25E6FE5BL,
|
||||
0x071C9C10BC07913FL, 0xC7BEEB7909AC2D97L,
|
||||
0xC3E58D353BC5D757L, 0xEB017892F38F61E8L,
|
||||
0xD4EFFB9C9B1CC21AL, 0x99727D26F494F7ABL,
|
||||
0xA3E063A2956B3E03L, 0x9D4A8B9A4AA09C30L,
|
||||
0x3F6AB7D500090FB4L, 0x9CC0F2A057268AC0L,
|
||||
0x3DEE9D2DEDBF42D1L, 0x330F49C87960A972L,
|
||||
0xC6B2720287421B41L, 0x0AC59EC07C00369CL,
|
||||
0xEF4EAC49CB353425L, 0xF450244EEF0129D8L,
|
||||
0x8ACC46E5CAF4DEB6L, 0x2FFEAB63989263F7L,
|
||||
0x8F7CB9FE5D7A4578L, 0x5BD8F7644E634635L,
|
||||
0x427A7315BF2DC900L, 0x17D0C4AA2125261CL,
|
||||
0x3992486C93518E50L, 0xB4CBFEE0A2D7D4C3L,
|
||||
0x7C75D6202C5DDD8DL, 0xDBC295D8E35B6C61L,
|
||||
0x60B369D302032B19L, 0xCE42685FDCE44132L,
|
||||
0x06F3DDB9DDF65610L, 0x8EA4D21DB5E148F0L,
|
||||
0x20B0FCE62FCD496FL, 0x2C1B912358B0EE31L,
|
||||
0xB28317B818F5A308L, 0xA89C1E189CA6D2CFL,
|
||||
0x0C6B18576AAADBC8L, 0xB65DEAA91299FAE3L,
|
||||
0xFB2B794B7F1027E7L, 0x04E4317F443B5BEBL,
|
||||
0x4B852D325939D0A6L, 0xD5AE6BEEFB207FFCL,
|
||||
0x309682B281C7D374L, 0xBAE309A194C3B475L,
|
||||
0x8CC3F97B13B49F05L, 0x98A9422FF8293967L,
|
||||
0x244B16B01076FF7CL, 0xF8BF571C663D67EEL,
|
||||
0x1F0D6758EEE30DA1L, 0xC9B611D97ADEB9B7L,
|
||||
0xB7AFD5887B6C57A2L, 0x6290AE846B984FE1L,
|
||||
0x94DF4CDEACC1A5FDL, 0x058A5BD1C5483AFFL,
|
||||
0x63166CC142BA3C37L, 0x8DB8526EB2F76F40L,
|
||||
0xE10880036F0D6D4EL, 0x9E0523C9971D311DL,
|
||||
0x45EC2824CC7CD691L, 0x575B8359E62382C9L,
|
||||
0xFA9E400DC4889995L, 0xD1823ECB45721568L,
|
||||
0xDAFD983B8206082FL, 0xAA7D29082386A8CBL,
|
||||
0x269FCD4403B87588L, 0x1B91F5F728BDD1E0L,
|
||||
0xE4669F39040201F6L, 0x7A1D7C218CF04ADEL,
|
||||
0x65623C29D79CE5CEL, 0x2368449096C00BB1L,
|
||||
0xAB9BF1879DA503BAL, 0xBC23ECB1A458058EL,
|
||||
0x9A58DF01BB401ECCL, 0xA070E868A85F143DL,
|
||||
0x4FF188307DF2239EL, 0x14D565B41A641183L,
|
||||
0xEE13337452701602L, 0x950E3DCF3F285E09L,
|
||||
0x59930254B9C80953L, 0x3BF299408930DA6DL,
|
||||
0xA955943F53691387L, 0xA15EDECAA9CB8784L,
|
||||
0x29142127352BE9A0L, 0x76F0371FFF4E7AFBL,
|
||||
0x0239F450274F2228L, 0xBB073AF01D5E868BL,
|
||||
0xBFC80571C10E96C1L, 0xD267088568222E23L,
|
||||
0x9671A3D48E80B5B0L, 0x55B5D38AE193BB81L,
|
||||
0x693AE2D0A18B04B8L, 0x5C48B4ECADD5335FL,
|
||||
0xFD743B194916A1CAL, 0x2577018134BE98C4L,
|
||||
0xE77987E83C54A4ADL, 0x28E11014DA33E1B9L,
|
||||
0x270CC59E226AA213L, 0x71495F756D1A5F60L,
|
||||
0x9BE853FB60AFEF77L, 0xADC786A7F7443DBFL,
|
||||
0x0904456173B29A82L, 0x58BC7A66C232BD5EL,
|
||||
0xF306558C673AC8B2L, 0x41F639C6B6C9772AL,
|
||||
0x216DEFE99FDA35DAL, 0x11640CC71C7BE615L,
|
||||
0x93C43694565C5527L, 0xEA038E6246777839L,
|
||||
0xF9ABF3CE5A3E2469L, 0x741E768D0FD312D2L,
|
||||
0x0144B883CED652C6L, 0xC20B5A5BA33F8552L,
|
||||
0x1AE69633C3435A9DL, 0x97A28CA4088CFDECL,
|
||||
0x8824A43C1E96F420L, 0x37612FA66EEEA746L,
|
||||
0x6B4CB165F9CF0E5AL, 0x43AA1C06A0ABFB4AL,
|
||||
0x7F4DC26FF162796BL, 0x6CBACC8E54ED9B0FL,
|
||||
0xA6B7FFEFD2BB253EL, 0x2E25BC95B0A29D4FL,
|
||||
0x86D6A58BDEF1388CL, 0xDED74AC576B6F054L,
|
||||
0x8030BDBC2B45805DL, 0x3C81AF70E94D9289L,
|
||||
0x3EFF6DDA9E3100DBL, 0xB38DC39FDFCC8847L,
|
||||
0x123885528D17B87EL, 0xF2DA0ED240B1B642L,
|
||||
0x44CEFADCD54BF9A9L, 0x1312200E433C7EE6L,
|
||||
0x9FFCC84F3A78C748L, 0xF0CD1F72248576BBL,
|
||||
0xEC6974053638CFE4L, 0x2BA7B67C0CEC4E4CL,
|
||||
0xAC2F4DF3E5CE32EDL, 0xCB33D14326EA4C11L,
|
||||
0xA4E9044CC77E58BCL, 0x5F513293D934FCEFL,
|
||||
0x5DC9645506E55444L, 0x50DE418F317DE40AL,
|
||||
0x388CB31A69DDE259L, 0x2DB4A83455820A86L,
|
||||
0x9010A91E84711AE9L, 0x4DF7F0B7B1498371L,
|
||||
0xD62A2EABC0977179L, 0x22FAC097AA8D5C0EL };
|
||||
|
||||
/** S-Box T3. */
|
||||
private static final long[] T3 = { 0xF49FCC2FF1DAF39BL, 0x487FD5C66FF29281L,
|
||||
0xE8A30667FCDCA83FL, 0x2C9B4BE3D2FCCE63L,
|
||||
0xDA3FF74B93FBBBC2L, 0x2FA165D2FE70BA66L,
|
||||
0xA103E279970E93D4L, 0xBECDEC77B0E45E71L,
|
||||
0xCFB41E723985E497L, 0xB70AAA025EF75017L,
|
||||
0xD42309F03840B8E0L, 0x8EFC1AD035898579L,
|
||||
0x96C6920BE2B2ABC5L, 0x66AF4163375A9172L,
|
||||
0x2174ABDCCA7127FBL, 0xB33CCEA64A72FF41L,
|
||||
0xF04A4933083066A5L, 0x8D970ACDD7289AF5L,
|
||||
0x8F96E8E031C8C25EL, 0xF3FEC02276875D47L,
|
||||
0xEC7BF310056190DDL, 0xF5ADB0AEBB0F1491L,
|
||||
0x9B50F8850FD58892L, 0x4975488358B74DE8L,
|
||||
0xA3354FF691531C61L, 0x0702BBE481D2C6EEL,
|
||||
0x89FB24057DEDED98L, 0xAC3075138596E902L,
|
||||
0x1D2D3580172772EDL, 0xEB738FC28E6BC30DL,
|
||||
0x5854EF8F63044326L, 0x9E5C52325ADD3BBEL,
|
||||
0x90AA53CF325C4623L, 0xC1D24D51349DD067L,
|
||||
0x2051CFEEA69EA624L, 0x13220F0A862E7E4FL,
|
||||
0xCE39399404E04864L, 0xD9C42CA47086FCB7L,
|
||||
0x685AD2238A03E7CCL, 0x066484B2AB2FF1DBL,
|
||||
0xFE9D5D70EFBF79ECL, 0x5B13B9DD9C481854L,
|
||||
0x15F0D475ED1509ADL, 0x0BEBCD060EC79851L,
|
||||
0xD58C6791183AB7F8L, 0xD1187C5052F3EEE4L,
|
||||
0xC95D1192E54E82FFL, 0x86EEA14CB9AC6CA2L,
|
||||
0x3485BEB153677D5DL, 0xDD191D781F8C492AL,
|
||||
0xF60866BAA784EBF9L, 0x518F643BA2D08C74L,
|
||||
0x8852E956E1087C22L, 0xA768CB8DC410AE8DL,
|
||||
0x38047726BFEC8E1AL, 0xA67738B4CD3B45AAL,
|
||||
0xAD16691CEC0DDE19L, 0xC6D4319380462E07L,
|
||||
0xC5A5876D0BA61938L, 0x16B9FA1FA58FD840L,
|
||||
0x188AB1173CA74F18L, 0xABDA2F98C99C021FL,
|
||||
0x3E0580AB134AE816L, 0x5F3B05B773645ABBL,
|
||||
0x2501A2BE5575F2F6L, 0x1B2F74004E7E8BA9L,
|
||||
0x1CD7580371E8D953L, 0x7F6ED89562764E30L,
|
||||
0xB15926FF596F003DL, 0x9F65293DA8C5D6B9L,
|
||||
0x6ECEF04DD690F84CL, 0x4782275FFF33AF88L,
|
||||
0xE41433083F820801L, 0xFD0DFE409A1AF9B5L,
|
||||
0x4325A3342CDB396BL, 0x8AE77E62B301B252L,
|
||||
0xC36F9E9F6655615AL, 0x85455A2D92D32C09L,
|
||||
0xF2C7DEA949477485L, 0x63CFB4C133A39EBAL,
|
||||
0x83B040CC6EBC5462L, 0x3B9454C8FDB326B0L,
|
||||
0x56F56A9E87FFD78CL, 0x2DC2940D99F42BC6L,
|
||||
0x98F7DF096B096E2DL, 0x19A6E01E3AD852BFL,
|
||||
0x42A99CCBDBD4B40BL, 0xA59998AF45E9C559L,
|
||||
0x366295E807D93186L, 0x6B48181BFAA1F773L,
|
||||
0x1FEC57E2157A0A1DL, 0x4667446AF6201AD5L,
|
||||
0xE615EBCACFB0F075L, 0xB8F31F4F68290778L,
|
||||
0x22713ED6CE22D11EL, 0x3057C1A72EC3C93BL,
|
||||
0xCB46ACC37C3F1F2FL, 0xDBB893FD02AAF50EL,
|
||||
0x331FD92E600B9FCFL, 0xA498F96148EA3AD6L,
|
||||
0xA8D8426E8B6A83EAL, 0xA089B274B7735CDCL,
|
||||
0x87F6B3731E524A11L, 0x118808E5CBC96749L,
|
||||
0x9906E4C7B19BD394L, 0xAFED7F7E9B24A20CL,
|
||||
0x6509EADEEB3644A7L, 0x6C1EF1D3E8EF0EDEL,
|
||||
0xB9C97D43E9798FB4L, 0xA2F2D784740C28A3L,
|
||||
0x7B8496476197566FL, 0x7A5BE3E6B65F069DL,
|
||||
0xF96330ED78BE6F10L, 0xEEE60DE77A076A15L,
|
||||
0x2B4BEE4AA08B9BD0L, 0x6A56A63EC7B8894EL,
|
||||
0x02121359BA34FEF4L, 0x4CBF99F8283703FCL,
|
||||
0x398071350CAF30C8L, 0xD0A77A89F017687AL,
|
||||
0xF1C1A9EB9E423569L, 0x8C7976282DEE8199L,
|
||||
0x5D1737A5DD1F7ABDL, 0x4F53433C09A9FA80L,
|
||||
0xFA8B0C53DF7CA1D9L, 0x3FD9DCBC886CCB77L,
|
||||
0xC040917CA91B4720L, 0x7DD00142F9D1DCDFL,
|
||||
0x8476FC1D4F387B58L, 0x23F8E7C5F3316503L,
|
||||
0x032A2244E7E37339L, 0x5C87A5D750F5A74BL,
|
||||
0x082B4CC43698992EL, 0xDF917BECB858F63CL,
|
||||
0x3270B8FC5BF86DDAL, 0x10AE72BB29B5DD76L,
|
||||
0x576AC94E7700362BL, 0x1AD112DAC61EFB8FL,
|
||||
0x691BC30EC5FAA427L, 0xFF246311CC327143L,
|
||||
0x3142368E30E53206L, 0x71380E31E02CA396L,
|
||||
0x958D5C960AAD76F1L, 0xF8D6F430C16DA536L,
|
||||
0xC8FFD13F1BE7E1D2L, 0x7578AE66004DDBE1L,
|
||||
0x05833F01067BE646L, 0xBB34B5AD3BFE586DL,
|
||||
0x095F34C9A12B97F0L, 0x247AB64525D60CA8L,
|
||||
0xDCDBC6F3017477D1L, 0x4A2E14D4DECAD24DL,
|
||||
0xBDB5E6D9BE0A1EEBL, 0x2A7E70F7794301ABL,
|
||||
0xDEF42D8A270540FDL, 0x01078EC0A34C22C1L,
|
||||
0xE5DE511AF4C16387L, 0x7EBB3A52BD9A330AL,
|
||||
0x77697857AA7D6435L, 0x004E831603AE4C32L,
|
||||
0xE7A21020AD78E312L, 0x9D41A70C6AB420F2L,
|
||||
0x28E06C18EA1141E6L, 0xD2B28CBD984F6B28L,
|
||||
0x26B75F6C446E9D83L, 0xBA47568C4D418D7FL,
|
||||
0xD80BADBFE6183D8EL, 0x0E206D7F5F166044L,
|
||||
0xE258A43911CBCA3EL, 0x723A1746B21DC0BCL,
|
||||
0xC7CAA854F5D7CDD3L, 0x7CAC32883D261D9CL,
|
||||
0x7690C26423BA942CL, 0x17E55524478042B8L,
|
||||
0xE0BE477656A2389FL, 0x4D289B5E67AB2DA0L,
|
||||
0x44862B9C8FBBFD31L, 0xB47CC8049D141365L,
|
||||
0x822C1B362B91C793L, 0x4EB14655FB13DFD8L,
|
||||
0x1ECBBA0714E2A97BL, 0x6143459D5CDE5F14L,
|
||||
0x53A8FBF1D5F0AC89L, 0x97EA04D81C5E5B00L,
|
||||
0x622181A8D4FDB3F3L, 0xE9BCD341572A1208L,
|
||||
0x1411258643CCE58AL, 0x9144C5FEA4C6E0A4L,
|
||||
0x0D33D06565CF620FL, 0x54A48D489F219CA1L,
|
||||
0xC43E5EAC6D63C821L, 0xA9728B3A72770DAFL,
|
||||
0xD7934E7B20DF87EFL, 0xE35503B61A3E86E5L,
|
||||
0xCAE321FBC819D504L, 0x129A50B3AC60BFA6L,
|
||||
0xCD5E68EA7E9FB6C3L, 0xB01C90199483B1C7L,
|
||||
0x3DE93CD5C295376CL, 0xAED52EDF2AB9AD13L,
|
||||
0x2E60F512C0A07884L, 0xBC3D86A3E36210C9L,
|
||||
0x35269D9B163951CEL, 0x0C7D6E2AD0CDB5FAL,
|
||||
0x59E86297D87F5733L, 0x298EF221898DB0E7L,
|
||||
0x55000029D1A5AA7EL, 0x8BC08AE1B5061B45L,
|
||||
0xC2C31C2B6C92703AL, 0x94CC596BAF25EF42L,
|
||||
0x0A1D73DB22540456L, 0x04B6A0F9D9C4179AL,
|
||||
0xEFFDAFA2AE3D3C60L, 0xF7C8075BB49496C4L,
|
||||
0x9CC5C7141D1CD4E3L, 0x78BD1638218E5534L,
|
||||
0xB2F11568F850246AL, 0xEDFABCFA9502BC29L,
|
||||
0x796CE5F2DA23051BL, 0xAAE128B0DC93537CL,
|
||||
0x3A493DA0EE4B29AEL, 0xB5DF6B2C416895D7L,
|
||||
0xFCABBD25122D7F37L, 0x70810B58105DC4B1L,
|
||||
0xE10FDD37F7882A90L, 0x524DCAB5518A3F5CL,
|
||||
0x3C9E85878451255BL, 0x4029828119BD34E2L,
|
||||
0x74A05B6F5D3CECCBL, 0xB610021542E13ECAL,
|
||||
0x0FF979D12F59E2ACL, 0x6037DA27E4F9CC50L,
|
||||
0x5E92975A0DF1847DL, 0xD66DE190D3E623FEL,
|
||||
0x5032D6B87B568048L, 0x9A36B7CE8235216EL,
|
||||
0x80272A7A24F64B4AL, 0x93EFED8B8C6916F7L,
|
||||
0x37DDBFF44CCE1555L, 0x4B95DB5D4B99BD25L,
|
||||
0x92D3FDA169812FC0L, 0xFB1A4A9A90660BB6L,
|
||||
0x730C196946A4B9B2L, 0x81E289AA7F49DA68L,
|
||||
0x64669A0F83B1A05FL, 0x27B3FF7D9644F48BL,
|
||||
0xCC6B615C8DB675B3L, 0x674F20B9BCEBBE95L,
|
||||
0x6F31238275655982L, 0x5AE488713E45CF05L,
|
||||
0xBF619F9954C21157L, 0xEABAC46040A8EAE9L,
|
||||
0x454C6FE9F2C0C1CDL, 0x419CF6496412691CL,
|
||||
0xD3DC3BEF265B0F70L, 0x6D0E60F5C3578A9EL };
|
||||
|
||||
/** S-Box T4. */
|
||||
private static final long[] T4 = { 0x5B0E608526323C55L, 0x1A46C1A9FA1B59F5L,
|
||||
0xA9E245A17C4C8FFAL, 0x65CA5159DB2955D7L,
|
||||
0x05DB0A76CE35AFC2L, 0x81EAC77EA9113D45L,
|
||||
0x528EF88AB6AC0A0DL, 0xA09EA253597BE3FFL,
|
||||
0x430DDFB3AC48CD56L, 0xC4B3A67AF45CE46FL,
|
||||
0x4ECECFD8FBE2D05EL, 0x3EF56F10B39935F0L,
|
||||
0x0B22D6829CD619C6L, 0x17FD460A74DF2069L,
|
||||
0x6CF8CC8E8510ED40L, 0xD6C824BF3A6ECAA7L,
|
||||
0x61243D581A817049L, 0x048BACB6BBC163A2L,
|
||||
0xD9A38AC27D44CC32L, 0x7FDDFF5BAAF410ABL,
|
||||
0xAD6D495AA804824BL, 0xE1A6A74F2D8C9F94L,
|
||||
0xD4F7851235DEE8E3L, 0xFD4B7F886540D893L,
|
||||
0x247C20042AA4BFDAL, 0x096EA1C517D1327CL,
|
||||
0xD56966B4361A6685L, 0x277DA5C31221057DL,
|
||||
0x94D59893A43ACFF7L, 0x64F0C51CCDC02281L,
|
||||
0x3D33BCC4FF6189DBL, 0xE005CB184CE66AF1L,
|
||||
0xFF5CCD1D1DB99BEAL, 0xB0B854A7FE42980FL,
|
||||
0x7BD46A6A718D4B9FL, 0xD10FA8CC22A5FD8CL,
|
||||
0xD31484952BE4BD31L, 0xC7FA975FCB243847L,
|
||||
0x4886ED1E5846C407L, 0x28CDDB791EB70B04L,
|
||||
0xC2B00BE2F573417FL, 0x5C9590452180F877L,
|
||||
0x7A6BDDFFF370EB00L, 0xCE509E38D6D9D6A4L,
|
||||
0xEBEB0F00647FA702L, 0x1DCC06CF76606F06L,
|
||||
0xE4D9F28BA286FF0AL, 0xD85A305DC918C262L,
|
||||
0x475B1D8732225F54L, 0x2D4FB51668CCB5FEL,
|
||||
0xA679B9D9D72BBA20L, 0x53841C0D912D43A5L,
|
||||
0x3B7EAA48BF12A4E8L, 0x781E0E47F22F1DDFL,
|
||||
0xEFF20CE60AB50973L, 0x20D261D19DFFB742L,
|
||||
0x16A12B03062A2E39L, 0x1960EB2239650495L,
|
||||
0x251C16FED50EB8B8L, 0x9AC0C330F826016EL,
|
||||
0xED152665953E7671L, 0x02D63194A6369570L,
|
||||
0x5074F08394B1C987L, 0x70BA598C90B25CE1L,
|
||||
0x794A15810B9742F6L, 0x0D5925E9FCAF8C6CL,
|
||||
0x3067716CD868744EL, 0x910AB077E8D7731BL,
|
||||
0x6A61BBDB5AC42F61L, 0x93513EFBF0851567L,
|
||||
0xF494724B9E83E9D5L, 0xE887E1985C09648DL,
|
||||
0x34B1D3C675370CFDL, 0xDC35E433BC0D255DL,
|
||||
0xD0AAB84234131BE0L, 0x08042A50B48B7EAFL,
|
||||
0x9997C4EE44A3AB35L, 0x829A7B49201799D0L,
|
||||
0x263B8307B7C54441L, 0x752F95F4FD6A6CA6L,
|
||||
0x927217402C08C6E5L, 0x2A8AB754A795D9EEL,
|
||||
0xA442F7552F72943DL, 0x2C31334E19781208L,
|
||||
0x4FA98D7CEAEE6291L, 0x55C3862F665DB309L,
|
||||
0xBD0610175D53B1F3L, 0x46FE6CB840413F27L,
|
||||
0x3FE03792DF0CFA59L, 0xCFE700372EB85E8FL,
|
||||
0xA7BE29E7ADBCE118L, 0xE544EE5CDE8431DDL,
|
||||
0x8A781B1B41F1873EL, 0xA5C94C78A0D2F0E7L,
|
||||
0x39412E2877B60728L, 0xA1265EF3AFC9A62CL,
|
||||
0xBCC2770C6A2506C5L, 0x3AB66DD5DCE1CE12L,
|
||||
0xE65499D04A675B37L, 0x7D8F523481BFD216L,
|
||||
0x0F6F64FCEC15F389L, 0x74EFBE618B5B13C8L,
|
||||
0xACDC82B714273E1DL, 0xDD40BFE003199D17L,
|
||||
0x37E99257E7E061F8L, 0xFA52626904775AAAL,
|
||||
0x8BBBF63A463D56F9L, 0xF0013F1543A26E64L,
|
||||
0xA8307E9F879EC898L, 0xCC4C27A4150177CCL,
|
||||
0x1B432F2CCA1D3348L, 0xDE1D1F8F9F6FA013L,
|
||||
0x606602A047A7DDD6L, 0xD237AB64CC1CB2C7L,
|
||||
0x9B938E7225FCD1D3L, 0xEC4E03708E0FF476L,
|
||||
0xFEB2FBDA3D03C12DL, 0xAE0BCED2EE43889AL,
|
||||
0x22CB8923EBFB4F43L, 0x69360D013CF7396DL,
|
||||
0x855E3602D2D4E022L, 0x073805BAD01F784CL,
|
||||
0x33E17A133852F546L, 0xDF4874058AC7B638L,
|
||||
0xBA92B29C678AA14AL, 0x0CE89FC76CFAADCDL,
|
||||
0x5F9D4E0908339E34L, 0xF1AFE9291F5923B9L,
|
||||
0x6E3480F60F4A265FL, 0xEEBF3A2AB29B841CL,
|
||||
0xE21938A88F91B4ADL, 0x57DFEFF845C6D3C3L,
|
||||
0x2F006B0BF62CAAF2L, 0x62F479EF6F75EE78L,
|
||||
0x11A55AD41C8916A9L, 0xF229D29084FED453L,
|
||||
0x42F1C27B16B000E6L, 0x2B1F76749823C074L,
|
||||
0x4B76ECA3C2745360L, 0x8C98F463B91691BDL,
|
||||
0x14BCC93CF1ADE66AL, 0x8885213E6D458397L,
|
||||
0x8E177DF0274D4711L, 0xB49B73B5503F2951L,
|
||||
0x10168168C3F96B6BL, 0x0E3D963B63CAB0AEL,
|
||||
0x8DFC4B5655A1DB14L, 0xF789F1356E14DE5CL,
|
||||
0x683E68AF4E51DAC1L, 0xC9A84F9D8D4B0FD9L,
|
||||
0x3691E03F52A0F9D1L, 0x5ED86E46E1878E80L,
|
||||
0x3C711A0E99D07150L, 0x5A0865B20C4E9310L,
|
||||
0x56FBFC1FE4F0682EL, 0xEA8D5DE3105EDF9BL,
|
||||
0x71ABFDB12379187AL, 0x2EB99DE1BEE77B9CL,
|
||||
0x21ECC0EA33CF4523L, 0x59A4D7521805C7A1L,
|
||||
0x3896F5EB56AE7C72L, 0xAA638F3DB18F75DCL,
|
||||
0x9F39358DABE9808EL, 0xB7DEFA91C00B72ACL,
|
||||
0x6B5541FD62492D92L, 0x6DC6DEE8F92E4D5BL,
|
||||
0x353F57ABC4BEEA7EL, 0x735769D6DA5690CEL,
|
||||
0x0A234AA642391484L, 0xF6F9508028F80D9DL,
|
||||
0xB8E319A27AB3F215L, 0x31AD9C1151341A4DL,
|
||||
0x773C22A57BEF5805L, 0x45C7561A07968633L,
|
||||
0xF913DA9E249DBE36L, 0xDA652D9B78A64C68L,
|
||||
0x4C27A97F3BC334EFL, 0x76621220E66B17F4L,
|
||||
0x967743899ACD7D0BL, 0xF3EE5BCAE0ED6782L,
|
||||
0x409F753600C879FCL, 0x06D09A39B5926DB6L,
|
||||
0x6F83AEB0317AC588L, 0x01E6CA4A86381F21L,
|
||||
0x66FF3462D19F3025L, 0x72207C24DDFD3BFBL,
|
||||
0x4AF6B6D3E2ECE2EBL, 0x9C994DBEC7EA08DEL,
|
||||
0x49ACE597B09A8BC4L, 0xB38C4766CF0797BAL,
|
||||
0x131B9373C57C2A75L, 0xB1822CCE61931E58L,
|
||||
0x9D7555B909BA1C0CL, 0x127FAFDD937D11D2L,
|
||||
0x29DA3BADC66D92E4L, 0xA2C1D57154C2ECBCL,
|
||||
0x58C5134D82F6FE24L, 0x1C3AE3515B62274FL,
|
||||
0xE907C82E01CB8126L, 0xF8ED091913E37FCBL,
|
||||
0x3249D8F9C80046C9L, 0x80CF9BEDE388FB63L,
|
||||
0x1881539A116CF19EL, 0x5103F3F76BD52457L,
|
||||
0x15B7E6F5AE47F7A8L, 0xDBD7C6DED47E9CCFL,
|
||||
0x44E55C410228BB1AL, 0xB647D4255EDB4E99L,
|
||||
0x5D11882BB8AAFC30L, 0xF5098BBB29D3212AL,
|
||||
0x8FB5EA14E90296B3L, 0x677B942157DD025AL,
|
||||
0xFB58E7C0A390ACB5L, 0x89D3674C83BD4A01L,
|
||||
0x9E2DA4DF4BF3B93BL, 0xFCC41E328CAB4829L,
|
||||
0x03F38C96BA582C52L, 0xCAD1BDBD7FD85DB2L,
|
||||
0xBBB442C16082AE83L, 0xB95FE86BA5DA9AB0L,
|
||||
0xB22E04673771A93FL, 0x845358C9493152D8L,
|
||||
0xBE2A488697B4541EL, 0x95A2DC2DD38E6966L,
|
||||
0xC02C11AC923C852BL, 0x2388B1990DF2A87BL,
|
||||
0x7C8008FA1B4F37BEL, 0x1F70D0C84D54E503L,
|
||||
0x5490ADEC7ECE57D4L, 0x002B3C27D9063A3AL,
|
||||
0x7EAEA3848030A2BFL, 0xC602326DED2003C0L,
|
||||
0x83A7287D69A94086L, 0xC57A5FCB30F57A8AL,
|
||||
0xB56844E479EBE779L, 0xA373B40F05DCBCE9L,
|
||||
0xD71A786E88570EE2L, 0x879CBACDBDE8F6A0L,
|
||||
0x976AD1BCC164A32FL, 0xAB21E25E9666D78BL,
|
||||
0x901063AAE5E5C33CL, 0x9818B34448698D90L,
|
||||
0xE36487AE3E1E8ABBL, 0xAFBDF931893BDCB4L,
|
||||
0x6345A0DC5FBBD519L, 0x8628FE269B9465CAL,
|
||||
0x1E5D01603F9C51ECL, 0x4DE44006A15049B7L,
|
||||
0xBF6C70E5F776CBB1L, 0x411218F2EF552BEDL,
|
||||
0xCB0C0708705A36A3L, 0xE74D14754F986044L,
|
||||
0xCD56D9430EA8280EL, 0xC12591D7535F5065L,
|
||||
0xC83223F1720AEF96L, 0xC3A0396F7363A51FL };
|
||||
|
||||
// The cached self-test result.
|
||||
private static Boolean valid;
|
||||
|
||||
// The context.
|
||||
private long a, b, c;
|
||||
|
||||
// Constructors.
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Trivial 0-arguments constructor.
|
||||
*/
|
||||
public Tiger()
|
||||
{
|
||||
super(Registry.TIGER_HASH, HASH_SIZE, BLOCK_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* Private copying constructor for cloning.
|
||||
*
|
||||
* @param that The instance being cloned.
|
||||
*/
|
||||
private Tiger(Tiger that)
|
||||
{
|
||||
this();
|
||||
this.a = that.a;
|
||||
this.b = that.b;
|
||||
this.c = that.c;
|
||||
this.count = that.count;
|
||||
this.buffer = (that.buffer != null) ? (byte[]) that.buffer.clone() : null;
|
||||
}
|
||||
|
||||
// Instance methods implementing BaseHash.
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
public Object clone()
|
||||
{
|
||||
return new Tiger(this);
|
||||
}
|
||||
|
||||
public boolean selfTest()
|
||||
{
|
||||
if (valid == null)
|
||||
{
|
||||
valid = new Boolean(DIGEST0.equals(Util.toString(new Tiger().digest())));
|
||||
}
|
||||
return valid.booleanValue();
|
||||
}
|
||||
|
||||
protected byte[] padBuffer()
|
||||
{
|
||||
int n = (int) (count % BLOCK_SIZE);
|
||||
int padding = (n < 56) ? (56 - n) : (120 - n);
|
||||
byte[] pad = new byte[padding + 8];
|
||||
|
||||
pad[0] = 1;
|
||||
long bits = count << 3;
|
||||
|
||||
pad[padding++] = (byte) bits;
|
||||
pad[padding++] = (byte) (bits >>> 8);
|
||||
pad[padding++] = (byte) (bits >>> 16);
|
||||
pad[padding++] = (byte) (bits >>> 24);
|
||||
pad[padding++] = (byte) (bits >>> 32);
|
||||
pad[padding++] = (byte) (bits >>> 40);
|
||||
pad[padding++] = (byte) (bits >>> 48);
|
||||
pad[padding] = (byte) (bits >>> 56);
|
||||
|
||||
return pad;
|
||||
}
|
||||
|
||||
protected byte[] getResult()
|
||||
{
|
||||
return new byte[] { (byte) a, (byte) (a >>> 8), (byte) (a >>> 16),
|
||||
(byte) (a >>> 24), (byte) (a >>> 32), (byte) (a >>> 40),
|
||||
(byte) (a >>> 48), (byte) (a >>> 56), (byte) b,
|
||||
(byte) (b >>> 8), (byte) (b >>> 16), (byte) (b >>> 24),
|
||||
(byte) (b >>> 32), (byte) (b >>> 40), (byte) (b >>> 48),
|
||||
(byte) (b >>> 56), (byte) c, (byte) (c >>> 8),
|
||||
(byte) (c >>> 16), (byte) (c >>> 24), (byte) (c >>> 32),
|
||||
(byte) (c >>> 40), (byte) (c >>> 48), (byte) (c >>> 56) };
|
||||
}
|
||||
|
||||
protected void resetContext()
|
||||
{
|
||||
a = A;
|
||||
b = B;
|
||||
c = C;
|
||||
}
|
||||
|
||||
protected void transform(byte[] in, int offset)
|
||||
{
|
||||
long x0, x1, x2, x3, x4, x5, x6, x7;
|
||||
|
||||
x0 = ((long) in[offset++] & 0xFF) | ((long) (in[offset++] & 0xFF) << 8)
|
||||
| ((long) (in[offset++] & 0xFF) << 16)
|
||||
| ((long) (in[offset++] & 0xFF) << 24)
|
||||
| ((long) (in[offset++] & 0xFF) << 32)
|
||||
| ((long) (in[offset++] & 0xFF) << 40)
|
||||
| ((long) (in[offset++] & 0xFF) << 48)
|
||||
| ((long) (in[offset++] & 0xFF) << 56);
|
||||
x1 = ((long) in[offset++] & 0xFF) | ((long) (in[offset++] & 0xFF) << 8)
|
||||
| ((long) (in[offset++] & 0xFF) << 16)
|
||||
| ((long) (in[offset++] & 0xFF) << 24)
|
||||
| ((long) (in[offset++] & 0xFF) << 32)
|
||||
| ((long) (in[offset++] & 0xFF) << 40)
|
||||
| ((long) (in[offset++] & 0xFF) << 48)
|
||||
| ((long) (in[offset++] & 0xFF) << 56);
|
||||
x2 = ((long) in[offset++] & 0xFF) | ((long) (in[offset++] & 0xFF) << 8)
|
||||
| ((long) (in[offset++] & 0xFF) << 16)
|
||||
| ((long) (in[offset++] & 0xFF) << 24)
|
||||
| ((long) (in[offset++] & 0xFF) << 32)
|
||||
| ((long) (in[offset++] & 0xFF) << 40)
|
||||
| ((long) (in[offset++] & 0xFF) << 48)
|
||||
| ((long) (in[offset++] & 0xFF) << 56);
|
||||
x3 = ((long) in[offset++] & 0xFF) | ((long) (in[offset++] & 0xFF) << 8)
|
||||
| ((long) (in[offset++] & 0xFF) << 16)
|
||||
| ((long) (in[offset++] & 0xFF) << 24)
|
||||
| ((long) (in[offset++] & 0xFF) << 32)
|
||||
| ((long) (in[offset++] & 0xFF) << 40)
|
||||
| ((long) (in[offset++] & 0xFF) << 48)
|
||||
| ((long) (in[offset++] & 0xFF) << 56);
|
||||
x4 = ((long) in[offset++] & 0xFF) | ((long) (in[offset++] & 0xFF) << 8)
|
||||
| ((long) (in[offset++] & 0xFF) << 16)
|
||||
| ((long) (in[offset++] & 0xFF) << 24)
|
||||
| ((long) (in[offset++] & 0xFF) << 32)
|
||||
| ((long) (in[offset++] & 0xFF) << 40)
|
||||
| ((long) (in[offset++] & 0xFF) << 48)
|
||||
| ((long) (in[offset++] & 0xFF) << 56);
|
||||
x5 = ((long) in[offset++] & 0xFF) | ((long) (in[offset++] & 0xFF) << 8)
|
||||
| ((long) (in[offset++] & 0xFF) << 16)
|
||||
| ((long) (in[offset++] & 0xFF) << 24)
|
||||
| ((long) (in[offset++] & 0xFF) << 32)
|
||||
| ((long) (in[offset++] & 0xFF) << 40)
|
||||
| ((long) (in[offset++] & 0xFF) << 48)
|
||||
| ((long) (in[offset++] & 0xFF) << 56);
|
||||
x6 = ((long) in[offset++] & 0xFF) | ((long) (in[offset++] & 0xFF) << 8)
|
||||
| ((long) (in[offset++] & 0xFF) << 16)
|
||||
| ((long) (in[offset++] & 0xFF) << 24)
|
||||
| ((long) (in[offset++] & 0xFF) << 32)
|
||||
| ((long) (in[offset++] & 0xFF) << 40)
|
||||
| ((long) (in[offset++] & 0xFF) << 48)
|
||||
| ((long) (in[offset++] & 0xFF) << 56);
|
||||
x7 = ((long) in[offset++] & 0xFF) | ((long) (in[offset++] & 0xFF) << 8)
|
||||
| ((long) (in[offset++] & 0xFF) << 16)
|
||||
| ((long) (in[offset++] & 0xFF) << 24)
|
||||
| ((long) (in[offset++] & 0xFF) << 32)
|
||||
| ((long) (in[offset++] & 0xFF) << 40)
|
||||
| ((long) (in[offset++] & 0xFF) << 48)
|
||||
| ((long) (in[offset] & 0xFF) << 56);
|
||||
|
||||
// save_abc ::=
|
||||
long aa = a, bb = b, cc = c;
|
||||
|
||||
// pass(aa, bb, cc, 5) ::=
|
||||
cc ^= x0;
|
||||
aa -= T1[(int) cc & 0xff] ^ T2[(int) (cc >> 16) & 0xff]
|
||||
^ T3[(int) (cc >> 32) & 0xff] ^ T4[(int) (cc >> 48) & 0xff];
|
||||
bb += T4[(int) (cc >> 8) & 0xff] ^ T3[(int) (cc >> 24) & 0xff]
|
||||
^ T2[(int) (cc >> 40) & 0xff] ^ T1[(int) (cc >> 56) & 0xff];
|
||||
bb *= 5;
|
||||
aa ^= x1;
|
||||
bb -= T1[(int) aa & 0xff] ^ T2[(int) (aa >> 16) & 0xff]
|
||||
^ T3[(int) (aa >> 32) & 0xff] ^ T4[(int) (aa >> 48) & 0xff];
|
||||
cc += T4[(int) (aa >> 8) & 0xff] ^ T3[(int) (aa >> 24) & 0xff]
|
||||
^ T2[(int) (aa >> 40) & 0xff] ^ T1[(int) (aa >> 56) & 0xff];
|
||||
cc *= 5;
|
||||
bb ^= x2;
|
||||
cc -= T1[(int) bb & 0xff] ^ T2[(int) (bb >> 16) & 0xff]
|
||||
^ T3[(int) (bb >> 32) & 0xff] ^ T4[(int) (bb >> 48) & 0xff];
|
||||
aa += T4[(int) (bb >> 8) & 0xff] ^ T3[(int) (bb >> 24) & 0xff]
|
||||
^ T2[(int) (bb >> 40) & 0xff] ^ T1[(int) (bb >> 56) & 0xff];
|
||||
aa *= 5;
|
||||
cc ^= x3;
|
||||
aa -= T1[(int) cc & 0xff] ^ T2[(int) (cc >> 16) & 0xff]
|
||||
^ T3[(int) (cc >> 32) & 0xff] ^ T4[(int) (cc >> 48) & 0xff];
|
||||
bb += T4[(int) (cc >> 8) & 0xff] ^ T3[(int) (cc >> 24) & 0xff]
|
||||
^ T2[(int) (cc >> 40) & 0xff] ^ T1[(int) (cc >> 56) & 0xff];
|
||||
bb *= 5;
|
||||
aa ^= x4;
|
||||
bb -= T1[(int) aa & 0xff] ^ T2[(int) (aa >> 16) & 0xff]
|
||||
^ T3[(int) (aa >> 32) & 0xff] ^ T4[(int) (aa >> 48) & 0xff];
|
||||
cc += T4[(int) (aa >> 8) & 0xff] ^ T3[(int) (aa >> 24) & 0xff]
|
||||
^ T2[(int) (aa >> 40) & 0xff] ^ T1[(int) (aa >> 56) & 0xff];
|
||||
cc *= 5;
|
||||
bb ^= x5;
|
||||
cc -= T1[(int) bb & 0xff] ^ T2[(int) (bb >> 16) & 0xff]
|
||||
^ T3[(int) (bb >> 32) & 0xff] ^ T4[(int) (bb >> 48) & 0xff];
|
||||
aa += T4[(int) (bb >> 8) & 0xff] ^ T3[(int) (bb >> 24) & 0xff]
|
||||
^ T2[(int) (bb >> 40) & 0xff] ^ T1[(int) (bb >> 56) & 0xff];
|
||||
aa *= 5;
|
||||
cc ^= x6;
|
||||
aa -= T1[(int) cc & 0xff] ^ T2[(int) (cc >> 16) & 0xff]
|
||||
^ T3[(int) (cc >> 32) & 0xff] ^ T4[(int) (cc >> 48) & 0xff];
|
||||
bb += T4[(int) (cc >> 8) & 0xff] ^ T3[(int) (cc >> 24) & 0xff]
|
||||
^ T2[(int) (cc >> 40) & 0xff] ^ T1[(int) (cc >> 56) & 0xff];
|
||||
bb *= 5;
|
||||
aa ^= x7;
|
||||
bb -= T1[(int) aa & 0xff] ^ T2[(int) (aa >> 16) & 0xff]
|
||||
^ T3[(int) (aa >> 32) & 0xff] ^ T4[(int) (aa >> 48) & 0xff];
|
||||
cc += T4[(int) (aa >> 8) & 0xff] ^ T3[(int) (aa >> 24) & 0xff]
|
||||
^ T2[(int) (aa >> 40) & 0xff] ^ T1[(int) (aa >> 56) & 0xff];
|
||||
cc *= 5;
|
||||
|
||||
// key_schedule ::=
|
||||
x0 -= x7 ^ 0xA5A5A5A5A5A5A5A5L;
|
||||
x1 ^= x0;
|
||||
x2 += x1;
|
||||
x3 -= x2 ^ ((~x1) << 19);
|
||||
x4 ^= x3;
|
||||
x5 += x4;
|
||||
x6 -= x5 ^ ((~x4) >>> 23);
|
||||
x7 ^= x6;
|
||||
x0 += x7;
|
||||
x1 -= x0 ^ ((~x7) << 19);
|
||||
x2 ^= x1;
|
||||
x3 += x2;
|
||||
x4 -= x3 ^ ((~x2) >>> 23);
|
||||
x5 ^= x4;
|
||||
x6 += x5;
|
||||
x7 -= x6 ^ 0x0123456789ABCDEFL;
|
||||
|
||||
// pass(cc, aa, bb, 7) ::=
|
||||
bb ^= x0;
|
||||
cc -= T1[(int) bb & 0xff] ^ T2[(int) (bb >> 16) & 0xff]
|
||||
^ T3[(int) (bb >> 32) & 0xff] ^ T4[(int) (bb >> 48) & 0xff];
|
||||
aa += T4[(int) (bb >> 8) & 0xff] ^ T3[(int) (bb >> 24) & 0xff]
|
||||
^ T2[(int) (bb >> 40) & 0xff] ^ T1[(int) (bb >> 56) & 0xff];
|
||||
aa *= 7;
|
||||
cc ^= x1;
|
||||
aa -= T1[(int) cc & 0xff] ^ T2[(int) (cc >> 16) & 0xff]
|
||||
^ T3[(int) (cc >> 32) & 0xff] ^ T4[(int) (cc >> 48) & 0xff];
|
||||
bb += T4[(int) (cc >> 8) & 0xff] ^ T3[(int) (cc >> 24) & 0xff]
|
||||
^ T2[(int) (cc >> 40) & 0xff] ^ T1[(int) (cc >> 56) & 0xff];
|
||||
bb *= 7;
|
||||
aa ^= x2;
|
||||
bb -= T1[(int) aa & 0xff] ^ T2[(int) (aa >> 16) & 0xff]
|
||||
^ T3[(int) (aa >> 32) & 0xff] ^ T4[(int) (aa >> 48) & 0xff];
|
||||
cc += T4[(int) (aa >> 8) & 0xff] ^ T3[(int) (aa >> 24) & 0xff]
|
||||
^ T2[(int) (aa >> 40) & 0xff] ^ T1[(int) (aa >> 56) & 0xff];
|
||||
cc *= 7;
|
||||
bb ^= x3;
|
||||
cc -= T1[(int) bb & 0xff] ^ T2[(int) (bb >> 16) & 0xff]
|
||||
^ T3[(int) (bb >> 32) & 0xff] ^ T4[(int) (bb >> 48) & 0xff];
|
||||
aa += T4[(int) (bb >> 8) & 0xff] ^ T3[(int) (bb >> 24) & 0xff]
|
||||
^ T2[(int) (bb >> 40) & 0xff] ^ T1[(int) (bb >> 56) & 0xff];
|
||||
aa *= 7;
|
||||
cc ^= x4;
|
||||
aa -= T1[(int) cc & 0xff] ^ T2[(int) (cc >> 16) & 0xff]
|
||||
^ T3[(int) (cc >> 32) & 0xff] ^ T4[(int) (cc >> 48) & 0xff];
|
||||
bb += T4[(int) (cc >> 8) & 0xff] ^ T3[(int) (cc >> 24) & 0xff]
|
||||
^ T2[(int) (cc >> 40) & 0xff] ^ T1[(int) (cc >> 56) & 0xff];
|
||||
bb *= 7;
|
||||
aa ^= x5;
|
||||
bb -= T1[(int) aa & 0xff] ^ T2[(int) (aa >> 16) & 0xff]
|
||||
^ T3[(int) (aa >> 32) & 0xff] ^ T4[(int) (aa >> 48) & 0xff];
|
||||
cc += T4[(int) (aa >> 8) & 0xff] ^ T3[(int) (aa >> 24) & 0xff]
|
||||
^ T2[(int) (aa >> 40) & 0xff] ^ T1[(int) (aa >> 56) & 0xff];
|
||||
cc *= 7;
|
||||
bb ^= x6;
|
||||
cc -= T1[(int) bb & 0xff] ^ T2[(int) (bb >> 16) & 0xff]
|
||||
^ T3[(int) (bb >> 32) & 0xff] ^ T4[(int) (bb >> 48) & 0xff];
|
||||
aa += T4[(int) (bb >> 8) & 0xff] ^ T3[(int) (bb >> 24) & 0xff]
|
||||
^ T2[(int) (bb >> 40) & 0xff] ^ T1[(int) (bb >> 56) & 0xff];
|
||||
aa *= 7;
|
||||
cc ^= x7;
|
||||
aa -= T1[(int) cc & 0xff] ^ T2[(int) (cc >> 16) & 0xff]
|
||||
^ T3[(int) (cc >> 32) & 0xff] ^ T4[(int) (cc >> 48) & 0xff];
|
||||
bb += T4[(int) (cc >> 8) & 0xff] ^ T3[(int) (cc >> 24) & 0xff]
|
||||
^ T2[(int) (cc >> 40) & 0xff] ^ T1[(int) (cc >> 56) & 0xff];
|
||||
bb *= 7;
|
||||
|
||||
// key_schedule ::=
|
||||
x0 -= x7 ^ 0xA5A5A5A5A5A5A5A5L;
|
||||
x1 ^= x0;
|
||||
x2 += x1;
|
||||
x3 -= x2 ^ ((~x1) << 19);
|
||||
x4 ^= x3;
|
||||
x5 += x4;
|
||||
x6 -= x5 ^ ((~x4) >>> 23);
|
||||
x7 ^= x6;
|
||||
x0 += x7;
|
||||
x1 -= x0 ^ ((~x7) << 19);
|
||||
x2 ^= x1;
|
||||
x3 += x2;
|
||||
x4 -= x3 ^ ((~x2) >>> 23);
|
||||
x5 ^= x4;
|
||||
x6 += x5;
|
||||
x7 -= x6 ^ 0x0123456789ABCDEFL;
|
||||
|
||||
// pass(bb,cc,aa,9) ::=
|
||||
aa ^= x0;
|
||||
bb -= T1[(int) aa & 0xff] ^ T2[(int) (aa >> 16) & 0xff]
|
||||
^ T3[(int) (aa >> 32) & 0xff] ^ T4[(int) (aa >> 48) & 0xff];
|
||||
cc += T4[(int) (aa >> 8) & 0xff] ^ T3[(int) (aa >> 24) & 0xff]
|
||||
^ T2[(int) (aa >> 40) & 0xff] ^ T1[(int) (aa >> 56) & 0xff];
|
||||
cc *= 9;
|
||||
bb ^= x1;
|
||||
cc -= T1[(int) bb & 0xff] ^ T2[(int) (bb >> 16) & 0xff]
|
||||
^ T3[(int) (bb >> 32) & 0xff] ^ T4[(int) (bb >> 48) & 0xff];
|
||||
aa += T4[(int) (bb >> 8) & 0xff] ^ T3[(int) (bb >> 24) & 0xff]
|
||||
^ T2[(int) (bb >> 40) & 0xff] ^ T1[(int) (bb >> 56) & 0xff];
|
||||
aa *= 9;
|
||||
cc ^= x2;
|
||||
aa -= T1[(int) cc & 0xff] ^ T2[(int) (cc >> 16) & 0xff]
|
||||
^ T3[(int) (cc >> 32) & 0xff] ^ T4[(int) (cc >> 48) & 0xff];
|
||||
bb += T4[(int) (cc >> 8) & 0xff] ^ T3[(int) (cc >> 24) & 0xff]
|
||||
^ T2[(int) (cc >> 40) & 0xff] ^ T1[(int) (cc >> 56) & 0xff];
|
||||
bb *= 9;
|
||||
aa ^= x3;
|
||||
bb -= T1[(int) aa & 0xff] ^ T2[(int) (aa >> 16) & 0xff]
|
||||
^ T3[(int) (aa >> 32) & 0xff] ^ T4[(int) (aa >> 48) & 0xff];
|
||||
cc += T4[(int) (aa >> 8) & 0xff] ^ T3[(int) (aa >> 24) & 0xff]
|
||||
^ T2[(int) (aa >> 40) & 0xff] ^ T1[(int) (aa >> 56) & 0xff];
|
||||
cc *= 9;
|
||||
bb ^= x4;
|
||||
cc -= T1[(int) bb & 0xff] ^ T2[(int) (bb >> 16) & 0xff]
|
||||
^ T3[(int) (bb >> 32) & 0xff] ^ T4[(int) (bb >> 48) & 0xff];
|
||||
aa += T4[(int) (bb >> 8) & 0xff] ^ T3[(int) (bb >> 24) & 0xff]
|
||||
^ T2[(int) (bb >> 40) & 0xff] ^ T1[(int) (bb >> 56) & 0xff];
|
||||
aa *= 9;
|
||||
cc ^= x5;
|
||||
aa -= T1[(int) cc & 0xff] ^ T2[(int) (cc >> 16) & 0xff]
|
||||
^ T3[(int) (cc >> 32) & 0xff] ^ T4[(int) (cc >> 48) & 0xff];
|
||||
bb += T4[(int) (cc >> 8) & 0xff] ^ T3[(int) (cc >> 24) & 0xff]
|
||||
^ T2[(int) (cc >> 40) & 0xff] ^ T1[(int) (cc >> 56) & 0xff];
|
||||
bb *= 9;
|
||||
aa ^= x6;
|
||||
bb -= T1[(int) aa & 0xff] ^ T2[(int) (aa >> 16) & 0xff]
|
||||
^ T3[(int) (aa >> 32) & 0xff] ^ T4[(int) (aa >> 48) & 0xff];
|
||||
cc += T4[(int) (aa >> 8) & 0xff] ^ T3[(int) (aa >> 24) & 0xff]
|
||||
^ T2[(int) (aa >> 40) & 0xff] ^ T1[(int) (aa >> 56) & 0xff];
|
||||
cc *= 9;
|
||||
bb ^= x7;
|
||||
cc -= T1[(int) bb & 0xff] ^ T2[(int) (bb >> 16) & 0xff]
|
||||
^ T3[(int) (bb >> 32) & 0xff] ^ T4[(int) (bb >> 48) & 0xff];
|
||||
aa += T4[(int) (bb >> 8) & 0xff] ^ T3[(int) (bb >> 24) & 0xff]
|
||||
^ T2[(int) (bb >> 40) & 0xff] ^ T1[(int) (bb >> 56) & 0xff];
|
||||
aa *= 9;
|
||||
|
||||
// feedforward ::=
|
||||
a ^= aa;
|
||||
b = bb - b;
|
||||
c += cc;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,626 @@
|
||||
/* Whirlpool.java --
|
||||
Copyright (C) 2001, 2002, 2006 Free Software Foundation, Inc.
|
||||
|
||||
This file is a part of GNU Classpath.
|
||||
|
||||
GNU Classpath is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or (at
|
||||
your option) any later version.
|
||||
|
||||
GNU Classpath is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with GNU Classpath; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
|
||||
USA
|
||||
|
||||
Linking this library statically or dynamically with other modules is
|
||||
making a combined work based on this library. Thus, the terms and
|
||||
conditions of the GNU General Public License cover the whole
|
||||
combination.
|
||||
|
||||
As a special exception, the copyright holders of this library give you
|
||||
permission to link this library with independent modules to produce an
|
||||
executable, regardless of the license terms of these independent
|
||||
modules, and to copy and distribute the resulting executable under
|
||||
terms of your choice, provided that you also meet, for each linked
|
||||
independent module, the terms and conditions of the license of that
|
||||
module. An independent module is a module which is not derived from
|
||||
or based on this library. If you modify this library, you may extend
|
||||
this exception to your version of the library, but you are not
|
||||
obligated to do so. If you do not wish to do so, delete this
|
||||
exception statement from your version. */
|
||||
|
||||
|
||||
package gnu.java.security.hash;
|
||||
|
||||
import gnu.java.security.Registry;
|
||||
import gnu.java.security.util.Util;
|
||||
|
||||
/**
|
||||
* <p>Whirlpool, a new 512-bit hashing function operating on messages less than
|
||||
* 2 ** 256 bits in length. The function structure is designed according to the
|
||||
* Wide Trail strategy and permits a wide variety of implementation trade-offs.
|
||||
* </p>
|
||||
*
|
||||
* <p><b>IMPORTANT</b>: This implementation is not thread-safe.</p>
|
||||
*
|
||||
* <p>References:</p>
|
||||
*
|
||||
* <ol>
|
||||
* <li><a href="http://planeta.terra.com.br/informatica/paulobarreto/WhirlpoolPage.html">
|
||||
* The WHIRLPOOL Hashing Function</a>.<br>
|
||||
* <a href="mailto:paulo.barreto@terra.com.br">Paulo S.L.M. Barreto</a> and
|
||||
* <a href="mailto:vincent.rijmen@esat.kuleuven.ac.be">Vincent Rijmen</a>.</li>
|
||||
* </ol>
|
||||
*/
|
||||
public final class Whirlpool extends BaseHash
|
||||
{
|
||||
|
||||
// Debugging methods and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private static final boolean DEBUG = false;
|
||||
|
||||
private static final int debuglevel = 3;
|
||||
|
||||
// Constants and variables
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
private static final int BLOCK_SIZE = 64; // inner block size in bytes
|
||||
|
||||
/** The digest of the 0-bit long message. */
|
||||
private static final String DIGEST0 = "470F0409ABAA446E49667D4EBE12A14387CEDBD10DD17B8243CAD550A089DC0F"
|
||||
+ "EEA7AA40F6C2AAAB71C6EBD076E43C7CFCA0AD32567897DCB5969861049A0F5A";
|
||||
|
||||
private static final int R = 10; // default number of rounds
|
||||
|
||||
private static final String Sd = // p. 19 [WHIRLPOOL]
|
||||
"\u1823\uc6E8\u87B8\u014F\u36A6\ud2F5\u796F\u9152"
|
||||
+ "\u60Bc\u9B8E\uA30c\u7B35\u1dE0\ud7c2\u2E4B\uFE57"
|
||||
+ "\u1577\u37E5\u9FF0\u4AdA\u58c9\u290A\uB1A0\u6B85"
|
||||
+ "\uBd5d\u10F4\ucB3E\u0567\uE427\u418B\uA77d\u95d8"
|
||||
+ "\uFBEE\u7c66\udd17\u479E\ucA2d\uBF07\uAd5A\u8333"
|
||||
+ "\u6302\uAA71\uc819\u49d9\uF2E3\u5B88\u9A26\u32B0"
|
||||
+ "\uE90F\ud580\uBEcd\u3448\uFF7A\u905F\u2068\u1AAE"
|
||||
+ "\uB454\u9322\u64F1\u7312\u4008\uc3Ec\udBA1\u8d3d"
|
||||
+ "\u9700\ucF2B\u7682\ud61B\uB5AF\u6A50\u45F3\u30EF"
|
||||
+ "\u3F55\uA2EA\u65BA\u2Fc0\udE1c\uFd4d\u9275\u068A"
|
||||
+ "\uB2E6\u0E1F\u62d4\uA896\uF9c5\u2559\u8472\u394c"
|
||||
+ "\u5E78\u388c\ud1A5\uE261\uB321\u9c1E\u43c7\uFc04"
|
||||
+ "\u5199\u6d0d\uFAdF\u7E24\u3BAB\ucE11\u8F4E\uB7EB"
|
||||
+ "\u3c81\u94F7\uB913\u2cd3\uE76E\uc403\u5644\u7FA9"
|
||||
+ "\u2ABB\uc153\udc0B\u9d6c\u3174\uF646\uAc89\u14E1"
|
||||
+ "\u163A\u6909\u70B6\ud0Ed\ucc42\u98A4\u285c\uF886";
|
||||
|
||||
private static final long[] T0 = new long[256];
|
||||
|
||||
private static final long[] T1 = new long[256];
|
||||
|
||||
private static final long[] T2 = new long[256];
|
||||
|
||||
private static final long[] T3 = new long[256];
|
||||
|
||||
private static final long[] T4 = new long[256];
|
||||
|
||||
private static final long[] T5 = new long[256];
|
||||
|
||||
private static final long[] T6 = new long[256];
|
||||
|
||||
private static final long[] T7 = new long[256];
|
||||
|
||||
private static final long[] rc = new long[R];
|
||||
|
||||
/** caches the result of the correctness test, once executed. */
|
||||
private static Boolean valid;
|
||||
|
||||
/** The 512-bit context as 8 longs. */
|
||||
private long H0, H1, H2, H3, H4, H5, H6, H7;
|
||||
|
||||
/** Work area for computing the round key schedule. */
|
||||
private long k00, k01, k02, k03, k04, k05, k06, k07;
|
||||
|
||||
private long Kr0, Kr1, Kr2, Kr3, Kr4, Kr5, Kr6, Kr7;
|
||||
|
||||
/** work area for transforming the 512-bit buffer. */
|
||||
private long n0, n1, n2, n3, n4, n5, n6, n7;
|
||||
|
||||
private long nn0, nn1, nn2, nn3, nn4, nn5, nn6, nn7;
|
||||
|
||||
/** work area for holding block cipher's intermediate values. */
|
||||
private long w0, w1, w2, w3, w4, w5, w6, w7;
|
||||
|
||||
// Static code - to intialise lookup tables --------------------------------
|
||||
|
||||
static
|
||||
{
|
||||
long time = System.currentTimeMillis();
|
||||
|
||||
int ROOT = 0x11d; // para. 2.1 [WHIRLPOOL]
|
||||
int i, r, j;
|
||||
long s, s2, s3, s4, s5, s8, s9, t;
|
||||
char c;
|
||||
final byte[] S = new byte[256];
|
||||
for (i = 0; i < 256; i++)
|
||||
{
|
||||
c = Sd.charAt(i >>> 1);
|
||||
|
||||
s = ((i & 1) == 0 ? c >>> 8 : c) & 0xFFL;
|
||||
s2 = s << 1;
|
||||
if (s2 > 0xFFL)
|
||||
{
|
||||
s2 ^= ROOT;
|
||||
}
|
||||
s3 = s2 ^ s;
|
||||
s4 = s2 << 1;
|
||||
if (s4 > 0xFFL)
|
||||
{
|
||||
s4 ^= ROOT;
|
||||
}
|
||||
s5 = s4 ^ s;
|
||||
s8 = s4 << 1;
|
||||
if (s8 > 0xFFL)
|
||||
{
|
||||
s8 ^= ROOT;
|
||||
}
|
||||
s9 = s8 ^ s;
|
||||
|
||||
S[i] = (byte) s;
|
||||
T0[i] = t = s << 56 | s << 48 | s3 << 40 | s << 32 | s5 << 24
|
||||
| s8 << 16 | s9 << 8 | s5;
|
||||
T1[i] = t >>> 8 | t << 56;
|
||||
T2[i] = t >>> 16 | t << 48;
|
||||
T3[i] = t >>> 24 | t << 40;
|
||||
T4[i] = t >>> 32 | t << 32;
|
||||
T5[i] = t >>> 40 | t << 24;
|
||||
T6[i] = t >>> 48 | t << 16;
|
||||
T7[i] = t >>> 56 | t << 8;
|
||||
}
|
||||
|
||||
for (r = 1, i = 0, j = 0; r < R + 1; r++)
|
||||
{
|
||||
rc[i++] = (S[j++] & 0xFFL) << 56 | (S[j++] & 0xFFL) << 48
|
||||
| (S[j++] & 0xFFL) << 40 | (S[j++] & 0xFFL) << 32
|
||||
| (S[j++] & 0xFFL) << 24 | (S[j++] & 0xFFL) << 16
|
||||
| (S[j++] & 0xFFL) << 8 | (S[j++] & 0xFFL);
|
||||
}
|
||||
|
||||
time = System.currentTimeMillis() - time;
|
||||
|
||||
if (DEBUG && debuglevel > 8)
|
||||
{
|
||||
System.out.println("==========");
|
||||
System.out.println();
|
||||
System.out.println("Static data");
|
||||
System.out.println();
|
||||
|
||||
System.out.println();
|
||||
System.out.println("T0[]:");
|
||||
for (i = 0; i < 64; i++)
|
||||
{
|
||||
for (j = 0; j < 4; j++)
|
||||
{
|
||||
System.out.print("0x" + Util.toString(T0[i * 4 + j]) + ", ");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
System.out.println();
|
||||
System.out.println("T1[]:");
|
||||
for (i = 0; i < 64; i++)
|
||||
{
|
||||
for (j = 0; j < 4; j++)
|
||||
{
|
||||
System.out.print("0x" + Util.toString(T1[i * 4 + j]) + ", ");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
System.out.println();
|
||||
System.out.println("T2[]:");
|
||||
for (i = 0; i < 64; i++)
|
||||
{
|
||||
for (j = 0; j < 4; j++)
|
||||
{
|
||||
System.out.print("0x" + Util.toString(T2[i * 4 + j]) + ", ");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
System.out.println();
|
||||
System.out.println("T3[]:");
|
||||
for (i = 0; i < 64; i++)
|
||||
{
|
||||
for (j = 0; j < 4; j++)
|
||||
{
|
||||
System.out.print("0x" + Util.toString(T3[i * 4 + j]) + ", ");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
System.out.println();
|
||||
System.out.println("T4[]:");
|
||||
for (i = 0; i < 64; i++)
|
||||
{
|
||||
for (j = 0; j < 4; j++)
|
||||
{
|
||||
System.out.print("0x" + Util.toString(T4[i * 4 + j]) + ", ");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
System.out.println();
|
||||
System.out.println("T5[]:");
|
||||
for (i = 0; i < 64; i++)
|
||||
{
|
||||
for (j = 0; j < 4; j++)
|
||||
{
|
||||
System.out.print("0x" + Util.toString(T5[i * 4 + j]) + ", ");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
System.out.println();
|
||||
System.out.println("T6[]:");
|
||||
for (i = 0; i < 64; i++)
|
||||
{
|
||||
for (j = 0; j < 4; j++)
|
||||
{
|
||||
System.out.print("0x" + Util.toString(T5[i * 4 + j]) + ", ");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
System.out.println();
|
||||
System.out.println("T7[]:");
|
||||
for (i = 0; i < 64; i++)
|
||||
{
|
||||
for (j = 0; j < 4; j++)
|
||||
{
|
||||
System.out.print("0x" + Util.toString(T5[i * 4 + j]) + ", ");
|
||||
}
|
||||
System.out.println();
|
||||
}
|
||||
System.out.println();
|
||||
System.out.println("rc[]:");
|
||||
for (i = 0; i < R; i++)
|
||||
{
|
||||
System.out.println("0x" + Util.toString(rc[i]));
|
||||
}
|
||||
System.out.println();
|
||||
|
||||
System.out.println();
|
||||
System.out.println("Total initialization time: " + time + " ms.");
|
||||
System.out.println();
|
||||
}
|
||||
}
|
||||
|
||||
// Constructor(s)
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/** Trivial 0-arguments constructor. */
|
||||
public Whirlpool()
|
||||
{
|
||||
super(Registry.WHIRLPOOL_HASH, 20, BLOCK_SIZE);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Private constructor for cloning purposes.</p>
|
||||
*
|
||||
* @param md the instance to clone.
|
||||
*/
|
||||
private Whirlpool(Whirlpool md)
|
||||
{
|
||||
this();
|
||||
|
||||
this.H0 = md.H0;
|
||||
this.H1 = md.H1;
|
||||
this.H2 = md.H2;
|
||||
this.H3 = md.H3;
|
||||
this.H4 = md.H4;
|
||||
this.H5 = md.H5;
|
||||
this.H6 = md.H6;
|
||||
this.H7 = md.H7;
|
||||
this.count = md.count;
|
||||
this.buffer = (byte[]) md.buffer.clone();
|
||||
}
|
||||
|
||||
// Class methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// Instance methods
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
// java.lang.Cloneable interface implementation ----------------------------
|
||||
|
||||
public Object clone()
|
||||
{
|
||||
return (new Whirlpool(this));
|
||||
}
|
||||
|
||||
// Implementation of concrete methods in BaseHash --------------------------
|
||||
|
||||
protected void transform(byte[] in, int offset)
|
||||
{
|
||||
// apply mu to the input
|
||||
n0 = (in[offset++] & 0xFFL) << 56 | (in[offset++] & 0xFFL) << 48
|
||||
| (in[offset++] & 0xFFL) << 40 | (in[offset++] & 0xFFL) << 32
|
||||
| (in[offset++] & 0xFFL) << 24 | (in[offset++] & 0xFFL) << 16
|
||||
| (in[offset++] & 0xFFL) << 8 | (in[offset++] & 0xFFL);
|
||||
n1 = (in[offset++] & 0xFFL) << 56 | (in[offset++] & 0xFFL) << 48
|
||||
| (in[offset++] & 0xFFL) << 40 | (in[offset++] & 0xFFL) << 32
|
||||
| (in[offset++] & 0xFFL) << 24 | (in[offset++] & 0xFFL) << 16
|
||||
| (in[offset++] & 0xFFL) << 8 | (in[offset++] & 0xFFL);
|
||||
n2 = (in[offset++] & 0xFFL) << 56 | (in[offset++] & 0xFFL) << 48
|
||||
| (in[offset++] & 0xFFL) << 40 | (in[offset++] & 0xFFL) << 32
|
||||
| (in[offset++] & 0xFFL) << 24 | (in[offset++] & 0xFFL) << 16
|
||||
| (in[offset++] & 0xFFL) << 8 | (in[offset++] & 0xFFL);
|
||||
n3 = (in[offset++] & 0xFFL) << 56 | (in[offset++] & 0xFFL) << 48
|
||||
| (in[offset++] & 0xFFL) << 40 | (in[offset++] & 0xFFL) << 32
|
||||
| (in[offset++] & 0xFFL) << 24 | (in[offset++] & 0xFFL) << 16
|
||||
| (in[offset++] & 0xFFL) << 8 | (in[offset++] & 0xFFL);
|
||||
n4 = (in[offset++] & 0xFFL) << 56 | (in[offset++] & 0xFFL) << 48
|
||||
| (in[offset++] & 0xFFL) << 40 | (in[offset++] & 0xFFL) << 32
|
||||
| (in[offset++] & 0xFFL) << 24 | (in[offset++] & 0xFFL) << 16
|
||||
| (in[offset++] & 0xFFL) << 8 | (in[offset++] & 0xFFL);
|
||||
n5 = (in[offset++] & 0xFFL) << 56 | (in[offset++] & 0xFFL) << 48
|
||||
| (in[offset++] & 0xFFL) << 40 | (in[offset++] & 0xFFL) << 32
|
||||
| (in[offset++] & 0xFFL) << 24 | (in[offset++] & 0xFFL) << 16
|
||||
| (in[offset++] & 0xFFL) << 8 | (in[offset++] & 0xFFL);
|
||||
n6 = (in[offset++] & 0xFFL) << 56 | (in[offset++] & 0xFFL) << 48
|
||||
| (in[offset++] & 0xFFL) << 40 | (in[offset++] & 0xFFL) << 32
|
||||
| (in[offset++] & 0xFFL) << 24 | (in[offset++] & 0xFFL) << 16
|
||||
| (in[offset++] & 0xFFL) << 8 | (in[offset++] & 0xFFL);
|
||||
n7 = (in[offset++] & 0xFFL) << 56 | (in[offset++] & 0xFFL) << 48
|
||||
| (in[offset++] & 0xFFL) << 40 | (in[offset++] & 0xFFL) << 32
|
||||
| (in[offset++] & 0xFFL) << 24 | (in[offset++] & 0xFFL) << 16
|
||||
| (in[offset++] & 0xFFL) << 8 | (in[offset++] & 0xFFL);
|
||||
|
||||
// transform K into the key schedule Kr; 0 <= r <= R
|
||||
k00 = H0;
|
||||
k01 = H1;
|
||||
k02 = H2;
|
||||
k03 = H3;
|
||||
k04 = H4;
|
||||
k05 = H5;
|
||||
k06 = H6;
|
||||
k07 = H7;
|
||||
|
||||
nn0 = n0 ^ k00;
|
||||
nn1 = n1 ^ k01;
|
||||
nn2 = n2 ^ k02;
|
||||
nn3 = n3 ^ k03;
|
||||
nn4 = n4 ^ k04;
|
||||
nn5 = n5 ^ k05;
|
||||
nn6 = n6 ^ k06;
|
||||
nn7 = n7 ^ k07;
|
||||
|
||||
// intermediate cipher output
|
||||
w0 = w1 = w2 = w3 = w4 = w5 = w6 = w7 = 0L;
|
||||
|
||||
for (int r = 0; r < R; r++)
|
||||
{
|
||||
// 1. compute intermediate round key schedule by applying ro[rc]
|
||||
// to the previous round key schedule --rc being the round constant
|
||||
Kr0 = T0[(int) ((k00 >> 56) & 0xFFL)] ^ T1[(int) ((k07 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((k06 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((k05 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((k04 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((k03 >> 16) & 0xFFL)]
|
||||
^ T6[(int) ((k02 >> 8) & 0xFFL)] ^ T7[(int) (k01 & 0xFFL)]
|
||||
^ rc[r];
|
||||
|
||||
Kr1 = T0[(int) ((k01 >> 56) & 0xFFL)] ^ T1[(int) ((k00 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((k07 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((k06 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((k05 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((k04 >> 16) & 0xFFL)]
|
||||
^ T6[(int) ((k03 >> 8) & 0xFFL)] ^ T7[(int) (k02 & 0xFFL)];
|
||||
|
||||
Kr2 = T0[(int) ((k02 >> 56) & 0xFFL)] ^ T1[(int) ((k01 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((k00 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((k07 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((k06 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((k05 >> 16) & 0xFFL)]
|
||||
^ T6[(int) ((k04 >> 8) & 0xFFL)] ^ T7[(int) (k03 & 0xFFL)];
|
||||
|
||||
Kr3 = T0[(int) ((k03 >> 56) & 0xFFL)] ^ T1[(int) ((k02 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((k01 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((k00 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((k07 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((k06 >> 16) & 0xFFL)]
|
||||
^ T6[(int) ((k05 >> 8) & 0xFFL)] ^ T7[(int) (k04 & 0xFFL)];
|
||||
|
||||
Kr4 = T0[(int) ((k04 >> 56) & 0xFFL)] ^ T1[(int) ((k03 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((k02 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((k01 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((k00 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((k07 >> 16) & 0xFFL)]
|
||||
^ T6[(int) ((k06 >> 8) & 0xFFL)] ^ T7[(int) (k05 & 0xFFL)];
|
||||
|
||||
Kr5 = T0[(int) ((k05 >> 56) & 0xFFL)] ^ T1[(int) ((k04 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((k03 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((k02 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((k01 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((k00 >> 16) & 0xFFL)]
|
||||
^ T6[(int) ((k07 >> 8) & 0xFFL)] ^ T7[(int) (k06 & 0xFFL)];
|
||||
|
||||
Kr6 = T0[(int) ((k06 >> 56) & 0xFFL)] ^ T1[(int) ((k05 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((k04 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((k03 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((k02 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((k01 >> 16) & 0xFFL)]
|
||||
^ T6[(int) ((k00 >> 8) & 0xFFL)] ^ T7[(int) (k07 & 0xFFL)];
|
||||
|
||||
Kr7 = T0[(int) ((k07 >> 56) & 0xFFL)] ^ T1[(int) ((k06 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((k05 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((k04 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((k03 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((k02 >> 16) & 0xFFL)]
|
||||
^ T6[(int) ((k01 >> 8) & 0xFFL)] ^ T7[(int) (k00 & 0xFFL)];
|
||||
|
||||
k00 = Kr0;
|
||||
k01 = Kr1;
|
||||
k02 = Kr2;
|
||||
k03 = Kr3;
|
||||
k04 = Kr4;
|
||||
k05 = Kr5;
|
||||
k06 = Kr6;
|
||||
k07 = Kr7;
|
||||
|
||||
// 2. incrementally compute the cipher output
|
||||
w0 = T0[(int) ((nn0 >> 56) & 0xFFL)] ^ T1[(int) ((nn7 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((nn6 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((nn5 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((nn4 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((nn3 >> 16) & 0xFFL)] ^ T6[(int) ((nn2 >> 8) & 0xFFL)]
|
||||
^ T7[(int) (nn1 & 0xFFL)] ^ Kr0;
|
||||
w1 = T0[(int) ((nn1 >> 56) & 0xFFL)] ^ T1[(int) ((nn0 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((nn7 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((nn6 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((nn5 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((nn4 >> 16) & 0xFFL)] ^ T6[(int) ((nn3 >> 8) & 0xFFL)]
|
||||
^ T7[(int) (nn2 & 0xFFL)] ^ Kr1;
|
||||
w2 = T0[(int) ((nn2 >> 56) & 0xFFL)] ^ T1[(int) ((nn1 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((nn0 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((nn7 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((nn6 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((nn5 >> 16) & 0xFFL)] ^ T6[(int) ((nn4 >> 8) & 0xFFL)]
|
||||
^ T7[(int) (nn3 & 0xFFL)] ^ Kr2;
|
||||
w3 = T0[(int) ((nn3 >> 56) & 0xFFL)] ^ T1[(int) ((nn2 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((nn1 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((nn0 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((nn7 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((nn6 >> 16) & 0xFFL)] ^ T6[(int) ((nn5 >> 8) & 0xFFL)]
|
||||
^ T7[(int) (nn4 & 0xFFL)] ^ Kr3;
|
||||
w4 = T0[(int) ((nn4 >> 56) & 0xFFL)] ^ T1[(int) ((nn3 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((nn2 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((nn1 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((nn0 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((nn7 >> 16) & 0xFFL)] ^ T6[(int) ((nn6 >> 8) & 0xFFL)]
|
||||
^ T7[(int) (nn5 & 0xFFL)] ^ Kr4;
|
||||
w5 = T0[(int) ((nn5 >> 56) & 0xFFL)] ^ T1[(int) ((nn4 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((nn3 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((nn2 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((nn1 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((nn0 >> 16) & 0xFFL)] ^ T6[(int) ((nn7 >> 8) & 0xFFL)]
|
||||
^ T7[(int) (nn6 & 0xFFL)] ^ Kr5;
|
||||
w6 = T0[(int) ((nn6 >> 56) & 0xFFL)] ^ T1[(int) ((nn5 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((nn4 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((nn3 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((nn2 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((nn1 >> 16) & 0xFFL)] ^ T6[(int) ((nn0 >> 8) & 0xFFL)]
|
||||
^ T7[(int) (nn7 & 0xFFL)] ^ Kr6;
|
||||
w7 = T0[(int) ((nn7 >> 56) & 0xFFL)] ^ T1[(int) ((nn6 >> 48) & 0xFFL)]
|
||||
^ T2[(int) ((nn5 >> 40) & 0xFFL)]
|
||||
^ T3[(int) ((nn4 >> 32) & 0xFFL)]
|
||||
^ T4[(int) ((nn3 >> 24) & 0xFFL)]
|
||||
^ T5[(int) ((nn2 >> 16) & 0xFFL)] ^ T6[(int) ((nn1 >> 8) & 0xFFL)]
|
||||
^ T7[(int) (nn0 & 0xFFL)] ^ Kr7;
|
||||
|
||||
nn0 = w0;
|
||||
nn1 = w1;
|
||||
nn2 = w2;
|
||||
nn3 = w3;
|
||||
nn4 = w4;
|
||||
nn5 = w5;
|
||||
nn6 = w6;
|
||||
nn7 = w7;
|
||||
}
|
||||
|
||||
// apply the Miyaguchi-Preneel hash scheme
|
||||
H0 ^= w0 ^ n0;
|
||||
H1 ^= w1 ^ n1;
|
||||
H2 ^= w2 ^ n2;
|
||||
H3 ^= w3 ^ n3;
|
||||
H4 ^= w4 ^ n4;
|
||||
H5 ^= w5 ^ n5;
|
||||
H6 ^= w6 ^ n6;
|
||||
H7 ^= w7 ^ n7;
|
||||
}
|
||||
|
||||
protected byte[] padBuffer()
|
||||
{
|
||||
// [WHIRLPOOL] p. 6:
|
||||
// "...padded with a 1-bit, then with as few 0-bits as necessary to
|
||||
// obtain a bit string whose length is an odd multiple of 256, and
|
||||
// finally with the 256-bit right-justified binary representation of L."
|
||||
// in this implementation we use 'count' as the number of bytes hashed
|
||||
// so far. hence the minimal number of bytes added to the message proper
|
||||
// are 33 (1 for the 1-bit followed by the 0-bits and the encoding of
|
||||
// the count framed in a 256-bit block). our formula is then:
|
||||
// count + 33 + padding = 0 (mod BLOCK_SIZE)
|
||||
int n = (int) ((count + 33) % BLOCK_SIZE);
|
||||
int padding = n == 0 ? 33 : BLOCK_SIZE - n + 33;
|
||||
|
||||
byte[] result = new byte[padding];
|
||||
|
||||
// padding is always binary 1 followed by binary 0s
|
||||
result[0] = (byte) 0x80;
|
||||
|
||||
// save (right justified) the number of bits hashed
|
||||
long bits = count * 8;
|
||||
int i = padding - 8;
|
||||
result[i++] = (byte) (bits >>> 56);
|
||||
result[i++] = (byte) (bits >>> 48);
|
||||
result[i++] = (byte) (bits >>> 40);
|
||||
result[i++] = (byte) (bits >>> 32);
|
||||
result[i++] = (byte) (bits >>> 24);
|
||||
result[i++] = (byte) (bits >>> 16);
|
||||
result[i++] = (byte) (bits >>> 8);
|
||||
result[i] = (byte) bits;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected byte[] getResult()
|
||||
{
|
||||
// apply inverse mu to the context
|
||||
byte[] result = new byte[] { (byte) (H0 >>> 56), (byte) (H0 >>> 48),
|
||||
(byte) (H0 >>> 40), (byte) (H0 >>> 32),
|
||||
(byte) (H0 >>> 24), (byte) (H0 >>> 16),
|
||||
(byte) (H0 >>> 8), (byte) H0,
|
||||
(byte) (H1 >>> 56), (byte) (H1 >>> 48),
|
||||
(byte) (H1 >>> 40), (byte) (H1 >>> 32),
|
||||
(byte) (H1 >>> 24), (byte) (H1 >>> 16),
|
||||
(byte) (H1 >>> 8), (byte) H1,
|
||||
(byte) (H2 >>> 56), (byte) (H2 >>> 48),
|
||||
(byte) (H2 >>> 40), (byte) (H2 >>> 32),
|
||||
(byte) (H2 >>> 24), (byte) (H2 >>> 16),
|
||||
(byte) (H2 >>> 8), (byte) H2,
|
||||
(byte) (H3 >>> 56), (byte) (H3 >>> 48),
|
||||
(byte) (H3 >>> 40), (byte) (H3 >>> 32),
|
||||
(byte) (H3 >>> 24), (byte) (H3 >>> 16),
|
||||
(byte) (H3 >>> 8), (byte) H3,
|
||||
(byte) (H4 >>> 56), (byte) (H4 >>> 48),
|
||||
(byte) (H4 >>> 40), (byte) (H4 >>> 32),
|
||||
(byte) (H4 >>> 24), (byte) (H4 >>> 16),
|
||||
(byte) (H4 >>> 8), (byte) H4,
|
||||
(byte) (H5 >>> 56), (byte) (H5 >>> 48),
|
||||
(byte) (H5 >>> 40), (byte) (H5 >>> 32),
|
||||
(byte) (H5 >>> 24), (byte) (H5 >>> 16),
|
||||
(byte) (H5 >>> 8), (byte) H5,
|
||||
(byte) (H6 >>> 56), (byte) (H6 >>> 48),
|
||||
(byte) (H6 >>> 40), (byte) (H6 >>> 32),
|
||||
(byte) (H6 >>> 24), (byte) (H6 >>> 16),
|
||||
(byte) (H6 >>> 8), (byte) H6,
|
||||
(byte) (H7 >>> 56), (byte) (H7 >>> 48),
|
||||
(byte) (H7 >>> 40), (byte) (H7 >>> 32),
|
||||
(byte) (H7 >>> 24), (byte) (H7 >>> 16),
|
||||
(byte) (H7 >>> 8), (byte) H7 };
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
protected void resetContext()
|
||||
{
|
||||
H0 = H1 = H2 = H3 = H4 = H5 = H6 = H7 = 0L;
|
||||
}
|
||||
|
||||
public boolean selfTest()
|
||||
{
|
||||
if (valid == null)
|
||||
{
|
||||
valid = new Boolean(
|
||||
DIGEST0.equals(Util.toString(new Whirlpool().digest())));
|
||||
}
|
||||
return valid.booleanValue();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user