Key (für AES-Verschlüsselung) aus String

[SNB1998]

Hallo Leute,


ich versuche ein Verschlüsselungsprogramm zu schreiben.

Verschlüsseln:
1) AES-Key erstellen
2) AES-Key mit RSA verschlüsseln
3) Text mit AES verschlüsseln
4) verschlüsselten AES-Key und verschlüsselten Text zurückgeben

public String encrypt(String Text, PublicKey publicKey) throws Exception{
        String encrypted = "";
        
        //AES Key erzeugen
        KeyGenerator keygen = KeyGenerator.getInstance("AES");
        keygen.init(new SecureRandom(new byte[] { 1, 2, 3, 4, 5 }));
        SecretKey key = keygen.generateKey();
        
        //AES Key mit RSA verschlüsseln und hinzufügen
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        encrypted += new String(cipher.doFinal(key.getEncoded())) + "\n";
        
        //Nachricht mit AES verschlüsseln und hinzufügen
        cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        encrypted += new String(cipher.doFinal(Text.getBytes()));
        
        return encrypted;
    }

Entschlüsseln:
1) verschlüsselten AES-Key auslesen und entschlüsseln
2) Text mit AES entschlüsseln
3) entschlüsselten Text zurückgeben

Allerdings komme ich da nicht weiter, da ich nicht weiß, wie ich aus dem entschlüsselten Key (als String) wieder ein Objekt der Klasse Key mache.

public String decrypt(String Verschlüsselter_Text, PrivateKey privateKey) throws Exception{
        String decrypted = "";
        
        //AES Key entschlüsseln
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        String keyAlsString = new String(cipher.doFinal(decrypted.split("\n")[0].getBytes()));
        
        Key key; //??? Key erstellen?   <-------  <--------
        
        Verschlüsselter_Text = Verschlüsselter_Text.substring(Verschlüsselter_Text.split("\n")[0].length()+1);
        
        
        //Text entschlüsseln
        cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, key);
        decrypted = new String(cipher.doFinal(Verschlüsselter_Text.getBytes()));
        
        return decrypted;
    }

 

[crypto]

Schau mal in die javax.crypto.spec

Mit der SecretKeySpec - class is das kein problem...

Ich weiß zwar ned was du vor hast, aber ich denk du solltest bei längeren texten mit streams arbeiten
un viell nich alles 5 mal von byte[] to string to byte[] konvertieren....
Nur so n hinweis... wird effizenter un universeller...

 

[ChristianK]

Wenn wir schon von universell reden, nimm doch einen KeyStore, der spart dir einiges an Arbeit...

 

[Tobse]

von cipher.doFinal kommt ein byte[] zurück, das kannst du direkt an den SecretKeySpec übergeben, der String macht nur probleme:

aesCipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(rsaCipher.doFinal(...), "AES"));

 

[SNB1998]

danke topse 😀

hier meine Lösung:

package crypter;

import java.io.ObjectInputStream;
import java.security.Key;
import java.security.PrivateKey;
import java.security.PublicKey;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;



public class Crypter {
    
    private Cipher eRSAcipher, dRSAcipher;
    private Cipher eAEScipher, dAEScipher;
    
    public Crypter() throws Exception {
        ObjectInputStream pub = new ObjectInputStream(getClass().getResourceAsStream("publicKey.RSA"));
        eRSAcipher = Cipher.getInstance("RSA");
        eRSAcipher.init(Cipher.ENCRYPT_MODE, (PublicKey) pub.readObject());
        ObjectInputStream pri = new ObjectInputStream(getClass().getResourceAsStream("privateKey.RSA"));
        dRSAcipher = Cipher.getInstance("RSA");
        dRSAcipher.init(Cipher.DECRYPT_MODE, (PrivateKey) pri.readObject());
        
        eAEScipher = Cipher.getInstance("AES");
        dAEScipher = Cipher.getInstance("AES");
    }

    public String encrypt(String text) throws Exception {
        //Generate Key
        SecretKey key = KeyGenerator.getInstance("AES").generateKey();
        eAEScipher.init(Cipher.ENCRYPT_MODE, key);
        
        //Encode Key with RSA
        byte[] keyutf8 = key.getEncoded();
        byte[] keyenc = eRSAcipher.doFinal(keyutf8);
        String enKey = new BASE64Encoder().encode(keyenc);
        
        // Encode Text
        byte[] utf8 = text.getBytes("UTF8");
        byte[] enc = eAEScipher.doFinal(utf8);
        String enText = new BASE64Encoder().encode(enc);
        
        //Return encrypted Message
        return enKey + "\n-----\n" + enText;
    }

    public String decrypt(String text) throws Exception {
        //Decode Key
        byte[] keydec = new BASE64Decoder().decodeBuffer(text.split("\n-----\n")[0]);
        byte[] keyutf8 = dRSAcipher.doFinal(keydec);
        Key key = new SecretKeySpec(keyutf8, "AES");
        dAEScipher.init(Cipher.DECRYPT_MODE, key);
        text = text.substring(text.split("\n-----\n")[0].length()+7);
        
        //Decode Text
        byte[] dec = new BASE64Decoder().decodeBuffer(text);
        byte[] utf8 = dAEScipher.doFinal(dec);
        String deText = new String(utf8, "UTF8");
        
        //Return decrypted Message
        return deText;
    }
}

Alles funktioniert einwandfrei. Im die RSA-Keys befinden sich im selben Package gespeichert.