Kryptera och dekryptera ZIP / RAR / 7Z-filer

Överblick

Kryptera/Dekryptera ZIP-filer

Det finns två tillgängliga krypteringsmetoder för ZIP-arkiv : den traditionella metoden, som nu anses vara svag, och den moderna AES-metoden. ZIP-standarden tillåter att alla poster krypteras med båda metoderna, även inom samma ZIP-arkiv. AES-kryptering ger starkare säkerhet och finns i olika nyckellängder (128-bitars, 192-bitars och 256-bitars). Detta ger bättre skydd för känsliga data som lagras i ZIP-arkiv.

Kryptera en ZIP med Deflate-metoden

    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());
    }

Denna kod skapar ett ZIP-arkiv med namnet "archive.zip" med hjälp av Deflate-komprimeringsmetoden och traditionell ZIP-kryptering. Den uppnår detta genom att först öppna en ny utdataström för arkivet med försök FileOutputStream. FileInputStream-källan fungerar som indataström för källfilen "alice29.txt" som kommer att läggas till i arkivet. Därefter skapas ett arkivobjekt som anger både Deflate-komprimeringsmetoden och traditionell kryptering. Lösenordet för kryptering är satt till "p@s$S". Catch-satsen hanterar alla undantag som kan uppstå under fil- eller arkivoperationer och skriver ut ett felmeddelande till konsolen.

Kryptera ZIP med AES-metoden

    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());
    }

Den här koden skapar ett ZIP-arkiv med namnet "archive.zip" med hjälp av Deflate-komprimeringsmetoden och krypterar data med den starka AES-256-algoritmen.
För dessa exempel tillhandahöll vi instanser av EncryptionSetting inom motsvarande Arkivkonstruktor . Det är möjligt att använda kryptering för en viss post och lämna andra oskyddade.

Använd ZIP-krypteringsalgoritmen och kryptera den andra posten av tre

    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());
    }

Den här koden visar att man skapar ett ZIP-arkiv med tre indatafiler: "alice29.txt", "asyoulik.txt" och "fields.c". Unikt är att den första och den sista filen läggs till okrypterade, medan den andra filen, "asyoulik.txt", är lösenordsskyddad med AES-256-kryptering med lösenordet "p@s$S".
Denna metod för selektiv kryptering filer i ett ZIP-arkiv är ovanligt. Aspose.Zip API för Java tillhandahåller dock funktionen för att kryptera specifika poster i ett ZIP-arkiv med olika krypteringsmetoder och lösenord. Även om detta ökar datasäkerheten, men komplicerar processen för arkivhantering och dekryptering

Kryptera ZIP med olika metoder och lösenord

    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());
    }

Denna kod skapar ett ZIP-arkiv som innehåller tre krypterade filer: "alice29.txt", "asyoulik.txt" och "fields.c". Varje fil är krypterad med en distinkt metod.
Den första delen speglar funktionaliteten i föregående kodexempel. Kärnavsnittet fokuserar på att skapa poster i arkivet för varje fil. Dessa poster refererar till deras namn och källfiler (Filobjekt). Kryptering tillämpas med olika metoder:

• "alice29.txt" AES-256-kryptering med lösenordet "p@s$S"
• "asyoulik.txt" Traditionell krypteringsmetod med lösenordet "p@s$D"
• "fields.c" : AES-256-kryptering med lösenordet "p@s$F"

Kryptera befintligt ZIP-arkiv

    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);
    }

Den här koden tar ett befintligt "plain.zip"-arkiv, tillämpar AES-kryptering på det med lösenordet "p@s$S" och sparar det som ett nytt arkiv med namnet "encrypted.zip"

Dekryptera ZIP-fil med lösenord

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

Den här koden extraherar den första posten från "source.zip"-arkivet och sparar den som en fil med namnet "first_entry.bin" med lösenordet "p@s$S".
Användaren har möjlighet att dekryptera antingen en specifik post i det krypterade ZIP-arkivet eller hela arkivet som helhet.

Dekryptera hela ZIP-filen

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

I det här fallet måste vi tillhandahålla lösenord inom en konstruktor.

Kryptera/Dekryptera RAR-fil med Java

Aspose.ZIP tillhandahåller inte funktionalitet för att skapa RAR-arkiv ; den stöder endast utvinning. Ett RAR-arkiv kan krypteras, med möjlighet att skydda filnamn eller inte.
I det tidigare scenariot måste användaren ange dekrypteringslösenordet i objektet RarArchiveLoadOptions vid initieringen av RAR-arkiv. I det senare fallet kan lösenordet tillhandahållas under extraheringen av enskilda poster.

Dekryptera RAR-fil med krypterade filnamn

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

Denna kod dekrypterar och extraherar innehållet i "source.rar"-arkivet till mappen "destination". Om arkivet är krypterat använder det det angivna dekrypteringslösenordet.
Här är en sammanfattning av hur det fungerar:

