Java 256-bit AES Passwort-basierte Verschlüsselung

Question

Ich muss eine 256-Bit-AES-Verschlüsselung implementieren, aber alle Beispiele, die ich online gefunden habe, verwenden einen "KeyGenerator", um einen 256-Bit-Schlüssel zu erzeugen, aber ich möchte meinen eigenen Schlüssel verwenden. Wie kann ich meinen eigenen Schlüssel erstellen? Ich habe versucht, ihn auf 256 Bit aufzufüllen, aber dann bekomme ich eine Fehlermeldung, dass der Schlüssel zu lang ist. Ich habe den Patch für unbegrenzte Zuständigkeit installiert, das ist also nicht das Problem :)

D.h.. Der KeyGenerator sieht wie folgt aus ...

// Get the KeyGenerator
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128); // 192 and 256 bits may not be available

// Generate the secret key specs.
SecretKey skey = kgen.generateKey();
byte[] raw = skey.getEncoded();

Der Code stammt von hier

EDITAR

Ich habe das Kennwort auf 256 Bytes aufgefüllt, nicht auf Bits, was zu lang ist. Im Folgenden finden Sie einige Codes, die ich jetzt verwende, da ich etwas mehr Erfahrung damit habe.

byte[] key = null; // TODO
byte[] input = null; // TODO
byte[] output = null;
SecretKeySpec keySpec = null;
keySpec = new SecretKeySpec(key, "AES");
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");
cipher.init(Cipher.ENCRYPT_MODE, keySpec);
output = cipher.doFinal(input)

Die "TODO"-Teile müssen Sie selbst erledigen :-)

Answer 1

Teilen Sie die password (a char[] ) und salt (a byte[] -8 Bytes, ausgewählt durch eine SecureRandom ist ein gutes Salz, das nicht geheim gehalten werden muss) mit dem Empfänger out-of-band. Aus diesen Informationen kann dann ein guter Schlüssel abgeleitet werden:

/* Derive the key, given password and salt. */
SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
KeySpec spec = new PBEKeySpec(password, salt, 65536, 256);
SecretKey tmp = factory.generateSecret(spec);
SecretKey secret = new SecretKeySpec(tmp.getEncoded(), "AES");

Die magischen Zahlen (die irgendwo als Konstanten definiert werden könnten) 65536 und 256 sind die Iterationszahl der Schlüsselableitung bzw. die Schlüsselgröße.

Die Funktion zur Ableitung des Schlüssels wird iteriert, so dass ein erheblicher Rechenaufwand erforderlich ist, der Angreifer daran hindert, schnell viele verschiedene Passwörter auszuprobieren. Die Anzahl der Iterationen kann je nach den verfügbaren Rechenressourcen geändert werden.

Die Schlüsselgröße kann auf 128 Bit reduziert werden, was immer noch als "starke" Verschlüsselung gilt, aber keine große Sicherheitsmarge bietet, wenn Angriffe entdeckt werden, die AES schwächen.

In Verbindung mit einem geeigneten Blockchain-Modus kann derselbe abgeleitete Schlüssel zur Verschlüsselung vieler Nachrichten verwendet werden. Unter Cipher Block Chaining (CBC) Bei CBC wird für jede Nachricht ein zufälliger Initialisierungsvektor (IV) generiert, der selbst bei identischem Klartext zu unterschiedlichem Chiffriertext führt. CBC ist vielleicht nicht der sicherste Modus, der Ihnen zur Verfügung steht (siehe AEAD weiter unten); es gibt viele andere Modi mit unterschiedlichen Sicherheitseigenschaften, aber sie verwenden alle eine ähnliche Zufallsinitialisierung. In jedem Fall sind die Ausgaben jeder Verschlüsselungsoperation der verschlüsselte Text y den Initialisierungsvektor:

/* Encrypt the message. */
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secret);
AlgorithmParameters params = cipher.getParameters();
byte[] iv = params.getParameterSpec(IvParameterSpec.class).getIV();
byte[] ciphertext = cipher.doFinal("Hello, World!".getBytes(StandardCharsets.UTF_8));

