anubis.java

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

             ^ Ker[0];
    int a1 = (in[i++] << 24 | (in[i++] & 0xFF) << 16 | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF))
             ^ Ker[1];
    int a2 = (in[i++] << 24 | (in[i++] & 0xFF) << 16 | (in[i++] & 0xFF) << 8 | (in[i++] & 0xFF))
             ^ Ker[2];
    int a3 = (in[i++] << 24 | (in[i++] & 0xFF) << 16 | (in[i++] & 0xFF) << 8 | (in[i] & 0xFF))
             ^ Ker[3];

    int b0, b1, b2, b3;
    // round function
    for (int r = 1; r < R; r++)
      {
        Ker = K[r];
        b0 = T0[a0 >>> 24] ^ T1[a1 >>> 24] ^ T2[a2 >>> 24] ^ T3[a3 >>> 24]
             ^ Ker[0];
        b1 = T0[(a0 >>> 16) & 0xFF] ^ T1[(a1 >>> 16) & 0xFF]
             ^ T2[(a2 >>> 16) & 0xFF] ^ T3[(a3 >>> 16) & 0xFF] ^ Ker[1];
        b2 = T0[(a0 >>> 8) & 0xFF] ^ T1[(a1 >>> 8) & 0xFF]
             ^ T2[(a2 >>> 8) & 0xFF] ^ T3[(a3 >>> 8) & 0xFF] ^ Ker[2];
        b3 = T0[a0 & 0xFF] ^ T1[a1 & 0xFF] ^ T2[a2 & 0xFF] ^ T3[a3 & 0xFF]
             ^ Ker[3];
        a0 = b0;
        a1 = b1;
        a2 = b2;
        a3 = b3;
        if (DEBUG && debuglevel > 6)
          {
            System.out.println("T" + r + "=" + Util.toString(a0)
                               + Util.toString(a1) + Util.toString(a2)
                               + Util.toString(a3));
          }
      }

    // last round function
    Ker = K[R];
    int tt = Ker[0];
    out[j++] = (byte) (S[a0 >>> 24] ^ (tt >>> 24));
    out[j++] = (byte) (S[a1 >>> 24] ^ (tt >>> 16));
    out[j++] = (byte) (S[a2 >>> 24] ^ (tt >>> 8));
    out[j++] = (byte) (S[a3 >>> 24] ^ tt);
    tt = Ker[1];
    out[j++] = (byte) (S[(a0 >>> 16) & 0xFF] ^ (tt >>> 24));
    out[j++] = (byte) (S[(a1 >>> 16) & 0xFF] ^ (tt >>> 16));
    out[j++] = (byte) (S[(a2 >>> 16) & 0xFF] ^ (tt >>> 8));
    out[j++] = (byte) (S[(a3 >>> 16) & 0xFF] ^ tt);
    tt = Ker[2];
    out[j++] = (byte) (S[(a0 >>> 8) & 0xFF] ^ (tt >>> 24));
    out[j++] = (byte) (S[(a1 >>> 8) & 0xFF] ^ (tt >>> 16));
    out[j++] = (byte) (S[(a2 >>> 8) & 0xFF] ^ (tt >>> 8));
    out[j++] = (byte) (S[(a3 >>> 8) & 0xFF] ^ tt);
    tt = Ker[3];
    out[j++] = (byte) (S[a0 & 0xFF] ^ (tt >>> 24));
    out[j++] = (byte) (S[a1 & 0xFF] ^ (tt >>> 16));
    out[j++] = (byte) (S[a2 & 0xFF] ^ (tt >>> 8));
    out[j] = (byte) (S[a3 & 0xFF] ^ tt);

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

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

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

  public Object clone()
  {
    Anubis result = new Anubis();
    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();
    for (int n = 4; n < 10; n++)
      {
        al.add(new Integer(n * 32 / 8));
      }

    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 32N-bit user-supplied key material; 4 &lt;= N &lt;= 10.
   * @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 % 4) != 0)
      {
        throw new InvalidKeyException("Key is not multiple of 32-bit.");
      }
    int N = uk.length / 4;
    if (N < 4 || N > 10)
      {
        throw new InvalidKeyException("Key is not 32N; 4 <= N <= 10");
      }
    int R = 8 + N;
    int[][] Ke = new int[R + 1][4]; // encryption round keys
    int[][] Kd = new int[R + 1][4]; // decryption round keys
    int[] tk = new int[N];
    int[] kk = new int[N];
    int r, i, j, k, k0, k1, k2, k3, tt;

    // apply mu to k0
    for (r = 0, i = 0; r < N;)
      {
        tk[r++] = uk[i++] << 24 | (uk[i++] & 0xFF) << 16
                  | (uk[i++] & 0xFF) << 8 | (uk[i++] & 0xFF);
      }
    for (r = 0; r <= R; r++)
      {
        if (r > 0)
          {
            // psi = key evolution function
            kk[0] = T0[(tk[0] >>> 24)] ^ T1[(tk[N - 1] >>> 16) & 0xFF]
                    ^ T2[(tk[N - 2] >>> 8) & 0xFF] ^ T3[tk[N - 3] & 0xFF];
            kk[1] = T0[(tk[1] >>> 24)] ^ T1[(tk[0] >>> 16) & 0xFF]
                    ^ T2[(tk[N - 1] >>> 8) & 0xFF] ^ T3[tk[N - 2] & 0xFF];
            kk[2] = T0[(tk[2] >>> 24)] ^ T1[(tk[1] >>> 16) & 0xFF]
                    ^ T2[(tk[0] >>> 8) & 0xFF] ^ T3[tk[N - 1] & 0xFF];
            kk[3] = T0[(tk[3] >>> 24)] ^ T1[(tk[2] >>> 16) & 0xFF]
                    ^ T2[(tk[1] >>> 8) & 0xFF] ^ T3[tk[0] & 0xFF];

            for (i = 4; i < N; i++)
              {
                kk[i] = T0[tk[i] >>> 24] ^ T1[(tk[i - 1] >>> 16) & 0xFF]
                        ^ T2[(tk[i - 2] >>> 8) & 0xFF] ^ T3[tk[i - 3] & 0xFF];
              }
            // apply sigma (affine addition) to round constant
            tk[0] = rc[r - 1] ^ kk[0];
            for (i = 1; i < N; i++)
              {
                tk[i] = kk[i];
              }
          }

        // phi = key selection function
        tt = tk[N - 1];
        k0 = T4[tt >>> 24];
        k1 = T4[(tt >>> 16) & 0xFF];
        k2 = T4[(tt >>> 8) & 0xFF];
        k3 = T4[tt & 0xFF];

        for (k = N - 2; k >= 0; k--)
          {
            tt = tk[k];
            k0 = T4[tt >>> 24] ^ (T5[(k0 >>> 24) & 0xFF] & 0xFF000000)
                 ^ (T5[(k0 >>> 16) & 0xFF] & 0x00FF0000)
                 ^ (T5[(k0 >>> 8) & 0xFF] & 0x0000FF00)
                 ^ (T5[k0 & 0xFF] & 0x000000FF);
            k1 = T4[(tt >>> 16) & 0xFF] ^ (T5[(k1 >>> 24) & 0xFF] & 0xFF000000)
                 ^ (T5[(k1 >>> 16) & 0xFF] & 0x00FF0000)
                 ^ (T5[(k1 >>> 8) & 0xFF] & 0x0000FF00)
                 ^ (T5[k1 & 0xFF] & 0x000000FF);
            k2 = T4[(tt >>> 8) & 0xFF] ^ (T5[(k2 >>> 24) & 0xFF] & 0xFF000000)
                 ^ (T5[(k2 >>> 16) & 0xFF] & 0x00FF0000)
                 ^ (T5[(k2 >>> 8) & 0xFF] & 0x0000FF00)
                 ^ (T5[(k2) & 0xFF] & 0x000000FF);
            k3 = T4[tt & 0xFF] ^ (T5[(k3 >>> 24) & 0xFF] & 0xFF000000)
                 ^ (T5[(k3 >>> 16) & 0xFF] & 0x00FF0000)
                 ^ (T5[(k3 >>> 8) & 0xFF] & 0x0000FF00)
                 ^ (T5[k3 & 0xFF] & 0x000000FF);
          }

        Ke[r][0] = k0;
        Ke[r][1] = k1;
        Ke[r][2] = k2;
        Ke[r][3] = k3;

        if (r == 0 || r == R)
          {
            Kd[R - r][0] = k0;
            Kd[R - r][1] = k1;
            Kd[R - r][2] = k2;
            Kd[R - r][3] = k3;
          }
        else
          {
            Kd[R - r][0] = T0[S[k0 >>> 24] & 0xFF]
                           ^ T1[S[(k0 >>> 16) & 0xFF] & 0xFF]
                           ^ T2[S[(k0 >>> 8) & 0xFF] & 0xFF]
                           ^ T3[S[k0 & 0xFF] & 0xFF];
            Kd[R - r][1] = T0[S[k1 >>> 24] & 0xFF]
                           ^ T1[S[(k1 >>> 16) & 0xFF] & 0xFF]
                           ^ T2[S[(k1 >>> 8) & 0xFF] & 0xFF]
                           ^ T3[S[k1 & 0xFF] & 0xFF];
            Kd[R - r][2] = T0[S[k2 >>> 24] & 0xFF]
                           ^ T1[S[(k2 >>> 16) & 0xFF] & 0xFF]
                           ^ T2[S[(k2 >>> 8) & 0xFF] & 0xFF]
                           ^ T3[S[k2 & 0xFF] & 0xFF];
            Kd[R - r][3] = T0[S[k3 >>> 24] & 0xFF]
                           ^ T1[S[(k3 >>> 16) & 0xFF] & 0xFF]
                           ^ T2[S[(k3 >>> 8) & 0xFF] & 0xFF]
                           ^ T3[S[k3 & 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.print("#" + r + ": ");
            for (j = 0; j < 4; j++)
              System.out.print("0x" + Util.toString(Ke[r][j]) + ", ");
            System.out.println();
          }
        System.out.println();
        System.out.println("Kd[]:");
        for (r = 0; r < R + 1; r++)
          {
            System.out.print("#" + r + ": ");
            for (j = 0; j < 4; j++)
              System.out.print("0x" + Util.toString(Kd[r][j]) + ", ");
            System.out.println();
          }
        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];
    anubis(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];
    anubis(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();
  }
}