Cifrar y descifrar archivos ZIP/RAR/7Z

Descripción general

Cifrar/descifrar archivos ZIP

Hay dos métodos de cifrado disponibles para archivos ZIP : el método tradicional, que ahora se considera débil, y el método AES moderno. El estándar ZIP permite cifrar cualquier entrada con cualquiera de los métodos, incluso dentro del mismo archivo ZIP. El cifrado AES ofrece mayor seguridad y está disponible en diferentes longitudes de clave (128 bits, 192 bits y 256 bits). Esto proporciona una mejor protección para los datos confidenciales almacenados en archivos ZIP.

Cifrar un ZIP con el método 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());
    }

Este código crea un archivo ZIP llamado "archive.zip" utilizando el método de compresión Deflate y el cifrado ZIP tradicional. Lo logra abriendo primero una nueva secuencia de salida para el archivo usando try FileOutputStream. La fuente FileInputStream sirve como flujo de entrada para el archivo fuente "alice29.txt" que se agregará al archivo. A continuación, se crea un objeto Archivo, especificando tanto el método de compresión Deflate como el cifrado tradicional. La contraseña para el cifrado está establecida en "p@s$S". La declaración catch maneja cualquier excepción que pueda surgir durante las operaciones de archivo o archivado, imprimiendo un mensaje de error en la consola.

Cifrar ZIP con el método 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());
    }

Este código crea un archivo ZIP llamado "archive.zip" utilizando el método de compresión Deflate y cifra los datos con el potente algoritmo AES-256.
Para estos ejemplos proporcionamos instancias de EncryptionSetting dentro del [Constructor de archivos] correspondiente ( https://reference.aspose.com/zip/java/com.aspose.zip/archive/#Archive-com.aspose.zip.ArchiveEntrySettings-) . Es posible aplicar cifrado a una entrada concreta dejando otras desprotegidas.

Utilizando el algoritmo de cifrado ZIP, cifre la segunda entrada de tres

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

Este código demuestra la creación de un archivo ZIP con tres archivos de entrada: "alice29.txt", "asyoulik.txt" y "fields.c". Únicamente, el primer y el último archivo se agregan sin cifrar, mientras que el segundo archivo, "asyoulik.txt", está protegido con contraseña mediante cifrado AES-256 con la contraseña "p@s$S".
Este enfoque de cifrado selectivo archivos dentro de un archivo ZIP es poco común. Sin embargo, la API Aspose.Zip para Java proporciona la funcionalidad de cifrar entradas específicas dentro de un archivo ZIP utilizando diferentes métodos de cifrado y contraseñas. Si bien esto mejora la seguridad de los datos, complica el proceso de gestión y descifrado de archivos.

Cifrar ZIP con diferentes métodos y contraseñas

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

Este código crea un archivo ZIP que contiene tres archivos cifrados: "alice29.txt", "asyoulik.txt" y "fields.c". Cada archivo se cifra con un método distinto.
La primera parte refleja la funcionalidad del ejemplo de código anterior. La sección principal se centra en la creación de entradas dentro del archivo para cada archivo. Estas entradas hacen referencia a sus nombres y archivos fuente (objetos de archivo). El cifrado se aplica con distintos métodos:

• "alice29.txt": cifrado AES-256 con la contraseña "p@s$S"
• "asyoulik.txt": tradicional método de cifrado con la contraseña "p@s$D"
• "fields.c" : cifrado AES-256 con la contraseña "p@s$F"

Cifrar archivo ZIP existente

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

Este código toma un archivo "plain.zip" existente, le aplica cifrado AES con la contraseña "p@s$S" y lo guarda como un nuevo archivo llamado "encrypted.zip".

Descifrar archivo ZIP con contraseña

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

Este código extrae la primera entrada del archivo "source.zip" y la guarda como un archivo llamado "first_entry.bin" usando la contraseña "p@s$S".
El usuario tiene la opción de descifrar una entrada específica dentro del archivo ZIP cifrado o todo el archivo en su conjunto.

Descifrar todo el archivo ZIP

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

En este caso necesitamos proporcionar una contraseña dentro de un constructor.

Cifrar/descifrar archivos RAR con Java

Aspose.ZIP no proporciona funcionalidad para crear archivos RAR ; solo admite la extracción. Un archivo RAR se puede cifrar, con la opción de proteger los nombres de los archivos o no.
En el escenario anterior, el usuario debe proporcionar la contraseña de descifrado dentro del objeto RarArchiveLoadOptions en la inicialización del Archivo RAR. En este último caso, la contraseña se puede proporcionar durante la extracción de entradas individuales.

Descifrar archivos RAR con nombres de archivos cifrados

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

Este código descifra y extrae el contenido del archivo "source.rar" a la carpeta "destino". Si el archivo está cifrado, utiliza la contraseña de descifrado especificada.
Aquí hay un desglose de cómo funciona:

• Cargar configuración con contraseña de descifrado: Primero, crea un objeto de configuración de carga para el archivo. Archivo RAR utilizando el operador de opciones RarArchiveLoadOptions. Luego establece la contraseña de descifrado para el archivo usando el método options.setDecryptionPassword.
• Abrir archivo cifrado: la siguiente línea abre el archivo "source.rar" para leerlo y editarlo usando un * construcción de prueba con recursos *. Especifica el objeto de opciones con la contraseña de descifrado para manejar archivos cifrados.
• Extraer contenido del archivo comprimido: Finalmente, el método archive.extractToDirectory extrae el contenido del archivo descifrado al "destino". carpeta.

Archivo RAR de descifrado dirigido

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

Este fragmento de código intenta extraer la primera entrada del archivo RAR "source.rar" y guardarla como "first_entry.bin", usando la contraseña de descifrado "p@s$S" si el archivo está cifrado.

Descifrar contenido de entrada RAR específico (transmisión)

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

Este fragmento de código apunta a una entrada específica dentro de un archivo RAR. Descifra el contenido de la entrada y lo transmite directamente a la memoria, suponiendo que solo se cifran los datos de la entrada, no los nombres de los archivos en sí.
Una descripción completa de lo que hace el código:

• Inicialización del búfer de memoria : Se crea un destino con nombre ByteArrayOutputStream para que sirva como un búfer en memoria para almacenar el contenido descifrado de la entrada de destino.
• Acceso a archivo y entrada: el código utiliza una prueba con -Bloque de recursos para abrir el archivo RAR fuente "source.rar". Dentro de otro bloque de prueba con recursos, recupera un flujo de entrada para la segunda entrada y lo descifra usando la contraseña "p@s$S".
• Descifrado y transmisión: los bytes descifrados se leen del flujo de entrada en fragmentos utilizando un búfer. Luego, cada fragmento se escribe en el ByteArrayOutputStream de destino hasta que se procesen todos los datos.
• Manejo de errores: el código incorpora un bloque catch para manejar cualquier posible IOException que pueda surgir durante el proceso de descifrado o transmisión. Si se produce un error, el mensaje de error se imprime en la secuencia de error estándar para fines de depuración.

Cifrar y descifrar archivos 7-ZIP con Java

Se implementará en Aspose.ZIP para la versión Java 24.4. La única opción de cifrado de archivos 7z es AES.

Cifrar y comprimir archivos 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);
        }
    }