Speichern Sie die ciphertext und die iv . Bei der Entschlüsselung wird die SecretKey wird auf genau dieselbe Weise neu generiert, wobei das Kennwort mit demselben Salt und denselben Iterationsparametern verwendet wird. Initialisieren Sie die Chiffre mit diesem Schlüssel y den mit der Nachricht gespeicherten Initialisierungsvektor:

/* Decrypt the message, given derived key and initialization vector. */
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE, secret, new IvParameterSpec(iv));
String plaintext = new String(cipher.doFinal(ciphertext), StandardCharsets.UTF_8);
System.out.println(plaintext);

---

Java 7 enthaltene API Unterstützung für AEAD-Verschlüsselungsmodi und der in OpenJDK und Oracle-Distributionen enthaltene "SunJCE"-Anbieter implementiert diese ab Java 8. Einer dieser Modi wird anstelle von CBC dringend empfohlen; er schützt sowohl die Integrität der Daten als auch ihre Privatsphäre.

---

A java.security.InvalidKeyException mit der Meldung "Illegale Schlüsselgröße oder Standardparameter" bedeutet, dass die Kryptostärke es begrenzt; die Dateien mit den Richtlinien für die unbegrenzte Zuständigkeit befinden sich nicht an der richtigen Stelle. In einem JDK sollten sie sich unter ${jdk}/jre/lib/security

Ausgehend von der Problembeschreibung klingt es so, als wären die Richtliniendateien nicht korrekt installiert. Systeme können leicht mehrere Java-Laufzeiten haben; überprüfen Sie, ob der richtige Speicherort verwendet wird.

Answer 2

Erwägen Sie die Verwendung des Spring Security Krypto-Modul

Das Spring Security Crypto Modul bietet Unterstützung für symmetrische Verschlüsselung, Schlüsselgenerierung und Passwortverschlüsselung. Der Code wird als Teil des Kernmoduls verteilt, hat aber keine Abhängigkeiten von anderem Spring Security (oder Spring) Code.

Es bietet eine einfache Abstraktion für die Verschlüsselung und scheint dem zu entsprechen, was hier benötigt wird,

Die "Standard"-Verschlüsselungsmethode ist 256-Bit-AES unter Verwendung von PKCS #5's PBKDF2 (Password-Based Key Derivation Function #2). Für diese Methode ist Java 6 erforderlich. Das zur Erzeugung des SecretKey verwendete Passwort sollte an einem sicheren Ort aufbewahrt und nicht weitergegeben werden. Das Salz wird verwendet, um Wörterbuchangriffe auf den Schlüssel zu verhindern, falls Ihre verschlüsselten Daten gefährdet sind. Außerdem wird ein 16-Byte-Zufallsvektor zur Initialisierung verwendet, damit jede verschlüsselte Nachricht eindeutig ist.

Ein Blick auf die Interna zeigt eine ähnliche Struktur wie erickson's Antwort .

Wie in der Frage erwähnt, erfordert dies auch die Java Cryptography Extension (JCE) Unbegrenzte Stärke Rechtsprechungsrichtlinie (sonst werden Sie auf InvalidKeyException: Illegal Key Size ). Es ist herunterladbar für Java 6 , Java 7 y Java 8 .

Beispiel für die Verwendung

import org.springframework.security.crypto.encrypt.Encryptors;
import org.springframework.security.crypto.encrypt.TextEncryptor;
import org.springframework.security.crypto.keygen.KeyGenerators;

