libjava/classpath/gnu/javax/crypto/cipher/Anubis.java

   1 /* Anubis.java --
   2    Copyright (C) 2001, 2002, 2003, 2006 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.javax.crypto.cipher;
  40
  41 import gnu.java.security.Configuration;
  42 import gnu.java.security.Registry;
  43 import gnu.java.security.util.Util;
  44
  45 import java.security.InvalidKeyException;
  46 import java.util.ArrayList;
  47 import java.util.Collections;
  48 import java.util.Iterator;
  49 import java.util.logging.Logger;
  50
  51 /**
  52  * Anubis is a 128-bit block cipher that accepts a variable-length key. The
  53  * cipher is a uniform substitution-permutation network whose inverse only
  54  * differs from the forward operation in the key schedule. The design of both
  55  * the round transformation and the key schedule is based upon the Wide Trail
  56  * strategy and permits a wide variety of implementation trade-offs.
  57  * <p>
  58  * References:
  59  * <ol>
  60  * <li><a
  61  * href="http://planeta.terra.com.br/informatica/paulobarreto/AnubisPage.html">The
  62  * ANUBIS Block Cipher</a>.<br>
  63  * <a href="mailto:paulo.barreto@terra.com.br">Paulo S.L.M. Barreto</a> and <a
  64  * href="mailto:vincent.rijmen@esat.kuleuven.ac.be">Vincent Rijmen</a>.</li>
  65  * </ol>
  66  */
  67 public final class Anubis
  68     extends BaseCipher
  69 {
  70   private static final Logger log = Logger.getLogger(Anubis.class.getName());
  71   private static final int DEFAULT_BLOCK_SIZE = 16; // in bytes
  72   private static final int DEFAULT_KEY_SIZE = 16; // in bytes
  73   private static final String Sd = // p. 25 [ANUBIS]
  74       "\uBA54\u2F74\u53D3\uD24D\u50AC\u8DBF\u7052\u9A4C"
  75     + "\uEAD5\u97D1\u3351\u5BA6\uDE48\uA899\uDB32\uB7FC"
  76     + "\uE39E\u919B\uE2BB\u416E\uA5CB\u6B95\uA1F3\uB102"
  77     + "\uCCC4\u1D14\uC363\uDA5D\u5FDC\u7DCD\u7F5A\u6C5C"
  78     + "\uF726\uFFED\uE89D\u6F8E\u19A0\uF089\u0F07\uAFFB"
  79     + "\u0815\u0D04\u0164\uDF76\u79DD\u3D16\u3F37\u6D38"
  80     + "\uB973\uE935\u5571\u7B8C\u7288\uF62A\u3E5E\u2746"
  81     + "\u0C65\u6861\u03C1\u57D6\uD958\uD866\uD73A\uC83C"
  82     + "\uFA96\uA798\uECB8\uC7AE\u694B\uABA9\u670A\u47F2"
  83     + "\uB522\uE5EE\uBE2B\u8112\u831B\u0E23\uF545\u21CE"
  84     + "\u492C\uF9E6\uB628\u1782\u1A8B\uFE8A\u09C9\u874E"
  85     + "\uE12E\uE4E0\uEB90\uA41E\u8560\u0025\uF4F1\u940B"
  86     + "\uE775\uEF34\u31D4\uD086\u7EAD\uFD29\u303B\u9FF8"
  87     + "\uC613\u0605\uC511\u777C\u7A78\u361C\u3959\u1856"
  88     + "\uB3B0\u2420\uB292\uA3C0\u4462\u10B4\u8443\u93C2"
  89     + "\u4ABD\u8F2D\uBC9C\u6A40\uCFA2\u804F\u1FCA\uAA42";
  90   private static final byte[] S = new byte[256];
  91   private static final int[] T0 = new int[256];
  92   private static final int[] T1 = new int[256];
  93   private static final int[] T2 = new int[256];
  94   private static final int[] T3 = new int[256];
  95   private static final int[] T4 = new int[256];
  96   private static final int[] T5 = new int[256];
  97   /**
  98    * Anubis round constants. This is the largest possible considering that we
  99    * always use R values, R = 8 + N, and 4 &lt;= N &lt;= 10.
 100    */
 101   private static final int[] rc = new int[18];
 102   /**
 103    * KAT vector (from ecb_vk): I=83
 104    * KEY=000000000000000000002000000000000000000000000000
 105    * CT=2E66AB15773F3D32FB6C697509460DF4
 106    */
 107   private static final byte[] KAT_KEY =
 108       Util.toBytesFromString("000000000000000000002000000000000000000000000000");
 109   private static final byte[] KAT_CT =
 110       Util.toBytesFromString("2E66AB15773F3D32FB6C697509460DF4");
 111   /** caches the result of the correctness test, once executed. */
 112   private static Boolean valid;
 113
 114   static
 115     {
 116       long time = System.currentTimeMillis();
 117       int ROOT = 0x11d; // para. 2.1 [ANUBIS]
 118       int i, s, s2, s4, s6, s8, t;
 119       char c;
 120       for (i = 0; i < 256; i++)
 121         {
 122           c = Sd.charAt(i >>> 1);
 123           s = ((i & 1) == 0 ? c >>> 8 : c) & 0xFF;
 124           S[i] = (byte) s;
 125           s2 = s << 1;
 126           if (s2 > 0xFF)
 127             s2 ^= ROOT;
 128           s4 = s2 << 1;
 129           if (s4 > 0xFF)
 130             s4 ^= ROOT;
 131           s6 = s4 ^ s2;
 132           s8 = s4 << 1;
 133           if (s8 > 0xFF)
 134             s8 ^= ROOT;
 135           T0[i] = s  << 24 | s2 << 16 | s4 << 8 | s6;
 136           T1[i] = s2 << 24 | s  << 16 | s6 << 8 | s4;
 137           T2[i] = s4 << 24 | s6 << 16 | s  << 8 | s2;
 138           T3[i] = s6 << 24 | s4 << 16 | s2 << 8 | s;
 139           T4[i] = s  << 24 | s  << 16 | s  << 8 | s;
 140           T5[s] = s  << 24 | s2 << 16 | s6 << 8 | s8;
 141         }
 142       // compute round constant
 143       for (i = 0, s = 0; i < 18;)
 144         rc[i++] =  S[(s++) & 0xFF]         << 24
 145                 | (S[(s++) & 0xFF] & 0xFF) << 16
 146                 | (S[(s++) & 0xFF] & 0xFF) << 8
 147                 | (S[(s++) & 0xFF] & 0xFF);
 148       time = System.currentTimeMillis() - time;
 149       if (Configuration.DEBUG)
 150         {
 151           log.fine("Static data");
 152           log.fine("T0[]:");
 153           StringBuilder sb;
 154           for (i = 0; i < 64; i++)
 155             {
 156               sb = new StringBuilder();
 157               for (t = 0; t < 4; t++)
 158                 sb.append("0x").append(Util.toString(T0[i * 4 + t])).append(", ");
 159               log.fine(sb.toString());
 160             }
 161           log.fine("T1[]:");
 162           for (i = 0; i < 64; i++)
 163             {
 164               sb = new StringBuilder();
 165               for (t = 0; t < 4; t++)
 166                 sb.append("0x").append(Util.toString(T1[i * 4 + t])).append(", ");
 167               log.fine(sb.toString());
 168             }
 169           log.fine("T2[]:");
 170           for (i = 0; i < 64; i++)
 171             {
 172               sb = new StringBuilder();
 173               for (t = 0; t < 4; t++)
 174                 sb.append("0x").append(Util.toString(T2[i * 4 + t])).append(", ");
 175               log.fine(sb.toString());
 176             }
 177           log.fine("T3[]:");
 178           for (i = 0; i < 64; i++)
 179             {
 180               sb = new StringBuilder();
 181               for (t = 0; t < 4; t++)
 182                 sb.append("0x").append(Util.toString(T3[i * 4 + t])).append(", ");
 183               log.fine(sb.toString());
 184             }
 185           log.fine("T4[]:");
 186           for (i = 0; i < 64; i++)
 187             {
 188               sb = new StringBuilder();
 189               for (t = 0; t < 4; t++)
 190                 sb.append("0x").append(Util.toString(T4[i * 4 + t])).append(", ");
 191               log.fine(sb.toString());
 192             }
 193           log.fine("T5[]:");
 194           for (i = 0; i < 64; i++)
 195             {
 196               sb = new StringBuilder();
 197               for (t = 0; t < 4; t++)
 198                 sb.append("0x").append(Util.toString(T5[i * 4 + t])).append(", ");
 199               log.fine(sb.toString());
 200             }
 201           log.fine("rc[]:");
 202           for (i = 0; i < 18; i++)
 203             log.fine("0x" + Util.toString(rc[i]));
 204           log.fine("Total initialization time: " + time + " ms.");
 205         }
 206     }
 207
 208   /** Trivial 0-arguments constructor. */
 209   public Anubis()
 210   {
 211     super(Registry.ANUBIS_CIPHER, DEFAULT_BLOCK_SIZE, DEFAULT_KEY_SIZE);
 212   }
 213
 214   private static void anubis(byte[] in, int i, byte[] out, int j, int[][] K)
 215   {
 216     // extract encryption round keys
 217     int R = K.length - 1;
 218     int[] Ker = K[0];
 219     // mu function + affine key addition
 220     int a0 = (in[i++]         << 24
 221            | (in[i++] & 0xFF) << 16
 222            | (in[i++] & 0xFF) <<  8
 223            | (in[i++] & 0xFF)      ) ^ Ker[0];
 224     int a1 = (in[i++]         << 24
 225            | (in[i++] & 0xFF) << 16
 226            | (in[i++] & 0xFF) <<  8
 227            | (in[i++] & 0xFF)      ) ^ Ker[1];
 228     int a2 = (in[i++]         << 24
 229            | (in[i++] & 0xFF) << 16
 230            | (in[i++] & 0xFF) <<  8
 231            | (in[i++] & 0xFF)      ) ^ Ker[2];
 232     int a3 = (in[i++]         << 24
 233            | (in[i++] & 0xFF) << 16
 234            | (in[i++] & 0xFF) <<  8
 235            | (in[i] & 0xFF)        ) ^ Ker[3];
 236     int b0, b1, b2, b3;
 237     // round function
 238     for (int r = 1; r < R; r++)
 239       {
 240         Ker = K[r];
 241         b0 = T0[ a0 >>> 24        ]
 242            ^ T1[ a1 >>> 24        ]
 243            ^ T2[ a2 >>> 24        ]
 244            ^ T3[ a3 >>> 24        ] ^ Ker[0];
 245         b1 = T0[(a0 >>> 16) & 0xFF]
 246            ^ T1[(a1 >>> 16) & 0xFF]
 247            ^ T2[(a2 >>> 16) & 0xFF]
 248            ^ T3[(a3 >>> 16) & 0xFF] ^ Ker[1];
 249         b2 = T0[(a0 >>>  8) & 0xFF]
 250            ^ T1[(a1 >>>  8) & 0xFF]
 251            ^ T2[(a2 >>>  8) & 0xFF]
 252            ^ T3[(a3 >>>  8) & 0xFF] ^ Ker[2];
 253         b3 = T0[ a0         & 0xFF]
 254            ^ T1[ a1         & 0xFF]
 255            ^ T2[ a2         & 0xFF]
 256            ^ T3[ a3         & 0xFF] ^ Ker[3];
 257         a0 = b0;
 258         a1 = b1;
 259         a2 = b2;
 260         a3 = b3;
 261         if (Configuration.DEBUG)
 262           log.fine("T" + r + "=" + Util.toString(a0) + Util.toString(a1)
 263                    + Util.toString(a2) + Util.toString(a3));
 264       }
 265     // last round function
 266     Ker = K[R];
 267     int tt = Ker[0];
 268     out[j++] = (byte)(S[ a0 >>> 24        ] ^ (tt >>> 24));
 269     out[j++] = (byte)(S[ a1 >>> 24        ] ^ (tt >>> 16));
 270     out[j++] = (byte)(S[ a2 >>> 24        ] ^ (tt >>> 8));
 271     out[j++] = (byte)(S[ a3 >>> 24        ] ^  tt);
 272     tt = Ker[1];
 273     out[j++] = (byte)(S[(a0 >>> 16) & 0xFF] ^ (tt >>> 24));
 274     out[j++] = (byte)(S[(a1 >>> 16) & 0xFF] ^ (tt >>> 16));
 275     out[j++] = (byte)(S[(a2 >>> 16) & 0xFF] ^ (tt >>> 8));
 276     out[j++] = (byte)(S[(a3 >>> 16) & 0xFF] ^  tt);
 277     tt = Ker[2];
 278     out[j++] = (byte)(S[(a0 >>>  8) & 0xFF] ^ (tt >>> 24));
 279     out[j++] = (byte)(S[(a1 >>>  8) & 0xFF] ^ (tt >>> 16));
 280     out[j++] = (byte)(S[(a2 >>>  8) & 0xFF] ^ (tt >>> 8));
 281     out[j++] = (byte)(S[(a3 >>>  8) & 0xFF] ^  tt);
 282     tt = Ker[3];
 283     out[j++] = (byte)(S[ a0         & 0xFF] ^ (tt >>> 24));
 284     out[j++] = (byte)(S[ a1         & 0xFF] ^ (tt >>> 16));
 285     out[j++] = (byte)(S[ a2         & 0xFF] ^ (tt >>> 8));
 286     out[j  ] = (byte)(S[ a3         & 0xFF] ^  tt);
 287     if (Configuration.DEBUG)
 288       log.fine("T=" + Util.toString(out, j - 15, 16) + "\n");
 289   }
 290
 291   public Object clone()
 292   {
 293     Anubis result = new Anubis();
 294     result.currentBlockSize = this.currentBlockSize;
 295
 296     return result;
 297   }
 298
 299   public Iterator blockSizes()
 300   {
 301     ArrayList al = new ArrayList();
 302     al.add(Integer.valueOf(DEFAULT_BLOCK_SIZE));
 303
 304     return Collections.unmodifiableList(al).iterator();
 305   }
 306
 307   public Iterator keySizes()
 308   {
 309     ArrayList al = new ArrayList();
 310     for (int n = 4; n < 10; n++)
 311       al.add(Integer.valueOf(n * 32 / 8));
 312     return Collections.unmodifiableList(al).iterator();
 313   }
 314
 315   /**
 316    * Expands a user-supplied key material into a session key for a designated
 317    * <i>block size</i>.
 318    *
 319    * @param uk the 32N-bit user-supplied key material; 4 &lt;= N &lt;= 10.
 320    * @param bs the desired block size in bytes.
 321    * @return an Object encapsulating the session key.
 322    * @exception IllegalArgumentException if the block size is not 16 (128-bit).
 323    * @exception InvalidKeyException if the key data is invalid.
 324    */
 325   public Object makeKey(byte[] uk, int bs) throws InvalidKeyException
 326   {
 327     if (bs != DEFAULT_BLOCK_SIZE)
 328       throw new IllegalArgumentException();
 329     if (uk == null)
 330       throw new InvalidKeyException("Empty key");
 331     if ((uk.length % 4) != 0)
 332       throw new InvalidKeyException("Key is not multiple of 32-bit.");
 333     int N = uk.length / 4;
 334     if (N < 4 || N > 10)
 335       throw new InvalidKeyException("Key is not 32N; 4 <= N <= 10");
 336     int R = 8 + N;
 337     int[][] Ke = new int[R + 1][4]; // encryption round keys
 338     int[][] Kd = new int[R + 1][4]; // decryption round keys
 339     int[] tk = new int[N];
 340     int[] kk = new int[N];
 341     int r, i, j, k, k0, k1, k2, k3, tt;
 342     // apply mu to k0
 343     for (r = 0, i = 0; r < N;)
 344       tk[r++] =  uk[i++]         << 24
 345               | (uk[i++] & 0xFF) << 16
 346               | (uk[i++] & 0xFF) << 8
 347               | (uk[i++] & 0xFF);
 348     for (r = 0; r <= R; r++)
 349       {
 350         if (r > 0)
 351           {
 352             // psi = key evolution function
 353             kk[0] = T0[(tk[0    ] >>> 24)       ]
 354                   ^ T1[(tk[N - 1] >>> 16) & 0xFF]
 355                   ^ T2[(tk[N - 2] >>>  8) & 0xFF]
 356                   ^ T3[ tk[N - 3]         & 0xFF];
 357             kk[1] = T0[(tk[1    ] >>> 24)       ]
 358                   ^ T1[(tk[0    ] >>> 16) & 0xFF]
 359                   ^ T2[(tk[N - 1] >>>  8) & 0xFF]
 360                   ^ T3[ tk[N - 2]         & 0xFF];
 361             kk[2] = T0[(tk[2    ] >>> 24)       ]
 362                   ^ T1[(tk[1    ] >>> 16) & 0xFF]
 363                   ^ T2[(tk[0    ] >>>  8) & 0xFF]
 364                   ^ T3[ tk[N - 1]         & 0xFF];
 365             kk[3] = T0[(tk[3    ] >>> 24)       ]
 366                   ^ T1[(tk[2    ] >>> 16) & 0xFF]
 367                   ^ T2[(tk[1    ] >>>  8) & 0xFF]
 368                   ^ T3[ tk[0    ]         & 0xFF];
 369             for (i = 4; i < N; i++)
 370               kk[i] = T0[ tk[i    ] >>> 24        ]
 371                     ^ T1[(tk[i - 1] >>> 16) & 0xFF]
 372                     ^ T2[(tk[i - 2] >>>  8) & 0xFF]
 373                     ^ T3[ tk[i - 3]         & 0xFF];
 374             // apply sigma (affine addition) to round constant
 375             tk[0] = rc[r - 1] ^ kk[0];
 376             for (i = 1; i < N; i++)
 377               tk[i] = kk[i];
 378           }
 379         // phi = key selection function
 380         tt = tk[N - 1];
 381         k0 = T4[ tt >>> 24        ];
 382         k1 = T4[(tt >>> 16) & 0xFF];
 383         k2 = T4[(tt >>>  8) & 0xFF];
 384         k3 = T4[ tt         & 0xFF];
 385         for (k = N - 2; k >= 0; k--)
 386           {
 387             tt = tk[k];
 388             k0 =  T4[ tt >>> 24        ]
 389                ^ (T5[(k0 >>> 24) & 0xFF] & 0xFF000000)
 390                ^ (T5[(k0 >>> 16) & 0xFF] & 0x00FF0000)
 391                ^ (T5[(k0 >>>  8) & 0xFF] & 0x0000FF00)
 392                ^ (T5 [k0         & 0xFF] & 0x000000FF);
 393             k1 =  T4[(tt >>> 16) & 0xFF]
 394                ^ (T5[(k1 >>> 24) & 0xFF] & 0xFF000000)
 395                ^ (T5[(k1 >>> 16) & 0xFF] & 0x00FF0000)
 396                ^ (T5[(k1 >>>  8) & 0xFF] & 0x0000FF00)
 397                ^ (T5[ k1         & 0xFF] & 0x000000FF);
 398             k2 =  T4[(tt >>>  8) & 0xFF]
 399                ^ (T5[(k2 >>> 24) & 0xFF] & 0xFF000000)
 400                ^ (T5[(k2 >>> 16) & 0xFF] & 0x00FF0000)
 401                ^ (T5[(k2 >>>  8) & 0xFF] & 0x0000FF00)
 402                ^ (T5[ k2         & 0xFF] & 0x000000FF);
 403             k3 =  T4[ tt         & 0xFF]
 404                ^ (T5[(k3 >>> 24) & 0xFF] & 0xFF000000)
 405                ^ (T5[(k3 >>> 16) & 0xFF] & 0x00FF0000)
 406                ^ (T5[(k3 >>>  8) & 0xFF] & 0x0000FF00)
 407                ^ (T5[ k3         & 0xFF] & 0x000000FF);
 408           }
 409         Ke[r][0] = k0;
 410         Ke[r][1] = k1;
 411         Ke[r][2] = k2;
 412         Ke[r][3] = k3;
 413         if (r == 0 || r == R)
 414           {
 415             Kd[R - r][0] = k0;
 416             Kd[R - r][1] = k1;
 417             Kd[R - r][2] = k2;
 418             Kd[R - r][3] = k3;
 419           }
 420         else
 421           {
 422             Kd[R - r][0] = T0[S[ k0 >>> 24        ] & 0xFF]
 423                          ^ T1[S[(k0 >>> 16) & 0xFF] & 0xFF]
 424                          ^ T2[S[(k0 >>>  8) & 0xFF] & 0xFF]
 425                          ^ T3[S[ k0         & 0xFF] & 0xFF];
 426             Kd[R - r][1] = T0[S[ k1 >>> 24        ] & 0xFF]
 427                          ^ T1[S[(k1 >>> 16) & 0xFF] & 0xFF]
 428                          ^ T2[S[(k1 >>>  8) & 0xFF] & 0xFF]
 429                          ^ T3[S[ k1         & 0xFF] & 0xFF];
 430             Kd[R - r][2] = T0[S[ k2 >>> 24        ] & 0xFF]
 431                          ^ T1[S[(k2 >>> 16) & 0xFF] & 0xFF]
 432                          ^ T2[S[(k2 >>>  8) & 0xFF] & 0xFF]
 433                          ^ T3[S[ k2         & 0xFF] & 0xFF];
 434             Kd[R - r][3] = T0[S[ k3 >>> 24        ] & 0xFF]
 435                          ^ T1[S[(k3 >>> 16) & 0xFF] & 0xFF]
 436                          ^ T2[S[(k3 >>>  8) & 0xFF] & 0xFF]
 437                          ^ T3[S[ k3         & 0xFF] & 0xFF];
 438           }
 439       }
 440     if (Configuration.DEBUG)
 441       {
 442         log.fine("Key schedule");
 443         log.fine("Ke[]:");
 444         StringBuilder sb;
 445         for (r = 0; r < R + 1; r++)
 446           {
 447             sb = new StringBuilder("#").append(r).append(": ");
 448             for (j = 0; j < 4; j++)
 449               sb.append("0x").append(Util.toString(Ke[r][j])).append(", ");
 450             log.fine(sb.toString());
 451           }
 452         log.fine("Kd[]:");
 453         for (r = 0; r < R + 1; r++)
 454           {
 455             sb = new StringBuilder("#").append(r).append(": ");
 456             for (j = 0; j < 4; j++)
 457               sb.append("0x").append(Util.toString(Kd[r][j])).append(", ");
 458             log.fine(sb.toString());
 459           }
 460       }
 461     return new Object[] { Ke, Kd };
 462   }
 463
 464   public void encrypt(byte[] in, int i, byte[] out, int j, Object k, int bs)
 465   {
 466     if (bs != DEFAULT_BLOCK_SIZE)
 467       throw new IllegalArgumentException();
 468     int[][] K = (int[][])((Object[]) k)[0];
 469     anubis(in, i, out, j, K);
 470   }
 471
 472   public void decrypt(byte[] in, int i, byte[] out, int j, Object k, int bs)
 473   {
 474     if (bs != DEFAULT_BLOCK_SIZE)
 475       throw new IllegalArgumentException();
 476     int[][] K = (int[][])((Object[]) k)[1];
 477     anubis(in, i, out, j, K);
 478   }
 479
 480   public boolean selfTest()
 481   {
 482     if (valid == null)
 483       {
 484         boolean result = super.selfTest(); // do symmetry tests
 485         if (result)
 486           result = testKat(KAT_KEY, KAT_CT);
 487         valid = Boolean.valueOf(result);
 488       }
 489     return valid.booleanValue();
 490   }
 491 }