java.security.InvalidKeyException:Illegal key size or default parameters

  AESEncryptDecryptUtil util = new AESEncryptDecryptUtil();
        String encrypedMessage = util
            .encrypt("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin scelerisque sodales augue, ac tristique nibh euismod nec. ");
        boolean status = util.isEncrypted(encrypedMessage);
 
        System.out.println("Encrypted : " + encrypedMessage);
        System.out.println("Message encrypted : " + status);
        System.out.println("Decrypted : " + util.decrypt(encrypedMessage));

   public String getUserName()
    {
        try
        {
            AESEncryptDecryptUtil util = new AESEncryptDecryptUtil();
            if (util.isEncrypted(userName))
            {
                return util.decrypt(userName);
            }
        }
        catch (EncryptDecryptException e)
        {
            e.printStackTrace();
        }
        return userName;
    }

Encrypted : CRYPT:keGhiojDBpgsUkdepcT6aFvzR0Jpsmi4no3TwP3OzFbAmjvvBxkSQHMyQ8uM81PTCTEWebe3HrE5
o/+jLgdmQB+CDxBMUvUrFRvFFAGsrCcS+cWgYTi+T5/LTUFonXBOc5r++GQbV2htxy9YislL2JPT
vMQAGrgMjOFTDBZvuJdeUIC6uKWjtndJidxigxHB
Message encrypted : true
Decrypted : Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin scelerisque sodales augue, ac tristique nibh euismod nec.

 
import java.io.UnsupportedEncodingException;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.security.AlgorithmParameters;
import java.security.InvalidKeyException;
import java.security.spec.InvalidParameterSpecException;
import java.security.spec.KeySpec;
 
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;
 
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
 
/**
 * AES Encryption/Decryption Utility that uses MAC address as the Master
 * Encryption Key Initial Vector need to be stored together with the encrypted
 * string so that we can use it to decrypt the message. This is the format that
 * will be produced from the encryption, both encrypted message and initial
 * vector are base 64 encoded, in UTF-8 char set
 * <code>CRYPT:initialVector+encryptedMessage</code>
 * 
 * @author gbugaj
 */
public class AESEncryptDecryptUtil
{
 
    private static final int ITERATIONS = 65536;
 
    private static final String STRING_ENCODING = "UTF-8";
 
    private static final String CRYPT_PREFIX = "CRYPT";
 
    /**
     * If we user Key size of 256 we will get java.security.InvalidKeyException:
     * Illegal key size or default parameters , Unless we configure Java
     * Cryptography Extension 128
     */
    private static final int KEY_SIZE = 128;
 