public class CryptoExample {
    public static void main(String[] args) {
        final String password = "I AM SHERLOCKED";  
        final String salt = KeyGenerators.string().generateKey();

        TextEncryptor encryptor = Encryptors.text(password, salt);      
        System.out.println("Salt: \"" + salt + "\"");

        String textToEncrypt = "*royal secrets*";
        System.out.println("Original text: \"" + textToEncrypt + "\"");

        String encryptedText = encryptor.encrypt(textToEncrypt);
        System.out.println("Encrypted text: \"" + encryptedText + "\"");

        // Could reuse encryptor but wanted to show reconstructing TextEncryptor
        TextEncryptor decryptor = Encryptors.text(password, salt);
        String decryptedText = decryptor.decrypt(encryptedText);
        System.out.println("Decrypted text: \"" + decryptedText + "\"");

        if(textToEncrypt.equals(decryptedText)) {
            System.out.println("Success: decrypted text matches");
        } else {
            System.out.println("Failed: decrypted text does not match");
        }       
    }
}

Und Beispielausgabe,

Salt: "feacbc02a3a697b0"
Original text: "\*royal secrets\*"
Encrypted text: "7c73c5a83fa580b5d6f8208768adc931ef3123291ac8bc335a1277a39d256d9a" 
Decrypted text: "\*royal secrets\*"
Success: decrypted text matches

Answer 3

Nach der Lektüre von Ericksons Vorschlägen und dem, was ich aus einigen anderen Beiträgen und diesem Beispiel entnommen habe aquí Ich habe versucht, den Code von Doug mit den empfohlenen Änderungen zu aktualisieren. Fühlen Sie sich frei zu bearbeiten, um es besser zu machen.

• Initialisierungsvektor ist nicht mehr festgelegt
• Der Verschlüsselungsschlüssel wird mit Hilfe des Codes von erickson abgeleitet
• 8-Byte-Salz wird in setupEncrypt() mit SecureRandom() erzeugt
• der Entschlüsselungsschlüssel wird aus dem Verschlüsselungssalz und dem Passwort generiert
• Die Entschlüsselungs-Chiffre wird aus dem Entschlüsselungsschlüssel und dem Initialisierungsvektor erzeugt.
• Entfernen der Hexenverdreher anstelle von org.apache.commons Codec Hex-Routinen

Einige Anmerkungen: Hier wird ein 128-Bit-Verschlüsselungsschlüssel verwendet - Java kann offenbar nicht sofort 256-Bit-Verschlüsselung. Die Implementierung von 256 erfordert die Installation einiger zusätzlicher Dateien in das Java-Installationsverzeichnis.

Außerdem bin ich kein Freund von Kryptowährungen. Passen Sie auf.

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.AlgorithmParameters;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.InvalidParameterSpecException;
import java.security.spec.KeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.CipherOutputStream;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;

public class Crypto
{
    String mPassword = null;
    public final static int SALT_LEN = 8;
    byte [] mInitVec = null;
    byte [] mSalt = null;
    Cipher mEcipher = null;
    Cipher mDecipher = null;
    private final int KEYLEN_BITS = 128; // see notes below where this is used.
    private final int ITERATIONS = 65536;
    private final int MAX_FILE_BUF = 1024;

    /**
     * create an object with just the passphrase from the user. Don't do anything else yet 
     * @param password
     */
    public Crypto (String password)
    {
        mPassword = password;
    }

    /**
     * return the generated salt for this object
     * @return
     */
    public byte [] getSalt ()
    {
        return (mSalt);
    }

    /**
     * return the initialization vector created from setupEncryption
     * @return
     */
    public byte [] getInitVec ()
    {
        return (mInitVec);
    }

    /**
     * debug/print messages
     * @param msg
     */
    private void Db (String msg)
    {
        System.out.println ("** Crypt ** " + msg);
    }

