Verschlüsseln und entschlüsseln Sie ZIP-/RAR-/7Z-Dateien

Übersicht

ZIP-Dateien verschlüsseln/entschlüsseln

Für ZIP-Archive stehen zwei Verschlüsselungsmethoden zur Verfügung: die traditionelle Methode, die heute als schwach gilt, und die moderne AES-Methode. Der ZIP-Standard ermöglicht die Verschlüsselung jedes Eintrags mit beiden Methoden, sogar innerhalb desselben ZIP-Archivs. Die AES-Verschlüsselung bietet höhere Sicherheit und ist in verschiedenen Schlüssellängen (128 Bit, 192 Bit und 256 Bit) verfügbar. Dies bietet einen besseren Schutz für sensible Daten, die in ZIP-Archiven gespeichert sind.

Verschlüsseln Sie eine ZIP-Datei mit der Deflate-Methode

    try (FileOutputStream zipFile = new FileOutputStream("archive.zip")) {
        try (FileInputStream source = new FileInputStream("alice29.txt")) {
            Archive archive = new Archive(new ArchiveEntrySettings(CompressionSettings.getDeflate(), new TraditionalEncryptionSettings("p@s$S")));
            archive.createEntry("alice29.txt", source);
            archive.save(zipFile);
        }
    } catch (IOException ex) {
        System.err.println(ex.getMessage());
    }

Dieser Code erstellt ein ZIP-Archiv mit dem Namen "archive.zip" unter Verwendung der Deflate-Komprimierungsmethode und der herkömmlichen ZIP-Verschlüsselung. Dies wird erreicht, indem zunächst mit try FileOutputStream ein neuer Ausgabestream für das Archiv geöffnet wird. Die FileInputStream-Quelle dient als Eingabestream für die Quelldatei "alice29.txt", die dem Archiv hinzugefügt wird. Als Nächstes wird ein Archivobjekt erstellt, das sowohl die Deflate-Komprimierungsmethode als auch die herkömmliche Verschlüsselung angibt. Das Passwort für die Verschlüsselung ist auf "p@s$S" eingestellt. Die Catch-Anweisung behandelt alle Ausnahmen, die während Datei- oder Archivierungsvorgängen auftreten können, und gibt eine Fehlermeldung an die Konsole aus.

Verschlüsseln von ZIP mit der AES-Methode

    try (FileOutputStream zipFile = new FileOutputStream("archive.zip")) {
        try (FileInputStream source = new FileInputStream("alice29.txt")) {
            try (Archive archive = new Archive(new ArchiveEntrySettings(CompressionSettings.getDeflate(), new AesEncryptionSettings("p@s$S", EncryptionMethod.AES256)))) {
                archive.createEntry("alice29.txt", source);
                archive.save(zipFile);
            }
        }
    } catch (IOException ex) {
        System.err.println(ex.getMessage());
    }

Dieser Code erstellt mithilfe der Deflate-Komprimierungsmethode ein ZIP-Archiv mit dem Namen "archive.zip" und verschlüsselt die Daten mit dem starken AES-256-Algorithmus.
Für diese Beispiele haben wir Instanzen von EncryptionSetting im entsprechenden Archivkonstruktor bereitgestellt. . Es ist möglich, bestimmte Einträge zu verschlüsseln und andere ungeschützt zu lassen.

Verschlüsseln Sie mit dem ZIP-Verschlüsselungsalgorithmus den zweiten von drei Einträgen

    try (FileOutputStream zipFile = new FileOutputStream("archive.zip")) {
        File source1 = new File("alice29.txt");
        File source2 = new File("asyoulik.txt");
        File source3 = new File("fields.c");

        try (Archive archive = new Archive()) {
            archive.createEntry("alice29.txt", source1);
            archive.createEntry("asyoulik.txt", source2, false, new ArchiveEntrySettings(null, new AesEncryptionSettings("p@s$S", EncryptionMethod.AES256)));
            archive.createEntry("fields.c", source3);
            archive.save(zipFile);
        }
    } catch (IOException ex) {
        System.err.println(ex.getMessage());
    }

Dieser Code demonstriert die Erstellung eines ZIP-Archivs mit drei Eingabedateien: "alice29.txt", "asyoulik.txt" und "fields.c". Einzigartig ist, dass die erste und die letzte Datei unverschlüsselt hinzugefügt werden, während die zweite Datei, "asyoulik.txt", durch die AES-256-Verschlüsselung mit dem Passwort "p@s$S" passwortgeschützt ist.
Dieser Ansatz der selektiven Verschlüsselung Dateien innerhalb eines ZIP-Archivs sind ungewöhnlich. Die Aspose.Zip-API für Java bietet jedoch die Funktionalität, bestimmte Einträge innerhalb eines ZIP-Archivs mit unterschiedlichen Verschlüsselungsmethoden und Passwörtern zu verschlüsseln. Dies erhöht zwar die Datensicherheit, verkompliziert jedoch den Prozess der Archivverwaltung und Entschlüsselung

