Protección de archivos con contraseña
La API Aspose.ZIP le permite comprimir y descomprimir archivos en C# o cualquier idioma .NET sin preocuparse por la estructura del archivo subyacente. Este artículo proporciona ejemplos de cómo implementar protección con contraseña con esquemas de cifrado tradicionales y AES. Además, muestra cómo trabajar con directorios y comprimir varios archivos utilizando técnicas de cifrado mixtas.
Protección con contraseña con cifrado tradicional
Aspose.ZIP permite la protección con contraseña tradicional para archivos comprimidos. Con una contraseña simple, puede proteger archivos individuales o directorios completos dentro de un archivo, asegurando que solo los usuarios autorizados puedan extraer el contenido.
Cifrar archivos con el esquema de cifrado tradicional
Cifre archivos utilizando un método de cifrado tradicional más simple. Este enfoque permite una protección básica de los archivos con contraseña, lo que garantiza que los archivos se compriman de forma segura y al mismo tiempo permanezcan accesibles mediante el uso de la contraseña correcta.
1 // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2 using (FileStream zipFile = File.Open(dataDir + "CompressWithTraditionalEncryption_out.zip", FileMode.Create))
3 {
4 using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
5 {
6 var archive = new Archive(new ArchiveEntrySettings(null, new TraditionalEncryptionSettings("p@s$")));
7 archive.CreateEntry("alice29.txt", source1);
8 archive.Save(zipFile);
9 }
10 }Cifrar archivos con cifrado AES
Aspose.ZIP para .NET proporciona capacidades de cifrado para ayudarlo a proteger archivos confidenciales dentro de archivos. La API admite el cifrado AES y ofrece varios tamaños de clave (128 bits, 192 bits y 256 bits) para distintos niveles de seguridad. Con estos métodos de cifrado, puede asegurarse de que sus datos estén bien protegidos y solo sean accesibles para usuarios autorizados.
Cifrado de archivos con AES128
Aspose.ZIP para .NET proporciona capacidades de cifrado para ayudarlo a proteger archivos confidenciales dentro de archivos. La API admite el cifrado AES y ofrece varios tamaños de clave (128 bits, 192 bits y 256 bits) para distintos niveles de seguridad. Con estos métodos de cifrado, puede asegurarse de que sus datos estén bien protegidos y solo sean accesibles para usuarios autorizados. Aquí tienes un ejemplo de cómo se hace.
1 // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2 using (FileStream zipFile = File.Open(dataDir + "PasswordProtectWithAES128_out.zip", FileMode.Create))
3 {
4 using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
5 {
6 using (var archive = new Archive(new ArchiveEntrySettings(null, new AesEcryptionSettings("p@s$", EncryptionMethod.AES128))))
7 {
8 archive.CreateEntry("alice29.txt", source1);
9 archive.Save(zipFile);
10 }
11 }
12 }Cifrado de archivos con AES192
El cifrado AES192 ofrece un mayor nivel de seguridad en comparación con AES128, con una sobrecarga de cifrado ligeramente mayor. Este método es adecuado para escenarios donde se requiere una protección más fuerte sin comprometer demasiado el rendimiento. Consulte el siguiente ejemplo para comprender su uso.
1 // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2 using (FileStream zipFile = File.Open(dataDir + "PasswordProtectWithAES192_out.zip", FileMode.Create))
3 {
4 using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
5 {
6 using (var archive = new Archive(new ArchiveEntrySettings(null, new AesEcryptionSettings("p@s$", EncryptionMethod.AES192))))
7 {
8 archive.CreateEntry("alice29.txt", source1);
9 archive.Save(zipFile);
10 }
11 }
12 }Cifrado de archivos con AES256
AES256 es la opción de cifrado más potente disponible en la familia AES y proporciona la máxima seguridad. Es ideal para proteger datos altamente confidenciales donde se necesita la máxima seguridad, incluso si se requiere más potencia computacional para el cifrado y descifrado. Vea el ejemplo a continuación.
1 // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2 using (FileStream zipFile = File.Open(dataDir + "PasswordProtectWithAES256_out.zip", FileMode.Create))
3 {
4 using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
5 {
6 using (var archive = new Archive(new ArchiveEntrySettings(null, new AesEcryptionSettings("p@s$", EncryptionMethod.AES256))))
7 {
8 archive.CreateEntry("alice29.txt", source1);
9 archive.Save(zipFile);
10 }
11 }
12 }Directorio protegido con contraseña
Además de cifrar archivos individuales, Aspose.ZIP le permite proteger con contraseña directorios completos. Esto es particularmente útil cuando necesita cifrar varios archivos a la vez, protegiendo todo el contenido de un directorio con una única contraseña.
1// Para obtener ejemplos completos y archivos de datos, vaya a https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2usando (FileStream zipFile = File.Open(".\\all_corpus_encrypted_out.zip", FileMode.Create))
3{
4 DirectoryInfo corpus = new DirectoryInfo(".\\CanterburyCorpus");
5 usando (var archive = new Archive(new ArchiveEntrySettings(null, new TraditionalEncryptionSettings("p@s$"))))
6 {
7 archive.CreateEntries(corpus);
8 archivo.Guardar(zipFile);
9 }
10} Cifre varios archivos con técnicas de cifrado mixtasAPI también admite el uso de diferentes técnicas de cifrado dentro del mismo archivo. Esto le permite aplicar una combinación de algoritmos de cifrado, como AES y protección con contraseña tradicional, a diferentes archivos según su sensibilidad y requisitos de seguridad. Esta flexibilidad permite un control más granular sobre la protección de archivos dentro de un archivo. Eche un vistazo a este ejemplo para ver cómo funciona en la práctica.
1 // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2 using (FileStream zipFile = File.Open(dataDir + "CompressWithTraditionalEncryption_out.zip", FileMode.Create))
3 {
4 using (FileStream source1 = File.Open(dataDir + "alice29.txt", FileMode.Open, FileAccess.Read))
5 {
6 var archive = new Archive(new ArchiveEntrySettings(null, new TraditionalEncryptionSettings("p@s$")));
7 archive.CreateEntry("alice29.txt", source1);
8 archive.Save(zipFile);
9 }
10 }Descompresión de archivos protegidos con contraseña
Después de cifrar archivos, también necesitará saber cómo descifrarlos y extraerlos cuando sea necesario. Aspose.ZIP simplifica la descompresión de archivos protegidos con contraseña, independientemente de si se utilizó cifrado tradicional o AES. Puede extraer archivos individualmente o descomprimir un directorio cifrado completo.
Descompresión de archivos tradicionalmente protegidos con contraseña
Extraiga fácilmente archivos que han sido protegidos con una contraseña tradicional. Este método maneja archivos protegidos mediante técnicas de cifrado más antiguas, lo que garantiza el acceso a sus datos una vez que se proporciona la contraseña correcta.
1 // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2 using (FileStream fs = File.OpenRead(dataDir + "CompressWithTraditionalEncryption_out.zip"))
3 {
4 using (var extracted = File.Create(dataDir + "alice_extracted_out.txt"))
5 {
6 using (Archive archive = new Archive(fs, new ArchiveLoadOptions() { DecryptionPassword = "p@s$" }))
7 {
8 using (var decompressed = archive.Entries[0].Open())
9 {
10 byte[] b = new byte[8192];
11 int bytesRead;
12 while (0 < (bytesRead = decompressed.Read(b, 0, b.Length)))
13 {
14 extracted.Write(b, 0, bytesRead);
15 }
16 }
17 }
18 }
19 }Descomprimir archivos cifrados AES
Esta sección cubre cómo extraer archivos cifrados mediante AES, uno de los estándares de cifrado más seguros. Ya sea que esté tratando con AES128, AES192 o AES256, el proceso de extracción es sencillo siempre que se proporcione la clave de descifrado correcta.
1 // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2 using (FileStream fs = File.OpenRead(dataDir + "PasswordProtectWithAES256_out.zip"))
3 {
4 using (var extracted = File.Create(dataDir + "alice_aesextracted_out.txt"))
5 {
6 using (Archive archive = new Archive(fs))
7 {
8 using (var decompressed = archive.Entries[0].Open("p@s$"))
9 {
10 byte[] b = new byte[8192];
11 int bytesRead;
12 while (0 < (bytesRead = decompressed.Read(b, 0, b.Length)))
13 {
14 extracted.Write(b, 0, bytesRead);
15 }
16 }
17 }
18 }
19 }Descomprimir el archivo almacenado cifrado AES
Extraiga archivos de un archivo que haya sido cifrado y almacenado sin compresión. Este proceso garantiza que incluso los archivos sin comprimir permanezcan seguros, protegiendo los datos confidenciales y manteniendo la estructura del archivo original.
1 // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2 using (FileStream fs = File.OpenRead(dataDir + "StoreMutlipleFilesWithoutCompressionWithPassword_out.zip"))
3 {
4 using (var extracted = File.Create(dataDir + "alice_aesextracted_out.txt"))
5 {
6 using (Archive archive = new Archive(fs, new ArchiveLoadOptions() { DecryptionPassword = "p@s$" }))
7 {
8 using (var decompressed = archive.Entries[0].Open())
9 {
10 byte[] b = new byte[8192];
11 int bytesRead;
12 while (0 < (bytesRead = decompressed.Read(b, 0, b.Length)))
13 {
14 extracted.Write(b, 0, bytesRead);
15 }
16 }
17 }
18 }
19 }Descomprimir carpeta cifrada en directorio
Extraiga directorios cifrados completos a su estructura de carpetas original. Este proceso restaura todos los archivos del archivo cifrado a un directorio específico preservando al mismo tiempo su jerarquía y seguridad originales, siempre que se utilice la clave de descifrado correcta.
1 // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2 using (FileStream zipFile = File.Open(".\\all_corpus_encrypted.zip", FileMode.Open))
3 {
4 new Archive(zipFile, new ArchiveLoadOptions() { DecryptionPassword = "p@s$" }).ExtractToDirectory(".\\all_corpus_decrypted");
5 }Descomprimiendo archivos
Aspose.ZIP para .NET ofrece una API fácil de usar para descomprimir archivos, ya sea que contengan un solo archivo, varios archivos o incluso archivos almacenados sin compresión. Esta sección muestra varios escenarios de descompresión y proporciona soluciones eficientes para extraer sus datos comprimidos.
Descomprimir archivo con un solo archivo
En escenarios donde un archivo contiene solo un archivo, la descompresión es sencilla. Puede extraer el contenido del archivo rápidamente y con una sobrecarga mínima, asegurando la integridad de los datos originales usando el siguiente ejemplo:
1 // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2 using (FileStream fs = File.OpenRead(dataDir + "CompressSingleFile_out.zip"))
3 {
4 using (Archive archive = new Archive(fs))
5 {
6 int percentReady = 0;
7 archive.Entries[0].ExtractionProgressed += (s, e) =>
8 {
9 int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
10 if (percent > percentReady)
11 {
12 Console.WriteLine(string.Format("{0}% decompressed", percent));
13 percentReady = percent;
14 }
15 };
16 archive.Entries[0].Extract(dataDir + "alice_extracted_out.txt");
17 }
18 }Descomprimir archivo que tenga varios archivos
Cuando se trabaja con archivos que contienen varios archivos, nuestra API simplifica el proceso de iteración a través de las entradas y extraerlas de manera eficiente. El seguimiento del progreso basado en eventos durante la extracción es especialmente útil para monitorear grandes tareas de descompresión.
1 // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2 using (FileStream zipFile = File.Open(dataDir + "CompressMultipleFiles_out.zip", FileMode.Open))
3 {
4 StringBuilder sb = new StringBuilder("Entries are: ");
5 int percentReady = 0;
6 using (Archive archive = new Archive(zipFile,
7 new ArchiveLoadOptions()
8 {
9 EntryListed = (s, e) => { sb.AppendFormat("{0}, ", e.Entry.Name); },
10 EntryExtractionProgressed = (s, e) =>
11 {
12 int percent = (int)((100 * e.ProceededBytes) / ((ArchiveEntry)s).UncompressedSize);
13 if (percent > percentReady)
14 {
15 Console.WriteLine(string.Format("{0}% compressed", percent)); percentReady = percent;
16 }
17 }
18 }))
19 {
20 Console.WriteLine(sb.ToString(0, sb.Length - 2));
21 using (var extracted = File.Create(dataDir + "alice_extracted_out.txt"))
22 {
23 using (var decompressed = archive.Entries[0].Open())
24 {
25 byte[] buffer = new byte[8192];
26 int bytesRead;
27 while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
28 {
29 extracted.Write(buffer, 0, bytesRead);
30 }
31 // Read from decompressed stream to extracting file.
32 }
33 }
34 percentReady = 0;
35 archive.Entries[1].Extract(dataDir + "asyoulik_extracted_out.txt");
36 }
37 }Extraer archivo almacenado sin compresión
Los archivos almacenados, que contienen archivos que no han sido comprimidos, también son compatibles con la API Aspose.Zip. Si bien estos archivos no reducen el tamaño del archivo, permiten un acceso rápido y una extracción eficiente de los datos almacenados. Esto es útil cuando necesita empaquetar archivos sin cambiar su estructura.
1 // For complete examples and data files, please go to https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2 using (FileStream zipFile = File.Open(dataDir + "StoreMultipleFilesWithoutCompression_out.zip", FileMode.Open))
3 {
4 using (Archive archive = new Archive(zipFile))
5 {
6 using (var extracted = File.Create(dataDir + "alice_extracted_store_out.txt"))
7 {
8 using (var decompressed = archive.Entries[0].Open())
9 {
10 byte[] buffer = new byte[8192];
11 int bytesRead;
12 while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
13 {
14 extracted.Write(buffer, 0, bytesRead);
15 }
16 // Read from decompressed stream to extracting file.
17 }
18 }
19
20 using (var extracted = File.Create(dataDir + "asyoulik_extracted_store_out.txt"))
21 {
22 using (var decompressed = archive.Entries[1].Open())
23 {
24 byte[] buffer = new byte[8192];
25 int bytesRead;
26 while (0 < (bytesRead = decompressed.Read(buffer, 0, buffer.Length)))
27 {
28 extracted.Write(buffer, 0, bytesRead);
29 }
30 // Read from decompressed stream to extracting file.
31 }
32 }
33 }
34 }