seedengine.java

kmlnjlkj nlkjlkjkljl okopokipoipo oipipipo i

    private boolean forEncryption;

    public void init(boolean forEncryption, CipherParameters params) throws IllegalArgumentException
    {
        this.forEncryption = forEncryption;
        wKey = createWorkingKey(((KeyParameter)params).getKey());
    }

    public String getAlgorithmName()
    {
        return "SEED";
    }

    public int getBlockSize()
    {
        return BLOCK_SIZE;
    }

    public int processBlock(byte[] in, int inOff, byte[] out, int outOff) throws DataLengthException, IllegalStateException
    {
        if (wKey == null)
        {
            throw new IllegalStateException("SEED engine not initialised");
        }

        if (inOff + BLOCK_SIZE > in.length)
        {
            throw new DataLengthException("input buffer too short");
        }

        if (outOff + BLOCK_SIZE > out.length)
        {
            throw new DataLengthException("output buffer too short");
        }

        long l = bytesToLong(in, inOff + 0);
        long r = bytesToLong(in, inOff + 8);

        if (forEncryption)
        {
            for (int i = 0; i < 16; i++)
            {
               long nl = r;

               r = l ^ F(wKey[2 * i], wKey[(2 * i) + 1], r);
               l = nl;
            }
        }
        else
        {
            for (int i = 15; i >= 0; i--)
            {
               long nl = r;

               r = l ^ F(wKey[2 * i], wKey[(2 * i) + 1], r);
               l = nl;
            }
        }

        longToBytes(out, outOff + 0, r);
        longToBytes(out, outOff + 8, l);

        return BLOCK_SIZE;
    }

    public void reset()
    {
    }

    private int[] createWorkingKey(byte[] inKey)
    {
        int[] key = new int[32];
        long lower = bytesToLong(inKey, 0);
        long upper = bytesToLong(inKey, 8);

        int key0 = extractW0(lower);
        int key1 = extractW1(lower);
        int key2 = extractW0(upper);
        int key3 = extractW1(upper);

        for (int i = 0; i < 16; i++)
        {
            key[2 * i] = G(key0 + key2 - KC[i]);
            key[2 * i + 1] = G(key1 - key3 + KC[i]);

            if (i % 2 == 0)
            {
                lower = rotateRight8(lower);
                key0 = extractW0(lower);
                key1 = extractW1(lower);
            }
            else
            {
                upper = rotateLeft8(upper);
                key2 = extractW0(upper);
                key3 = extractW1(upper);
            }
        }

        return key;
    }

    private int extractW1(long lVal)
    {
        return (int)lVal;
    }

    private int extractW0(long lVal)
    {
        return (int)(lVal >> 32);
    }

    private long rotateLeft8(long x)
    {
        return (x << 8) | (x >>> 56);
    }

    private long rotateRight8(long x)
    {
        return (x >>> 8) | (x << 56);
    }

    private long bytesToLong(
        byte[]  src,
        int     srcOff)
    {
        long    word = 0;

        for (int i = 0; i <= 7; i++)
        {
            word = (word << 8) + (src[i + srcOff] & 0xff);
        }

        return word;
    }

    private void longToBytes(
        byte[]  dest,
        int     destOff,
        long    value)
    {
        for (int i = 0; i < 8; i++)
        {
            dest[i + destOff] = (byte)(value >> ((7 - i) * 8));
        }
    }

    private int G(int x)
    {
        return SS0[x & 0xff] ^ SS1[(x >> 8) & 0xff] ^ SS2[(x >> 16) & 0xff] ^ SS3[(x >> 24) & 0xff];
    }

    private long F(int ki0, int ki1, long r)
    {
        int r0 = (int)(r >> 32);
        int r1 = (int)r;
        int rd1 = phaseCalc2(r0, ki0, r1, ki1);
        int rd0 = rd1 + phaseCalc1(r0, ki0, r1, ki1);

        return ((long)rd0 << 32) | (rd1 & 0xffffffffL);
    }

    private int phaseCalc1(int r0, int ki0, int r1, int ki1)
    {
        return G(G((r0 ^ ki0) ^ (r1 ^ ki1)) + (r0 ^ ki0));
    }

    private int phaseCalc2(int r0, int ki0, int r1, int ki1)
    {
        return G(phaseCalc1(r0, ki0, r1, ki1) + G((r0 ^ ki0) ^ (r1 ^ ki1)));
    }
}