package encryptUtils;

    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.KeyGenerator;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.SecretKey;

    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;

    import java.security.cert.CertificateException;
    import java.security.InvalidKeyException;
    import java.security.KeyStore;
    import java.security.KeyStoreException;
    import java.security.NoSuchAlgorithmException;
    import java.security.UnrecoverableKeyException;

    public class AES {
        public static void generateKey(
                String password,
                String userName)
                throws CryptoException {
            KeyGenerator KeyGen;

            try {
                KeyGen = KeyGenerator.getInstance("AES");
            } catch (NoSuchAlgorithmException ex) {
                throw new CryptoException("Error generateKey | KeyGenerator.getInstance", ex);
            }

            KeyGen.init(128);
            SecretKey SecKey = KeyGen.generateKey();
            saveKey(SecKey, password, userName);
        }

        private static void saveKey(
                SecretKey key,
                String password,
                String userName)
                throws CryptoException {
            KeyStore keyStore;

            try {
                keyStore = KeyStore.getInstance("JCEKS");
            } catch (KeyStoreException ex) {
                throw new CryptoException("Error saveKey | KeyStore.getInstance", ex);
            }

            try {
                keyStore.load(null, null);
            } catch (IOException | NoSuchAlgorithmException | CertificateException ex) {
                throw new CryptoException("Error saveKey | keyStore.load", ex);
            }

            try {
                keyStore.setKeyEntry(userName, key, password.toCharArray(), null);
            } catch (KeyStoreException ex) {
                throw new CryptoException("Error saveKey | keyStore.setKeyEntry", ex);
            }

            try {
                keyStore.store(new FileOutputStream(userName + ".jceks"), password.toCharArray());
            } catch (KeyStoreException | IOException | NoSuchAlgorithmException | CertificateException ex) {
                throw new CryptoException("Error saveKey | keyStore.store", ex);
            }
        }

        public static SecretKey loadKey(
                String password,
                String userName)
                throws CryptoException {
            KeyStore keyStore;

            try {
                keyStore = KeyStore.getInstance("JCEKS");
            } catch (KeyStoreException ex) {
                throw new CryptoException("Error loadKey | KeyStore.getInstance", ex);
            }

            try {
                keyStore.load(new FileInputStream(userName + ".jceks"), password.toCharArray());
            } catch (IOException | NoSuchAlgorithmException | CertificateException ex) {
                throw new CryptoException("Error loadKey | keyStore.load", ex);
            }

            SecretKey key;

            try {
                key = (SecretKey) keyStore.getKey(userName, password.toCharArray());
            } catch (KeyStoreException | NoSuchAlgorithmException | UnrecoverableKeyException ex) {
                throw new CryptoException("Error loadKey | key = (SecretKey) keyStore.getKey", ex);
            }

            return key;
        }

        public static byte[] encryptString(
                SecretKey key,
                String toEncrypt)
                throws CryptoException {
            byte[] toEncryptBytes;

            try {
                toEncryptBytes = toEncrypt.getBytes("UTF8");
            } catch (UnsupportedEncodingException ex) {
                throw new CryptoException("Error encryptString | String.getBytes", ex);
            }

            byte[] outputBytes = doCrypto(Cipher.ENCRYPT_MODE, key, toEncryptBytes);
            return outputBytes;
        }

        public static String decryptString(
                SecretKey key,
                byte[] toDecryptBytes)
                throws CryptoException {
            byte[] outputBytes = doCrypto(Cipher.DECRYPT_MODE, key, toDecryptBytes);

            String ciphtx = new String(outputBytes);
            return ciphtx;
        }

        public static File encryptFile(
                SecretKey key,
                File inputFile)
                throws CryptoException {
            FileInputStream inputStream;

            try {
                inputStream = new FileInputStream(inputFile);
            } catch (FileNotFoundException ex) {
                throw new CryptoException("Error encryptFile | new FileInputStream", ex);
            }

            byte[] inputBytes = new byte[(int) inputFile.length()];

            try {
                inputStream.read(inputBytes);
            } catch (IOException ex) {
                throw new CryptoException("Error encryptFile | FileInputStream.read", ex);
            }

            byte[] outputBytes = doCrypto(Cipher.ENCRYPT_MODE, key, inputBytes);

            FileOutputStream outputStream;
            File outputFile = new File(inputFile.getName() + ".enc");

            try {
                outputStream = new FileOutputStream(outputFile);
            } catch (FileNotFoundException ex) {
                throw new CryptoException("Error encryptFile | new FileOutputStream", ex);
            }

            try {
                outputStream.write(outputBytes);
            } catch (IOException ex) {
                throw new CryptoException("Error encryptFile | FileOutputStream.write", ex);
            }

            try {
                inputStream.close();
            } catch (IOException ex) {
                throw new CryptoException("Error encryptFile | FileInputStream.close", ex);
            }

            try {
                outputStream.close();
            } catch (IOException ex) {
                throw new CryptoException("Error encryptFile | FileOutputStream.close", ex);
            }

            return outputFile;
        }

        public static File decryptFile(
                SecretKey key,
                File inputFile)
                throws CryptoException {
            FileInputStream inputStream;

            try {
                inputStream = new FileInputStream(inputFile);
            } catch (FileNotFoundException ex) {
                throw new CryptoException("Error decryptFile | new FileInputStream", ex);
            }

            byte[] inputBytes = new byte[(int) inputFile.length()];

            try {
                inputStream.read(inputBytes);
            } catch (IOException ex) {
                throw new CryptoException("Error decryptFile | FileInputStream.read", ex);
            }

            byte[] outputBytes = doCrypto(Cipher.DECRYPT_MODE, key, inputBytes);
            FileOutputStream outputStream;
            File outputFile = new File("dec" + inputFile.getName().substring(0, inputFile.getName().length() - 4));

            try {
                outputStream = new FileOutputStream(outputFile);
            } catch (FileNotFoundException ex) {
                throw new CryptoException("Error decryptFile | new FileOutputStream", ex);
            }

            try {
                outputStream.write(outputBytes);
            } catch (IOException ex) {
                throw new CryptoException("Error decryptFile | FileOutputStream.write", ex);
            }

            try {
                inputStream.close();
            } catch (IOException ex) {
                throw new CryptoException("Error decryptFile | FileInputStream.close", ex);
            }

            try {
                outputStream.close();
            } catch (IOException ex) {
                throw new CryptoException("Error decryptFile | FileOutputStream.close", ex);
            }

            return outputFile;
        }

        private static byte[] doCrypto(
                int cipherMode,
                SecretKey key,
                byte[] inputBytes)
                throws CryptoException {
            Cipher cipher;

            try {
                cipher = Cipher.getInstance("AES");
            } catch (NoSuchAlgorithmException | NoSuchPaddingException ex) {
                throw new CryptoException("Error doCrypto | cipher.getInstance", ex);
            }

            try {
                cipher.init(cipherMode, key);
            } catch (InvalidKeyException ex) {
                throw new CryptoException("Error doCrypto | cipher.init", ex);
            }

            byte[] outputBytes;

            try {
                outputBytes = cipher.doFinal(inputBytes);
            } catch (IllegalBlockSizeException | BadPaddingException ex) {
                throw new CryptoException("Error doCrypto | cipher.doFinal", ex);
            }

            return outputBytes;
        }
    }

