speed.java

jpeg2000编解码

    }

    /**
     * Work out all the various constant choices.
     */
    private void set_constants(int key_length)
    {
        this.key_length = key_length;
        key_bits = key_length * 8;
        key_len_dbyte = key_length / 2;
        set_sqrt_15(key_bits);

        data_bits = block_size * 8;
        f_wd_len = data_bits / 8;    // ???  SPEED word in bits
        h_wd_len = f_wd_len / 2;    // half a SPEED word in bits

        switch (data_bits)
        {
        case 256:
            f_wd_mask = 0xFFFFFFFF;
            h_wd_mask = 0xFFFF;
            v_shift = 11;
            kb_bits = 2 * rounds;
            break ;

        case 128:
            f_wd_mask = 0xFFFF;
            h_wd_mask = 0xFF;
            v_shift = 4;
            kb_bits = rounds;
            break ;

        case 64:
            f_wd_mask = 0xFF;
            h_wd_mask = 0xF;
            v_shift = 1;
            kb_bits = rounds / 2;
            break ;

        default:
            throw new CryptixException("SPEED: " + data_bits + " is bad data size (not 64/128/256)");
        }
    }

    /**
     * Three constants are taken from the square root of 15, with 3 different
     * ones for each possible key length.
     * Also checks validity of key length here.
     */
    private void set_sqrt_15(int size)
    {
        /* fractional part of sqrt(15), used in key scheduling */
        switch (size)
        {
          case  48: s0 = 0xDF7B; s1 = 0xD629; s2 = 0xE9DB; return;
          case  64: s0 = 0x362F; s1 = 0x5D00; s2 = 0xF20F; return;
          case  80: s0 = 0xC3D1; s1 = 0x1FD2; s2 = 0x589B; return;
          case  96: s0 = 0x4312; s1 = 0x91EB; s2 = 0x718E; return;
          case 112: s0 = 0xBF2A; s1 = 0x1E7D; s2 = 0xB257; return;
          case 128: s0 = 0x77A6; s1 = 0x1654; s2 = 0x6B2A; return;
          case 144: s0 = 0x0D9B; s1 = 0xA9D3; s2 = 0x668F; return;
          case 160: s0 = 0x19BE; s1 = 0xF855; s2 = 0x6D98; return;
          case 176: s0 = 0x022D; s1 = 0xE4E2; s2 = 0xD017; return;
          case 192: s0 = 0xEA2F; s1 = 0x7572; s2 = 0xC3B5; return;
          case 208: s0 = 0x1086; s1 = 0x480C; s2 = 0x3AA6; return;
          case 224: s0 = 0x9CA0; s1 = 0x98F7; s2 = 0xD0E4; return;
          case 240: s0 = 0x253C; s1 = 0xC901; s2 = 0x55F3; return;
          case 256: s0 = 0x9BF4; s1 = 0xF659; s2 = 0xD76C; return;

          default:
            throw new CryptixException("SPEED: " + size + " is bad key length (not 48 .. 256 % 16)");
        }
    }

    private int[] kb;    // scheduling temp buffer, for dump of data

    void dump()
    {
        if (0 == data_bits)
        {
            err.println("no data set yet");
            return ;
        }

        err.println("KEY SCHEDULE");
        err.println(" data_bits " + data_bits);
        err.println(" kb_bits " + kb_bits);
        err.println(" kb.length " + kb.length);
        err.println(" f_wd_mask " + Hex.intToString(f_wd_mask));
        err.println(" h_wd_mask " + Hex.intToString(h_wd_mask));
        err.println(" v_shift " + v_shift);

        err.println(" double byte buffer");
        for(int i = 0; i < key_len_dbyte; i++)
        {
            err.print(" " + Hex.intToString(kb[i]));
        }
        err.println();

        switch (data_bits)
        {
        case 256:
            for (int i = 0; i < kb_bits / 2; i++)
                err.print(" " + Hex.intToString(round_key[i]));
            break;

        case 128:
            for (int i = 0; i < kb_bits; i++)
                err.print(" " + Hex.shortToString(round_key[i]));
            break;

        case 64:
            for (int i = 0; i < kb_bits * 2; i++)
            {
                err.print(" " + Hex.byteToString(round_key[i]));
            }
            break;

        default:
            throw new CryptixException("SPEED: data_bits=" + data_bits + " illegal in key_schedule?");
        }
        err.println();
    }

    private void to_internal(byte in[], int offset, int buf[])
    {
        //
        // Translate bytes into SPEED internal words.
        //
        switch (data_bits)
        {
        case 256:
            for (int i = 0; i < 8; i++)
            {
                buf[i] =
                      ((in[offset + 4*i  ]      ) & 0xFF)
                    | ((in[offset + 4*i+1] <<  8) & 0xFF00)
                    | ((in[offset + 4*i+2] << 16) & 0xFF0000)
                    | ((in[offset + 4*i+3] << 24) & 0xFF000000);
            }
            break;

        case 128:
            // err.println("TO 128");
            for (int i = 0; i < 8; i++)
            {
                buf[i] =
                      ((in[offset + 2*i  ]      ) & 0xFF)
                    | ((in[offset + 2*i+1] <<  8) & 0xFF00);
                //err.print(" " + Hex.intToString(buf[i]));
            }
            // err.println();
            // err.println("-----");
            break;

        case 64:
            for (int i = 0; i < 8; i++)
            {
                buf[i] = (in[offset + i] & 0xFF);
            }
            break;

        default:
            throw new CryptixException("SPEED: " + data_bits + " illegal in key_schedule?");
        }
    }

    /**
     * Encrypts a block. The in and out buffers can be the same.
     *
     * @param in The data to be encrypted.
     * @param in_offset   The start of data within the in buffer.
     * @param out The encrypted data.
     * @param out_offset  The start of data within the out buffer.
     */
    protected void 
    blockEncrypt(byte in[], int in_offset, byte out[], int out_offset)
    {
        int[] big_in  = new int[8];     // long ??
        int[] big_out = new int[8];     // long ??

        to_internal(in, in_offset, big_in);
        encrypt(big_in, big_out);
        from_internal(big_out, out, out_offset);
    }

    private void from_internal(int buf[], byte out[], int offset)
    {
        //
        // Translate internal words back into bytes.
        //
        switch (data_bits)
        {
        case 256:
            for (int i = 0; i < 8; i++)
            {
                out[4*i   + offset] = (byte)( buf[i]         & 0xFF);
                out[4*i+1 + offset] = (byte)((buf[i] >>>  8) & 0xFF);
                out[4*i+2 + offset] = (byte)((buf[i] >>> 16) & 0xFF);
                out[4*i+3 + offset] = (byte)((buf[i] >>> 24) & 0xFF);
            }
            break;

        case 128:
            for (int i = 0; i < 8; i++)
            {
                out[2*i   + offset] = (byte)( buf[i]         & 0xFF);
                out[2*i+1 + offset] = (byte)((buf[i] >>>  8) & 0xFF);
            }
            break;

        case 64:
            for (int i = 0; i < 8; i++)
            {
                out[i + offset] = (byte)(buf[i] & 0xFF);
            }
            break;

        default:
            throw new CryptixException("SPEED: data_bits=" + data_bits + " illegal in key_schedule?");
        }
    }

    /**
     * Decrypts a block. The in and out buffers can be the same.
     *
     * @param in The data to be decrypted.
     * @param in_offset   The start of data within the in buffer.
     * @param out The decrypted data.
     * @param out_offset  The start of data within the out buffer.
     */
    protected void
    blockDecrypt(byte in[], int in_offset, byte out[], int out_offset)
    {
        //
        // Translate bytes into SPEED internal words.
        //
        int[] big_in  = new int[8];     // long ??
        int[] big_out = new int[8];     // long ??

        to_internal(in, in_offset, big_in);
        decrypt(big_in, big_out);
        from_internal(big_out, out, out_offset);
    }

    /**
     * Encrypts a block.
     */
    private void encrypt(int in[], int out[])
    {
        int t0 = in[0], 
            t1 = in[1],
            t2 = in[2],
            t3 = in[3],
            t4 = in[4],
            t5 = in[5],
            t6 = in[6],
            t7 = in[7];

        int k = 0;   /* points to the first round key */
        int quarter_rounds = rounds / 4;

        //
        // In the following 4 passes, only the first assignment
        // changes, which is the nonlinear function.
        //
        /* Pass 1 uses FF1 */
        for (int i = 0; i < quarter_rounds; i++)
        {
            int temp = ((t6) & (t3)) ^ ((t5) & (t1)) ^
                       ((t4) & (t2)) ^ ((t1) & (t0)) ^ (t0);

            int vv   = (((temp >>> h_wd_len) + temp) & h_wd_mask)
                   >>> v_shift;
            //
            //    rotate_data_right(t7, h_wd_len - 1)
            //    + rotate_data_right(temp, vv)
            //    + round_key[k++];
            //
            t7 &= f_wd_mask;        // not re-used
            int rot1 = (t7 >>> (h_wd_len - 1))
                       | (t7 << (f_wd_len - (h_wd_len - 1)));

            temp &= f_wd_mask;        // not re-used
            int rot2 = (temp >>> vv)
                       | (temp << (f_wd_len - vv));

            temp = rot1 + rot2 + round_key[k++];

            t7 = t6; t6 = t5; t5 = t4; t4 = t3;
            t3 = t2; t2 = t1; t1 = t0; t0 = temp & f_wd_mask;
        }

if (DEBUG_SLOW && debuglevel >= 5) {
    debug("PASS 1: " + Hex.intToString(t7) +
                 " " + Hex.intToString(t6) +
                 " " + Hex.intToString(t5) +
                 " " + Hex.intToString(t4) +
                 " " + Hex.intToString(t3) +
                 " " + Hex.intToString(t2) +
                 " " + Hex.intToString(t1) +
                 " " + Hex.intToString(t0) +
                 " ");
}

        /* Pass 2 uses FF2 */
        for (int i = 0; i < quarter_rounds; i++)
        {
            int temp = ((t6) & (t4) & (t0)) ^ ((t4) & (t3) & (t0))
                ^ ((t5) & (t2)) ^ ((t4) & (t3)) ^ ((t4) & (t1))
                ^ ((t3) & (t0)) ^ (t1);

            int vv   = (((temp >>> h_wd_len) + temp) & h_wd_mask)
                   >>> v_shift;
            //
            //    rotate_data_right(t7, h_wd_len - 1)
            //    + rotate_data_right(temp, vv)
            //    + round_key[k++];
            //
            t7 &= f_wd_mask;        // not re-used
            int rot1 = (t7 >>> (h_wd_len - 1))
                       | (t7 << (f_wd_len - (h_wd_len - 1)));

            temp &= f_wd_mask;        // not re-used
            int rot2 = (temp >>> vv)
                       | (temp << (f_wd_len - vv));

            temp = rot1 + rot2 + round_key[k++];

            t7 = t6; t6 = t5; t5 = t4; t4 = t3;
            t3 = t2; t2 = t1; t1 = t0; t0 = temp & f_wd_mask;
        }

if (DEBUG_SLOW && debuglevel >= 5) {
    debug("PASS 2: " + Hex.intToString(t7) +
                 " " + Hex.intToString(t6) +
                 " " + Hex.intToString(t5) +
                 " " + Hex.intToString(t4) +
                 " " + Hex.intToString(t3) +
                 " " + Hex.intToString(t2) +
                 " " + Hex.intToString(t1) +
                 " " + Hex.intToString(t0) +
                 " ");
}

        /* Pass 3 uses FF3 */
        for (int i = 0; i < quarter_rounds; i++)