AES 128bit ECB Encryption Ciphered Text Overflow

Question

I am currently trying to make a program using BouncyCastle library to encrypt and decrypt a hex string (length 16) using a hex key (length 16). It works, however, after encryption, the ciphered text is twice as long as what was expected (current output length 32, expected output length 16).

Current Output:

 Input: helloworldsingap
Length: 16

   Key: 0000000000000000000000000000004D
Length: 16

Cipher: 47DDFB51938DB86E6CC3EF9F078C78C6FC5E0686775522C07BB46BAB18E0FCFA
Length: 32

Output: helloworldsingap
Length: 16

Expected Output:

 Input: helloworldsingap
Length: 16

   Key: 0000000000000000000000000000004D
Length: 16

Cipher: 47DDFB51938DB86E6CC3EF9F078C78C6
Length: 16

Output: helloworldsingap
Length: 16

For my current output, the first half of the cipher text is correct. Does anyone know what is the extra 16 characters at the end of the cipher for my current output, and how do I remove it?

Here is my program:

package com.optixal.tests;

import java.security.Security;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class AES128ECB {

    public static void main(String[] args) throws Exception {

        Security.addProvider(new BouncyCastleProvider());

        // Input
        String hexInput = "68656c6c6f776f726c6473696e676170";
        byte[] byteInput = toByteArray(hexInput);

        // Key
        String hexKey = decToHex(77);
        byte[] byteKey = toByteArray(hexKey);

        System.out.println(" Input: " + new String(byteInput));
        System.out.println("Length: " + byteInput.length + "\n");
        System.out.println("   Key: " + hexKey);
        System.out.println("Length: " + byteKey.length + "\n");

        SecretKeySpec key = new SecretKeySpec(byteKey, "AES");
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding", "BC");

        // Encrypt
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] cipherText = new byte[cipher.getOutputSize(byteInput.length)];
        int ctLength = cipher.update(byteInput, 0, byteInput.length, cipherText, 0);
        ctLength += cipher.doFinal(cipherText, ctLength);
        System.out.println("Cipher: " + toHexString(cipherText));
        System.out.println("Length: " + ctLength + "\n");

        // Decrypt
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] plainText = new byte[cipher.getOutputSize(ctLength)];
        int ptLength = cipher.update(cipherText, 0, ctLength, plainText, 0);
        ptLength += cipher.doFinal(plainText, ptLength);
        System.out.println("Output: " + new String(plainText));
        System.out.println("Length: " + ptLength);
    }

    private static final String hexDigits = "0123456789ABCDEF";
    private static final char[] hexDigitsArray = hexDigits.toCharArray();

    public static String decToHex(int dec) {

        final int sizeOfIntInHalfBytes = 32;
        final int numberOfBitsInAHalfByte = 4;
        final int halfByte = 0x0F;

        StringBuilder hexBuilder = new StringBuilder(sizeOfIntInHalfBytes);
        hexBuilder.setLength(sizeOfIntInHalfBytes);
        for (int i = sizeOfIntInHalfBytes - 1; i >= 0; --i) {
            int j = dec & halfByte;
            hexBuilder.setCharAt(i, hexDigitsArray[j]);
            dec >>= numberOfBitsInAHalfByte;
        }
        return hexBuilder.toString();
    }

    public static String toHexString(byte[] array) {
        return DatatypeConverter.printHexBinary(array);
    }

    public static byte[] toByteArray(String s) {
        return DatatypeConverter.parseHexBinary(s);
    }

}

Thanks!

Muhammad Imran Muhammad Imran · Accepted Answer · 2015-07-06T06:00:08

using AES/ECB/NoPadding instead of AES/ECB/PKCS7Padding at line

Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding", "BC");

will solve your problem.

enter image description here

AES 128bit ECB Encryption Ciphered Text Overflow

1 Answers