Crittografa e decrittografa file ZIP/RAR/7Z

Overview

Crittografa/decrittografa file ZIP

Sono disponibili due metodi di crittografia per gli archivi ZIP : il metodo tradizionale, che ora è considerato debole, e il moderno metodo AES Lo standard ZIP consente di crittografare qualsiasi voce con entrambi i metodi, anche all’interno dello stesso archivio ZIP. La crittografia AES offre una maggiore sicurezza ed è disponibile in diverse lunghezze di chiave (128 bit, 192 bit e 256 bit). migliore protezione per i dati sensibili archiviati negli archivi ZIP.

Crittografa un ZIP con il metodo Deflate

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

Questo codice crea un archivio ZIP denominato "archive.zip" utilizzando il metodo di compressione Deflate e la crittografia ZIP tradizionale. Ottiene questo risultato aprendo prima un nuovo flusso di output per l’archivio utilizzando try FileOutputStream. L’origine FileInputStream funge da flusso di input per il file sorgente "alice29.txt" Successivamente, viene creato un oggetto Archive, specificando sia il metodo di compressione Deflate che la crittografia tradizionale impostato su "p@s$S". L’istruzione catch gestisce eventuali eccezioni che potrebbero verificarsi durante le operazioni su file o archivio, stampando un messaggio di errore sulla console.

Crittografia ZIP con metodo AES

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

Questo codice crea un archivio ZIP denominato "archive.zip" utilizzando il metodo di compressione Deflate e crittografa i dati con il potente algoritmo AES-256.
Per questi esempi abbiamo fornito delle istanze di EncryptionSetting all’interno del corrispondente costruttore di archivio . È possibile applicare la crittografia per una voce particolare lasciandone altre non protette.

Utilizzando l'algoritmo di crittografia ZIP, crittografa la seconda voce di 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());
    }

Questo codice dimostra la creazione di un archivio ZIP con tre file di input: "alice29.txt", "asyoulik.txt" e "fields.c" In modo univoco, il primo e l’ultimo file vengono aggiunti non crittografati, mentre il secondo file, "asyoulik.txt", è protetto da password utilizzando la crittografia AES-256 con la password "p@s$S".
Questo approccio di crittografia selettiva dei file all’interno di un archivio ZIP non è comune. Tuttavia, l’API Aspose.Zip per Java fornisce la funzionalità per crittografare voci specifiche all’interno di un archivio ZIP utilizzando metodi di crittografia e password diversi, migliorando allo stesso tempo i dati sicurezza, ma complica il processo di gestione e decrittazione degli archivi

Crittografa ZIP con metodi e password diversi

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

Questo codice crea un archivio ZIP contenente tre file crittografati: "alice29.txt", "asyoulik.txt" e "fields.c". Ogni file viene crittografato con un metodo distinto.
La prima parte rispecchia la funzionalità dell’esempio di codice precedente La sezione principale si concentra sulla creazione di voci all’interno dell’archivio per ciascun file. Queste voci fanno riferimento ai loro nomi e ai file di origine (oggetti file). La crittografia viene applicata con metodi diversi:

• "alice29.txt"
• "asyoulik.txt" : Metodo di crittografia tradizionale con la password "p@s$D"
• "fields.c": Crittografia AES-256 con la password "p@s$F"

Crittografa archivio ZIP esistente

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

Questo codice prende un archivio "plain.zip" esistente, vi applica la crittografia AES con la password "p@s$S" e lo salva come un nuovo archivio denominato "crittografato.zip"

Decodifica file ZIP con password

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

Questo codice estrae la prima voce dall’archivio "source.zip" e la salva come file denominato "first_entry.bin" utilizzando la password "p@s$S".
L’utente ha la possibilità di decrittografare una voce specifica all’interno dell’archivio ZIP crittografato o l’intero archivio nel suo complesso.

Decodifica intero file ZIP

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

In questo caso dobbiamo fornire la password all’interno di un costruttore.

Crittografa/decrittografa file RAR con Java

Aspose.ZIP non fornisce funzionalità per la creazione di archivi RAR ; supporta esclusivamente l’estrazione. Un archivio RAR può essere crittografato, con l’opzione di proteggere o meno i nomi dei file.
Nel primo scenario, l’utente deve fornire la password di decrittazione all’interno di RarArchiveLoadOptions oggetto all’inizializzazione dell’archivio RAR. In quest’ultimo caso la password può essere fornita durante l’estrazione delle singole voci.

Decrittografa file RAR con nomi di file crittografati

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

Questo codice decodifica ed estrae il contenuto dell’archivio "source.rar" nella cartella ‘destinazione’. Se l’archivio è crittografato, utilizza la password di decrittografia specificata.
Ecco un’analisi dettagliata di come funziona:

