procyberian/gcc
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Imported GNU Classpath 0.90

Browse source 
Imported GNU Classpath 0.90
       * scripts/makemake.tcl: LocaleData.java moved to gnu/java/locale.

       * sources.am: Regenerated.
       * gcj/javaprims.h: Regenerated.
       * Makefile.in: Regenerated.
       * gcj/Makefile.in: Regenerated.
       * include/Makefile.in: Regenerated.
       * testsuite/Makefile.in: Regenerated.

       * gnu/java/lang/VMInstrumentationImpl.java: New override.
       * gnu/java/net/local/LocalSocketImpl.java: Likewise.
       * gnu/classpath/jdwp/VMMethod.java: Likewise.
       * gnu/classpath/jdwp/VMVirtualMachine.java: Update to latest
       interface.
       * java/lang/Thread.java: Add UncaughtExceptionHandler.
       * java/lang/reflect/Method.java: Implements GenericDeclaration and
       isSynthetic(),
       * java/lang/reflect/Field.java: Likewise.
       * java/lang/reflect/Constructor.java
       * java/lang/Class.java: Implements Type, GenericDeclaration,
       getSimpleName() and getEnclosing*() methods.
       * java/lang/Class.h: Add new public methods.
       * java/lang/Math.java: Add signum(), ulp() and log10().
       * java/lang/natMath.cc (log10): New function.
       * java/security/VMSecureRandom.java: New override.
       * java/util/logging/Logger.java: Updated to latest classpath
       version.
       * java/util/logging/LogManager.java: New override.

From-SVN: r113887
This commit is contained in:
Mark Wielaard 2006-05-18 17:29:21 +00:00
parent eaec4980e1
commit 4f9533c772
1640 changed files with 126485 additions and 104808 deletions
Download patch file Download diff file Expand all files Collapse all files

2
libjava/classpath/gnu/java/security/hash/Haval.java
View file

@ -567,7 +567,7 @@ public class Haval extends BaseHash
{
if (valid == null)
{
valid = new Boolean(DIGEST0.equals(Util.toString(new Haval().digest())));
valid = Boolean.valueOf(DIGEST0.equals(Util.toString(new Haval().digest())));
}
return valid.booleanValue();
}

2
libjava/classpath/gnu/java/security/hash/MD2.java
View file

@ -181,7 +181,7 @@ public class MD2 extends BaseHash
{
if (valid == null)
{
valid = new Boolean(DIGEST0.equals(Util.toString(new MD2().digest())));
valid = Boolean.valueOf(DIGEST0.equals(Util.toString(new MD2().digest())));
}
return valid.booleanValue();
}

2
libjava/classpath/gnu/java/security/hash/MD4.java
View file

@ -154,7 +154,7 @@ public class MD4 extends BaseHash
{
if (valid == null)
{
valid = new Boolean(DIGEST0.equals(Util.toString(new MD4().digest())));
valid = Boolean.valueOf(DIGEST0.equals(Util.toString(new MD4().digest())));
}
return valid.booleanValue();
}

2
libjava/classpath/gnu/java/security/hash/MD5.java
View file

@ -358,7 +358,7 @@ public class MD5 extends BaseHash
{
if (valid == null)
{
valid = new Boolean(DIGEST0.equals(Util.toString(new MD5().digest())));
valid = Boolean.valueOf(DIGEST0.equals(Util.toString(new MD5().digest())));
}
return valid.booleanValue();
}

2
libjava/classpath/gnu/java/security/hash/RipeMD128.java
View file

@ -283,7 +283,7 @@ public class RipeMD128 extends BaseHash
{
if (valid == null)
{
valid = new Boolean
valid = Boolean.valueOf
(DIGEST0.equals(Util.toString(new RipeMD128().digest())));
}
return valid.booleanValue();

2
libjava/classpath/gnu/java/security/hash/RipeMD160.java
View file

@ -320,7 +320,7 @@ public class RipeMD160 extends BaseHash
{
if (valid == null)
{
valid = new Boolean
valid = Boolean.valueOf
(DIGEST0.equals(Util.toString(new RipeMD160().digest())));
}
return valid.booleanValue();

2
libjava/classpath/gnu/java/security/hash/Sha160.java
View file

@ -229,7 +229,7 @@ public class Sha160 extends BaseHash
md.update((byte) 0x62); // b
md.update((byte) 0x63); // c
String result = Util.toString(md.digest());
valid = new Boolean(DIGEST0.equals(result));
valid = Boolean.valueOf(DIGEST0.equals(result));
}
return valid.booleanValue();
}

2
libjava/classpath/gnu/java/security/hash/Sha256.java
View file

