964 lines
38 KiB
C#
964 lines
38 KiB
C#
// WinZipAesTests.cs
|
|
// ------------------------------------------------------------------
|
|
//
|
|
// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
|
|
// All rights reserved.
|
|
//
|
|
// This code module is part of DotNetZip, a zipfile class library.
|
|
//
|
|
// ------------------------------------------------------------------
|
|
//
|
|
// This code is licensed under the Microsoft Public License.
|
|
// See the file License.txt for the license details.
|
|
// More info on: http://dotnetzip.codeplex.com
|
|
//
|
|
// ------------------------------------------------------------------
|
|
//
|
|
// last saved (in emacs):
|
|
// Time-stamp: <2011-July-13 21:25:38>
|
|
//
|
|
// ------------------------------------------------------------------
|
|
//
|
|
// This module defines the tests of the WinZIP AES Encryption capability
|
|
// of DotNetZip.
|
|
//
|
|
// ------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Collections.Generic;
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
|
|
using Ionic.Zip;
|
|
using Ionic.Zip.Tests.Utilities;
|
|
|
|
namespace Ionic.Zip.Tests.WinZipAes
|
|
{
|
|
/// <summary>
|
|
/// Summary description for WinZipAesTests
|
|
/// </summary>
|
|
[TestClass]
|
|
public class WinZipAesTests : IonicTestClass
|
|
{
|
|
public WinZipAesTests() : base() { }
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_CreateZip()
|
|
{
|
|
WZA_CreateZip_Impl("WZA_CreateZip", 14400, 5000);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void WZA_CreateZip_VerySmallFiles()
|
|
{
|
|
WZA_CreateZip_Impl("WZA_CreateZip_VerySmallFiles", 14, 5);
|
|
}
|
|
|
|
|
|
|
|
private void WZA_CreateZip_Impl(string name, int size1, int size2)
|
|
{
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip! [WZA_CreateZip_Impl]");
|
|
|
|
string filename = null;
|
|
int entries = _rnd.Next(11) + 8;
|
|
var checksums = new Dictionary<string, string>();
|
|
var filesToZip = new List<string>();
|
|
for (int i = 0; i < entries; i++)
|
|
{
|
|
int filesize = _rnd.Next(size1) + size2;
|
|
if (_rnd.Next(2) == 1)
|
|
{
|
|
filename = Path.Combine(TopLevelDir, String.Format("Data{0}.bin", i));
|
|
TestUtilities.CreateAndFillFileBinary(filename, filesize);
|
|
}
|
|
else
|
|
{
|
|
filename = Path.Combine(TopLevelDir, String.Format("Data{0}.txt", i));
|
|
TestUtilities.CreateAndFillFileText(filename, filesize);
|
|
}
|
|
|
|
var chk = TestUtilities.ComputeChecksum(filename);
|
|
checksums.Add(Path.GetFileName(filename), TestUtilities.CheckSumToString(chk));
|
|
filesToZip.Add(filename);
|
|
}
|
|
|
|
|
|
Ionic.Zip.EncryptionAlgorithm[] EncOptions = {
|
|
EncryptionAlgorithm.None,
|
|
EncryptionAlgorithm.WinZipAes256,
|
|
EncryptionAlgorithm.WinZipAes128,
|
|
EncryptionAlgorithm.PkzipWeak
|
|
};
|
|
|
|
for (int k = 0; k < EncOptions.Length; k++)
|
|
{
|
|
|
|
for (int m = 0; m < 2; m++)
|
|
{
|
|
//string password = TestUtilities.GenerateRandomPassword();
|
|
string password = Path.GetRandomFileName().Replace(".", "-");
|
|
Directory.SetCurrentDirectory(TopLevelDir);
|
|
TestContext.WriteLine("\n\n==================Trial {0}.{1}..", k, m);
|
|
string zipFileToCreate = Path.Combine(TopLevelDir, String.Format("{0}-{1}-{2}.zip", name, k, m));
|
|
|
|
TestContext.WriteLine("Creating file {0}", zipFileToCreate);
|
|
TestContext.WriteLine(" Password: {0}", password);
|
|
TestContext.WriteLine(" Encryption: {0}", EncOptions[k].ToString());
|
|
TestContext.WriteLine(" NonSeekable output: {0}", (m == 0) ? "No" : "Yes");
|
|
TestContext.WriteLine(" #entries: {0}", entries);
|
|
|
|
string comment = String.Format("This archive uses Encryption: {0}, password({1}), NonSeekable=({2})",
|
|
EncOptions[k], password, (m == 0) ? "No" : "Yes");
|
|
|
|
_DotNetZip_CreateZip(filesToZip, EncOptions[k], password, comment, zipFileToCreate, (m==1));
|
|
|
|
if (EncOptions[k] == EncryptionAlgorithm.None)
|
|
BasicVerifyZip(zipFileToCreate);
|
|
else
|
|
BasicVerifyZip(zipFileToCreate, password);
|
|
|
|
|
|
TestContext.WriteLine("---------------Reading {0}...", zipFileToCreate);
|
|
System.Threading.Thread.Sleep(1200); // seems to be a race condition? sometimes?
|
|
using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
|
|
{
|
|
string extractDir = String.Format("extract-{0}.{1}", k, m);
|
|
foreach (var e in zip2)
|
|
{
|
|
TestContext.WriteLine(" Entry: {0} c({1}) unc({2})", e.FileName, e.CompressedSize, e.UncompressedSize);
|
|
Assert.AreEqual<EncryptionAlgorithm>(EncOptions[k], e.Encryption);
|
|
e.ExtractWithPassword(extractDir, password);
|
|
filename = Path.Combine(extractDir, e.FileName);
|
|
string actualCheckString = TestUtilities.CheckSumToString(TestUtilities.ComputeChecksum(filename));
|
|
Assert.IsTrue(checksums.ContainsKey(e.FileName), "Checksum is missing");
|
|
Assert.AreEqual<string>(checksums[e.FileName], actualCheckString, "Checksums for ({0}) do not match.", e.FileName);
|
|
TestContext.WriteLine(" Checksums match ({0}).\n", actualCheckString);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void _DotNetZip_CreateZip(List<string> filesToZip,
|
|
EncryptionAlgorithm encryption,
|
|
string password,
|
|
string comment,
|
|
string zipFileToCreate,
|
|
bool nonSeekable)
|
|
{
|
|
// Want to test the library when saving to non-seekable output streams. Like
|
|
// stdout or ASPNET's Response.OutputStream. This simulates it.
|
|
if (nonSeekable)
|
|
{
|
|
using (var outStream = new Ionic.Zip.Tests.NonSeekableOutputStream(File.Create(zipFileToCreate)))
|
|
{
|
|
using (ZipFile zip1 = new ZipFile())
|
|
{
|
|
zip1.Encryption = encryption;
|
|
if (zip1.Encryption != EncryptionAlgorithm.None)
|
|
zip1.Password = password;
|
|
|
|
zip1.AddFiles(filesToZip, "");
|
|
zip1.Comment = comment;
|
|
zip1.Save(outStream);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
using (ZipFile zip1 = new ZipFile())
|
|
{
|
|
zip1.Encryption = encryption;
|
|
if (zip1.Encryption != EncryptionAlgorithm.None)
|
|
zip1.Password = password;
|
|
|
|
zip1.AddFiles(filesToZip, "");
|
|
zip1.Comment = comment;
|
|
zip1.Save(zipFileToCreate);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
[TestMethod]
|
|
[ExpectedException(typeof(Ionic.Zip.BadPasswordException))]
|
|
public void WZA_CreateZip_NoPassword()
|
|
{
|
|
string zipFileToCreate = "WZA_CreateZip_NoPassword.zip";
|
|
TestContext.WriteLine("Creating file {0}", zipFileToCreate);
|
|
int entries = _rnd.Next(11) + 8;
|
|
|
|
string filename = null;
|
|
var checksums = new Dictionary<string, string>();
|
|
using (ZipFile zip1 = new ZipFile())
|
|
{
|
|
zip1.Encryption = EncryptionAlgorithm.WinZipAes256;
|
|
for (int i = 0; i < entries; i++)
|
|
{
|
|
if (_rnd.Next(2) == 1)
|
|
{
|
|
filename = Path.Combine(TopLevelDir, String.Format("Data{0}.bin", i));
|
|
int filesize = _rnd.Next(144000) + 5000;
|
|
TestUtilities.CreateAndFillFileBinary(filename, filesize);
|
|
}
|
|
else
|
|
{
|
|
filename = Path.Combine(TopLevelDir, String.Format("Data{0}.txt", i));
|
|
int filesize = _rnd.Next(144000) + 5000;
|
|
TestUtilities.CreateAndFillFileText(filename, filesize);
|
|
}
|
|
zip1.AddFile(filename, "");
|
|
|
|
var chk = TestUtilities.ComputeChecksum(filename);
|
|
checksums.Add(Path.GetFileName(filename), TestUtilities.CheckSumToString(chk));
|
|
}
|
|
|
|
zip1.Comment = String.Format("This archive uses Encryption: {0}, no password!", zip1.Encryption);
|
|
// With no password, we expect no encryption in the output.
|
|
zip1.Save(zipFileToCreate);
|
|
}
|
|
|
|
#if NOT
|
|
WinzipVerify(zipFileToCreate);
|
|
|
|
// validate all the checksums
|
|
using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
|
|
{
|
|
foreach (ZipEntry e in zip2)
|
|
{
|
|
if (!e.IsDirectory)
|
|
{
|
|
e.Extract("unpack");
|
|
string PathToExtractedFile = Path.Combine("unpack", e.FileName);
|
|
|
|
Assert.IsTrue(e.Encryption == EncryptionAlgorithm.None);
|
|
Assert.IsTrue(checksums.ContainsKey(e.FileName));
|
|
|
|
// verify the checksum of the file is correct
|
|
string expectedCheckString = checksums[e.FileName];
|
|
string actualCheckString = TestUtilities.CheckSumToString(TestUtilities.ComputeChecksum(PathToExtractedFile));
|
|
Assert.AreEqual<String>(expectedCheckString, actualCheckString, "Unexpected checksum on extracted filesystem file ({0}).", PathToExtractedFile);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_CreateZip_DirectoriesOnly()
|
|
{
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip! [WZA_CreateZip_DirectoriesOnly]");
|
|
|
|
string zipFileToCreate = "WZA_CreateZip_DirectoriesOnly.zip";
|
|
Assert.IsFalse(File.Exists(zipFileToCreate));
|
|
|
|
string password = TestUtilities.GenerateRandomPassword();
|
|
string dirToZip = Path.Combine(TopLevelDir, "zipthis");
|
|
Directory.CreateDirectory(dirToZip);
|
|
|
|
int entries = 0;
|
|
int subdirCount = _rnd.Next(8) + 8;
|
|
|
|
TestContext.WriteLine("Creating file {0}", zipFileToCreate);
|
|
TestContext.WriteLine(" Password: {0}", password);
|
|
TestContext.WriteLine(" #directories: {0}", subdirCount);
|
|
|
|
for (int i = 0; i < subdirCount; i++)
|
|
{
|
|
string subdir = Path.Combine(dirToZip, "EmptyDir" + i);
|
|
Directory.CreateDirectory(subdir);
|
|
}
|
|
|
|
using (ZipFile zip1 = new ZipFile())
|
|
{
|
|
zip1.Encryption = EncryptionAlgorithm.WinZipAes256;
|
|
zip1.Password = password;
|
|
zip1.AddDirectory(Path.GetFileName(dirToZip));
|
|
zip1.Save(zipFileToCreate);
|
|
}
|
|
|
|
BasicVerifyZip(zipFileToCreate, password);
|
|
|
|
Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), entries);
|
|
}
|
|
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_CreateZip_ZeroLengthFiles_256()
|
|
{
|
|
string password = TestUtilities.GenerateRandomPassword(12);
|
|
_Internal_CreateZip_ZeroLengthFiles(password, EncryptionAlgorithm.WinZipAes256);
|
|
}
|
|
[TestMethod]
|
|
public void WZA_CreateZip_ZeroLengthFiles_128()
|
|
{
|
|
string password = TestUtilities.GenerateRandomPassword(12);
|
|
_Internal_CreateZip_ZeroLengthFiles(password, EncryptionAlgorithm.WinZipAes128);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void WZA_CreateZip_ZeroLengthFiles_NoPassword_256()
|
|
{
|
|
_Internal_CreateZip_ZeroLengthFiles(null, EncryptionAlgorithm.WinZipAes256);
|
|
}
|
|
[TestMethod]
|
|
public void WZA_CreateZip_ZeroLengthFiles_NoPassword_128()
|
|
{
|
|
_Internal_CreateZip_ZeroLengthFiles(null, EncryptionAlgorithm.WinZipAes128);
|
|
}
|
|
|
|
public void _Internal_CreateZip_ZeroLengthFiles(string password, EncryptionAlgorithm algorithm)
|
|
{
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip! [_Internal_CreateZip_ZeroLengthFiles]");
|
|
|
|
string zipFileToCreate = "WZA_CreateZip_ZeroLengthFiles.zip";
|
|
Assert.IsFalse(File.Exists(zipFileToCreate));
|
|
|
|
TestContext.WriteLine("Creating file {0}", zipFileToCreate);
|
|
TestContext.WriteLine(" Password: {0}", password);
|
|
|
|
// create a bunch of zero-length files
|
|
int entries = _rnd.Next(21) + 5;
|
|
int i;
|
|
string[] filesToZip = new string[entries];
|
|
for (i = 0; i < entries; i++)
|
|
filesToZip[i] = TestUtilities.CreateUniqueFile("zerolength", TopLevelDir);
|
|
|
|
using (ZipFile zip = new ZipFile())
|
|
{
|
|
zip.Encryption = algorithm;
|
|
zip.Password = password;
|
|
zip.AddFiles(filesToZip);
|
|
zip.Save(zipFileToCreate);
|
|
}
|
|
|
|
BasicVerifyZip(zipFileToCreate, password);
|
|
|
|
Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate),
|
|
filesToZip.Length);
|
|
}
|
|
|
|
|
|
|
|
private void WinzipCreate(string zipfile, string fileOrDir, string encryptionArg, string password)
|
|
{
|
|
string[] files = { fileOrDir };
|
|
WinzipCreate(zipfile, files, encryptionArg, password);
|
|
}
|
|
|
|
private void WinzipCreate(string zipfile, IEnumerable<string> files, string encryptionArg, string password)
|
|
{
|
|
string args = null;
|
|
if (password == null)
|
|
{
|
|
args = String.Format("-a -whs {0}", zipfile);
|
|
}
|
|
else
|
|
{
|
|
args = String.Format("-a -whs -s\"{0}\" {1} {2}", password, encryptionArg, zipfile);
|
|
}
|
|
|
|
// This had better not be too long a list, otherwise the cmd
|
|
// line length limit will be exceeded. To avoid that, could
|
|
// use directory names, but.... for now let's just hope.
|
|
foreach (var f in files)
|
|
args += " " + f;
|
|
|
|
string wzzipOut = this.Exec(wzzip, args);
|
|
TestContext.WriteLine(wzzipOut);
|
|
}
|
|
|
|
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_ReadEncryptedZips()
|
|
{
|
|
_Internal_ReadEncryptedZips(true);
|
|
}
|
|
|
|
|
|
[TestMethod]
|
|
[ExpectedException(typeof(Ionic.Zip.BadPasswordException))]
|
|
public void WZA_ReadZip_Fail_BadPassword()
|
|
{
|
|
_Internal_ReadEncryptedZips(false);
|
|
}
|
|
|
|
|
|
private void _Internal_ReadEncryptedZips(bool correctPw)
|
|
{
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip!");
|
|
|
|
string[] cryptoArg = new string[] { "-ycAES128", "-ycAES256", };
|
|
for (int m = 0; m < cryptoArg.Length; m++)
|
|
{
|
|
Directory.SetCurrentDirectory(TopLevelDir);
|
|
|
|
// get a set of files to zip up
|
|
string subdir = Path.Combine(TopLevelDir, "files" + m);
|
|
string[] filesToZip;
|
|
Dictionary<string, byte[]> checksums;
|
|
Compatibility.CreateFilesAndChecksums(subdir, out filesToZip, out checksums);
|
|
string password = TestUtilities.GenerateRandomPassword();
|
|
string[] dirsToZip = new string[]
|
|
{
|
|
subdir + "\\*.*",
|
|
};
|
|
string zipFileToCreate = String.Format("WZA_ReadZips-{0}.zip", m);
|
|
WinzipCreate(zipFileToCreate, dirsToZip, cryptoArg[m], password);
|
|
|
|
_Internal_ReadZip(zipFileToCreate, (correctPw) ? password : null, filesToZip.Length);
|
|
}
|
|
}
|
|
|
|
|
|
[TestMethod]
|
|
[ExpectedException(typeof(Ionic.Zip.BadPasswordException))]
|
|
public void WZA_ReadZip_Fail_NoPassword_128()
|
|
{
|
|
string password = TestUtilities.GenerateRandomPassword();
|
|
GenerateFiles_CreateZip("-ycAES128", password, 1);
|
|
}
|
|
|
|
[TestMethod]
|
|
[ExpectedException(typeof(Ionic.Zip.BadPasswordException))]
|
|
public void WZA_ReadZip_Fail_NoPassword_256()
|
|
{
|
|
string password = TestUtilities.GenerateRandomPassword();
|
|
GenerateFiles_CreateZip("-ycAES256", password, 1);
|
|
}
|
|
|
|
[TestMethod]
|
|
[ExpectedException(typeof(Ionic.Zip.BadPasswordException))]
|
|
public void WZA_ReadZip_Fail_WrongPassword()
|
|
{
|
|
string password = TestUtilities.GenerateRandomPassword();
|
|
GenerateFiles_CreateZip("-ycAES256", password, 2);
|
|
}
|
|
|
|
[TestMethod]
|
|
[ExpectedException(typeof(Ionic.Zip.BadPasswordException))]
|
|
public void WZA_ReadZip_Fail_WrongMethod()
|
|
{
|
|
string password = TestUtilities.GenerateRandomPassword();
|
|
GenerateFiles_CreateZip("-ycAES256", password, 3);
|
|
}
|
|
|
|
|
|
public void GenerateFiles_CreateZip(string cryptoArg, string password, int pwFlavor)
|
|
{
|
|
// This method generates files, then zips them up using WinZip, then tries
|
|
// to unzip using DotNetZip. It is parameterized to test both success and
|
|
// failure cases. If pwFlavor is zero, then it uses the correct password to
|
|
// unzip, and everything should work. If pwFlavor is non-zero then it uses
|
|
// some incorrect password, either null or a bogus string, and generates a failure.
|
|
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip! [GenerateFiles_CreateZip]");
|
|
|
|
Directory.SetCurrentDirectory(TopLevelDir);
|
|
// get a set of files to zip up
|
|
string subdir = Path.Combine(TopLevelDir, "files");
|
|
|
|
string[] filesToZip = TestUtilities.GenerateFilesFlat(subdir);
|
|
string zipFileToCreate = "GenerateFiles_CreateZip.zip";
|
|
|
|
WinzipCreate(zipFileToCreate, subdir, cryptoArg, password);
|
|
|
|
string pwForReading = (pwFlavor == 0)
|
|
? password
|
|
: (pwFlavor == 1)
|
|
? null
|
|
: (pwFlavor == 2)
|
|
? "-wrongpassword-"
|
|
: TestUtilities.GenerateRandomPassword();
|
|
|
|
_Internal_ReadZip(zipFileToCreate, pwForReading, filesToZip.Length);
|
|
}
|
|
|
|
|
|
|
|
int zipCount = 0;
|
|
private void _Internal_ReadZip(string zipFileToRead, string password, int expectedFilesExtracted)
|
|
{
|
|
Directory.SetCurrentDirectory(TopLevelDir);
|
|
|
|
Assert.IsTrue(File.Exists(zipFileToRead), "The zip file '{0}' does not exist.", zipFileToRead);
|
|
|
|
// extract all the files
|
|
int actualFilesExtracted = 0;
|
|
string extractDir = String.Format("Extract{0}", zipCount++);
|
|
|
|
using (ZipFile zip2 = ZipFile.Read(zipFileToRead))
|
|
{
|
|
//zip2.Password = password;
|
|
foreach (ZipEntry e in zip2)
|
|
{
|
|
if (!e.IsDirectory)
|
|
{
|
|
if (password == "-null-")
|
|
e.Extract(extractDir);
|
|
else
|
|
e.ExtractWithPassword(extractDir, password);
|
|
actualFilesExtracted++;
|
|
}
|
|
}
|
|
}
|
|
Assert.AreEqual<int>(expectedFilesExtracted, actualFilesExtracted);
|
|
}
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_OneZeroByteFile_wi11131()
|
|
{
|
|
string zipF = "WZA_OneZeroByteFile_wi11131.zip";
|
|
TestContext.WriteLine("Create file {0}", zipF);
|
|
using (ZipFile zipFile = new ZipFile())
|
|
{
|
|
zipFile.Encryption = EncryptionAlgorithm.WinZipAes256;
|
|
zipFile.Password = TestUtilities.GenerateRandomPassword();
|
|
zipFile.AddEntry("dummy", new byte[0]);
|
|
using (var fs = File.Create(zipF))
|
|
{
|
|
zipFile.Save(fs);
|
|
}
|
|
}
|
|
|
|
BasicVerifyZip(zipF);
|
|
Assert.AreEqual<int>(1, TestUtilities.CountEntries(zipF));
|
|
}
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_CreateZip_NoCompression()
|
|
{
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip! [WZA_CreateZip_NoCompression]");
|
|
|
|
string zipFileToCreate = "WZA_CreateZip_NoCompression.zip";
|
|
string password = TestUtilities.GenerateRandomPassword();
|
|
|
|
TestContext.WriteLine("=======================================");
|
|
TestContext.WriteLine("Creating file {0}", zipFileToCreate);
|
|
TestContext.WriteLine(" Password: {0}", password);
|
|
int entries = _rnd.Next(21) + 5;
|
|
|
|
string filename = null;
|
|
var checksums = new Dictionary<string, string>();
|
|
using (ZipFile zip1 = new ZipFile())
|
|
{
|
|
zip1.Encryption = EncryptionAlgorithm.WinZipAes256;
|
|
zip1.Password = password;
|
|
zip1.CompressionLevel = Ionic.Zlib.CompressionLevel.None;
|
|
|
|
for (int i = 0; i < entries; i++)
|
|
{
|
|
if (_rnd.Next(2) == 1)
|
|
{
|
|
filename = Path.Combine(TopLevelDir, String.Format("Data{0}.bin", i));
|
|
int filesize = _rnd.Next(144000) + 5000;
|
|
TestUtilities.CreateAndFillFileBinary(filename, filesize);
|
|
}
|
|
else
|
|
{
|
|
filename = Path.Combine(TopLevelDir, String.Format("Data{0}.txt", i));
|
|
int filesize = _rnd.Next(144000) + 5000;
|
|
TestUtilities.CreateAndFillFileText(filename, filesize);
|
|
}
|
|
zip1.AddFile(filename, "");
|
|
|
|
var chk = TestUtilities.ComputeChecksum(filename);
|
|
checksums.Add(Path.GetFileName(filename), TestUtilities.CheckSumToString(chk));
|
|
}
|
|
|
|
zip1.Comment = String.Format("This archive uses Encryption({0}) password({1}) no compression.", zip1.Encryption, password);
|
|
zip1.Save(zipFileToCreate);
|
|
}
|
|
|
|
BasicVerifyZip(zipFileToCreate, password);
|
|
|
|
// validate all the checksums
|
|
using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
|
|
{
|
|
foreach (ZipEntry e in zip2)
|
|
{
|
|
if (!e.IsDirectory)
|
|
{
|
|
Assert.AreEqual<short>(0, (short)e.CompressionMethod);
|
|
e.ExtractWithPassword("unpack", password);
|
|
string PathToExtractedFile = Path.Combine("unpack", e.FileName);
|
|
Assert.IsTrue(checksums.ContainsKey(e.FileName));
|
|
|
|
// verify the checksum of the file is correct
|
|
string expectedCheckString = checksums[e.FileName];
|
|
string actualCheckString = TestUtilities.CheckSumToString(TestUtilities.ComputeChecksum(PathToExtractedFile));
|
|
Assert.AreEqual<String>(expectedCheckString, actualCheckString, "Unexpected checksum on extracted filesystem file ({0}).", PathToExtractedFile);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_CreateZip_EmptyPassword()
|
|
{
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip! [WZA_CreateZip_EmptyPassword]");
|
|
|
|
// Using a blank password, eh?
|
|
// Just what exactly is this *supposed* to do?
|
|
//
|
|
string zipFileToCreate = "WZA_CreateZip_EmptyPassword.zip";
|
|
string password = "";
|
|
|
|
TestContext.WriteLine("=======================================");
|
|
TestContext.WriteLine("Creating file {0}", zipFileToCreate);
|
|
TestContext.WriteLine(" Password: '{0}'", password);
|
|
int entries = _rnd.Next(21) + 5;
|
|
|
|
string filename = null;
|
|
var checksums = new Dictionary<string, string>();
|
|
using (ZipFile zip1 = new ZipFile())
|
|
{
|
|
zip1.Encryption = EncryptionAlgorithm.WinZipAes256;
|
|
zip1.Password = password;
|
|
|
|
for (int i = 0; i < entries; i++)
|
|
{
|
|
if (_rnd.Next(2) == 1)
|
|
{
|
|
filename = Path.Combine(TopLevelDir, String.Format("Data{0}.bin", i));
|
|
int filesize = _rnd.Next(144000) + 5000;
|
|
TestUtilities.CreateAndFillFileBinary(filename, filesize);
|
|
}
|
|
else
|
|
{
|
|
filename = Path.Combine(TopLevelDir, String.Format("Data{0}.txt", i));
|
|
int filesize = _rnd.Next(144000) + 5000;
|
|
TestUtilities.CreateAndFillFileText(filename, filesize);
|
|
}
|
|
zip1.AddFile(filename, "");
|
|
|
|
var chk = TestUtilities.ComputeChecksum(filename);
|
|
checksums.Add(Path.GetFileName(filename), TestUtilities.CheckSumToString(chk));
|
|
}
|
|
|
|
zip1.Comment = String.Format("This archive uses Encryption({0}) password({1}) no compression.", zip1.Encryption, password);
|
|
zip1.Save(zipFileToCreate);
|
|
}
|
|
|
|
BasicVerifyZip(zipFileToCreate, password);
|
|
|
|
// validate all the checksums
|
|
using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
|
|
{
|
|
foreach (ZipEntry e in zip2)
|
|
{
|
|
if (!e.IsDirectory)
|
|
{
|
|
e.ExtractWithPassword("unpack", password);
|
|
string PathToExtractedFile = Path.Combine("unpack", e.FileName);
|
|
Assert.IsTrue(checksums.ContainsKey(e.FileName));
|
|
|
|
// verify the checksum of the file is correct
|
|
string expectedCheckString = checksums[e.FileName];
|
|
string actualCheckString = TestUtilities.CheckSumToString(TestUtilities.ComputeChecksum(PathToExtractedFile));
|
|
Assert.AreEqual<String>(expectedCheckString, actualCheckString, "Unexpected checksum on extracted filesystem file ({0}).", PathToExtractedFile);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_RemoveEntryAndSave()
|
|
{
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip! [WZA_RemoveEntryAndSave]");
|
|
|
|
// make a few text files
|
|
string[] TextFiles = new string[5];
|
|
for (int i = 0; i < TextFiles.Length; i++)
|
|
{
|
|
TextFiles[i] = Path.Combine(TopLevelDir, String.Format("TextFile{0}.txt", i));
|
|
TestUtilities.CreateAndFillFileText(TextFiles[i], _rnd.Next(4000) + 5000);
|
|
}
|
|
TestContext.WriteLine(new String('=', 66));
|
|
TestContext.WriteLine("RemoveEntryAndSave()");
|
|
string password = Path.GetRandomFileName();
|
|
for (int k = 0; k < 2; k++)
|
|
{
|
|
TestContext.WriteLine(new String('-', 55));
|
|
TestContext.WriteLine("Trial {0}", k);
|
|
string zipFileToCreate = Path.Combine(TopLevelDir, String.Format("RemoveEntryAndSave-{0}.zip", k));
|
|
|
|
// create the zip: add some files, and Save() it
|
|
using (ZipFile zip = new ZipFile())
|
|
{
|
|
if (k == 1)
|
|
{
|
|
TestContext.WriteLine("Specifying a password...");
|
|
zip.Password = password;
|
|
zip.Encryption = EncryptionAlgorithm.WinZipAes256;
|
|
}
|
|
for (int i = 0; i < TextFiles.Length; i++)
|
|
zip.AddFile(TextFiles[i], "");
|
|
|
|
zip.AddEntry("Readme.txt", "This is the content of the file. Ho ho ho!");
|
|
TestContext.WriteLine("Save...");
|
|
zip.Save(zipFileToCreate);
|
|
}
|
|
|
|
if (k == 1)
|
|
BasicVerifyZip(zipFileToCreate, password);
|
|
|
|
// remove a file and re-Save
|
|
using (ZipFile zip2 = ZipFile.Read(zipFileToCreate))
|
|
{
|
|
int entryToRemove = _rnd.Next(TextFiles.Length);
|
|
TestContext.WriteLine("Removing an entry...: {0}", Path.GetFileName(TextFiles[entryToRemove]));
|
|
zip2.RemoveEntry(Path.GetFileName(TextFiles[entryToRemove]));
|
|
zip2.Save();
|
|
}
|
|
|
|
// Verify the files are in the zip
|
|
Assert.AreEqual<int>(TestUtilities.CountEntries(zipFileToCreate), TextFiles.Length,
|
|
String.Format("Trial {0}: The Zip file has the wrong number of entries.", k));
|
|
|
|
if (k == 1)
|
|
BasicVerifyZip(zipFileToCreate, password);
|
|
}
|
|
}
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_SmallBuffers_wi7967()
|
|
{
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip! [WZA_SmallBuffers_wi7967]");
|
|
|
|
Directory.SetCurrentDirectory(TopLevelDir);
|
|
|
|
string password = Path.GetRandomFileName() + Path.GetFileNameWithoutExtension(Path.GetRandomFileName());
|
|
|
|
int[] sizes = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 13, 21, 35, 93 };
|
|
for (int i = 0; i < sizes.Length; i++)
|
|
{
|
|
string zipFileToCreate = Path.Combine(TopLevelDir, String.Format("WZA_SmallBuffers_wi7967-{0}.zip", i));
|
|
//MemoryStream zippedStream = new MemoryStream();
|
|
byte[] buffer = new byte[sizes[i]];
|
|
_rnd.NextBytes(buffer);
|
|
MemoryStream source = new MemoryStream(buffer);
|
|
|
|
using (var zip = new ZipFile())
|
|
{
|
|
source.Seek(0, SeekOrigin.Begin);
|
|
zip.Password = password;
|
|
zip.Encryption = EncryptionAlgorithm.WinZipAes256;
|
|
zip.AddEntry(Path.GetRandomFileName(), source);
|
|
zip.Save(zipFileToCreate);
|
|
}
|
|
|
|
BasicVerifyZip(zipFileToCreate, password);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_InMemory_wi8493()
|
|
{
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip! [WZA_InMemory_wi8493]");
|
|
|
|
string password = Path.GetFileNameWithoutExtension(Path.GetRandomFileName());
|
|
|
|
using (MemoryStream ms = new MemoryStream())
|
|
{
|
|
for (int m = 0; m < 2; m++)
|
|
{
|
|
string zipFileToCreate =
|
|
String.Format("WZA_InMemory_wi8493-{0}.zip", m);
|
|
|
|
using (var zip = new ZipFile())
|
|
{
|
|
zip.Password = password;
|
|
zip.Encryption = EncryptionAlgorithm.WinZipAes256;
|
|
zip.AddEntry(Path.GetRandomFileName(), "Hello, World!");
|
|
if (m==1)
|
|
zip.Save(ms);
|
|
else
|
|
zip.Save(zipFileToCreate);
|
|
}
|
|
|
|
if (m==1)
|
|
File.WriteAllBytes(zipFileToCreate,ms.ToArray());
|
|
|
|
BasicVerifyZip(zipFileToCreate, password);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_InMemory_wi8493a()
|
|
{
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip! [WZA_InMemory_wi8493a]");
|
|
|
|
string zipFileToCreate = "WZA_InMemory_wi8493a.zip";
|
|
string password = Path.GetFileNameWithoutExtension(Path.GetRandomFileName());
|
|
|
|
string[] TextFiles = new string[25 + _rnd.Next(8)];
|
|
for (int i = 0; i < TextFiles.Length; i++)
|
|
{
|
|
TextFiles[i] = Path.Combine(TopLevelDir, String.Format("TextFile{0}.txt", i));
|
|
TestUtilities.CreateAndFillFileText(TextFiles[i], _rnd.Next(14000) + 13000);
|
|
}
|
|
|
|
using (MemoryStream ms = new MemoryStream())
|
|
{
|
|
using (var zip = new ZipFile())
|
|
{
|
|
zip.Password = password;
|
|
zip.Encryption = EncryptionAlgorithm.WinZipAes256;
|
|
zip.AddEntry("Readme.txt", "Hello, World! ABC ABC ABC ABC ABCDE ABC ABCDEF ABC ABCD");
|
|
zip.AddFiles(TextFiles, "files");
|
|
zip.Save(ms);
|
|
}
|
|
File.WriteAllBytes(zipFileToCreate,ms.ToArray());
|
|
|
|
BasicVerifyZip(zipFileToCreate, password);
|
|
}
|
|
}
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_MacCheck_ZeroLengthEntry_wi13892()
|
|
{
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip!");
|
|
|
|
// This zipfile has some zero-length entries. Previously
|
|
// DotNetZip was throwing a spurious MAC mismatch error on
|
|
// those zero-length entries.
|
|
string baseFileName = "wi13892.zip";
|
|
string extractDir = "extract";
|
|
string password = "C-XPSQ5-BRT5302-";
|
|
|
|
string sourceDir = CurrentDir;
|
|
for (int i = 0; i < 3; i++)
|
|
sourceDir = Path.GetDirectoryName(sourceDir);
|
|
|
|
string fqFileName = Path.Combine(Path.Combine(sourceDir,
|
|
"Zip Tests\\bin\\Debug\\zips"),
|
|
baseFileName);
|
|
|
|
TestContext.WriteLine("Reading zip file: '{0}'", fqFileName);
|
|
using (ZipFile zip = ZipFile.Read(fqFileName))
|
|
{
|
|
zip.Password = password;
|
|
foreach (ZipEntry e in zip)
|
|
{
|
|
TestContext.WriteLine("{1,-22} {2,9} {3,5:F0}% {4,9} {5,3} {6:X8} {0}",
|
|
e.FileName,
|
|
e.LastModified.ToString("yyyy-MM-dd HH:mm:ss"),
|
|
e.UncompressedSize,
|
|
e.CompressionRatio,
|
|
e.CompressedSize,
|
|
(e.UsesEncryption) ? "Y" : "N",
|
|
e.Crc);
|
|
e.Extract(extractDir);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
[TestMethod]
|
|
public void WZA_Update_SwitchCompression()
|
|
{
|
|
if (!WinZipIsPresent)
|
|
throw new Exception("no winzip! [WZA_Update_SwitchCompression]");
|
|
|
|
string zipFileToCreate = "WZA_Update_SwitchCompression.zip";
|
|
string password = TestUtilities.GenerateRandomPassword();
|
|
|
|
TestContext.WriteLine("=======================================");
|
|
TestContext.WriteLine("Creating file {0}", zipFileToCreate);
|
|
TestContext.WriteLine(" Password: {0}", password);
|
|
int entries = _rnd.Next(21) + 5;
|
|
|
|
string filename = null;
|
|
var checksums = new Dictionary<string, string>();
|
|
using (ZipFile zip1 = new ZipFile())
|
|
{
|
|
zip1.Encryption = EncryptionAlgorithm.WinZipAes256;
|
|
zip1.CompressionLevel = Ionic.Zlib.CompressionLevel.BestCompression;
|
|
zip1.Password = password;
|
|
|
|
for (int i = 0; i < entries; i++)
|
|
{
|
|
if (_rnd.Next(2) == 1)
|
|
{
|
|
filename = Path.Combine(TopLevelDir, String.Format("Data{0}.bin", i));
|
|
int filesize = _rnd.Next(144000) + 5000;
|
|
TestUtilities.CreateAndFillFileBinary(filename, filesize);
|
|
}
|
|
else
|
|
{
|
|
filename = Path.Combine(TopLevelDir, String.Format("Data{0}.txt", i));
|
|
int filesize = _rnd.Next(144000) + 5000;
|
|
TestUtilities.CreateAndFillFileText(filename, filesize);
|
|
}
|
|
zip1.AddFile(filename, "");
|
|
|
|
var chk = TestUtilities.ComputeChecksum(filename);
|
|
checksums.Add(Path.GetFileName(filename), TestUtilities.CheckSumToString(chk));
|
|
}
|
|
|
|
zip1.Comment = String.Format("This archive uses Encryption({0}) password({1}) no compression.", zip1.Encryption, password);
|
|
TestContext.WriteLine("{0}", zip1.Comment);
|
|
TestContext.WriteLine("Saving the zip...");
|
|
zip1.Save(zipFileToCreate);
|
|
}
|
|
|
|
BasicVerifyZip(zipFileToCreate, password);
|
|
|
|
TestContext.WriteLine("=======================================");
|
|
TestContext.WriteLine("Updating the zip file");
|
|
|
|
// Update the zip file
|
|
using (ZipFile zip = ZipFile.Read(zipFileToCreate))
|
|
{
|
|
for (int j = 0; j < 5; j++)
|
|
{
|
|
zip[j].Password = password;
|
|
zip[j].CompressionMethod = 0;
|
|
}
|
|
zip.Save(); // this should succeed
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|