• Carica impostazioni con password di decrittografia: Innanzitutto, crea un oggetto delle impostazioni di caricamento per l’archivio RAR utilizzando l’operatore delle opzioni RarArchiveLoadOptions. Quindi imposta la password di decrittografia per l’archivio utilizzando il metodo options.setDecryptionPassword.
• Apri archivio crittografato: La riga successiva apre il file "source.rar" ; archivio per la lettura e la modifica utilizzando un costrutto try-with-resources. Specifica l’oggetto opzioni con la password di decrittografia per gestire gli archivi crittografati.
• Estrai contenuto archivio: , il metodo archive.extractToDirectory estrae il contenuto dell’archivio decrittografato nella cartella "di destinazione".

File RAR di decrittografia mirata

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

Questo frammento di codice tenta di estrarre la prima voce dall’archivio RAR "source.rar" e di salvarla come "first_entry.bin", utilizzando la password di decrittazione "p@s$S" se l’archivio è crittografato.

Decrittografia del contenuto di una voce RAR specifica (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());
        }
    }

Questo frammento di codice prende di mira una voce specifica all’interno di un archivio RAR. Decrittografa il contenuto della voce e lo trasmette direttamente in memoria, presupponendo che siano crittografati solo i dati della voce, non i nomi dei file stessi.
Una descrizione completa di ciò che il codice fa:

• Inizializzazione del buffer di memoria: Viene creata una destinazione denominata ByteArrayOutputStream che funge da buffer in memoria per archiviare il contenuto decrittografato della voce di destinazione.
• Accesso all’archivio e alle voci: Il codice utilizza un blocco try-with-resources per aprire l’archivio RAR di origine "source.rar" blocca, recupera un flusso di input per la seconda voce e lo decrittografa utilizzando la password "p@s$S".
• Decrittografia e streaming: i byte vengono letti dal flusso di input in blocchi utilizzando un buffer. Ogni blocco viene quindi scritto nel ByteArrayOutputStream di destinazione finché tutti i dati non vengono elaborati.
• Gestione degli errori: catch blocco per gestire qualsiasi potenziale IOException che potrebbe verificarsi durante il processo di decrittografia o streaming. Se si verifica un errore, il messaggio di errore viene stampato nel flusso di errori standard per scopi di debug.

Crittografa e decrittografa file 7-ZIP con Java

Sarà implementato in Aspose.ZIP per la versione Java 24.4. L’unica opzione di crittografia dell’archivio 7z è AES.

Crittografa e comprimi file 7-Zip con 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);
        }
    }

Gli archivi 7Z supportano la possibilità di crittografare ogni voce con la propria password o di lasciarla non protetta. Questo codice crea un nuovo archivio 7z con compressione e crittografia LZMA2 e AES.

• Apertura file: Un FileStream viene utilizzato per aprire un nuovo file denominato "archive.7z" in modalità di creazione
• Inizializzazione di oggetti: per i file "alice29.txt", "asyoulik.txt" e "fields.c"
• Creazione di un 7-. zip: L’oggetto SevenZipArchive viene creato con : - Impostazioni di compressione LZMA2
  - Impostazioni Crittografia AES utilizzando la password "p@s$S&."
• Aggiunta di file: I metodi CreateEntry vengono utilizzati per aggiungere ciascun file all’archivio da una fonte separata
• Salvataggio del file Archivio: L’archivio viene salvato nel flusso di file szFile utilizzando il metodo Salva

Crittografia selettiva nell'archivio 7z

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

Questo codice crea un archivio 7z contenente tre file: "alice29.txt", "asyoulik.txt" e "fields.c". Il gli ultimi due file vengono compressi e crittografati utilizzando password diverse.
A differenza del codice precedente, il metodo archive.CreateEntry viene utilizzato sull’oggetto archivio per creare voci per ciascun file. txt" dall’oggetto FileInfo source2, il terzo parametro di CreateEntry è impostato su false Ciò indica che verranno utilizzate le impostazioni di compressione e crittografia personalizzate, definite nel quarto parametro (un oggetto SevenZipEntrySettings). in questo caso, le impostazioni specificano la compressione "Zip LZMA2" e la crittografia "Zip AES" con la password "p@s$S"
Simile a ZIP, l’utente può decrittografare l’intero archivio o una voce specifica da esso.
Archivio 7Z può essere crittografato con o senza protezione dei nomi dei file Se i nomi dei file sono crittografato, è necessario fornire la password durante l’istanziazione dell’archivio .

Decifratura 7z con nomi di file crittografati

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

Questo codice utilizza un blocco try-with-resources per aprire un archivio 7z denominato "archive.7z" protetto con la password "p@s$S". Quindi estrae il contenuto dell’archivio nella cartella "C:\estratta". Indipendentemente dal fatto che i nomi dei file siano crittografati o meno, è sicuro fornire la password all’interno del costruttore di estrazione. L’esempio seguente funzionerà solo quando solo il contenuto è protetto.

Decrittografia voce specifica 7z

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

Questo codice utilizza un blocco try-with-resources per aprire un archivio 7z denominato "archive.7z" protetto con la password "p@s$S". Quindi estrae il contenuto dell’archivio nella cartella "C:\estratta". Indipendentemente dal fatto che i nomi dei file siano crittografati o meno, è sicuro fornire la password all’interno del costruttore di estrazione. L’esempio seguente funzionerà solo quando solo il contenuto è protetto.