    private static final byte[] SALT = { (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0 };
 
    private SecretKeySpec secret;
 
    private Cipher cipher;
 
    private BASE64Encoder base64Encoder;
 
    private BASE64Decoder base64Decoder;
 
    private AESEncryptDecryptUtil() throws EncryptDecryptException
    {
        try
        {
            /* Derive the key, given password and salt. */
            SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
            KeySpec spec;
 
            spec = new PBEKeySpec(getHardwareKey(), SALT, ITERATIONS, KEY_SIZE);
            SecretKey tmp = factory.generateSecret(spec);
            secret = new SecretKeySpec(tmp.getEncoded(), "AES");
 
            // CBC = Cipher Block chaining
            // PKCS5Padding Indicates that the keys are padded
            cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
 
            // For production use commons base64 encoder
            base64Decoder = new BASE64Decoder();
            base64Encoder = new BASE64Encoder();
        }
        catch (Exception e)
        {
            throw new EncryptDecryptException("Unable to initialize", e);
        }
 
    }
 
    /**
     * Get hardware key to be used for encryption, we rely on MAC address as the
     * key, with fallback to JVM name then windows machine name
     * 
     * @return key as char[]
     * @throws EncryptDecryptException
     */
    private char[] getHardwareKey() throws EncryptDecryptException
    {
 
        // Exceptions from this are ignored as we move to next available method
        try
        {
            InetAddress address = InetAddress.getLocalHost();
            NetworkInterface nic = NetworkInterface.getByInetAddress(address);
            if (nic != null)
            {
                byte[] mac = nic.getHardwareAddress();
                if (mac != null && mac.length > 0)
                {
                    return new String(mac, STRING_ENCODING).toCharArray();
                }
            }
        }
        catch (UnknownHostException e)
        {
            e.printStackTrace();
        }
        catch (SocketException e)
        {
            e.printStackTrace();
        }
        catch (UnsupportedEncodingException e)
        {
            e.printStackTrace();
        }
 
        // Could not obtain MAC Address so we are falling back on the computer
        // name then on the JVM Name
        RuntimeMXBean rmx = ManagementFactory.getRuntimeMXBean();
        String jvmName = rmx.getName();
        String[] parts = jvmName.split("@");
        if (parts.length > 0)
        {
            String name = parts[1];
            if (name != null && !name.isEmpty())
            {
                return name.toCharArray();
            }
        }
 
        String name = System.getenv("COMPUTERNAME");
        if (name != null && !name.isEmpty())
        {
            return name.toCharArray();
        }
        throw new EncryptDecryptException("Unable to obtain Secure Key");
    }
 
    /**
     * Encrypt given input string
     * 
     * @param input
     * @return
     * @throws EncryptDecryptException
     */
    public String encrypt(String input) throws EncryptDecryptException
    {
        try
        {
            byte[] inputBytes = input.getBytes(STRING_ENCODING);
            cipher.init(Cipher.ENCRYPT_MODE, secret);
            AlgorithmParameters params = cipher.getParameters();
            byte[] iv = params.getParameterSpec(IvParameterSpec.class).getIV();
            byte[] ciphertext = cipher.doFinal(inputBytes);
            byte[] out = new byte[iv.length + ciphertext.length];
            System.arraycopy(iv, 0, out, 0, iv.length);
            System.arraycopy(ciphertext, 0, out, iv.length, ciphertext.length);
            return CRYPT_PREFIX + ":" + base64Encoder.encode(out);
        }
 
        catch (IllegalBlockSizeException e)
        {
            throw new EncryptDecryptException("Unable to encrypt", e);
        }
        catch (BadPaddingException e)
        {
            throw new EncryptDecryptException("Unable to encrypt", e);
        }
        catch (InvalidKeyException e)
        {
            throw new EncryptDecryptException("Unable to encrypt", e);
        }
        catch (InvalidParameterSpecException e)
        {
            throw new EncryptDecryptException("Unable to encrypt", e);
        }
        catch (UnsupportedEncodingException e)
        {
            throw new EncryptDecryptException("Unable to encrypt", e);
        }
    }
 
    /**
     * Decrypt input string
     * 
     * @param input
     * @return decrypted string
     * @throws EncryptDecryptException
     */
    @SuppressWarnings("restriction")
    public String decrypt(String input) throws EncryptDecryptException
 
    {
        if (!input.startsWith(CRYPT_PREFIX))
        {
            throw new EncryptDecryptException("Unable to decrypt, input string does not start with 'CRYPT'");
        }
 
        try
        {
            byte[] data = base64Decoder.decodeBuffer(input.substring(6, input.length()));
            int keylen = KEY_SIZE / 8;
            byte[] iv = new byte[keylen];
            System.arraycopy(data, 0, iv, 0, keylen);
            cipher.init(Cipher.DECRYPT_MODE, secret, new IvParameterSpec(iv));
            return new String(cipher.doFinal(data, keylen, data.length - keylen), STRING_ENCODING);
        }
        catch (Exception e)
        {
            throw new EncryptDecryptException("Unable to decrypt ", e);
        }
    }
 
    /**
     * Helper Exception to wrap arround Encryption/Decryption exceptions
     */
    @SuppressWarnings("serial")
    private static class EncryptDecryptException extends Exception
    {
        public EncryptDecryptException()
        {
            super();
        }
 
        public EncryptDecryptException(String msg)
        {
            super(msg);
        }
 
        public EncryptDecryptException(String msg, Throwable t)
        {
            super(msg, t);
        }
 
        public EncryptDecryptException(Throwable t)
        {
            super(t);
        }
    }
 
    /**
     * Check if given string is already encrypted
     * 
     * @param input
     * @return
     */
    private boolean isEncrypted(String input)
    {
        if (input == null || input.isEmpty())
        {
            return false;
        }
        return input.startsWith(CRYPT_PREFIX);
    }
 
    public static void main(String[] args) throws EncryptDecryptException
    {
        AESEncryptDecryptUtil util = new AESEncryptDecryptUtil();
        String encrypedMessage = util
            .encrypt("TEST");
        boolean status = util.isEncrypted(encrypedMessage);
 
        System.out.println("Encrypted : " + encrypedMessage);
        System.out.println("Message encrypted : " + status);
        System.out.println("Decrypted : " + util.decrypt(encrypedMessage));
    }
 
}