Los archivos 7Z admiten la capacidad de cifrar cada entrada con su propia contraseña o dejarla desprotegida. Este código crea un nuevo archivo 7z con compresión y cifrado LZMA2 y AES.

• Apertura de archivos: Un FileStream se utiliza para abrir un nuevo archivo llamado "archive.7z" en el modo de creación.
• Inicialización de objetos: se crean tres objetos FileInfo para los archivos "alice29.txt", "asyoulik.txt" y "fields.c".
• Creación de un archivo 7-zip: El objeto SevenZipArchive se crea con:
  - configuración de compresión LZMA2.
  - Configuración de cifrado AES usando la contraseña "p@s$S"
• Agregar archivos: Los métodos CreateEntry se utilizan para agregar cada archivo al archivo desde un archivo separado. fuente.
• Guardar el archivo: el archivo se guarda en la secuencia de archivos szFile usando el método Guardar.

Cifrado selectivo en archivo 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);
        }
    }

Este código crea un archivo 7z que contiene tres archivos: "alice29.txt", "asyoulik.txt" y "fields.c". Los dos últimos archivos se comprimen y cifran con contraseñas diferentes.
A diferencia del código anterior, el método archive.CreateEntry se utiliza en el objeto de archivo para crear entradas para cada archivo. Al crear la entrada para "asyoulik.txt" desde el objeto FileInfo source2, el tercer parámetro de CreateEntry se establece en false. Esto indica que se utilizarán configuraciones personalizadas de compresión y cifrado, definidas en el cuarto parámetro (un objeto SevenZipEntrySettings). En este caso, la configuración especifica la compresión "Zip LZMA2" y el cifrado "Zip AES" con la contraseña "p@s$S".
Similar al ZIP, el usuario puede descifrar el archivo completo o una entrada particular del mismo.
Archivo 7Z se puede cifrar con o sin protección nombres de archivos. Si los nombres de los archivos están cifrados, debe proporcionar una contraseña al crear instancias de archivo .

Descifrado 7z con nombres de archivos cifrados

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

Este código utiliza un bloque de prueba con recursos para abrir un archivo 7z llamado "archive.7z" protegido con la contraseña "p@s$S". Luego extrae el contenido del archivo a la carpeta "C:\extracted".
Ya sea que los nombres de los archivos estén cifrados o no, es seguro proporcionar una contraseña dentro del constructor de extracción. El siguiente ejemplo solo funcionará cuando solo el contenido esté protegido.

Descifrando la entrada específica de 7z

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

Este código utiliza un bloque de prueba con recursos para abrir un archivo 7z llamado "archive.7z" protegido con la contraseña "p@s$S". Luego extrae el contenido del archivo a la carpeta "C:\extracted".
Ya sea que los nombres de los archivos estén cifrados o no, es seguro proporcionar una contraseña dentro del constructor de extracción. El siguiente ejemplo solo funcionará cuando solo el contenido esté protegido.