khazad.java

linux下建立JAVA虚拟机的源码KAFFE

          for (i = 0; i < 64; i++)
            {
              for (j = 0; j < 4; j++)
                System.out.print("0x" + Util.toString(T7[i * 4 + j]) + ", ");
              System.out.println();
            }
          System.out.println();
          System.out.println("rc[]:");
          for (i = 0; i < R + 1; i++)
            System.out.print("0x" + Util.toString(rc[i][0])
                             + Util.toString(rc[i][1]));
          System.out.println();

          System.out.println("Total initialization time: " + time + " ms.");
          System.out.println();
        }
    }

  // Constructor(s)
  // -------------------------------------------------------------------------

  /** Trivial 0-arguments constructor. */
  public Khazad()
  {
    super(Registry.KHAZAD_CIPHER, DEFAULT_BLOCK_SIZE, DEFAULT_KEY_SIZE);
  }

  // Class methods
  // -------------------------------------------------------------------------

  private static void khazad(byte[] in, int i, byte[] out, int j, int[][] K)
  {
    // sigma(K[0])
    int k0 = K[0][0];
    int k1 = K[0][1];
    int a0 = (in[i++] << 24 | (in[i++] & 0xFF) << 16 | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF))
             ^ k0;
    int a1 = (in[i++] << 24 | (in[i++] & 0xFF) << 16 | (in[i++] & 0xFF) << 8 | (in[i] & 0xFF))
             ^ k1;

    int b0, b1;
    // round function
    for (int r = 1; r < R; r++)
      {
        k0 = K[r][0];
        k1 = K[r][1];
        b0 = T0[a0 >>> 24] ^ T1[(a0 >>> 16) & 0xFF] ^ T2[(a0 >>> 8) & 0xFF]
             ^ T3[a0 & 0xFF] ^ T4[a1 >>> 24] ^ T5[(a1 >>> 16) & 0xFF]
             ^ T6[(a1 >>> 8) & 0xFF] ^ T7[a1 & 0xFF] ^ k0;
        b1 = T0[a1 >>> 24] ^ T1[(a1 >>> 16) & 0xFF] ^ T2[(a1 >>> 8) & 0xFF]
             ^ T3[a1 & 0xFF] ^ T4[a0 >>> 24] ^ T5[(a0 >>> 16) & 0xFF]
             ^ T6[(a0 >>> 8) & 0xFF] ^ T7[a0 & 0xFF] ^ k1;
        a0 = b0;
        a1 = b1;

        if (DEBUG && debuglevel > 6)
          {
            System.out.println("T" + r + "=" + Util.toString(a0)
                               + Util.toString(a1));
          }
      }

    // sigma(K[R]) o gamma applied to previous output
    k0 = K[R][0];
    k1 = K[R][1];

    out[j++] = (byte) (S[a0 >>> 24] ^ (k0 >>> 24));
    out[j++] = (byte) (S[(a0 >>> 16) & 0xFF] ^ (k0 >>> 16));
    out[j++] = (byte) (S[(a0 >>> 8) & 0xFF] ^ (k0 >>> 8));
    out[j++] = (byte) (S[a0 & 0xFF] ^ k0);
    out[j++] = (byte) (S[a1 >>> 24] ^ (k1 >>> 24));
    out[j++] = (byte) (S[(a1 >>> 16) & 0xFF] ^ (k1 >>> 16));
    out[j++] = (byte) (S[(a1 >>> 8) & 0xFF] ^ (k1 >>> 8));
    out[j] = (byte) (S[a1 & 0xFF] ^ k1);

    if (DEBUG && debuglevel > 6)
      {
        System.out.println("T=" + Util.toString(out, j - 7, 8));
        System.out.println();
      }
  }

  // Instance methods
  // -------------------------------------------------------------------------

  // java.lang.Cloneable interface implementation ----------------------------

  public Object clone()
  {
    Khazad result = new Khazad();
    result.currentBlockSize = this.currentBlockSize;

    return result;
  }

  // IBlockCipherSpi interface implementation --------------------------------

  public Iterator blockSizes()
  {
    ArrayList al = new ArrayList();
    al.add(new Integer(DEFAULT_BLOCK_SIZE));

    return Collections.unmodifiableList(al).iterator();
  }

  public Iterator keySizes()
  {
    ArrayList al = new ArrayList();
    al.add(new Integer(DEFAULT_KEY_SIZE));

    return Collections.unmodifiableList(al).iterator();
  }

  /**
   * <p>Expands a user-supplied key material into a session key for a
   * designated <i>block size</i>.</p>
   *
   * @param uk the 128-bit user-supplied key material.
   * @param bs the desired block size in bytes.
   * @return an Object encapsulating the session key.
   * @exception IllegalArgumentException if the block size is not 16 (128-bit).
   * @exception InvalidKeyException if the key data is invalid.
   */
  public Object makeKey(byte[] uk, int bs) throws InvalidKeyException
  {
    if (bs != DEFAULT_BLOCK_SIZE)
      {
        throw new IllegalArgumentException();
      }
    if (uk == null)
      {
        throw new InvalidKeyException("Empty key");
      }
    if (uk.length != 16)
      {
        throw new InvalidKeyException("Key is not 128-bit.");
      }
    int[][] Ke = new int[R + 1][2]; // encryption round keys
    int[][] Kd = new int[R + 1][2]; // decryption round keys

    int r, i;
    int k20, k21, k10, k11, rc0, rc1, kr0, kr1;

    i = 0;
    k20 = uk[i++] << 24 | (uk[i++] & 0xFF) << 16 | (uk[i++] & 0xFF) << 8
          | (uk[i++] & 0xFF);
    k21 = uk[i++] << 24 | (uk[i++] & 0xFF) << 16 | (uk[i++] & 0xFF) << 8
          | (uk[i++] & 0xFF);
    k10 = uk[i++] << 24 | (uk[i++] & 0xFF) << 16 | (uk[i++] & 0xFF) << 8
          | (uk[i++] & 0xFF);
    k11 = uk[i++] << 24 | (uk[i++] & 0xFF) << 16 | (uk[i++] & 0xFF) << 8
          | (uk[i++] & 0xFF);

    for (r = 0, i = 0; r <= R; r++)
      {
        rc0 = rc[r][0];
        rc1 = rc[r][1];

        kr0 = T0[k10 >>> 24] ^ T1[(k10 >>> 16) & 0xFF] ^ T2[(k10 >>> 8) & 0xFF]
              ^ T3[k10 & 0xFF] ^ T4[(k11 >>> 24) & 0xFF]
              ^ T5[(k11 >>> 16) & 0xFF] ^ T6[(k11 >>> 8) & 0xFF]
              ^ T7[k11 & 0xFF] ^ rc0 ^ k20;
        kr1 = T0[k11 >>> 24] ^ T1[(k11 >>> 16) & 0xFF] ^ T2[(k11 >>> 8) & 0xFF]
              ^ T3[k11 & 0xFF] ^ T4[(k10 >>> 24) & 0xFF]
              ^ T5[(k10 >>> 16) & 0xFF] ^ T6[(k10 >>> 8) & 0xFF]
              ^ T7[k10 & 0xFF] ^ rc1 ^ k21;

        Ke[r][0] = kr0;
        Ke[r][1] = kr1;
        k20 = k10;
        k21 = k11;
        k10 = kr0;
        k11 = kr1;

        if (r == 0 || r == R)
          {
            Kd[R - r][0] = kr0;
            Kd[R - r][1] = kr1;
          }
        else
          {
            Kd[R - r][0] = T0[S[kr0 >>> 24] & 0xFF]
                           ^ T1[S[(kr0 >>> 16) & 0xFF] & 0xFF]
                           ^ T2[S[(kr0 >>> 8) & 0xFF] & 0xFF]
                           ^ T3[S[kr0 & 0xFF] & 0xFF]
                           ^ T4[S[kr1 >>> 24] & 0xFF]
                           ^ T5[S[(kr1 >>> 16) & 0xFF] & 0xFF]
                           ^ T6[S[(kr1 >>> 8) & 0xFF] & 0xFF]
                           ^ T7[S[kr1 & 0xFF] & 0xFF];
            Kd[R - r][1] = T0[S[kr1 >>> 24] & 0xFF]
                           ^ T1[S[(kr1 >>> 16) & 0xFF] & 0xFF]
                           ^ T2[S[(kr1 >>> 8) & 0xFF] & 0xFF]
                           ^ T3[S[kr1 & 0xFF] & 0xFF]
                           ^ T4[S[kr0 >>> 24] & 0xFF]
                           ^ T5[S[(kr0 >>> 16) & 0xFF] & 0xFF]
                           ^ T6[S[(kr0 >>> 8) & 0xFF] & 0xFF]
                           ^ T7[S[kr0 & 0xFF] & 0xFF];
          }
      }

    if (DEBUG && debuglevel > 8)
      {
        System.out.println();
        System.out.println("Key schedule");
        System.out.println();
        System.out.println("Ke[]:");
        for (r = 0; r < R + 1; r++)
          {
            System.out.println("#" + r + ": 0x" + Util.toString(Ke[r][0])
                               + Util.toString(Ke[r][1]));
          }
        System.out.println();
        System.out.println("Kd[]:");
        for (r = 0; r < R + 1; r++)
          {
            System.out.println("#" + r + ": 0x" + Util.toString(Kd[r][0])
                               + Util.toString(Kd[r][1]));
          }
        System.out.println();
      }

    return new Object[] { Ke, Kd };
  }

  public void encrypt(byte[] in, int i, byte[] out, int j, Object k, int bs)
  {
    if (bs != DEFAULT_BLOCK_SIZE)
      {
        throw new IllegalArgumentException();
      }

    int[][] K = (int[][]) ((Object[]) k)[0];
    khazad(in, i, out, j, K);
  }

  public void decrypt(byte[] in, int i, byte[] out, int j, Object k, int bs)
  {
    if (bs != DEFAULT_BLOCK_SIZE)
      {
        throw new IllegalArgumentException();
      }

    int[][] K = (int[][]) ((Object[]) k)[1];
    khazad(in, i, out, j, K);
  }

  public boolean selfTest()
  {
    if (valid == null)
      {
        boolean result = super.selfTest(); // do symmetry tests
        if (result)
          {
            result = testKat(KAT_KEY, KAT_CT);
          }
        valid = new Boolean(result);
      }
    return valid.booleanValue();
  }
}