Java-Code

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.SecretKeySpec;

/**
 * 2016 © SiCuSoft Tutorials
 * Simple Text Crypter AES, SHA-256
 * www.sicusoft.at
 * @author Etzelsdorfer Thomas
 */
public class AESJava {

    private static Cipher cipher;
    private static final String AES = "AES";
    private static final String SHA_INSTANCE_256 = "SHA-256";

    /**
     * Konstruktor der Klasse mit der 
     * Initialisiertung des Cipher Objektes
     */
    public AESJava() {
        try {
            AESJava.cipher = Cipher.getInstance(AES);
        } catch (NoSuchAlgorithmException | NoSuchPaddingException ex) {
            ex.printStackTrace();
        }
    }

    /**
     * Methode erstellt einen Key ({@link SecretKeySpec} aus einem übergebenen
     * Passwort und gibt diesen Key zurück.
     *
     * @param password
     * @return key
     */
    public SecretKeySpec createStringKey(String password) {
        SecretKeySpec key = null;
        try {
            byte[] keyByte = (password).getBytes("UTF-8");
            MessageDigest sha = MessageDigest.getInstance(SHA_INSTANCE_256);
            keyByte = sha.digest(keyByte);
            keyByte = Arrays.copyOf(keyByte, 16);
            key = new SecretKeySpec(keyByte, AES);
        } catch (UnsupportedEncodingException | NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return key;
    }

    /**
     * Methode verschlüsselt einen Text und gibt den Text zurück
     *
     * @param text normaler Text
     * @param key schlüssel
     * @return verschlüsselter Text
     */
    public String encryptText(String text, SecretKeySpec key) {
        String encodedText = "";
        try {
            cipher = Cipher.getInstance(AES);
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] encrypt = cipher.doFinal(text.getBytes());
            Base64.Encoder encoder = Base64.getEncoder();
            encodedText = encoder.encodeToString(encrypt);
        } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException e) {
            e.printStackTrace();
        }
        return encodedText;
    }

    /**
     * Metode entschlüsselt den Text
     *
     * @param encodedText verschlüsselter Text
     * @param key schlüssel 
     * @return entschlüsselter Text
     */
    public String decryptText(String encodedText, SecretKeySpec key) {
        String decodedText = "";
        try {
            Base64.Decoder decoder = Base64.getDecoder();
            byte[] de = decoder.decode(encodedText);
            cipher = Cipher.getInstance(AES);
            cipher.init(Cipher.DECRYPT_MODE, key);
            byte[] cipherData = cipher.doFinal(de);
            decodedText = new String(cipherData);
        } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException e) {
            e.printStackTrace();
        }
        return decodedText;
    }
}