password encryption and decryption with Base 64

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package endecrypt;


import java.security.Key;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
/**
 *
 * @author WeiZhang
 */
public class EnDecrypt {


    /**
     * @param args the command line arguments
     */
    
    
    private static final String ALGO = "AES";
    private static final int ITERATIONS = 2;
    //18 bytes output salt with length 24 with no padding
    private static final int saltSize = 24;
    private static final byte[] keyValue = 
        new byte[] { 'T', 'o', 'e', 'B', 'e', 's', 't',
                    'S', 'e', 'c', 'r','e', 't', 'K', 'e', 'y' };
    
    //AES algorithm
    public static String encrypt(String data) throws Exception {
        String salt = generateSalt();
        Key key = generateKey();
        Cipher c = Cipher.getInstance(ALGO);
        c.init(Cipher.ENCRYPT_MODE, key);
        String valueToEnc = null; 
        String eValue = data; 
        for (int i = 0; i < ITERATIONS; i++) { 
            valueToEnc = salt + eValue; 
            byte[] encValue = c.doFinal(valueToEnc.getBytes());
            eValue = Base64.getEncoder().encodeToString(encValue);
        } 
        return salt + eValue;
    }
    
    //generate random salt with 18 bytes, output has length 24 in base64 with no padding
    public static String generateSalt() {
        SecureRandom random = new SecureRandom();
        byte bytes[] = new byte[18];
        random.nextBytes(bytes);
        String s = Base64.getEncoder().encodeToString(bytes);
System.out.println("generateing salt is : " + s.length() + "  " + s);        
        return s;
    }
    
    
    public static String decrypt(String encryptedData) throws Exception {
        String salt = encryptedData.substring(0, saltSize);
        
        Key key = generateKey();
        Cipher c = Cipher.getInstance(ALGO);
        c.init(Cipher.DECRYPT_MODE, key);
        String dValue = null; 
        String valueToDecrypt = encryptedData.substring(saltSize); 
        for (int i = 0; i < ITERATIONS; i++) { 
            byte[] decordedValue = Base64.getDecoder().decode(valueToDecrypt);
            byte[] decValue = c.doFinal(decordedValue);
            dValue = new String(decValue).substring(salt.length()); 
            valueToDecrypt = dValue; 
        } 
        return dValue; 
    }
    
    private static Key generateKey() throws Exception {
        Key key = new SecretKeySpec(keyValue, ALGO);
        return key;
    }
    
    public static void main(String[] args) {
        // TODO code application logic here
        String password = "12536";
        String passwordEnc = null, passwordDec = null;
        
        //better choose any string with lentgh 16
        String salt = "choose a simple clear salt";
        
        String test = "cGFzc3dvcmQ=";
        
        
        try {
            passwordEnc = EnDecrypt.encrypt(password);
            passwordDec = EnDecrypt.decrypt(passwordEnc);
//            test = EnDecrypt.decrypt(test);
        } catch (Exception ex) {
            Logger.getLogger(EnDecrypt.class.getName()).log(Level.SEVERE, null, ex);
        }
        


        System.out.println("Plain Text : " + password);
        System.out.println("Encrypted Text : " + passwordEnc);
        System.out.println("Decrypted Text : " + passwordDec);
        
//        System.out.println("decode is: " + test);
    }
    
    
    
    
}