• Ladda inställningar med dekrypteringslösenord: Först skapar det ett laddningsinställningar för RAR-arkiv med alternativoperatorn RarArchiveLoadOptions. Den ställer sedan in dekrypteringslösenordet för arkivet med metoden options.setDecryptionPassword.
• Öppna krypterat arkiv: Nästa rad öppnar arkivet "source.rar" för läsning och redigering med en prova-med-resurser-konstruktion. Den specificerar alternativobjektet med dekrypteringslösenordet för att hantera krypterade arkiv.
• Extrahera arkivinnehåll: Slutligen extraherar metoden archive.extractToDirectory innehållet i det dekrypterade arkivet till "destinationen" mapp.

RAR-fil för riktad dekryptering

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

Detta kodavsnitt försöker extrahera den första posten från "source.rar" RAR-arkivet och spara den som "first_entry.bin", med hjälp av dekrypteringslösenordet "p@s$S" om arkivet är krypterat.

Dekryptera specifikt RAR-innehåll (ström)

    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());
        }
    }

Detta kodavsnitt riktar sig mot en specifik post i ett RAR-arkiv. Den dekrypterar postens innehåll och strömmar det direkt till minnet, förutsatt att endast postens data är krypterad, inte själva filnamnen.
En fullständig beskrivning av vad koden gör:

• Initiering av minnesbuffert : En ByteArrayOutputStream namngiven destination skapas för att fungera som en buffert i minnet för lagring av det dekrypterade innehållet i den riktade posten.
• Arkiv- och poståtkomst: Koden använder ett försök med -Resources block för att öppna käll-RAR-arkivet "source.rar". Inuti ett annat försök-med-resurser-block hämtar den en ingångsström för den andra posten och dekrypterar den med lösenordet "p@s$S".
• Dekryptering och strömning: De dekrypterade byten läses från indataströmmen i bitar med hjälp av en buffert. Varje bit skrivs sedan till destinationen ByteArrayOutputStream tills all data har bearbetats.
• Felhantering: Koden innehåller ett fångstblock att hantera eventuella IOExceptions som kan uppstå under dekrypterings- eller streamingprocessen. Om ett fel uppstår skrivs felmeddelandet ut till standardfelströmmen för felsökningsändamål.

Kryptera och dekryptera 7-ZIP-fil med Java

Kommer att implementeras i Aspose.ZIP för Java 24.4 version. Det enda 7z-arkivkrypteringsalternativet är AES.

Kryptera och komprimera 7-Zip-fil med LZMA2

    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 arkiv stöder en förmåga att kryptera varje post med eget lösenord eller lämna oskyddad. Denna kod skapar ett nytt 7z-arkiv med LZMA2- och AES-komprimering och kryptering.

• Filöppning: En FileStream används för att öppna en ny fil med namnet "archive.7z" i skapande läge.
• Initialisering av objekt: Tre FileInfo-objekt skapas för filerna "alice29.txt", "asyoulik.txt" och "fields.c".
• Skapa en 7-zip-fil: SevenZipArchive-objektet skapas med:
  - LZMA2 komprimeringsinställningar.
  - AES-kryptering-inställningar med lösenordet "p@s$S"
• Lägga till filer: CreateEntry-metoderna används för att lägga till varje fil till arkivet från en separat källa.
• Spara arkivet: Arkivet sparas i filströmmen szFile med hjälp av Spara-metoden.

Selektiv kryptering i 7z-arkiv

    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);
        }
    }

Denna kod skapar ett 7z-arkiv som innehåller tre filer: "alice29.txt", "asyoulik.txt" och "fields.c". De två sistnämnda filerna komprimeras och krypteras med olika lösenord.
Till skillnad från föregående kod används archive.CreateEntry-metoden på arkivobjektet för att skapa poster för varje fil. När du skapar posten för "asyoulik.txt" från source2 FileInfo-objektet, är den tredje parametern för CreateEntry inställd på false. Detta indikerar att anpassade komprimerings- och krypteringsinställningar kommer att användas, definierade i den fjärde parametern (ett SevenZipEntrySettings-objekt). I det här fallet anger inställningarna "Zip LZMA2"-komprimering och "Zip AES"-kryptering med lösenordet "p@s$S".
På samma sätt som ZIP kan användaren dekryptera antingen hela arkivet eller en viss post från det.
7Z archive kan krypteras med eller utan skydd filnamn. Om filnamnen är krypterade måste du ange lösenord vid arkivinstansering .

7z-dekryptering med krypterade filnamn

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

Den här koden använder ett försök-med-resurser-block för att öppna ett 7z-arkiv med namnet "archive.7z" skyddat med lösenordet "p@s$S". Den extraherar sedan arkivets innehåll till mappen "C:\extracted".
Oavsett om filnamnen är krypterade eller inte, är det säkert att ange lösenord inom extraherande konstruktor. Exemplet nedan fungerar bara när endast innehåll är skyddat.

Dekrypterar 7z-specifik ingång

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

Den här koden använder ett försök-med-resurser-block för att öppna ett 7z-arkiv med namnet "archive.7z" skyddat med lösenordet "p@s$S". Den extraherar sedan arkivets innehåll till mappen "C:\extracted".
Oavsett om filnamnen är krypterade eller inte, är det säkert att ange lösenord inom extraherande konstruktor. Exemplet nedan fungerar bara när endast innehåll är skyddat.