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

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