jceblockcipher.java

来自「bouncycastle 是一个JAVA安全提供者」· Java 代码 · 共 1,120 行 · 第 1/2 页

        byte[]  input,
        int     inputOffset,
        int     inputLen) 
    {
        int     length = cipher.getUpdateOutputSize(inputLen);

        if (length > 0)
        {
                byte[]  out = new byte[length];

                int len = cipher.processBytes(input, inputOffset, inputLen, out, 0);

                if (len == 0)
                {
                    return null;
                }
                else if (len != out.length)
                {
                    byte[]  tmp = new byte[len];

                    System.arraycopy(out, 0, tmp, 0, len);

                    return tmp;
                }

                return out;
        }

        cipher.processBytes(input, inputOffset, inputLen, null, 0);

        return null;
    }

    protected int engineUpdate(
        byte[]  input,
        int     inputOffset,
        int     inputLen,
        byte[]  output,
        int     outputOffset)
        throws ShortBufferException
    {
        try
        {
            return cipher.processBytes(input, inputOffset, inputLen, output, outputOffset);
        }
        catch (DataLengthException e)
        {
            throw new ShortBufferException(e.getMessage());
        }
    }

    protected byte[] engineDoFinal(
        byte[]  input,
        int     inputOffset,
        int     inputLen) 
        throws IllegalBlockSizeException, BadPaddingException
    {
        int     len = 0;
        byte[]  tmp = new byte[engineGetOutputSize(inputLen)];

        if (inputLen != 0)
        {
            len = cipher.processBytes(input, inputOffset, inputLen, tmp, 0);
        }

        try
        {
            len += cipher.doFinal(tmp, len);
        }
        catch (DataLengthException e)
        {
            throw new IllegalBlockSizeException(e.getMessage());
        }
        catch (InvalidCipherTextException e)
        {
            throw new BadPaddingException(e.getMessage());
        }

        byte[]  out = new byte[len];

        System.arraycopy(tmp, 0, out, 0, len);

        return out;
    }

    protected int engineDoFinal(
        byte[]  input,
        int     inputOffset,
        int     inputLen,
        byte[]  output,
        int     outputOffset) 
        throws IllegalBlockSizeException, BadPaddingException
    {
        int     len = 0;

        if (inputLen != 0)
        {
                len = cipher.processBytes(input, inputOffset, inputLen, output, outputOffset);
        }

        try
        {
            return (len + cipher.doFinal(output, outputOffset + len));
        }
        catch (DataLengthException e)
        {
            throw new IllegalBlockSizeException(e.getMessage());
        }
        catch (InvalidCipherTextException e)
        {
            throw new BadPaddingException(e.getMessage());
        }
    }

    /*
     * The ciphers that inherit from us.
     */

    /**
     * DES
     */
    static public class DES
        extends JCEBlockCipher
    {
        public DES()
        {
            super(new DESEngine());
        }
    }

    /**
     * DESCBC
     */
    static public class DESCBC
        extends JCEBlockCipher
    {
        public DESCBC()
        {
            super(new CBCBlockCipher(new DESEngine()), 64);
        }
    }

    /**
     * DESede
     */
    static public class DESede
        extends JCEBlockCipher
    {
        public DESede()
        {
            super(new DESedeEngine());
        }
    }

    /**
     * DESedeCBC
     */
    static public class DESedeCBC
        extends JCEBlockCipher
    {
        public DESedeCBC()
        {
            super(new CBCBlockCipher(new DESedeEngine()), 64);
        }
    }

    /**
     *  GOST28147
     */
    static public class GOST28147
        extends JCEBlockCipher
    {
        public GOST28147()
        {
            super(new GOST28147Engine());
        }
    }
    
    static public class GOST28147cbc
        extends JCEBlockCipher
    {
        public GOST28147cbc()
        {
            super(new CBCBlockCipher(new GOST28147Engine()), 64);
        }
    }
    
    /**
     * SKIPJACK
     */
    static public class Skipjack
        extends JCEBlockCipher
    {
        public Skipjack()
        {
            super(new SkipjackEngine());
        }
    }

    /**
     * Blowfish
     */
    static public class Blowfish
        extends JCEBlockCipher
    {
        public Blowfish()
        {
            super(new BlowfishEngine());
        }
    }

    /**
     * Twofish
     */
    static public class Twofish
        extends JCEBlockCipher
    {
        public Twofish()
        {
            super(new TwofishEngine());
        }
    }

    /**
     * RC2
     */
    static public class RC2
        extends JCEBlockCipher
    {
        public RC2()
        {
            super(new RC2Engine());
        }
    }

    /**
     * RC2CBC
     */
    static public class RC2CBC
        extends JCEBlockCipher
    {
        public RC2CBC()
        {
            super(new CBCBlockCipher(new RC2Engine()), 64);
        }
    }

    /**
     * RC5
     */
    static public class RC5
        extends JCEBlockCipher
    {
        public RC5()
        {
            super(new RC532Engine());
        }
    }

    /**
     * RC564
     */
    static public class RC564
        extends JCEBlockCipher
    {
        public RC564()
        {
            super(new RC564Engine());
        }
    }

    /**
     * RC6
     */
    static public class RC6
        extends JCEBlockCipher
    {
        public RC6()
        {
            super(new RC6Engine());
        }
    }

    /**
     * AES
     */
    static public class AES
        extends JCEBlockCipher
    {
        public AES()
        {
            super(new AESFastEngine());
        }
    }

    /**
     * AESCBC
     */
    static public class AESCBC
        extends JCEBlockCipher
    {
        public AESCBC()
        {
            super(new CBCBlockCipher(new AESFastEngine()), 128);
        }
    }

    /**
     * AESCFB
     */
    static public class AESCFB
        extends JCEBlockCipher
    {
        public AESCFB()
        {
            super(new CFBBlockCipher(new AESFastEngine(), 128), 128);
        }
    }
    
    /**
     * AESOFB
     */
    static public class AESOFB
        extends JCEBlockCipher
    {
        public AESOFB()
        {
            super(new OFBBlockCipher(new AESFastEngine(), 128), 128);
        }
    }
    
    /**
     * Rijndael
     */
    static public class Rijndael
        extends JCEBlockCipher
    {
        public Rijndael()
        {
            super(new RijndaelEngine());
        }
    }

    /**
     * Serpent
     */
    static public class Serpent
        extends JCEBlockCipher
    {
        public Serpent()
        {
            super(new SerpentEngine());
        }
    }

    /**
     * Camellia
     */
    static public class Camellia
        extends JCEBlockCipher
    {
        public Camellia()
        {
            super(new CamelliaEngine());
        }
    }
    
    /**
     * CAST5
     */
    static public class CAST5
        extends JCEBlockCipher
    {
        public CAST5()
        {
            super(new CAST5Engine());
        }
    }

    /**
     * CAST5 CBC
     */
    static public class CAST5CBC
        extends JCEBlockCipher
    {
        public CAST5CBC()
        {
            super(new CBCBlockCipher(new CAST5Engine()), 64);
        }
    }

    /**
     * CAST6
     */
    static public class CAST6
        extends JCEBlockCipher
    {
        public CAST6()
        {
            super(new CAST6Engine());
        }
    }

    /**
     * IDEA
     */
    static public class IDEA
        extends JCEBlockCipher
    {
        public IDEA()
        {
            super(new IDEAEngine());
        }
    }

    /**
     * IDEA CBC
     */
    static public class IDEACBC
        extends JCEBlockCipher
    {
        public IDEACBC()
        {
            super(new CBCBlockCipher(new IDEAEngine()), 64);
        }
    }

    /**
     * PBEWithMD5AndDES
     */
    static public class PBEWithMD5AndDES
        extends JCEBlockCipher
    {
        public PBEWithMD5AndDES()
        {
            super(new CBCBlockCipher(new DESEngine()));
        }
    }

    /**
     * PBEWithMD5AndRC2
     */
    static public class PBEWithMD5AndRC2
        extends JCEBlockCipher
    {
        public PBEWithMD5AndRC2()
        {
            super(new CBCBlockCipher(new RC2Engine()));
        }
    }

    /**
     * PBEWithSHA1AndDES
     */
    static public class PBEWithSHA1AndDES
        extends JCEBlockCipher
    {
        public PBEWithSHA1AndDES()
        {
            super(new CBCBlockCipher(new DESEngine()));
        }
    }

    /**
     * PBEWithSHA1AndRC2
     */
    static public class PBEWithSHA1AndRC2
        extends JCEBlockCipher
    {
        public PBEWithSHA1AndRC2()
        {
            super(new CBCBlockCipher(new RC2Engine()));
        }
    }

    /**
     * PBEWithSHAAnd3-KeyTripleDES-CBC
     */
    static public class PBEWithSHAAndDES3Key
        extends JCEBlockCipher
    {
        public PBEWithSHAAndDES3Key()
        {
            super(new CBCBlockCipher(new DESedeEngine()));
        }
    }

    /**
     * PBEWithSHAAnd2-KeyTripleDES-CBC
     */
    static public class PBEWithSHAAndDES2Key
        extends JCEBlockCipher
    {
        public PBEWithSHAAndDES2Key()
        {
            super(new CBCBlockCipher(new DESedeEngine()));
        }
    }

    /**
     * PBEWithSHAAnd128BitRC2-CBC
     */
    static public class PBEWithSHAAnd128BitRC2
        extends JCEBlockCipher
    {
        public PBEWithSHAAnd128BitRC2()
        {
            super(new CBCBlockCipher(new RC2Engine()));
        }
    }

    /**
     * PBEWithSHAAnd40BitRC2-CBC
     */
    static public class PBEWithSHAAnd40BitRC2
        extends JCEBlockCipher
    {
        public PBEWithSHAAnd40BitRC2()
        {
            super(new CBCBlockCipher(new RC2Engine()));
        }
    }

    /**
     * PBEWithSHAAndTwofish-CBC
     */
    static public class PBEWithSHAAndTwofish
        extends JCEBlockCipher
    {
        public PBEWithSHAAndTwofish()
        {
            super(new CBCBlockCipher(new TwofishEngine()));
        }
    }

    /**
     * PBEWithSHAAndIDEA-CBC
     */
    static public class PBEWithSHAAndIDEA
        extends JCEBlockCipher
    {
        public PBEWithSHAAndIDEA()
        {
            super(new CBCBlockCipher(new IDEAEngine()));
        }
    }
    
    /**
     * PBEWithAES-CBC
     */
    static public class PBEWithAESCBC
        extends JCEBlockCipher
    {
        public PBEWithAESCBC()
        {
            super(new CBCBlockCipher(new AESFastEngine()));
        }
    }
}