libjava/classpath/gnu/java/security/hash/Whirlpool.java

   1 /* Whirlpool.java --
   2    Copyright (C) 2001, 2002, 2006, 2010 Free Software Foundation, Inc.
   3
   4 This file is a part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or (at
   9 your option) any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; if not, write to the Free Software
  18 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  19 USA
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version.  */
  37
  38
  39 package gnu.java.security.hash;
  40
  41 import gnu.java.lang.CPStringBuilder;
  42
  43 import gnu.java.security.Configuration;
  44 import gnu.java.security.Registry;
  45 import gnu.java.security.util.Util;
  46
  47 import java.util.logging.Logger;
  48
  49 /**
  50  * Whirlpool, a new 512-bit hashing function operating on messages less than
  51  * 2 ** 256 bits in length. The function structure is designed according to the
  52  * Wide Trail strategy and permits a wide variety of implementation trade-offs.
  53  * <p>
  54  * This implementation is of Whirlpool Version 3, described in [1] last revised
  55  * on May 24th, 2003.
  56  * <p>
  57  * <b>IMPORTANT</b>: This implementation is not thread-safe.
  58  * <p>
  59  * References:
  60  * <ol>
  61  *    <li><a href="http://planeta.terra.com.br/informatica/paulobarreto/WhirlpoolPage.html">
  62  *    The WHIRLPOOL Hashing Function</a>.<br>
  63  *    <a href="mailto:paulo.barreto@terra.com.br">Paulo S.L.M. Barreto</a> and
  64  *    <a href="mailto:vincent.rijmen@iaik.tugraz.at">Vincent Rijmen</a>.</li>
  65  * </ol>
  66  */
  67 public final class Whirlpool
  68     extends BaseHash
  69 {
  70   private static final Logger log = Configuration.DEBUG ?
  71                         Logger.getLogger(Whirlpool.class.getName()) : null;
  72
  73   private static final int BLOCK_SIZE = 64; // inner block size in bytes
  74
  75   /** The digest of the 0-bit long message. */
  76   private static final String DIGEST0 =
  77       "19FA61D75522A4669B44E39C1D2E1726C530232130D407F89AFEE0964997F7A7"
  78     + "3E83BE698B288FEBCF88E3E03C4F0757EA8964E59B63D93708B138CC42A66EB3";
  79
  80   /** Default number of rounds. */
  81   private static final int R = 10;
  82
  83   /** Whirlpool S-box; p. 19. */
  84   private static final String S_box = // p. 19 [WHIRLPOOL]
  85       "\u1823\uc6E8\u87B8\u014F\u36A6\ud2F5\u796F\u9152"
  86     + "\u60Bc\u9B8E\uA30c\u7B35\u1dE0\ud7c2\u2E4B\uFE57"
  87     + "\u1577\u37E5\u9FF0\u4AdA\u58c9\u290A\uB1A0\u6B85"
  88     + "\uBd5d\u10F4\ucB3E\u0567\uE427\u418B\uA77d\u95d8"
  89     + "\uFBEE\u7c66\udd17\u479E\ucA2d\uBF07\uAd5A\u8333"
  90     + "\u6302\uAA71\uc819\u49d9\uF2E3\u5B88\u9A26\u32B0"
  91     + "\uE90F\ud580\uBEcd\u3448\uFF7A\u905F\u2068\u1AAE"
  92     + "\uB454\u9322\u64F1\u7312\u4008\uc3Ec\udBA1\u8d3d"
  93     + "\u9700\ucF2B\u7682\ud61B\uB5AF\u6A50\u45F3\u30EF"
  94     + "\u3F55\uA2EA\u65BA\u2Fc0\udE1c\uFd4d\u9275\u068A"
  95     + "\uB2E6\u0E1F\u62d4\uA896\uF9c5\u2559\u8472\u394c"
  96     + "\u5E78\u388c\ud1A5\uE261\uB321\u9c1E\u43c7\uFc04"
  97     + "\u5199\u6d0d\uFAdF\u7E24\u3BAB\ucE11\u8F4E\uB7EB"
  98     + "\u3c81\u94F7\uB913\u2cd3\uE76E\uc403\u5644\u7FA9"
  99     + "\u2ABB\uc153\udc0B\u9d6c\u3174\uF646\uAc89\u14E1"
 100     + "\u163A\u6909\u70B6\ud0Ed\ucc42\u98A4\u285c\uF886";
 101
 102   /** The 64-bit lookup tables; section 7.1 p. 13. */
 103   private static final long[] T0 = new long[256];
 104   private static final long[] T1 = new long[256];
 105   private static final long[] T2 = new long[256];
 106   private static final long[] T3 = new long[256];
 107   private static final long[] T4 = new long[256];
 108   private static final long[] T5 = new long[256];
 109   private static final long[] T6 = new long[256];
 110   private static final long[] T7 = new long[256];
 111
 112   /** The round constants. */
 113   private static final long[] rc = new long[R];
 114
 115   /** caches the result of the correctness test, once executed. */
 116   private static Boolean valid;
 117
 118   /** The 512-bit context as 8 longs. */
 119   private long H0, H1, H2, H3, H4, H5, H6, H7;
 120
 121   /** Work area for computing the round key schedule. */
 122   private long k00, k01, k02, k03, k04, k05, k06, k07;
 123   private long Kr0, Kr1, Kr2, Kr3, Kr4, Kr5, Kr6, Kr7;
 124
 125   /** work area for transforming the 512-bit buffer. */
 126   private long n0, n1, n2, n3, n4, n5, n6, n7;
 127   private long nn0, nn1, nn2, nn3, nn4, nn5, nn6, nn7;
 128
 129   /** work area for holding block cipher's intermediate values. */
 130   private long w0, w1, w2, w3, w4, w5, w6, w7;
 131
 132   static
 133     {
 134       long time = System.currentTimeMillis();
 135       int ROOT = 0x11D; // para. 2.1 [WHIRLPOOL]
 136       int i, r, j;
 137       long s1, s2, s4, s5, s8, s9, t;
 138       char c;
 139       final byte[] S = new byte[256];
 140       for (i = 0; i < 256; i++)
 141         {
 142           c = S_box.charAt(i >>> 1);
 143
 144           s1 = ((i & 1) == 0 ? c >>> 8 : c) & 0xFFL;
 145           s2 = s1 << 1;
 146           if (s2 > 0xFFL)
 147             s2 ^= ROOT;
 148
 149           s4 = s2 << 1;
 150           if (s4 > 0xFFL)
 151             s4 ^= ROOT;
 152
 153           s5 = s4 ^ s1;
 154           s8 = s4 << 1;
 155           if (s8 > 0xFFL)
 156             s8 ^= ROOT;
 157
 158           s9 = s8 ^ s1;
 159
 160           T0[i] = t = s1 << 56 | s1 << 48 | s4 << 40 | s1 << 32
 161                     | s8 << 24 | s5 << 16 | s2 <<  8 | s9;
 162           T1[i] = t >>>  8 | t << 56;
 163           T2[i] = t >>> 16 | t << 48;
 164           T3[i] = t >>> 24 | t << 40;
 165           T4[i] = t >>> 32 | t << 32;
 166           T5[i] = t >>> 40 | t << 24;
 167           T6[i] = t >>> 48 | t << 16;
 168           T7[i] = t >>> 56 | t <<  8;
 169         }
 170       for (r = 0, i = 0; r < R; )
 171         rc[r++] = (T0[i++] & 0xFF00000000000000L)
 172                 ^ (T1[i++] & 0x00FF000000000000L)
 173                 ^ (T2[i++] & 0x0000FF0000000000L)
 174                 ^ (T3[i++] & 0x000000FF00000000L)
 175                 ^ (T4[i++] & 0x00000000FF000000L)
 176                 ^ (T5[i++] & 0x0000000000FF0000L)
 177                 ^ (T6[i++] & 0x000000000000FF00L)
 178                 ^ (T7[i++] & 0x00000000000000FFL);
 179       time = System.currentTimeMillis() - time;
 180       if (Configuration.DEBUG)
 181         {
 182           log.fine("Static data");
 183           log.fine("T0[]:");
 184           CPStringBuilder sb;
 185           for (i = 0; i < 64; i++)
 186             {
 187               sb = new CPStringBuilder();
 188               for (j = 0; j < 4; j++)
 189                 sb.append("0x").append(Util.toString(T0[i * 4 + j])).append(", ");
 190
 191               log.fine(sb.toString());
 192             }
 193           log.fine("T1[]:");
 194           for (i = 0; i < 64; i++)
 195             {
 196               sb = new CPStringBuilder();
 197               for (j = 0; j < 4; j++)
 198                 sb.append("0x").append(Util.toString(T1[i * 4 + j])).append(", ");
 199
 200               log.fine(sb.toString());
 201             }
 202           log.fine("T2[]:");
 203           for (i = 0; i < 64; i++)
 204             {
 205               sb = new CPStringBuilder();
 206               for (j = 0; j < 4; j++)
 207                 sb.append("0x").append(Util.toString(T2[i * 4 + j])).append(", ");
 208
 209               log.fine(sb.toString());
 210             }
 211           log.fine("T3[]:");
 212           for (i = 0; i < 64; i++)
 213             {
 214               sb = new CPStringBuilder();
 215               for (j = 0; j < 4; j++)
 216                 sb.append("0x").append(Util.toString(T3[i * 4 + j])).append(", ");
 217
 218               log.fine(sb.toString());
 219             }
 220           log.fine("\nT4[]:");
 221           for (i = 0; i < 64; i++)
 222             {
 223               sb = new CPStringBuilder();
 224               for (j = 0; j < 4; j++)
 225                 sb.append("0x").append(Util.toString(T4[i * 4 + j])).append(", ");
 226
 227               log.fine(sb.toString());
 228             }
 229           log.fine("T5[]:");
 230           for (i = 0; i < 64; i++)
 231             {
 232               sb = new CPStringBuilder();
 233               for (j = 0; j < 4; j++)
 234                 sb.append("0x").append(Util.toString(T5[i * 4 + j])).append(", ");
 235
 236               log.fine(sb.toString());
 237             }
 238           log.fine("T6[]:");
 239           for (i = 0; i < 64; i++)
 240             {
 241               sb = new CPStringBuilder();
 242               for (j = 0; j < 4; j++)
 243                 sb.append("0x").append(Util.toString(T5[i * 4 + j])).append(", ");
 244
 245               log.fine(sb.toString());
 246             }
 247           log.fine("T7[]:");
 248           for (i = 0; i < 64; i++)
 249             {
 250               sb = new CPStringBuilder();
 251               for (j = 0; j < 4; j++)
 252                 sb.append("0x").append(Util.toString(T5[i * 4 + j])).append(", ");
 253
 254               log.fine(sb.toString());
 255             }
 256           log.fine("rc[]:");
 257           for (i = 0; i < R; i++)
 258             log.fine("0x" + Util.toString(rc[i]));
 259
 260           log.fine("Total initialization time: " + time + " ms.");
 261         }
 262     }
 263
 264   /** Trivial 0-arguments constructor. */
 265   public Whirlpool()
 266   {
 267     super(Registry.WHIRLPOOL_HASH, 20, BLOCK_SIZE);
 268   }
 269
 270   /**
 271    * Private constructor for cloning purposes.
 272    *
 273    * @param md the instance to clone.
 274    */
 275   private Whirlpool(Whirlpool md)
 276   {
 277     this();
 278
 279     this.H0 = md.H0;
 280     this.H1 = md.H1;
 281     this.H2 = md.H2;
 282     this.H3 = md.H3;
 283     this.H4 = md.H4;
 284     this.H5 = md.H5;
 285     this.H6 = md.H6;
 286     this.H7 = md.H7;
 287     this.count = md.count;
 288     this.buffer = (byte[]) md.buffer.clone();
 289   }
 290
 291   public Object clone()
 292   {
 293     return (new Whirlpool(this));
 294   }
 295
 296   protected void transform(byte[] in, int offset)
 297   {
 298     // apply mu to the input
 299     n0 = (in[offset++] & 0xFFL) << 56
 300        | (in[offset++] & 0xFFL) << 48
 301        | (in[offset++] & 0xFFL) << 40
 302        | (in[offset++] & 0xFFL) << 32
 303        | (in[offset++] & 0xFFL) << 24
 304        | (in[offset++] & 0xFFL) << 16
 305        | (in[offset++] & 0xFFL) <<  8
 306        | (in[offset++] & 0xFFL);
 307     n1 = (in[offset++] & 0xFFL) << 56
 308        | (in[offset++] & 0xFFL) << 48
 309        | (in[offset++] & 0xFFL) << 40
 310        | (in[offset++] & 0xFFL) << 32
 311        | (in[offset++] & 0xFFL) << 24
 312        | (in[offset++] & 0xFFL) << 16
 313        | (in[offset++] & 0xFFL) <<  8
 314        | (in[offset++] & 0xFFL);
 315     n2 = (in[offset++] & 0xFFL) << 56
 316        | (in[offset++] & 0xFFL) << 48
 317        | (in[offset++] & 0xFFL) << 40
 318        | (in[offset++] & 0xFFL) << 32
 319        | (in[offset++] & 0xFFL) << 24
 320        | (in[offset++] & 0xFFL) << 16
 321        | (in[offset++] & 0xFFL) <<  8
 322        | (in[offset++] & 0xFFL);
 323     n3 = (in[offset++] & 0xFFL) << 56
 324        | (in[offset++] & 0xFFL) << 48
 325        | (in[offset++] & 0xFFL) << 40
 326        | (in[offset++] & 0xFFL) << 32
 327        | (in[offset++] & 0xFFL) << 24
 328        | (in[offset++] & 0xFFL) << 16
 329        | (in[offset++] & 0xFFL) <<  8
 330        | (in[offset++] & 0xFFL);
 331     n4 = (in[offset++] & 0xFFL) << 56
 332        | (in[offset++] & 0xFFL) << 48
 333        | (in[offset++] & 0xFFL) << 40
 334        | (in[offset++] & 0xFFL) << 32
 335        | (in[offset++] & 0xFFL) << 24
 336        | (in[offset++] & 0xFFL) << 16
 337        | (in[offset++] & 0xFFL) <<  8
 338        | (in[offset++] & 0xFFL);
 339     n5 = (in[offset++] & 0xFFL) << 56
 340        | (in[offset++] & 0xFFL) << 48
 341        | (in[offset++] & 0xFFL) << 40
 342        | (in[offset++] & 0xFFL) << 32
 343        | (in[offset++] & 0xFFL) << 24
 344        | (in[offset++] & 0xFFL) << 16
 345        | (in[offset++] & 0xFFL) <<  8
 346        | (in[offset++] & 0xFFL);
 347     n6 = (in[offset++] & 0xFFL) << 56
 348        | (in[offset++] & 0xFFL) << 48
 349        | (in[offset++] & 0xFFL) << 40
 350        | (in[offset++] & 0xFFL) << 32
 351        | (in[offset++] & 0xFFL) << 24
 352        | (in[offset++] & 0xFFL) << 16
 353        | (in[offset++] & 0xFFL) <<  8
 354        | (in[offset++] & 0xFFL);
 355     n7 = (in[offset++] & 0xFFL) << 56
 356        | (in[offset++] & 0xFFL) << 48
 357        | (in[offset++] & 0xFFL) << 40
 358        | (in[offset++] & 0xFFL) << 32
 359        | (in[offset++] & 0xFFL) << 24
 360        | (in[offset++] & 0xFFL) << 16
 361        | (in[offset++] & 0xFFL) <<  8
 362        | (in[offset++] & 0xFFL);
 363     // transform K into the key schedule Kr; 0 <= r <= R
 364     k00 = H0;
 365     k01 = H1;
 366     k02 = H2;
 367     k03 = H3;
 368     k04 = H4;
 369     k05 = H5;
 370     k06 = H6;
 371     k07 = H7;
 372     nn0 = n0 ^ k00;
 373     nn1 = n1 ^ k01;
 374     nn2 = n2 ^ k02;
 375     nn3 = n3 ^ k03;
 376     nn4 = n4 ^ k04;
 377     nn5 = n5 ^ k05;
 378     nn6 = n6 ^ k06;
 379     nn7 = n7 ^ k07;
 380     // intermediate cipher output
 381     w0 = w1 = w2 = w3 = w4 = w5 = w6 = w7 = 0L;
 382     for (int r = 0; r < R; r++)
 383       {
 384         // 1. compute intermediate round key schedule by applying ro[rc]
 385         // to the previous round key schedule --rc being the round constant
 386         Kr0 = T0[(int)((k00 >> 56) & 0xFFL)]
 387             ^ T1[(int)((k07 >> 48) & 0xFFL)]
 388             ^ T2[(int)((k06 >> 40) & 0xFFL)]
 389             ^ T3[(int)((k05 >> 32) & 0xFFL)]
 390             ^ T4[(int)((k04 >> 24) & 0xFFL)]
 391             ^ T5[(int)((k03 >> 16) & 0xFFL)]
 392             ^ T6[(int)((k02 >>  8) & 0xFFL)]
 393             ^ T7[(int)( k01        & 0xFFL)] ^ rc[r];
 394         Kr1 = T0[(int)((k01 >> 56) & 0xFFL)]
 395             ^ T1[(int)((k00 >> 48) & 0xFFL)]
 396             ^ T2[(int)((k07 >> 40) & 0xFFL)]
 397             ^ T3[(int)((k06 >> 32) & 0xFFL)]
 398             ^ T4[(int)((k05 >> 24) & 0xFFL)]
 399             ^ T5[(int)((k04 >> 16) & 0xFFL)]
 400             ^ T6[(int)((k03 >>  8) & 0xFFL)]
 401             ^ T7[(int)( k02        & 0xFFL)];
 402         Kr2 = T0[(int)((k02 >> 56) & 0xFFL)]
 403             ^ T1[(int)((k01 >> 48) & 0xFFL)]
 404             ^ T2[(int)((k00 >> 40) & 0xFFL)]
 405             ^ T3[(int)((k07 >> 32) & 0xFFL)]
 406             ^ T4[(int)((k06 >> 24) & 0xFFL)]
 407             ^ T5[(int)((k05 >> 16) & 0xFFL)]
 408             ^ T6[(int)((k04 >>  8) & 0xFFL)]
 409             ^ T7[(int)( k03        & 0xFFL)];
 410         Kr3 = T0[(int)((k03 >> 56) & 0xFFL)]
 411             ^ T1[(int)((k02 >> 48) & 0xFFL)]
 412             ^ T2[(int)((k01 >> 40) & 0xFFL)]
 413             ^ T3[(int)((k00 >> 32) & 0xFFL)]
 414             ^ T4[(int)((k07 >> 24) & 0xFFL)]
 415             ^ T5[(int)((k06 >> 16) & 0xFFL)]
 416             ^ T6[(int)((k05 >>  8) & 0xFFL)]
 417             ^ T7[(int)( k04        & 0xFFL)];
 418         Kr4 = T0[(int)((k04 >> 56) & 0xFFL)]
 419             ^ T1[(int)((k03 >> 48) & 0xFFL)]
 420             ^ T2[(int)((k02 >> 40) & 0xFFL)]
 421             ^ T3[(int)((k01 >> 32) & 0xFFL)]
 422             ^ T4[(int)((k00 >> 24) & 0xFFL)]
 423             ^ T5[(int)((k07 >> 16) & 0xFFL)]
 424             ^ T6[(int)((k06 >>  8) & 0xFFL)]
 425             ^ T7[(int)( k05        & 0xFFL)];
 426         Kr5 = T0[(int)((k05 >> 56) & 0xFFL)]
 427             ^ T1[(int)((k04 >> 48) & 0xFFL)]
 428             ^ T2[(int)((k03 >> 40) & 0xFFL)]
 429             ^ T3[(int)((k02 >> 32) & 0xFFL)]
 430             ^ T4[(int)((k01 >> 24) & 0xFFL)]
 431             ^ T5[(int)((k00 >> 16) & 0xFFL)]
 432             ^ T6[(int)((k07 >>  8) & 0xFFL)]
 433             ^ T7[(int)( k06        & 0xFFL)];
 434         Kr6 = T0[(int)((k06 >> 56) & 0xFFL)]
 435             ^ T1[(int)((k05 >> 48) & 0xFFL)]
 436             ^ T2[(int)((k04 >> 40) & 0xFFL)]
 437             ^ T3[(int)((k03 >> 32) & 0xFFL)]
 438             ^ T4[(int)((k02 >> 24) & 0xFFL)]
 439             ^ T5[(int)((k01 >> 16) & 0xFFL)]
 440             ^ T6[(int)((k00 >>  8) & 0xFFL)]
 441             ^ T7[(int)( k07        & 0xFFL)];
 442         Kr7 = T0[(int)((k07 >> 56) & 0xFFL)]
 443             ^ T1[(int)((k06 >> 48) & 0xFFL)]
 444             ^ T2[(int)((k05 >> 40) & 0xFFL)]
 445             ^ T3[(int)((k04 >> 32) & 0xFFL)]
 446             ^ T4[(int)((k03 >> 24) & 0xFFL)]
 447             ^ T5[(int)((k02 >> 16) & 0xFFL)]
 448             ^ T6[(int)((k01 >>  8) & 0xFFL)]
 449             ^ T7[(int)( k00        & 0xFFL)];
 450         k00 = Kr0;
 451         k01 = Kr1;
 452         k02 = Kr2;
 453         k03 = Kr3;
 454         k04 = Kr4;
 455         k05 = Kr5;
 456         k06 = Kr6;
 457         k07 = Kr7;
 458         // 2. incrementally compute the cipher output
 459         w0 = T0[(int)((nn0 >> 56) & 0xFFL)]
 460            ^ T1[(int)((nn7 >> 48) & 0xFFL)]
 461            ^ T2[(int)((nn6 >> 40) & 0xFFL)]
 462            ^ T3[(int)((nn5 >> 32) & 0xFFL)]
 463            ^ T4[(int)((nn4 >> 24) & 0xFFL)]
 464            ^ T5[(int)((nn3 >> 16) & 0xFFL)]
 465            ^ T6[(int)((nn2 >>  8) & 0xFFL)]
 466            ^ T7[(int)( nn1        & 0xFFL)] ^ Kr0;
 467         w1 = T0[(int)((nn1 >> 56) & 0xFFL)]
 468            ^ T1[(int)((nn0 >> 48) & 0xFFL)]
 469            ^ T2[(int)((nn7 >> 40) & 0xFFL)]
 470            ^ T3[(int)((nn6 >> 32) & 0xFFL)]
 471            ^ T4[(int)((nn5 >> 24) & 0xFFL)]
 472            ^ T5[(int)((nn4 >> 16) & 0xFFL)]
 473            ^ T6[(int)((nn3 >>  8) & 0xFFL)]
 474            ^ T7[(int)( nn2        & 0xFFL)] ^ Kr1;
 475         w2 = T0[(int)((nn2 >> 56) & 0xFFL)]
 476            ^ T1[(int)((nn1 >> 48) & 0xFFL)]
 477            ^ T2[(int)((nn0 >> 40) & 0xFFL)]
 478            ^ T3[(int)((nn7 >> 32) & 0xFFL)]
 479            ^ T4[(int)((nn6 >> 24) & 0xFFL)]
 480            ^ T5[(int)((nn5 >> 16) & 0xFFL)]
 481            ^ T6[(int)((nn4 >>  8) & 0xFFL)]
 482            ^ T7[(int)( nn3        & 0xFFL)] ^ Kr2;
 483         w3 = T0[(int)((nn3 >> 56) & 0xFFL)]
 484            ^ T1[(int)((nn2 >> 48) & 0xFFL)]
 485            ^ T2[(int)((nn1 >> 40) & 0xFFL)]
 486            ^ T3[(int)((nn0 >> 32) & 0xFFL)]
 487            ^ T4[(int)((nn7 >> 24) & 0xFFL)]
 488            ^ T5[(int)((nn6 >> 16) & 0xFFL)]
 489            ^ T6[(int)((nn5 >>  8) & 0xFFL)]
 490            ^ T7[(int)( nn4        & 0xFFL)] ^ Kr3;
 491         w4 = T0[(int)((nn4 >> 56) & 0xFFL)]
 492            ^ T1[(int)((nn3 >> 48) & 0xFFL)]
 493            ^ T2[(int)((nn2 >> 40) & 0xFFL)]
 494            ^ T3[(int)((nn1 >> 32) & 0xFFL)]
 495            ^ T4[(int)((nn0 >> 24) & 0xFFL)]
 496            ^ T5[(int)((nn7 >> 16) & 0xFFL)]
 497            ^ T6[(int)((nn6 >>  8) & 0xFFL)]
 498            ^ T7[(int)( nn5        & 0xFFL)] ^ Kr4;
 499         w5 = T0[(int)((nn5 >> 56) & 0xFFL)]
 500            ^ T1[(int)((nn4 >> 48) & 0xFFL)]
 501            ^ T2[(int)((nn3 >> 40) & 0xFFL)]
 502            ^ T3[(int)((nn2 >> 32) & 0xFFL)]
 503            ^ T4[(int)((nn1 >> 24) & 0xFFL)]
 504            ^ T5[(int)((nn0 >> 16) & 0xFFL)]
 505            ^ T6[(int)((nn7 >>  8) & 0xFFL)]
 506            ^ T7[(int)( nn6        & 0xFFL)] ^ Kr5;
 507         w6 = T0[(int)((nn6 >> 56) & 0xFFL)]
 508            ^ T1[(int)((nn5 >> 48) & 0xFFL)]
 509            ^ T2[(int)((nn4 >> 40) & 0xFFL)]
 510            ^ T3[(int)((nn3 >> 32) & 0xFFL)]
 511            ^ T4[(int)((nn2 >> 24) & 0xFFL)]
 512            ^ T5[(int)((nn1 >> 16) & 0xFFL)]
 513            ^ T6[(int)((nn0 >>  8) & 0xFFL)]
 514            ^ T7[(int)( nn7        & 0xFFL)] ^ Kr6;
 515         w7 = T0[(int)((nn7 >> 56) & 0xFFL)]
 516            ^ T1[(int)((nn6 >> 48) & 0xFFL)]
 517            ^ T2[(int)((nn5 >> 40) & 0xFFL)]
 518            ^ T3[(int)((nn4 >> 32) & 0xFFL)]
 519            ^ T4[(int)((nn3 >> 24) & 0xFFL)]
 520            ^ T5[(int)((nn2 >> 16) & 0xFFL)]
 521            ^ T6[(int)((nn1 >>  8) & 0xFFL)]
 522            ^ T7[(int)( nn0        & 0xFFL)] ^ Kr7;
 523         nn0 = w0;
 524         nn1 = w1;
 525         nn2 = w2;
 526         nn3 = w3;
 527         nn4 = w4;
 528         nn5 = w5;
 529         nn6 = w6;
 530         nn7 = w7;
 531       }
 532     // apply the Miyaguchi-Preneel hash scheme
 533     H0 ^= w0 ^ n0;
 534     H1 ^= w1 ^ n1;
 535     H2 ^= w2 ^ n2;
 536     H3 ^= w3 ^ n3;
 537     H4 ^= w4 ^ n4;
 538     H5 ^= w5 ^ n5;
 539     H6 ^= w6 ^ n6;
 540     H7 ^= w7 ^ n7;
 541   }
 542
 543   protected byte[] padBuffer()
 544   {
 545     // [WHIRLPOOL] p. 6:
 546     // "...padded with a 1-bit, then with as few 0-bits as necessary to
 547     // obtain a bit string whose length is an odd multiple of 256, and
 548     // finally with the 256-bit right-justified binary representation of L."
 549     // in this implementation we use 'count' as the number of bytes hashed
 550     // so far. hence the minimal number of bytes added to the message proper
 551     // are 33 (1 for the 1-bit followed by the 0-bits and the encoding of
 552     // the count framed in a 256-bit block). our formula is then:
 553     //          count + 33 + padding = 0 (mod BLOCK_SIZE)
 554     int n = (int)((count + 33) % BLOCK_SIZE);
 555     int padding = n == 0 ? 33 : BLOCK_SIZE - n + 33;
 556     byte[] result = new byte[padding];
 557     // padding is always binary 1 followed by binary 0s
 558     result[0] = (byte) 0x80;
 559     // save (right justified) the number of bits hashed
 560     long bits = count * 8;
 561     int i = padding - 8;
 562     result[i++] = (byte)(bits >>> 56);
 563     result[i++] = (byte)(bits >>> 48);
 564     result[i++] = (byte)(bits >>> 40);
 565     result[i++] = (byte)(bits >>> 32);
 566     result[i++] = (byte)(bits >>> 24);
 567     result[i++] = (byte)(bits >>> 16);
 568     result[i++] = (byte)(bits >>>  8);
 569     result[i  ] = (byte) bits;
 570     return result;
 571   }
 572
 573   protected byte[] getResult()
 574   {
 575     // apply inverse mu to the context
 576     return new byte[] {
 577       (byte)(H0 >>> 56), (byte)(H0 >>> 48), (byte)(H0 >>> 40), (byte)(H0 >>> 32),
 578       (byte)(H0 >>> 24), (byte)(H0 >>> 16), (byte)(H0 >>>  8), (byte) H0,
 579       (byte)(H1 >>> 56), (byte)(H1 >>> 48), (byte)(H1 >>> 40), (byte)(H1 >>> 32),
 580       (byte)(H1 >>> 24), (byte)(H1 >>> 16), (byte)(H1 >>>  8), (byte) H1,
 581       (byte)(H2 >>> 56), (byte)(H2 >>> 48), (byte)(H2 >>> 40), (byte)(H2 >>> 32),
 582       (byte)(H2 >>> 24), (byte)(H2 >>> 16), (byte)(H2 >>>  8), (byte) H2,
 583       (byte)(H3 >>> 56), (byte)(H3 >>> 48), (byte)(H3 >>> 40), (byte)(H3 >>> 32),
 584       (byte)(H3 >>> 24), (byte)(H3 >>> 16), (byte)(H3 >>>  8), (byte) H3,
 585       (byte)(H4 >>> 56), (byte)(H4 >>> 48), (byte)(H4 >>> 40), (byte)(H4 >>> 32),
 586       (byte)(H4 >>> 24), (byte)(H4 >>> 16), (byte)(H4 >>>  8), (byte) H4,
 587       (byte)(H5 >>> 56), (byte)(H5 >>> 48), (byte)(H5 >>> 40), (byte)(H5 >>> 32),
 588       (byte)(H5 >>> 24), (byte)(H5 >>> 16), (byte)(H5 >>>  8), (byte) H5,
 589       (byte)(H6 >>> 56), (byte)(H6 >>> 48), (byte)(H6 >>> 40), (byte)(H6 >>> 32),
 590       (byte)(H6 >>> 24), (byte)(H6 >>> 16), (byte)(H6 >>>  8), (byte) H6,
 591       (byte)(H7 >>> 56), (byte)(H7 >>> 48), (byte)(H7 >>> 40), (byte)(H7 >>> 32),
 592       (byte)(H7 >>> 24), (byte)(H7 >>> 16), (byte)(H7 >>>  8), (byte) H7 };
 593
 594   }
 595
 596   protected void resetContext()
 597   {
 598     H0 = H1 = H2 = H3 = H4 = H5 = H6 = H7 = 0L;
 599   }
 600
 601   public boolean selfTest()
 602   {
 603     if (valid == null)
 604       {
 605         String d = Util.toString(new Whirlpool().digest());
 606         valid = Boolean.valueOf(DIGEST0.equals(d));
 607       }
 608     return valid.booleanValue();
 609   }
 610 }