    /**
     * this must be called after creating the initial Crypto object. It creates a salt of SALT_LEN bytes
     * and generates the salt bytes using secureRandom().  The encryption secret key is created 
     * along with the initialization vectory. The member variable mEcipher is created to be used
     * by the class later on when either creating a CipherOutputStream, or encrypting a buffer
     * to be written to disk.
     *  
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     * @throws NoSuchPaddingException
     * @throws InvalidParameterSpecException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     * @throws UnsupportedEncodingException
     * @throws InvalidKeyException
     */
    public void setupEncrypt () throws NoSuchAlgorithmException, 
                                                           InvalidKeySpecException, 
                                                           NoSuchPaddingException, 
                                                           InvalidParameterSpecException, 
                                                           IllegalBlockSizeException, 
                                                           BadPaddingException, 
                                                           UnsupportedEncodingException, 
                                                           InvalidKeyException
    {
        SecretKeyFactory factory = null;
        SecretKey tmp = null;

        // crate secureRandom salt and store  as member var for later use
         mSalt = new byte [SALT_LEN];
        SecureRandom rnd = new SecureRandom ();
        rnd.nextBytes (mSalt);
        Db ("generated salt :" + Hex.encodeHexString (mSalt));

        factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");

        /* Derive the key, given password and salt. 
         * 
         * in order to do 256 bit crypto, you have to muck with the files for Java's "unlimted security"
         * The end user must also install them (not compiled in) so beware. 
         * see here:  http://www.javamex.com/tutorials/cryptography/unrestricted_policy_files.shtml
         */
        KeySpec spec = new PBEKeySpec (mPassword.toCharArray (), mSalt, ITERATIONS, KEYLEN_BITS);
        tmp = factory.generateSecret (spec);
        SecretKey secret = new SecretKeySpec (tmp.getEncoded(), "AES");

        /* Create the Encryption cipher object and store as a member variable
         */
        mEcipher = Cipher.getInstance ("AES/CBC/PKCS5Padding");
        mEcipher.init (Cipher.ENCRYPT_MODE, secret);
        AlgorithmParameters params = mEcipher.getParameters ();

        // get the initialization vectory and store as member var 
        mInitVec = params.getParameterSpec (IvParameterSpec.class).getIV();

        Db ("mInitVec is :" + Hex.encodeHexString (mInitVec));
    }

    /**
     * If a file is being decrypted, we need to know the pasword, the salt and the initialization vector (iv). 
     * We have the password from initializing the class. pass the iv and salt here which is
     * obtained when encrypting the file initially.
     *   
     * @param initvec
     * @param salt
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     * @throws NoSuchPaddingException
     * @throws InvalidKeyException
     * @throws InvalidAlgorithmParameterException
     * @throws DecoderException
     */
    public void setupDecrypt (String initvec, String salt) throws NoSuchAlgorithmException, 
                                                                                       InvalidKeySpecException, 
                                                                                       NoSuchPaddingException, 
                                                                                       InvalidKeyException, 
                                                                                       InvalidAlgorithmParameterException, 
                                                                                       DecoderException
    {
        SecretKeyFactory factory = null;
        SecretKey tmp = null;
        SecretKey secret = null;

        // since we pass it as a string of input, convert to a actual byte buffer here
        mSalt = Hex.decodeHex (salt.toCharArray ());
       Db ("got salt " + Hex.encodeHexString (mSalt));

        // get initialization vector from passed string
        mInitVec = Hex.decodeHex (initvec.toCharArray ());
        Db ("got initvector :" + Hex.encodeHexString (mInitVec));

        /* Derive the key, given password and salt. */
        // in order to do 256 bit crypto, you have to muck with the files for Java's "unlimted security"
        // The end user must also install them (not compiled in) so beware. 
        // see here: 
      // http://www.javamex.com/tutorials/cryptography/unrestricted_policy_files.shtml
        factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
        KeySpec spec = new PBEKeySpec(mPassword.toCharArray (), mSalt, ITERATIONS, KEYLEN_BITS);

        tmp = factory.generateSecret(spec);
        secret = new SecretKeySpec(tmp.getEncoded(), "AES");

        /* Decrypt the message, given derived key and initialization vector. */
        mDecipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        mDecipher.init(Cipher.DECRYPT_MODE, secret, new IvParameterSpec(mInitVec));
    }

