Archives protégées par mot de passe
L’API Aspose.ZIP vous permet de compresser et décompresser des fichiers en C# ou dans n’importe quel langage .NET sans vous soucier de la structure des fichiers sous-jacents. Cet article fournit des exemples de mise en œuvre d’une protection par mot de passe avec des schémas de chiffrement traditionnels et AES. De plus, il montre comment travailler avec des répertoires et compresser plusieurs fichiers à l’aide de techniques de cryptage mixtes.
Protection par mot de passe avec cryptage traditionnel
Aspose.ZIP permet une protection par mot de passe traditionnelle pour les fichiers compressés. À l’aide d’un simple mot de passe, vous pouvez sécuriser des fichiers individuels ou des répertoires entiers dans une archive, garantissant ainsi que seuls les utilisateurs autorisés peuvent en extraire le contenu.
Cryptez les fichiers avec le schéma de cryptage traditionnel
Chiffrez les fichiers à l’aide d’une méthode de cryptage traditionnelle plus simple. Cette approche permet une protection de base par mot de passe des archives, garantissant que les fichiers sont compressés en toute sécurité tout en restant accessibles grâce à l’utilisation du mot de passe correct.
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 }Crypter les fichiers avec le cryptage AES
Aspose.ZIP pour .NET fournit des fonctionnalités de cryptage pour vous aider à sécuriser les fichiers sensibles dans les archives. L’API prend en charge le cryptage AES, offrant plusieurs tailles de clé (128 bits, 192 bits et 256 bits) pour différents niveaux de sécurité. Avec ces méthodes de cryptage, vous pouvez vous assurer que vos données sont bien protégées et accessibles uniquement aux utilisateurs autorisés.
Cryptage des fichiers avec AES128
Aspose.ZIP pour .NET fournit des fonctionnalités de cryptage pour vous aider à sécuriser les fichiers sensibles dans les archives. L’API prend en charge le cryptage AES, offrant plusieurs tailles de clé (128 bits, 192 bits et 256 bits) pour différents niveaux de sécurité. Avec ces méthodes de cryptage, vous pouvez vous assurer que vos données sont bien protégées et accessibles uniquement aux utilisateurs autorisés. Voici un exemple de la façon dont cela est fait.
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 }Cryptage des fichiers avec AES192
Le cryptage AES192 offre un niveau de sécurité plus élevé que l’AES128, avec une surcharge de cryptage légèrement accrue. Cette méthode convient aux scénarios dans lesquels une protection plus forte est requise sans trop compromettre les performances. Consultez l’exemple suivant pour comprendre son utilisation.
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 }Cryptage des fichiers avec AES256
AES256 est l’option de cryptage la plus puissante disponible dans la famille AES, offrant une sécurité maximale. Il est idéal pour protéger les données hautement sensibles où la plus grande sécurité est nécessaire, même si cela nécessite plus de puissance de calcul pour le cryptage et le déchiffrement. Voir l’exemple ci-dessous.
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 }Répertoire protégé par mot de passe
En plus de chiffrer des fichiers individuels, Aspose.ZIP vous permet de protéger par mot de passe des répertoires entiers. Ceci est particulièrement utile lorsque vous devez chiffrer plusieurs fichiers à la fois, en sécurisant tout le contenu d’un répertoire sous un seul mot de passe.
1// Pour des exemples complets et des fichiers de données, veuillez vous rendre sur https://github.com/aspose-zip/Aspose.ZIP-for-.NET
2en utilisant (FileStream zipFile = File.Open(".\\all_corpus_encrypted_out.zip", FileMode.Create))
3{
4 Corpus DirectoryInfo = new DirectoryInfo(".\\CanterburyCorpus");
5 using (var archive = new Archive(new ArchiveEntrySettings(null, new TraditionalEncryptionSettings("p@s$"))))
6 {
7 archive.CreateEntries(corpus);
8 archive.Save(zipFile);
9 }
10} Cryptez plusieurs fichiers avec des techniques de cryptage mixtesL’API prend également en charge l’utilisation de différentes techniques de cryptage au sein de la même archive. Cela vous permet d’appliquer un mélange d’algorithmes de chiffrement, tels que AES et la protection par mot de passe traditionnelle, à différents fichiers en fonction de leurs exigences de sensibilité et de sécurité. Cette flexibilité permet un contrôle plus granulaire de la protection des fichiers au sein d’une archive. Jetez un œil à cet exemple pour voir comment cela fonctionne dans la pratique.
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 }Décompression des fichiers protégés par mot de passe
Après avoir chiffré les archives, vous devrez également savoir comment décrypter et extraire des fichiers en cas de besoin. Aspose.ZIP simplifie la décompression des archives protégées par mot de passe, que le cryptage traditionnel ou AES ait été utilisé. Vous pouvez extraire des fichiers individuellement ou décompresser un répertoire crypté entier.
Décompression des archives traditionnellement protégées par mot de passe
Extrayez facilement les fichiers protégés par un mot de passe traditionnel. Cette méthode gère les archives sécurisées à l’aide d’anciennes techniques de cryptage, garantissant l’accès à vos données une fois le mot de passe correct fourni.
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 }Décompresser les archives cryptées AES
Cette section explique comment extraire des fichiers cryptés à l’aide d’AES, l’une des normes de cryptage les plus sécurisées. Que vous ayez affaire à AES128, AES192 ou AES256, le processus d’extraction est simple tant que la clé de déchiffrement correcte est fournie.
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 }Décompresser les archives stockées cryptées AES
Extrayez des fichiers d’une archive qui a été cryptée et stockée sans compression. Ce processus garantit que même les fichiers non compressés restent sécurisés, protégeant les données sensibles tout en conservant la structure des fichiers d’origine.
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 }Décompresser le dossier crypté dans le répertoire
Extrayez des répertoires cryptés entiers dans leur structure de dossiers d’origine. Ce processus restaure tous les fichiers de l’archive cryptée dans un répertoire spécifié tout en préservant leur hiérarchie et leur sécurité d’origine, à condition que la clé de déchiffrement correcte soit utilisée.
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 }Décompression des archives
Aspose.ZIP pour .NET propose une API facile à utiliser pour décompresser les archives, qu’elles contiennent un seul fichier, plusieurs fichiers ou même des fichiers stockés sans compression. Cette section présente divers scénarios de décompression, fournissant des solutions efficaces pour extraire vos données compressées.
** Décompresser l’archive ayant un seul fichier **
Dans les scénarios où une archive ne contient qu’un seul fichier, la décompression est simple. Vous pouvez extraire le contenu de l’archive rapidement et avec une surcharge minimale, garantissant ainsi l’intégrité des données d’origine à l’aide de l’exemple suivant :
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 }** Décompresser l’archive contenant plusieurs fichiers **
Lorsque vous travaillez avec des archives contenant plusieurs fichiers, notre API simplifie le processus d’itération des entrées et de leur extraction efficace. Le suivi de la progression basé sur les événements pendant l’extraction est particulièrement utile pour surveiller les tâches de décompression volumineuses.
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 }Extraire les archives stockées sans compression
Les archives stockées, qui contiennent des fichiers qui n’ont pas été compressés, sont également prises en charge par l’API Aspose.Zip. Bien que ces archives ne réduisent pas la taille des fichiers, elles permettent un accès rapide et une extraction efficace des données stockées. Ceci est utile lorsque vous devez regrouper des fichiers sans modifier leur structure.
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 }