package encryptUtils;

    import java.io.File;

    import javax.crypto.SecretKey;

    public class Main {

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

            /*
            *   AES
            */
            System.out.println( "----- AES -----" );

            //change from File to String and give path to method
            File inputFile = new File("pic.jpg");
            //File inputFile = new File("cleartext.txt");

            //Should be char array to empty when finished with
            String password = "password";
            String userName = "bob";

            try {
                System.out.println("n----- Generate Key -----");
                AES.generateKey(password, userName);
                System.out.println("----- ---------- -----n----- Load Key -----");
                SecretKey AESkey = AES.loadKey(password, userName);

                System.out.println("----- ---------- -----n----- File Encryption -----ninputFileName: " + inputFile.getName());
                File encryptedFile = AES.encryptFile(AESkey, inputFile);
                System.out.println( "encryptedFileName: " + encryptedFile.getName() + "n----- ---------- -----n----- File Decryption -----");
                File decryptedFile = AES.decryptFile(AESkey, encryptedFile);

                System.out.println( "decryptedFileName: " + decryptedFile.getName() + "n----- ---------- -----n----- String Encryption -----");
                byte[]outputBytes = AES.encryptString(AESkey, "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.");
                System.out.println(new String(outputBytes) + "n----- ---------- -----n----- String Decryption -----");
                String decryptedString = AES.decryptString(AESkey, outputBytes);
                System.out.println(decryptedString + "n----- ---------- -----n");
            } catch (CryptoException ex) {
                System.out.println(ex.getMessage());
                ex.printStackTrace();
            }

            System.out.println("nEnd");
        }
    }