@ -217,7 +217,7 @@ public class Sha256 extends BaseHash
md.update((byte) 0x62); // b
md.update((byte) 0x63); // c
String result = Util.toString(md.digest());
valid = new Boolean(DIGEST0.equals(result));
valid = Boolean.valueOf(DIGEST0.equals(result));
}
return valid.booleanValue();

2
libjava/classpath/gnu/java/security/hash/Sha384.java
View file

@ -254,7 +254,7 @@ public class Sha384 extends BaseHash
md.update((byte) 0x62); // b
md.update((byte) 0x63); // c
String result = Util.toString(md.digest());
valid = new Boolean(DIGEST0.equals(result));
valid = Boolean.valueOf(DIGEST0.equals(result));
}
return valid.booleanValue();
}

2
libjava/classpath/gnu/java/security/hash/Sha512.java
View file

@ -256,7 +256,7 @@ public class Sha512 extends BaseHash
md.update((byte) 0x62); // b
md.update((byte) 0x63); // c
String result = Util.toString(md.digest());
valid = new Boolean(DIGEST0.equals(result));
valid = Boolean.valueOf(DIGEST0.equals(result));
}
return valid.booleanValue();
}

2
libjava/classpath/gnu/java/security/hash/Tiger.java
View file

@ -640,7 +640,7 @@ public class Tiger extends BaseHash
{
if (valid == null)
{
valid = new Boolean(DIGEST0.equals(Util.toString(new Tiger().digest())));
valid = Boolean.valueOf(DIGEST0.equals(Util.toString(new Tiger().digest())));
}
return valid.booleanValue();
}

577
libjava/classpath/gnu/java/security/hash/Whirlpool.java
View file

