blowfish.java

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

          }
        ctx.p[i] ^= data;
      }

    // We swap the left and right words here only, so we can avoid
    // swapping altogether during encryption/decryption.
    int t;
    Block x = new Block();
    x.left = x.right = 0;
    for (int i = 0; i < ctx.p.length; i += 2)
      {
        blowfishEncrypt(x, ctx);
        ctx.p[i] = x.right;
        ctx.p[i + 1] = x.left;
        t = x.right;
        x.right = x.left;
        x.left = t;
      }
    for (int i = 0; i < ctx.s0.length; i += 2)
      {
        blowfishEncrypt(x, ctx);
        ctx.s0[i] = x.right;
        ctx.s0[i + 1] = x.left;
        t = x.right;
        x.right = x.left;
        x.left = t;
      }
    for (int i = 0; i < ctx.s1.length; i += 2)
      {
        blowfishEncrypt(x, ctx);
        ctx.s1[i] = x.right;
        ctx.s1[i + 1] = x.left;
        t = x.right;
        x.right = x.left;
        x.left = t;
      }
    for (int i = 0; i < ctx.s2.length; i += 2)
      {
        blowfishEncrypt(x, ctx);
        ctx.s2[i] = x.right;
        ctx.s2[i + 1] = x.left;
        t = x.right;
        x.right = x.left;
        x.left = t;
      }
    for (int i = 0; i < ctx.s3.length; i += 2)
      {
        blowfishEncrypt(x, ctx);
        ctx.s3[i] = x.right;
        ctx.s3[i + 1] = x.left;
        t = x.right;
        x.right = x.left;
        x.left = t;
      }
    x.left = x.right = 0;
    return ctx;
  }

  public void encrypt(byte[] in, int i, byte[] out, int o, Object k, int bs)
  {
    Block x = new Block();
    x.left = (in[i] & 0xff) << 24 | (in[i + 1] & 0xff) << 16
             | (in[i + 2] & 0xff) << 8 | (in[i + 3] & 0xff);
    x.right = (in[i + 4] & 0xff) << 24 | (in[i + 5] & 0xff) << 16
              | (in[i + 6] & 0xff) << 8 | (in[i + 7] & 0xff);
    blowfishEncrypt(x, (Context) k);
    out[o] = (byte) (x.right >>> 24);
    out[o + 1] = (byte) (x.right >>> 16);
    out[o + 2] = (byte) (x.right >>> 8);
    out[o + 3] = (byte) x.right;
    out[o + 4] = (byte) (x.left >>> 24);
    out[o + 5] = (byte) (x.left >>> 16);
    out[o + 6] = (byte) (x.left >>> 8);
    out[o + 7] = (byte) x.left;
    x.left = x.right = 0;
  }

  public void decrypt(byte[] in, int i, byte[] out, int o, Object k, int bs)
  {
    Block x = new Block();
    x.left = (in[i] & 0xff) << 24 | (in[i + 1] & 0xff) << 16
             | (in[i + 2] & 0xff) << 8 | (in[i + 3] & 0xff);
    x.right = (in[i + 4] & 0xff) << 24 | (in[i + 5] & 0xff) << 16
              | (in[i + 6] & 0xff) << 8 | (in[i + 7] & 0xff);
    blowfishDecrypt(x, (Context) k);
    out[o] = (byte) (x.right >>> 24);
    out[o + 1] = (byte) (x.right >>> 16);
    out[o + 2] = (byte) (x.right >>> 8);
    out[o + 3] = (byte) x.right;
    out[o + 4] = (byte) (x.left >>> 24);
    out[o + 5] = (byte) (x.left >>> 16);
    out[o + 6] = (byte) (x.left >>> 8);
    out[o + 7] = (byte) x.left;
    x.left = x.right = 0;
  }

  // Own methods
  // -----------------------------------------------------------------

  /** Encrypt a single pair of 32-bit integers. */
  private void blowfishEncrypt(Block x, Context ctx)
  {
    int[] p = ctx.p;
    int[] s0 = ctx.s0, s1 = ctx.s1, s2 = ctx.s2, s3 = ctx.s3;
    x.left ^= p[0];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[1];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[2];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[3];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[4];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[5];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[6];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[7];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[8];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[9];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[10];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[11];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[12];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[13];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[14];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[15];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[16];
    x.right ^= p[17];
  }

  /** Decrypt a single pair of 32-bit integers. */
  private void blowfishDecrypt(Block x, Context ctx)
  {
    int[] p = ctx.p;
    int[] s0 = ctx.s0, s1 = ctx.s1, s2 = ctx.s2, s3 = ctx.s3;
    x.left ^= p[17];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[16];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[15];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[14];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[13];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[12];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[11];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[10];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[9];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[8];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[7];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[6];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[5];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[4];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[3];
    x.right ^= ((s0[x.left >>> 24] + s1[x.left >>> 16 & 0xff]) ^ s2[x.left >>> 8 & 0xff])
               + s3[x.left & 0xff] ^ p[2];
    x.left ^= ((s0[x.right >>> 24] + s1[x.right >>> 16 & 0xff]) ^ s2[x.right >>> 8 & 0xff])
              + s3[x.right & 0xff] ^ p[1];
    x.right ^= p[0];
  }

  public boolean selfTest()
  {
    if (valid == null)
      {
        boolean result = super.selfTest(); // symmetry
        if (result)
          {
            result = testKat(TV_KEY, TV_CT);
          }
        valid = new Boolean(result);
      }
    return valid.booleanValue();
  }

  // Inner classes.
  // -----------------------------------------------------------------------

  /** A simple wrapper for the P- and S-boxes. */
  private class Context implements Cloneable
  {

    // Constants and variables.
    // --------------------------------------------------------------------

    /** The P-array. */
    int[] p, s0, s1, s2, s3;

    // Constructors.
    // --------------------------------------------------------------------

    /** Default 0-arguments constructor. */
    Context()
    {
      p = new int[18];
      s0 = new int[256];
      s1 = new int[256];
      s2 = new int[256];
      s3 = new int[256];
    }

    /**
     * Private constructor for cloneing.
     *
     * @param that The instance being cloned.
     */
    private Context(Context that)
    {
      this.p = (int[]) that.p.clone();
      this.s0 = (int[]) that.s0.clone();
      this.s1 = (int[]) that.s1.clone();
      this.s2 = (int[]) that.s2.clone();
      this.s3 = (int[]) that.s3.clone();
    }

    // Clonable interface implementation.
    // --------------------------------------------------------------------

    public Object clone()
    {
      return new Context(this);
    }
  }

  private class Block
  {
    int left, right;
  }
}