Verschlüsseln Sie ZIP mit verschiedenen Methoden und Passwörtern

    try (FileOutputStream zipFile = new FileOutputStream("archive.zip")) {
        File source1 = new File("alice29.txt");
        File source2 = new File("asyoulik.txt");
        File source3 = new File("fields.c");

        try (Archive archive = new Archive()) {
            archive.createEntry("alice29.txt", source1, false, new ArchiveEntrySettings(null, new AesEncryptionSettings("p@s$S", EncryptionMethod.AES256)));
            archive.createEntry("asyoulik.txt", source2, false, new ArchiveEntrySettings(null, new TraditionalEncryptionSettings("p@s$D")));
            archive.createEntry("fields.c", source3, false, new ArchiveEntrySettings(null, new AesEncryptionSettings("p@s$F", EncryptionMethod.AES256)));
            archive.save(zipFile);
        }
    } catch (IOException ex) {
        System.err.println(ex.getMessage());
    }

Dieser Code erstellt ein ZIP-Archiv mit drei verschlüsselten Dateien: "alice29.txt", "asyoulik.txt" und "fields.c". Jede Datei wird mit einer bestimmten Methode verschlüsselt.
Der erste Teil spiegelt die Funktionalität des vorherigen Codebeispiels wider. Der Kernabschnitt konzentriert sich auf die Erstellung von Einträgen im Archiv für jede Datei. Diese Einträge verweisen auf ihre Namen und Quelldateien (Dateiobjekte). Die Verschlüsselung wird mit unterschiedlichen Methoden angewendet:

• "alice29.txt" : AES-256-Verschlüsselung mit dem Passwort "p@s$S"
• "asyoulik.txt" : Traditionell Verschlüsselungsmethode mit dem Passwort "p@s$D"
• "fields.c" : AES-256-Verschlüsselung mit dem Passwort "p@s$F"

Vorhandenes ZIP-Archiv verschlüsseln

    try (Archive archive = new Archive("plain.zip")) {
        ArchiveSaveOptions options = new ArchiveSaveOptions();
        options.setEncryptionOptions(new AesEncryptionSettings("p@s$S", EncryptionMethod.AES256));
        archive.save("encrypted.zip", options);
    }

Dieser Code nimmt ein vorhandenes "plain.zip"-Archiv, wendet AES-Verschlüsselung darauf mit dem Passwort "p@s$S" an und speichert es als neues Archiv mit dem Namen "encrypted.zip"

ZIP-Datei mit Passwort entschlüsseln

    try (Archive archive = new Archive("source.zip")) {
        archive.getEntries().get(0).extract("first_entry.bin", "p@s$S");
    }

Dieser Code extrahiert den ersten Eintrag aus dem Archiv "source.zip" und speichert ihn als Datei mit dem Namen "first_entry.bin" unter Verwendung des Passworts "p@s$S".
Der Benutzer hat die Möglichkeit, entweder einen bestimmten Eintrag innerhalb des verschlüsselten ZIP-Archivs oder das gesamte Archiv als Ganzes zu entschlüsseln.

Ganze ZIP-Datei entschlüsseln

    ArchiveLoadOptions options = new ArchiveLoadOptions();
    options.setDecryptionPassword("p@s$S");
    try (Archive archive = new Archive("source.zip", options)) {
        archive.extractToDirectory("destination");
    }

In diesem Fall müssen wir ein Passwort innerhalb eines Konstruktors bereitstellen.

RAR-Datei mit Java verschlüsseln/entschlüsseln

Aspose.ZIP bietet keine Funktionalität zum Erstellen von RAR-Archiven ; es unterstützt ausschließlich die Extraktion. Ein RAR-Archiv kann verschlüsselt werden, mit der Option, Dateinamen zu schützen oder nicht.
Im ersteren Szenario muss der Benutzer das Entschlüsselungskennwort im Objekt RarArchiveLoadOptions bei der Initialisierung angeben RAR-Archiv. Im letzteren Fall kann das Passwort beim Extrahieren einzelner Einträge angegeben werden.

Entschlüsseln Sie die RAR-Datei mit verschlüsselten Dateinamen

    RarArchiveLoadOptions options = new RarArchiveLoadOptions();
    options.setDecryptionPassword("p@s$S");
    try (RarArchive archive = new RarArchive("source.rar", options)) {
        archive.extractToDirectory("destination");
    }

