AES kann nicht entschlüsselt werden

[bennsoncat]

Hallo, ich habe mir eine Klasse zusammengebastelt, mit der ich einen Text mit einem 64 Zeichen langen Passwort ver- und entschlüsseln möchte.

import java.security.Key;
import java.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

public class SuperStringCrypt {

    private static String k1;
    private static String k2;
    private static String k3;
    private static String k4;

    public static void setKeys(String i1, String i2, String i3, String i4) {
        k1 = i1;
        k2 = i2;
        k3 = i3;
        k4 = i4;
    }

    public static String encrypt(String t) {
        try {
            Cipher c = Cipher.getInstance("AES");
   
            Key key = new SecretKeySpec(k1.getBytes("UTF-8"), "AES");
            c.init(Cipher.ENCRYPT_MODE, key);
            byte[] encVal = c.doFinal(t.getBytes("UTF-8"));
   
            key = new SecretKeySpec(k2.getBytes("UTF-8"), "AES");
            c.init(Cipher.ENCRYPT_MODE, key);
            encVal = c.doFinal(encVal);
   
            key = new SecretKeySpec(k3.getBytes("UTF-8"), "AES");
            c.init(Cipher.ENCRYPT_MODE, key);
            encVal = c.doFinal(encVal);
   
            key = new SecretKeySpec(k4.getBytes("UTF-8"), "AES");
            c.init(Cipher.ENCRYPT_MODE, key);
            encVal = c.doFinal(encVal);
   
            String base64 = Base64.getEncoder().encodeToString(encVal);
            return base64;
        } catch(Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String decrypt(String t) {
        try {
            Cipher c = Cipher.getInstance("AES");
            byte[] decVal = Base64.getDecoder().decode(t);

            Key key = new SecretKeySpec(k1.getBytes("UTF-8"), "AES");
            c.init(Cipher.DECRYPT_MODE, key);
            decVal = c.doFinal(decVal);
   
            key = new SecretKeySpec(k2.getBytes("UTF-8"), "AES");
            c.init(Cipher.DECRYPT_MODE, key);
            decVal = c.doFinal(decVal);
   
            key = new SecretKeySpec(k3.getBytes("UTF-8"), "AES");
            c.init(Cipher.DECRYPT_MODE, key);
            decVal = c.doFinal(decVal);
   
            key = new SecretKeySpec(k4.getBytes("UTF-8"), "AES");
            c.init(Cipher.DECRYPT_MODE, key);
            decVal = c.doFinal(decVal);

            return new String(decVal, "UTF-8");
        } catch(Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

Hier mal eine Beispiel Klasse zur Anwendung:

public class Main {

    public static void main(String[] args) {
        SuperStringCrypt.setKeys("=cRHo28Cf6XnGevD", "qzsLUFIgEtNuV937", "J0WKMwlhakimO1A4", "bTQjpdPSYB5rxZy?");

        String encrypted = SuperStringCrypt.encrypt("Hallo Welt");

        System.out.println(encrypted);

        String decrypted = SuperStringCrypt.decrypt(encrypted);

        System.out.println(decrypted);

    }

}

Ich bekomme aber immer bei der Benutzung dieser Klasse das ausgegeben:

rvNr5/x7i1GlVH2Mf90Vw0T31MqN5kqd0cmi6PlrwyxSaxL43AmL8EQF9Ziw+qjjpfVMVRd8BpsFqmXVCTWoCQ==
javax.crypto.BadPaddingException: Given final block not properly padded
    at com.sun.crypto.provider.CipherCore.doFinal(CipherCore.java:966)
    at com.sun.crypto.provider.CipherCore.doFinal(CipherCore.java:824)
    at com.sun.crypto.provider.AESCipher.engineDoFinal(AESCipher.java:436)
    at javax.crypto.Cipher.doFinal(Cipher.java:2165)
    at SuperStringCrypt.decrypt(SuperStringCrypt.java:57)
    at Main.main(Main.java:11)
null

Die Verschlüsselung funktioniert, aber die Entschlüsselung nicht. Wo ist der Fehler? Könnt ihr mir helfen?

 

[bennsoncat]

SORRY!
Fehler selbst gefunden

Beim Entschlüsseln muss natürlich mit k4 angefangen werden.

 

[Tobse]

Hinweis: Diese Strings sind als Schlüssel völlig nutzlos und leicht zu knacken. Benutze den AES PBE Cipher oder PBKDF2

 

[bennsoncat]

Hinweis: Diese Strings sind als Schlüssel völlig nutzlos und leicht zu knacken. Benutze den AES PBE Cipher oder PBKDF2

Besser?:

import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.Key;
import java.security.MessageDigest;
import java.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

public class SuperStringCrypt {

    private static byte[] k1;
    private static byte[] k2;
    private static byte[] k3;
    private static byte[] k4;

    public static void setKeys(String i1, String i2, String i3, String i4) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
      
            md.update(i1.getBytes("UTF-8"));
            k1 = md.digest();
      
            md.update(i2.getBytes("UTF-8"));
            k2 = md.digest();
      
            md.update(i3.getBytes("UTF-8"));
            k3 = md.digest();
      
            md.update(i4.getBytes("UTF-8"));
            k4 = md.digest();
        } catch (Exception e) {
            k1 = null;
            k2 = null;
            k3 = null;
            k4 = null;
            e.printStackTrace();
        }
  
    }

    public static String encrypt(String t) {
        try {
            Cipher c = Cipher.getInstance("AES");
      
            Key key = new SecretKeySpec(k1, "AES");
            c.init(Cipher.ENCRYPT_MODE, key);
            byte[] encVal = c.doFinal(t.getBytes("UTF-8"));
      
            key = new SecretKeySpec(k2, "AES");
            c.init(Cipher.ENCRYPT_MODE, key);
            encVal = c.doFinal(encVal);
      
            key = new SecretKeySpec(k3, "AES");
            c.init(Cipher.ENCRYPT_MODE, key);
            encVal = c.doFinal(encVal);
      
            key = new SecretKeySpec(k4, "AES");
            c.init(Cipher.ENCRYPT_MODE, key);
            encVal = c.doFinal(encVal);
      
            String base64 = Base64.getEncoder().encodeToString(encVal);
            return URLEncoder.encode(base64, "UTF-8");
        } catch(Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String decrypt(String t) {
        try {
            t = URLDecoder.decode(t, "UTF-8");
            Cipher c = Cipher.getInstance("AES");
            byte[] decodedValue = Base64.getDecoder().decode(t);

            Key key = new SecretKeySpec(k4, "AES");
            c.init(Cipher.DECRYPT_MODE, key);
            decodedValue = c.doFinal(decodedValue);
      
            key = new SecretKeySpec(k3, "AES");
            c.init(Cipher.DECRYPT_MODE, key);
            decodedValue = c.doFinal(decodedValue);
      
            key = new SecretKeySpec(k2, "AES");
            c.init(Cipher.DECRYPT_MODE, key);
            decodedValue = c.doFinal(decodedValue);
      
            key = new SecretKeySpec(k1, "AES");
            c.init(Cipher.DECRYPT_MODE, key);
            decodedValue = c.doFinal(decodedValue);
      
            return new String(decodedValue, "UTF-8");
        } catch(Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

Wenn nicht, poste mal deine Version der Klasse. Ja, ich weiß, das ist jetzt nicht optimal, aber ich möchte ohne Salz verschlüsseln. Aber, ist das sicherer als vorher und reichte das?

EDIT: Hier noch eine Version:

import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.Key;
import java.security.MessageDigest;
import java.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

public class SuperStringCrypt {

    private static byte[] keyBytes;

    public static void setKey(String k) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(k.getBytes("UTF-8"));
            keyBytes = md.digest();
        } catch (Exception e) {
            keyBytes = null;
            e.printStackTrace();
        }
    
    }

    public static String encrypt(String t) {
        try {
            Cipher c = Cipher.getInstance("AES");
        
            Key key = new SecretKeySpec(keyBytes, "AES");
            c.init(Cipher.ENCRYPT_MODE, key);
            byte[] encVal = c.doFinal(t.getBytes("UTF-8"));
        
            String base64 = Base64.getEncoder().encodeToString(encVal);
            return URLEncoder.encode(base64, "UTF-8");
        } catch(Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String decrypt(String t) {
        try {
            t = URLDecoder.decode(t, "UTF-8");
            Cipher c = Cipher.getInstance("AES");
            byte[] decodedValue = Base64.getDecoder().decode(t);

            Key key = new SecretKeySpec(keyBytes, "AES");
            c.init(Cipher.DECRYPT_MODE, key);
            decodedValue = c.doFinal(decodedValue);
        
            return new String(decodedValue, "UTF-8");
        } catch(Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

Ist das bei einem 62 oder 64 stelligen Password sicher genug? Hab gelesen das mit MD5 mehrere Passwörter den selben Hash haben können.

EDIT:
Ich habe mir natürlich auch sowas angeguckt, bin aber nicht zufrieden damit, da nicht der ganze Hash genommen wird (unsicher?):

byte[] key = (SALT2 + username + password).getBytes("UTF-8");
MessageDigest sha = MessageDigest.getInstance("SHA-1");
key = sha.digest(key);
key = Arrays.copyOf(key, 16); // use only first 128 bit

SecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES");

--------
Was ist denn jetzt die beste Möglichkeit, um einen Text mit einem 62 oder 64 stelligen Passwort zu verschlüsseln?

 

[bennsoncat]

Ich frag mal woanders... Das hier ist nicht mehr der richtige Platz

 

[Tobse]

Ich sehe, du verstehst nichts von Verschlüsselung. Ist nicht böse gemeint, aber Verschlüsselung ist eine äußerst sensible Angelegenheit. Wenn man nicht 100% weiss, was man tut, ist das Ergebnis ganz schnell unsicher.

Bzgl. MD5 und den Passwörtern: Passwörter sind selten als Kryptographische Schlüssel zu verwenden (aufgrund der Länge und der geringen Variation der einzelnen Bytes). Um aus einem Passwort einen Kryptographisch nutzbaren Schlüssel zu machen benutzt man eine sogenannte Key-Derivation-Function: Sie nimmt ein Passwort und ein Salt und wandelt es deterministisch (also immer mit dem selben Ergebnis) in einen Kryptographischen Schlüssel um. MD5 kann man zwar als KDF betrachten; praktisch erhöht es aber die Sicherheit nicht, weil es viel zu wenig Rechenleistung benötigt.
Es gibt vordefinierte Verfahren für KDFs, darunte rauch PBKDF2 (Password Based Key Derivation Function Version 2); PBKDF2 baut immer auf einem Hash-Algorithmus (so auch MD5) auf; PBKDF2-SHA256 ist aber deutlich sicherer als PBKDF2-MD5 (weil SHA256 sicherer ist als MD5, diverse Quellen darüber siehe Google).
Ergo: schiebe dein Passwort durch PBKDF2 (dann muss es auch nichtmehr genau 64 Zeichen lang sein) und verschlüssele damit. Für eine sichere Verschlüsselung braucht es aber noch einen guten IV, guten Cipher Mode of Operation und ein brauchbares Padding. Cipher.getInstance("AES") (was identisch ist mit Cipher.getInstance("AES/ECB/NoPadding")) taugt dafür nicht. Recherchiere einfach mal noch ein bisschen, da gibts viele Infos im Netz.