    /**
     * This is where we write out the actual encrypted data to disk using the Cipher created in setupEncrypt().
     * Pass two file objects representing the actual input (cleartext) and output file to be encrypted.
     * 
     * there may be a way to write a cleartext header to the encrypted file containing the salt, but I ran
     * into uncertain problems with that. 
     *  
     * @param input - the cleartext file to be encrypted
     * @param output - the encrypted data file
     * @throws IOException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    public void WriteEncryptedFile (File input, File output) throws 
                                                                                          IOException, 
                                                                                          IllegalBlockSizeException, 
                                                                                          BadPaddingException
    {
        FileInputStream fin;
        FileOutputStream fout;
        long totalread = 0;
        int nread = 0;
        byte [] inbuf = new byte [MAX_FILE_BUF];

        fout = new FileOutputStream (output);
        fin = new FileInputStream (input);

        while ((nread = fin.read (inbuf)) > 0 )
        {
            Db ("read " + nread + " bytes");
            totalread += nread;

            // create a buffer to write with the exact number of bytes read. Otherwise a short read fills inbuf with 0x0
            // and results in full blocks of MAX_FILE_BUF being written. 
            byte [] trimbuf = new byte [nread];
            for (int i = 0; i < nread; i++)
                trimbuf[i] = inbuf[i];

            // encrypt the buffer using the cipher obtained previosly
            byte [] tmp = mEcipher.update (trimbuf);

            // I don't think this should happen, but just in case..
            if (tmp != null)
                fout.write (tmp);
        }

        // finalize the encryption since we've done it in blocks of MAX_FILE_BUF
        byte [] finalbuf = mEcipher.doFinal ();
        if (finalbuf != null)
            fout.write (finalbuf);

        fout.flush();
        fin.close();
        fout.close();

        Db ("wrote " + totalread + " encrypted bytes");
    }

    /**
     * Read from the encrypted file (input) and turn the cipher back into cleartext. Write the cleartext buffer back out
     * to disk as (output) File.
     * 
     * I left CipherInputStream in here as a test to see if I could mix it with the update() and final() methods of encrypting
     *  and still have a correctly decrypted file in the end. Seems to work so left it in.
     *  
     * @param input - File object representing encrypted data on disk 
     * @param output - File object of cleartext data to write out after decrypting
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     * @throws IOException
     */
    public void ReadEncryptedFile (File input, File output) throws 
                                                                                                                                            IllegalBlockSizeException, 
                                                                                                                                            BadPaddingException, 
                                                                                                                                            IOException
    {
        FileInputStream fin; 
        FileOutputStream fout;
        CipherInputStream cin;
        long totalread = 0;
        int nread = 0;
        byte [] inbuf = new byte [MAX_FILE_BUF];

        fout = new FileOutputStream (output);
        fin = new FileInputStream (input);

        // creating a decoding stream from the FileInputStream above using the cipher created from setupDecrypt()
        cin = new CipherInputStream (fin, mDecipher);

        while ((nread = cin.read (inbuf)) > 0 )
        {
            Db ("read " + nread + " bytes");
            totalread += nread;

            // create a buffer to write with the exact number of bytes read. Otherwise a short read fills inbuf with 0x0
            byte [] trimbuf = new byte [nread];
            for (int i = 0; i < nread; i++)
                trimbuf[i] = inbuf[i];

            // write out the size-adjusted buffer
            fout.write (trimbuf);
        }

        fout.flush();
        cin.close();
        fin.close ();       
        fout.close();   

        Db ("wrote " + totalread + " encrypted bytes");
    }

