JAVA (AES/CBC/PKCS5PADDING) What is the corresponding C/C++

Question

Cipher.getInstance("AES/CBC/PKCS5PADDING") i using the Sun JCE provider：

public static void main(String[] args) throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, ShortBufferException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException
{
    System.out.println("=======================AES/CBC/PKCS5Padding=====================");
    // key
    byte[] key = "0123456789abcdef".getBytes("UTF-8");
    dump("key", key);
    // iv
    byte[] iv = "fedcba9876543210".getBytes("UTF-8");
    dump("iv", iv);

    byte[] indata = "bsmith is a good guy.".getBytes("UTF-8");
    dump("indata", indata);

    AES aes = new AES();
    aes.init(key, iv);
    byte[] outdata = aes.encrypt(indata);
    dump("outdata", outdata);

    byte[] indata1 = aes.decrypt(outdata);
    dump("indata1", indata1);
}

private Cipher enc;
private Cipher dec;
private SecretKeySpec keySpec;
private IvParameterSpec ivSpec;

public AES()
{
}

/**
 * init the AES key.
 * the key must be 128, 192, or 256 bits.
 * @param key the AES key.
 * @param keyoff the AES key offset.
 * @param keylen the AES key length, the key length must be 16 bytes because SunJCE only support 16 bytes key.
 * @param iv the IV for CBC, the length of iv must be 16 bytes.
 * @param ivoff the iv offset.
 */
public void init(byte[] key, int keyoff, int keylen, byte[] iv, int ivoff)
{
    keySpec = new SecretKeySpec(key, keyoff, keylen, "AES");
    ivSpec = new IvParameterSpec(iv, ivoff, 16);
}

/**
 * init the AES key.
 * the key must be 16 bytes, because SunJCE only support 16 bytes key..
 * @param key the AES key.
 * @param iv the iv for CBC, iv must be 16 bytes length.
 */
public void init(byte[] key, byte[] iv)
{
    keySpec = new SecretKeySpec(key, "AES");
    ivSpec = new IvParameterSpec(iv);
}

/**
* get the maximal cipher data length after encrypted.
* @param len the plain data length.
* @return the cipher data length.
*/
public int getCipherLen(int len)
{
    // for PKCS#1 v1.5 padding
    // max padding BLOCK_SIZE=16.
    int pad = len%16;
    if (0 == pad)
    {
        return len + 16;
    }
    return len - pad + 16;
}

/**
 * encrypt the input data to output data.
 * the input data length must be the times of 16 bytes.
 * and the output data length is equals to the input data.
 * @param indata the input data.
 * @param inoff the input data offset.
 * @param inlen the input data length.
 * @param outdata the output data.
 * @param outoff the output data offset.
 */
public void encrypt(byte[] indata, int inoff, int inlen, byte[] outdata, int outoff) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, ShortBufferException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException
{
    initEncryptor();
    enc.doFinal(indata, inoff, inlen, outdata, outoff);
}

/**
 * encrypt the input data to output data.
 * @param indata the input data.
 * @param inoff the input data offset.
 * @param inlen the input data length.
 * @return the output encrypted data.
 */
public byte[] encrypt(byte[] indata, int inoff, int inlen) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, ShortBufferException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException
{
    initEncryptor();
    return enc.doFinal(indata, inoff, inlen);
}

/**
 * encrypt the input data to output data.
 * @param indata the input data.
 * @return the output data.
 * @throws NoSuchAlgorithmException
 * @throws NoSuchPaddingException
 * @throws InvalidKeyException
 * @throws InvalidAlgorithmParameterException
 * @throws IllegalBlockSizeException
 * @throws BadPaddingException
 */
public byte[] encrypt(byte[] indata) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException
{
    initEncryptor();
    return enc.doFinal(indata);
}

/**
* the maximal plain data length after decrypted.
* @param len the cipher data length that will be decrypted.
* @return the maximal plain data length.
*/
public int getPlainLen(int len)
{
    // for PKCS#1 v1.5 padding
    // len always be times of BLOCK_SIZE=16.
    return len;
}

/**
 * decrypt the input data to output data.
 * @param indata the input data.
 * @param inoff the input data offset.
 * @param inlen the input data length.
 * @param outdata the output data.
 * @param outoff the output data offset.
 */
public void decrypt(byte[] indata, int inoff, int inlen, byte[] outdata, int outoff) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, ShortBufferException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException
{
    initDecryptor();
    dec.doFinal(indata, inoff, inlen, outdata, outoff);
}

/**
 * decrypt the input data to output data.
 * @param indata the input data.
 * @param inoff the input data offset.
 * @param inlen the input data length.
 * @return the output decrypted data.
 */
public byte[] decrypt(byte[] indata, int inoff, int inlen) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, ShortBufferException, InvalidAlgorithmParameterException
{
    initDecryptor();
    return dec.doFinal(indata, inoff, inlen);
}

/**
 * decrypt the input data to output data.
 * @param indata the input cipher data.
 * @return the output plain data.
 * @throws NoSuchAlgorithmException
 * @throws NoSuchPaddingException
 * @throws InvalidKeyException
 * @throws InvalidAlgorithmParameterException
 * @throws IllegalBlockSizeException
 * @throws BadPaddingException
 */
public byte[] decrypt(byte[] indata) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException
{
    initDecryptor();
    return dec.doFinal(indata);
}

private void initEncryptor() throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException
{
    if (null == enc)
    {
        enc = Cipher.getInstance("AES/CBC/PKCS5Padding");
        enc.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
    }
}

private void initDecryptor() throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException
{
    if (null == dec)
    {
        dec = Cipher.getInstance("AES/CBC/PKCS5Padding");
        dec.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
    }
}

}

Corresponds to what is C/C++? I found crypto++ Just right，Others are not，But the algorithms inside too much, I just need to have AES。That is too complicated, I will not, I am a novice，Do you familiar with this algorithm, I want to transplant it into Android, packaged as so。

Answer 1

First of all, PKCS#5 padding is better known as PKCS#7 padding. PKCS#5 padding is actually for 8 byte block ciphers, and PKCS#7 padding is for 16 byte block ciphers. Otherwise they are identical.

The cryptographic library is all right if it supplies AES and CBC. This is more or less a given, as CBC is one of the more common modes. The availability of the right padding mode may differ, although most C++ libraries will support PKCS#5 padding, as it is the de-facto standard.

As there are (NIST) test vectors available, and since the byte order is known, any library that supports the combination of algorithm, mode and padding mode should be inter-operable.