PBE decryption does not work

[Rob Lee]

Hello all,

The encryption in the code below works fine but i get error for decryption. any clues?

public final class lastry {
    
    /** name of the character set to use for converting between characters and bytes */
    private static final String CHARSET_NAME = "UTF-8";

    /** random number generator algorithm */
    private static final String RNG_ALGORITHM = "SHA1PRNG";

    /** message digest algorithm (must be sufficiently long to provide the key and initialization vector) */
    private static final String DIGEST_ALGORITHM = "SHA-256";

    /** key algorithm (must be compatible with CIPHER_ALGORITHM) */
    private static final String KEY_ALGORITHM = "AES";

    /** cipher algorithm (must be compatible with KEY_ALGORITHM) */
    private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding";

    private static  byte[] salt="985abb".getBytes();
    private static final int iterations=64;
    private static final String password="ya man";
    private static final byte[] cleartext="to be enc".getBytes();
    
    public lastry() throws Exception{
        encrypt(salt, iterations, password, cleartext);
        decrypt(salt, iterations, password, cleartext);
    }
    
    public static byte[] encrypt(
             byte[] salt,
             int iterations,
             String password,
             byte[] cleartext)
            throws Exception
    {
    /* generate salt randomly */
        SecureRandom.getInstance(RNG_ALGORITHM).nextBytes(salt);

        /* compute key and initialization vector */
        final MessageDigest shaDigest = MessageDigest.getInstance(DIGEST_ALGORITHM);
        byte[] pw = password.getBytes(CHARSET_NAME);

        for (int i = 0; i < iterations; i++)
        {
            /* add salt */
            final byte[] salted = new byte[pw.length + salt.length];
            System.arraycopy(pw, 0, salted, 0, pw.length);
            System.arraycopy(salt, 0, salted, pw.length, salt.length);
            Arrays.fill(pw, (byte) 0x00);

            /* compute SHA-256 digest */
            shaDigest.reset();
            pw = shaDigest.digest(salted);
            Arrays.fill(salted, (byte) 0x00);
        }

        /* extract the 16-byte key and initialization vector from the SHA-256 digest */
        final byte[] key = new byte[16];
        final byte[] iv = new byte[16];
        System.arraycopy(pw, 0, key, 0, 16);
        System.arraycopy(pw, 16, iv, 0, 16);
        Arrays.fill(pw, (byte) 0x00);

        /* perform AES-128 encryption */
        final Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

        cipher.init(
                Cipher.ENCRYPT_MODE,
                new SecretKeySpec (key, KEY_ALGORITHM),
                new IvParameterSpec(iv));
        

        Arrays.fill(key, (byte) 0x00);
        Arrays.fill(iv, (byte) 0x00);
        byte[] encrypted = cipher.doFinal(cleartext);
        String encryptedString = new String(Base64.encodeBase64(encrypted));
        System.out.println(encryptedString);
        String salte=new String (Base64.encodeBase64(salt));
        salte.toString();
        System.out.println(salte);
        
        
        return encrypted;
    }
    
    
    public static String decrypt(
             byte[] salt,
             int iterations,
             String password,
             byte[] ciphertext)
            throws Exception
    {
        /* compute key and initialization vector */
        final MessageDigest shaDigest = MessageDigest.getInstance(DIGEST_ALGORITHM);
        byte[] pw = password.getBytes(CHARSET_NAME);
        
        
        for (int i = 0; i < iterations; i++)
        {
            /* add salt */
            final byte[] salted = new byte[pw.length + salt.length];
            System.arraycopy(pw, 0, salted, 0, pw.length);
            System.arraycopy(salt, 0, salted, pw.length, salt.length);
            Arrays.fill(pw, (byte) 0x00);

            /* compute SHA-256 digest */
            shaDigest.reset();
            pw = shaDigest.digest(salted);
            Arrays.fill(salted, (byte) 0x00);
        }

        /* extract the 16-byte key and initialization vector from the SHA-256 digest */
        final byte[] key = new byte[16];
        final byte[] iv = new byte[16];
        System.arraycopy(pw, 0, key, 0, 16);
        System.arraycopy(pw, 16, iv, 0, 16);
        Arrays.fill(pw, (byte) 0x00);

        /* perform AES-128 decryption */
        final Cipher ciph = Cipher.getInstance(CIPHER_ALGORITHM);

        ciph.init(
                Cipher.DECRYPT_MODE,
                new SecretKeySpec(key, KEY_ALGORITHM),
                new IvParameterSpec(iv));

        Arrays.fill(key, (byte) 0x00);
        Arrays.fill(iv, (byte) 0x00);
        
        byte[] cciphertext=Base64.decodeBase64(encrypt(salt, 1000, "ya man", "to be enc".getBytes()));
        byte[] plainText = ciph.doFinal(cciphertext);
        String decryptedText= new String (Base64.decodeBase64 (plainText));
        System.out.println(decryptedText);
        
        return decryptedText;
    }
    
     public static void main(String args[]) throws Exception {
        
        lastry tr= new lastry();
    }
}

the output is (Exception in thread "main" javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher)
I do prefer salt to victors , so any sample code to tweak the program to use salt only will be much welcomed.

Thank you