Dieser Code entschlüsselt und extrahiert den Inhalt des Archivs "source.rar" in den Ordner "destination". Wenn das Archiv verschlüsselt ist, verwendet es das angegebene Entschlüsselungskennwort.
Hier ist eine Aufschlüsselung der Funktionsweise:

• Einstellungen mit Entschlüsselungskennwort laden: Zuerst wird ein Ladeeinstellungsobjekt für erstellt RAR-Archiv mit dem Optionsoperator RarArchiveLoadOptions. Anschließend wird das Entschlüsselungskennwort für das Archiv mithilfe der Methode options.setDecryptionPassword festgelegt.
• Verschlüsseltes Archiv öffnen: Die nächste Zeile öffnet das Archiv "source.rar" zum Lesen und Bearbeiten mithilfe von a try-with-resources-Konstrukt. Sie gibt das Optionsobjekt mit dem Entschlüsselungskennwort an, um verschlüsselte Archive zu verarbeiten.
• Archivinhalte extrahieren: Schließlich extrahiert die Methode archive.extractToDirectory den Inhalt des entschlüsselten Archivs zum "Ziel" ordner.

Gezielte Entschlüsselung der RAR-Datei

    try (RarArchive archive = new RarArchive("source.rar")) {
        archive.getEntries().get(0).extract("first_entry.bin", "p@s$S");
    }

Dieses Code-Snippet versucht, den ersten Eintrag aus dem RAR-Archiv "source.rar" zu extrahieren und ihn als "first_entry.bin" zu speichern, wobei das Entschlüsselungskennwort "p@s$S" verwendet wird, wenn das Archiv verschlüsselt ist.

Entschlüsseln spezifischer RAR-Eintragsinhalte (Stream)

    ByteArrayOutputStream destination = new ByteArrayOutputStream();
    try (RarArchive archive = new RarArchive("source.rar")) {
        try (InputStream source = archive.getEntries().get(1).open("p@s$S")) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = source.read(buffer, 0, buffer.length)) > 0) {
                destination.write(buffer, 0, bytesRead);
            }
        } catch (IOException ex) {
            System.err.println(ex.getMessage());
        }
    }

Dieses Code-Snippet zielt auf einen bestimmten Eintrag in einem RAR-Archiv ab. Es entschlüsselt den Inhalt des Eintrags und streamt ihn direkt in den Speicher, vorausgesetzt, dass nur die Eintragsdaten verschlüsselt sind, nicht die Dateinamen selbst.
Eine vollständige Beschreibung der Funktion des Codes:

• Initialisierung des Speicherpuffers : Ein ByteArrayOutputStream benanntes Ziel wird erstellt, um als In-Memory-Puffer zum Speichern des entschlüsselten Inhalts des Zieleintrags zu dienen.
• Archiv- und Eintragszugriff: Der Code verwendet ein Try-with -resources-Block zum Öffnen des Quell-RAR-Archivs "source.rar". In einem anderen Try-with-Resources-Block wird ein Eingabestream für den zweiten Eintrag abgerufen und mit dem Passwort "p@s$S" entschlüsselt.
• Entschlüsselung und Streaming: Die entschlüsselten Bytes werden mithilfe eines Puffers in Blöcken aus dem Eingabestream gelesen. Jeder Block wird dann in den Ziel-ByteArrayOutputStream geschrieben, bis alle Daten verarbeitet sind.
• Fehlerbehandlung: Der Code enthält einen Catch-Block zur Behandlung alle potenziellen IOExceptions, die während des Entschlüsselungs- oder Streaming-Prozesses auftreten könnten. Wenn ein Fehler auftritt, wird die Fehlermeldung zu Debugging-Zwecken im Standardfehlerstrom ausgegeben.

7-ZIP-Datei mit Java verschlüsseln und entschlüsseln

Wird in Aspose.ZIP für Java 24.4-Version implementiert. Die einzige 7z-Archivverschlüsselungsoption ist AES.

7-Zip-Datei mit LZMA2 verschlüsseln und komprimieren

    using (FileStream szFile = File.Open("archive.7z", FileMode.Create))
    {
        FileInfo source1 = new FileInfo("alice29.txt");
        FileInfo source2 = new FileInfo("asyoulik.txt");	
        FileInfo source3 = new FileInfo("fields.c");

        using (var archive = new SevenZipArchive(new SevenZipEntrySettings(new SevenZipLZMA2CompressionSettings(), new SevenZipAESEncryptionSettings("p@s$S"))))
        {
            archive.CreateEntry("alice29.txt", source1);
            archive.CreateEntry("asyoulik.txt", source2);
            archive.CreateEntry("fields.c", source3);
            archive.Save(szFile);
        }
    }

7Z-Archive unterstützen die Möglichkeit, jeden Eintrag mit einem eigenen Passwort zu verschlüsseln oder ungeschützt zu lassen. Dieser Code erstellt ein neues 7z-Archiv mit LZMA2- und AES-Komprimierung und -Verschlüsselung.