@ -42,25 +42,25 @@ import gnu.java.security.Registry;
import gnu.java.security.util.Util;
/**
* <p>Whirlpool, a new 512-bit hashing function operating on messages less than
* 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>
*
* <p>
* This implementation is of Whirlpool Version 3, described in [1] last revised
* on May 24th, 2003.
* <p>
* <b>IMPORTANT</b>: This implementation is not thread-safe.
* <p>
* References:
* <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>
* <a href="mailto:vincent.rijmen@iaik.tugraz.at">Vincent Rijmen</a>.</li>
* </ol>
*/
public final class Whirlpool extends BaseHash
{
// Debugging methods and variables
// -------------------------------------------------------------------------
@ -74,45 +74,43 @@ public final class Whirlpool extends BaseHash
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 String DIGEST0 =
"19FA61D75522A4669B44E39C1D2E1726C530232130D407F89AFEE0964997F7A7"
+ "3E83BE698B288FEBCF88E3E03C4F0757EA8964E59B63D93708B138CC42A66EB3";
private static final int R = 10; // default number of rounds
/** Default number of rounds. */
private static final int R = 10;
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";
/** Whirlpool S-box; p. 19. */
private static final String S_box = // 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";
/** The 64-bit lookup tables; section 7.1 p. 13. */
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];
/** The round constants. */
private static final long[] rc = new long[R];
/** caches the result of the correctness test, once executed. */
@ -123,12 +121,10 @@ public final class Whirlpool extends BaseHash
/** 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. */
@ -140,72 +136,67 @@ public final class Whirlpool extends BaseHash
{
long time = System.currentTimeMillis();
int ROOT = 0x11d; // para. 2.1 [WHIRLPOOL]
int ROOT = 0x11D; // para. 2.1 [WHIRLPOOL]
int i, r, j;
long s, s2, s3, s4, s5, s8, s9, t;
long s1, s2, s4, s5, s8, s9, t;
char c;
final byte[] S = new byte[256];
for (i = 0; i < 256; i++)
{
c = Sd.charAt(i >>> 1);
c = S_box.charAt(i >>> 1);
s = ((i & 1) == 0 ? c >>> 8 : c) & 0xFFL;
s2 = s << 1;
s1 = ((i & 1) == 0 ? c >>> 8 : c) & 0xFFL;
s2 = s1 << 1;
if (s2 > 0xFFL)
{
s2 ^= ROOT;
}
s3 = s2 ^ s;
s2 ^= ROOT;
s4 = s2 << 1;
if (s4 > 0xFFL)
{
s4 ^= ROOT;
}
s5 = s4 ^ s;
s4 ^= ROOT;
s5 = s4 ^ s1;
s8 = s4 << 1;
if (s8 > 0xFFL)
{
s8 ^= ROOT;
}
s9 = s8 ^ s;
s8 ^= ROOT;
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;
s9 = s8 ^ s1;
T0[i] = t = s1 << 56 | s1 << 48 | s4 << 40 | s1 << 32
| s8 << 24 | s5 << 16 | s2 << 8 | s9;
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;
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);
}
for (r = 0, i = 0; r < R; )
rc[r++] = (T0[i++] & 0xFF00000000000000L)
^ (T1[i++] & 0x00FF000000000000L)
^ (T2[i++] & 0x0000FF0000000000L)
^ (T3[i++] & 0x000000FF00000000L)
^ (T4[i++] & 0x00000000FF000000L)
^ (T5[i++] & 0x0000000000FF0000L)
^ (T6[i++] & 0x000000000000FF00L)
^ (T7[i++] & 0x00000000000000FFL);
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.print("0x" + Util.toString(T0[i * 4 + j]) + ", ");
System.out.println();
}
System.out.println();
@ -213,9 +204,8 @@ public final class Whirlpool extends BaseHash
for (i = 0; i < 64; i++)
{
for (j = 0; j < 4; j++)
{
System.out.print("0x" + Util.toString(T1[i * 4 + j]) + ", ");
}
System.out.print("0x" + Util.toString(T1[i * 4 + j]) + ", ");
System.out.println();
}
System.out.println();
@ -223,9 +213,8 @@ public final class Whirlpool extends BaseHash
for (i = 0; i < 64; i++)
{
for (j = 0; j < 4; j++)
{
System.out.print("0x" + Util.toString(T2[i * 4 + j]) + ", ");
}
System.out.print("0x" + Util.toString(T2[i * 4 + j]) + ", ");
System.out.println();
}
System.out.println();
@ -233,9 +222,8 @@ public final class Whirlpool extends BaseHash
for (i = 0; i < 64; i++)
{
for (j = 0; j < 4; j++)
{
System.out.print("0x" + Util.toString(T3[i * 4 + j]) + ", ");
}
System.out.print("0x" + Util.toString(T3[i * 4 + j]) + ", ");
System.out.println();
}
System.out.println();
@ -243,9 +231,8 @@ public final class Whirlpool extends BaseHash
for (i = 0; i < 64; i++)
{
for (j = 0; j < 4; j++)
{
System.out.print("0x" + Util.toString(T4[i * 4 + j]) + ", ");
}
System.out.print("0x" + Util.toString(T4[i * 4 + j]) + ", ");
System.out.println();
}
System.out.println();
@ -253,9 +240,8 @@ public final class Whirlpool extends BaseHash
for (i = 0; i < 64; i++)
{
for (j = 0; j < 4; j++)
{
System.out.print("0x" + Util.toString(T5[i * 4 + j]) + ", ");
}
System.out.print("0x" + Util.toString(T5[i * 4 + j]) + ", ");
System.out.println();
}
System.out.println();
@ -263,9 +249,8 @@ public final class Whirlpool extends BaseHash
for (i = 0; i < 64; i++)
{
for (j = 0; j < 4; j++)
{
System.out.print("0x" + Util.toString(T5[i * 4 + j]) + ", ");
}
System.out.print("0x" + Util.toString(T5[i * 4 + j]) + ", ");
System.out.println();
}
System.out.println();
@ -273,17 +258,15 @@ public final class Whirlpool extends BaseHash
for (i = 0; i < 64; i++)
{
for (j = 0; j < 4; j++)
{
System.out.print("0x" + Util.toString(T5[i * 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("0x" + Util.toString(rc[i]));
System.out.println();
System.out.println();
@ -340,38 +323,70 @@ public final class Whirlpool extends 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);
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;
@ -399,62 +414,70 @@ public final class Whirlpool extends BaseHash
{
// 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)];
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;
@ -466,54 +489,70 @@ public final class Whirlpool extends BaseHash
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;
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;
@ -547,7 +586,7 @@ public final class Whirlpool extends BaseHash
// 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 n = (int)((count + 33) % BLOCK_SIZE);
int padding = n == 0 ? 33 : BLOCK_SIZE - n + 33;
byte[] result = new byte[padding];
@ -558,14 +597,14 @@ public final class Whirlpool extends BaseHash
// 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;
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;
}
@ -573,38 +612,24 @@ public final class Whirlpool extends BaseHash
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 };
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;
}
@ -617,10 +642,8 @@ public final class Whirlpool extends BaseHash
public boolean selfTest()
{
if (valid == null)
{
valid = new Boolean(
DIGEST0.equals(Util.toString(new Whirlpool().digest())));
}
valid = Boolean.valueOf(DIGEST0.equals(Util.toString(new Whirlpool().digest())));
return valid.booleanValue();
}
}