Java.Security.InvalidKeyException: Unzulässige Schlüsselgröße

1. die java.security.InvalidKeyException: Illegal key size in Java
2. Mögliche Gründe für java.security.InvalidKeyException: Illegal key size
3. Beseitigen Sie die java.security.InvalidKeyException: Illegal key size

Dieses Tutorial stellt den Java-Code vor, der die java.security.InvalidKeyException: Illegal key size enthält. Dann lernen wir die möglichen Gründe dafür kennen.

Schließlich führt es uns zur Lösung, indem es den angegebenen Fehler beseitigt.

die java.security.InvalidKeyException: Illegal key size in Java

Beispielcode (Klasse App1.java):

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

public class App1 {
  private String crypKey = "qkjll5@2md3gs5Q@FDFqf";

  public String cryptAString(String str) {
    String ret = "";
    try {
      byte[] crypKeyData = this.crypKey.getBytes();
      SecretKeySpec secretKeySpec = new SecretKeySpec(crypKeyData, "AES");
      Cipher cipher = Cipher.getInstance("AES");
      cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
      ret = new String(cipher.doFinal(str.getBytes("UTF-8")));

    } catch (NoSuchPaddingException | NoSuchAlgorithmException | InvalidKeyException
        | UnsupportedEncodingException | BadPaddingException | IllegalBlockSizeException ex) {
      ex.printStackTrace();
    }
    return ret;
  }
}

Der cryptKey lautet wie folgt:

private String crypKey = "qkjll5@2md3gs5Q@FDFqf";

Die oben angegebene Funktion akzeptiert ein Argument vom Typ string. Es sollte das verschlüsseln, wenn wir dieses Programm ausführen, aber es gibt uns den Fehler java.security.InvalidKeyException: Illegal key size.

Was bedeutet das und was sind die Gründe? Sehen wir uns das im folgenden Abschnitt an.

Mögliche Gründe für java.security.InvalidKeyException: Illegal key size

Dieser Fehler bedeutet, dass unsere Java Virtual Machine (JVM) eine Richtlinie verwendet, die aufgrund der US-Exportgesetze nur begrenzte Schlüsselgrößen für die Kryptografie zulässt.

Nun, der Punkt ist, warum bekommen wir diesen Fehler? Nachfolgend sind zwei Möglichkeiten angegeben.

1. Erstens verwenden wir einen Algorithmus, der eine n-Bit-Verschlüsselung erfordert; Wenn wir überschreiten, erhalten wir diesen Fehler.
2. Wir haben die Richtliniendatei für die Gerichtsbarkeit mit unbegrenzter Stärke noch nicht installiert.

Was sind das für Dateien? Diese Dateien sind Java Cryptography Extensions (JCE), die es den Java-Anwendungen ermöglichen, die Vorteile der leistungsstarken Version von Standardalgorithmen zu nutzen.

Laut der Java-Dokumentation benötigen die neuesten Versionen des Java Development Kit (JDK) diese Art von Dateien nicht. Sie müssen lediglich eine ältere Version von JDK verwenden.

Die nächste Frage ist, welche Datei sollen wir für welche JDK-Version installieren? Lassen Sie uns das unten lernen.

Java 9 und höher

Gemäß Sicherheitsupdates im Migrationsleitfaden von Java 9 sind die Gerichtsbarkeitsrichtliniendateien mit unbegrenzter Stärke bereits in Java 9 enthalten und werden standardmäßig verwendet.

Wenn wir eine Anwendung ausführen möchten, die die JCE-Jurisdiktionsrichtliniendateien mit unbegrenzter Stärke mit älteren Versionen von JDK erfordert, müssen wir sie nicht mit Java 9 oder höher herunterladen und installieren. Der Grund dafür ist, dass sie bereits standardmäßig enthalten sind und verwendet werden.

Wenn wir diesen Fehler beim Arbeiten mit Java 9 immer noch erhalten, werden die Richtlinienkonfigurationen auf die restriktivere Richtlinie (limited) geändert. Aber das ist kein Problem, weil die begrenzten kryptografischen Java-Richtliniendateien verfügbar sind.

Der zweite Grund kann die Verwendung des falschen Algorithmus sein, während das bereitgestellte Argument vom Typ string verschlüsselt wird. Manchmal werden die Anforderungen von keiner der standardmäßig bereitgestellten Richtliniendateien erfüllt; In diesem Fall können wir die Richtliniendateien an unsere Bedürfnisse anpassen.

Überprüfen Sie dazu die Sicherheitseigenschaft namens crypto.policy in der Datei <java-home>/conf/security/java.security, oder werfen Sie einen Blick in das Java Platform, Standard Edition Security Developer’s Guide unter Konfiguration der kryptografischen Stärke.

Java 8 und früher

1. Java 8 Update 161 und höher – Ab Java 8 u161 verwendet Java 8 standardmäßig eine Gerichtsbarkeitsrichtlinie mit unbegrenzter Stärke. Erhalten wir diesen Fehler immer noch, wird die Konfiguration auf eingeschränkt geändert.

   Im nächsten Abschnitt sehen wir die Anweisungen zum Ändern auf unbegrenzt.