    /**
     * adding main() for usage demonstration. With member vars, some of the locals would not be needed
     */
    public static void main(String [] args)
    {

        // create the input.txt file in the current directory before continuing
        File input = new File ("input.txt");
        File eoutput = new File ("encrypted.aes");
        File doutput = new File ("decrypted.txt");
        String iv = null;
        String salt = null;
        Crypto en = new Crypto ("mypassword");

        /*
         * setup encryption cipher using password. print out iv and salt
         */
        try
      {
          en.setupEncrypt ();
          iv = Hex.encodeHexString (en.getInitVec ()).toUpperCase ();
          salt = Hex.encodeHexString (en.getSalt ()).toUpperCase ();
      }
      catch (InvalidKeyException e)
      {
          e.printStackTrace();
      }
      catch (NoSuchAlgorithmException e)
      {
          e.printStackTrace();
      }
      catch (InvalidKeySpecException e)
      {
          e.printStackTrace();
      }
      catch (NoSuchPaddingException e)
      {
          e.printStackTrace();
      }
      catch (InvalidParameterSpecException e)
      {
          e.printStackTrace();
      }
      catch (IllegalBlockSizeException e)
      {
          e.printStackTrace();
      }
      catch (BadPaddingException e)
      {
          e.printStackTrace();
      }
      catch (UnsupportedEncodingException e)
      {
          e.printStackTrace();
      }

        /*
         * write out encrypted file
         */
        try
      {
          en.WriteEncryptedFile (input, eoutput);
          System.out.printf ("File encrypted to " + eoutput.getName () + "\niv:" + iv + "\nsalt:" + salt + "\n\n");
      }
      catch (IllegalBlockSizeException e)
      {
          e.printStackTrace();
      }
      catch (BadPaddingException e)
      {
          e.printStackTrace();
      }
      catch (IOException e)
      {
          e.printStackTrace();
      }

        /*
         * decrypt file
         */
        Crypto dc = new Crypto ("mypassword");
        try
      {
          dc.setupDecrypt (iv, salt);
      }
      catch (InvalidKeyException e)
      {
          e.printStackTrace();
      }
      catch (NoSuchAlgorithmException e)
      {
          e.printStackTrace();
      }
      catch (InvalidKeySpecException e)
      {
          e.printStackTrace();
      }
      catch (NoSuchPaddingException e)
      {
          e.printStackTrace();
      }
      catch (InvalidAlgorithmParameterException e)
      {
          e.printStackTrace();
      }
      catch (DecoderException e)
      {
          e.printStackTrace();
      }

        /*
         * write out decrypted file
         */
        try
      {
          dc.ReadEncryptedFile (eoutput, doutput);
          System.out.println ("decryption finished to " + doutput.getName ());
      }
      catch (IllegalBlockSizeException e)
      {
          e.printStackTrace();
      }
      catch (BadPaddingException e)
      {
          e.printStackTrace();
      }
      catch (IOException e)
      {
          e.printStackTrace();
      }
   }

}

Answer 4

Es ist einfach, einen eigenen Schlüssel aus einem Byte-Array zu erzeugen:

byte[] raw = ...; // 32 bytes in size for a 256 bit key
Key skey = new javax.crypto.spec.SecretKeySpec(raw, "AES");

Die Erstellung eines 256-Bit-Schlüssels ist jedoch nicht ausreichend. Wenn der Schlüsselgenerator keine 256-Bit-Schlüssel für Sie erzeugen kann, dann muss der Cipher Klasse unterstützt wahrscheinlich auch nicht AES 256-bit. Sie sagen, dass Sie den Patch für unbegrenzte Zuständigkeit installiert haben, also sollte die AES-256-Verschlüsselung unterstützt werden (aber dann sollten auch 256-Bit-Schlüssel unterstützt werden, also könnte dies ein Konfigurationsproblem sein).

Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, skey);
byte[] encrypted = cipher.doFinal(plainText.getBytes());

Eine Abhilfe für die fehlende AES-256-Unterstützung besteht darin, eine frei verfügbare AES-256-Implementierung als eigenen Anbieter zu verwenden. Dies beinhaltet die Erstellung eines eigenen Provider Unterklasse und ihre Verwendung mit Cipher.getInstance(String, Provider) . Dies kann jedoch ein komplizierter Prozess sein.

Answer 5

Was ich in der Vergangenheit getan habe, ist Hash der Schlüssel über etwas wie SHA256, dann extrahieren Sie die Bytes aus dem Hash in den Schlüssel byte[].

Nachdem Sie Ihre byte[] haben, können Sie einfach tun:

SecretKeySpec key = new SecretKeySpec(keyBytes, "AES");
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] encryptedBytes = cipher.doFinal(clearText.getBytes());