• Dateiöffnung: Ein FileStream wird verwendet, um eine neue Datei mit dem Namen "archive.7z" im Erstellungsmodus zu öffnen.
• Objekte initialisieren: Drei FileInfo-Objekte werden für die Dateien "alice29.txt", "asyoulik.txt" und "fields.c" erstellt.
• Erstellen einer 7-zip-Datei: Das SevenZipArchive-Objekt wird erstellt mit:
  - LZMA2-Komprimierungseinstellungen.
  - AES-Verschlüsselung-Einstellungen mit dem Passwort "p@s$S"
• Hinzufügen von Dateien: Die CreateEntry-Methoden werden verwendet, um jede Datei separat zum Archiv hinzuzufügen Quelle.
• Speichern des Archivs: Das Archiv wird mit der Save-Methode im szFile-Dateistream gespeichert.

Selektive Verschlüsselung im 7z-Archiv

    using (FileStream szFile = File.Open("archive.7z", FileMode.Create))
    {
        FileInfo source1 = new FileInfo("alice29.txt");
        FileInfo source2 = new FileInfo("asyoulik.txt");
        FileInfo source3 = new FileInfo("fields.c");

        using (var archive = new SevenZipArchive())
        {
            archive.CreateEntry("alice29.txt", source1);
            archive.CreateEntry("asyoulik.txt", source2, false, new SevenZipEntrySettings(new SevenZipLZMA2CompressionSettings(), new SevenZipAESEncryptionSettings("p@s$S")));
            archive.CreateEntry("fields.c", source3, false, new SevenZipEntrySettings(new SevenZipLZMA2CompressionSettings(), new SevenZipAESEncryptionSettings("$ecret")));
            archive.Save(szFile);
        }
    }

Dieser Code erstellt ein 7z-Archiv mit drei Dateien: "alice29.txt", "asyoulik.txt" und "fields.c". Die beiden letztgenannten Dateien werden mit unterschiedlichen Passwörtern komprimiert und verschlüsselt.
Im Gegensatz zum vorherigen Code wird die Methode archive.CreateEntry für das Archivobjekt verwendet, um Einträge für jede Datei zu erstellen. Beim Erstellen des Eintrags für "asyoulik.txt" aus dem FileInfo-Objekt source2 wird der dritte Parameter von CreateEntry auf false gesetzt. Dies gibt an, dass benutzerdefinierte Komprimierungs- und Verschlüsselungseinstellungen verwendet werden, die im vierten Parameter (einem SevenZipEntrySettings-Objekt) definiert sind. In diesem Fall legen die Einstellungen die Komprimierung "Zip LZMA2" und die Verschlüsselung "Zip AES" mit dem Passwort "p@s$S" fest.
Ähnlich wie bei ZIP kann der Benutzer entweder das gesamte Archiv oder einen bestimmten Eintrag daraus entschlüsseln.
7Z-Archiv kann mit oder ohne Schutz verschlüsselt werden Dateinamen. Wenn Dateinamen verschlüsselt sind, müssen Sie ein Passwort bei der Archivinstanziierung angeben.

7z-Entschlüsselung mit verschlüsselten Dateinamen

    try (SevenZipArchive archive = new SevenZipArchive("archive.7z", "p@s$S")) {
        archive.extractToDirectory("C:\\extracted");
    }

Dieser Code verwendet einen Try-with-Resources-Block, um ein 7z-Archiv mit dem Namen "archive.7z" zu öffnen, das mit dem Passwort "p@s$S" geschützt ist. Anschließend wird der Inhalt des Archivs in den Ordner "C:\extracted" extrahiert.
Unabhängig davon, ob Dateinamen verschlüsselt sind oder nicht, ist es sicher, im Extraktionskonstruktor ein Kennwort anzugeben. Das folgende Beispiel funktioniert nur, wenn nur Inhalte geschützt sind.

Entschlüsselung eines 7z-spezifischen Eintrags

    try (SevenZipArchive archive = new SevenZipArchive("archive.7z")) {
        archive.getEntries().get(0).extract("data.bin", "p@s$S");
    }

Dieser Code verwendet einen Try-with-Resources-Block, um ein 7z-Archiv mit dem Namen "archive.7z" zu öffnen, das mit dem Passwort "p@s$S" geschützt ist. Anschließend wird der Inhalt des Archivs in den Ordner "C:\extracted" extrahiert.
Unabhängig davon, ob Dateinamen verschlüsselt sind oder nicht, ist es sicher, im Extraktionskonstruktor ein Kennwort anzugeben. Das folgende Beispiel funktioniert nur, wenn nur Inhalte geschützt sind.