2. Java 8 Update 151 und höher – Ab Java 8 u151 ist die Gerichtsbarkeitsrichtlinie für unbegrenzte Stärke in Java 8 enthalten, aber standardmäßig nicht aktiviert.

   Um es zu aktivieren, müssen wir unsere Datei java.security bearbeiten, die wir unter <java_home>/jre/lib/security (für JDK) oder unter <java_home>/lib/security (für JRE). Entkommentieren/fügen Sie die folgende Zeile ein:

   crypto.policy = unlimited
   

   Stellen Sie sicher, dass wir diese Datei mit einem Editor bearbeiten, der als Administrator ausgeführt wird. Vergessen Sie nicht, die Java Virtual Machine neu zu starten, da die Richtlinie erst nach einem Neustart wirksam wird.

   Dies ist insbesondere für langlaufende Serverprozesse erforderlich, beispielsweise Tomcat. In Anbetracht der Abwärtskompatibilität funktioniert es auch, wenn Sie die Anweisungen im nächsten Abschnitt zum Installieren von Richtliniendateien befolgen.

3. Vor Java 8 Update 151 – Für Java 8 u144 und früher müssen wir die Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files installieren, die auf der offiziellen Website von Oracle verfügbar sind.

Führen Sie die folgenden Schritte aus, um diese Dateien zu installieren:

1. Laden Sie die Gerichtsstandsrichtliniendateien für die Java Cryptography Extension mit unbegrenzter Stärke herunter.

   Wir können hier(https://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html) und hier(https://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html) gehen, um Java Cryptography Extension Unlimited Strength Jurisdiction Policy Files für Java 6 bzw. 7 herunterzuladen.

2. Dekomprimieren Sie sie und extrahieren Sie sie in die heruntergeladene Datei. Als Ergebnis wird ein Unterverzeichnis namens jce erstellt.

   Dieses Verzeichnis enthält die folgenden Dateien:

   README.txt
   local_policy.jar
   US_export_policy.jar
   

3. Installieren Sie eine Richtlinie mit unbegrenzter Stärke JAR-Dateien. Denken Sie daran, wenn wir zu einer ursprünglichen starken, aber eingeschränkten Richtlinienversion zurückkehren möchten, erstellen Sie eine Kopie der ursprünglichen Java Cryptography Extension-Richtliniendateien (US_export_policy.jar und local_policy.jar).

4. Ersetzen Sie starke Richtliniendateien durch eine Version mit unbegrenzter Stärke, die wir im vorherigen Schritt extrahiert haben. Die Standardspeicherorte für JAR-Dateien der Java Cryptography Extension-Jurisdiktionsrichtlinie lauten wie folgt:

   4.1 <java-home>/lib/security für das Unix-Betriebssystem.
   4.2 <java-home>\lib\security für das Windows-Betriebssystem.
   4.3 Für JDK befindet es sich in jre/lib/security.

Beseitigen Sie die java.security.InvalidKeyException: Illegal key size

Beispielcode (Klasse App1.java):

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

public class App1 {
  private String crypKey = "qkjll5@2md3gs5Q@FDFqf";

  public String cryptAString(String str) {
    String ret = "";
    try {
      byte[] crypKeyData = this.crypKey.getBytes();
      SecretKeySpec secretKeySpec = new SecretKeySpec(crypKeyData, "ARCFOUR");
      Cipher cipher = Cipher.getInstance("ARCFOUR");
      cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
      ret = new String(cipher.doFinal(str.getBytes("UTF-8")));

    } catch (NoSuchPaddingException | NoSuchAlgorithmException | InvalidKeyException
        | UnsupportedEncodingException | BadPaddingException | IllegalBlockSizeException ex) {
      ex.printStackTrace();
    }
    return ret;
  }
}

Beispielcode (Klasse Test.java):

public class Test {
  public static void main(String[] args) {
    App1 app = new App1();
    String str = "ThisIsFoundation";
    String cryptedStr = app.cryptAString(str);
    System.out.println(cryptedStr);
    System.out.println(cryptedStr.chars().count());
  }
}

Es wird die verschlüsselte Zeichenfolge als ??c[D]???J??n? und die Anzahl davon beträgt 15 Zeichen. Wie haben wir das gelöst?

Wir können InvalidKeyException auf zwei Arten loswerden.

1. Wir können es auch lösen, indem wir Richtliniendateien für Java Cryptography Extension (JCE) installieren (alle Details finden Sie im vorherigen Abschnitt).
2. Wir können auch den Algorithmusnamen ändern.

In unserem Fall liegt das Problem an der Größe von crypKey, die mehr als 16 Zeichen beträgt. Die Klasse Cipher lässt uns also nicht mit einer Schlüssellänge von mehr als 128 Bit verschlüsseln (wobei 128 Bit == 16 Bytes == 16 Chars).

Der Wert von crypKey darf also die Grenze von 16 Chars nicht überschreiten.

Um mehr als 16 Zeichen zu überschreiten, installieren wir entweder JCE-Richtliniendateien oder aktualisieren den Algorithmusnamen. Wir werden den Algorithmusnamen ändern, weil wir die eingebaute Beschränkung der Schlüsselgröße beibehalten wollen.

Also aktualisieren wir den Algorithmusnamen von AES auf ARCFOUR. Denn der ARCFOUR-Algorithmus kann mit verschiedenen Schlüsselgrössen verwendet werden.