using ICSharpCode.SharpZipLib.Checksum;

using ICSharpCode.SharpZipLib.Core;

using ICSharpCode.SharpZipLib.Encryption;

using ICSharpCode.SharpZipLib.Zip.Compression;

using ICSharpCode.SharpZipLib.Zip.Compression.Streams;

using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Security.Cryptography;

using System.Text;

namespace ICSharpCode.SharpZipLib.Zip

{

#region Keys Required Event Args

/// <summary>

/// Arguments used with KeysRequiredEvent

/// </summary>

public class KeysRequiredEventArgs : EventArgs

{

#region Constructors

/// <summary>

/// Initialise a new instance of <see cref="KeysRequiredEventArgs"></see>

/// </summary>

/// <param name="name">The name of the file for which keys are required.</param>

public KeysRequiredEventArgs(string name)

{

fileName = name;

}

/// <summary>

/// Initialise a new instance of <see cref="KeysRequiredEventArgs"></see>

/// </summary>

/// <param name="name">The name of the file for which keys are required.</param>

/// <param name="keyValue">The current key value.</param>

public KeysRequiredEventArgs(string name, byte[] keyValue)

{

fileName = name;

key = keyValue;

}

#endregion Constructors

#region Properties

/// <summary>

/// Gets the name of the file for which keys are required.

/// </summary>

public string FileName

{

get { return fileName; }

}

/// <summary>

/// Gets or sets the key value

/// </summary>

public byte[] Key

{

get => key;

set => key = value;

}

#endregion Properties

#region Instance Fields

private readonly string fileName;

private byte[] key;

#endregion Instance Fields

}

#endregion Keys Required Event Args

#region Test Definitions

/// <summary>

/// The strategy to apply to testing.

/// </summary>

public enum TestStrategy

{

/// <summary>

/// Find the first error only.

/// </summary>

FindFirstError,

/// <summary>

/// Find all possible errors.

/// </summary>

FindAllErrors,

}

/// <summary>

/// The operation in progress reported by a <see cref="ZipTestResultHandler"/> during testing.

/// </summary>

/// <seealso cref="ZipFile.TestArchive(bool)">TestArchive</seealso>

public enum TestOperation

{

/// <summary>

/// Setting up testing.

/// </summary>

Initialising,

/// <summary>

/// Testing an individual entries header

/// </summary>

EntryHeader,

/// <summary>

/// Testing an individual entries data

/// </summary>

EntryData,

/// <summary>

/// Testing an individual entry has completed.

/// </summary>

EntryComplete,

/// <summary>

/// Running miscellaneous tests

/// </summary>

MiscellaneousTests,

/// <summary>

/// Testing is complete

/// </summary>

Complete,

}

/// <summary>

/// Status returned by <see cref="ZipTestResultHandler"/> during testing.

/// </summary>

/// <seealso cref="ZipFile.TestArchive(bool)">TestArchive</seealso>

public class TestStatus

{

#region Constructors

/// <summary>

/// Initialise a new instance of <see cref="TestStatus"/>

/// </summary>

/// <param name="file">The <see cref="ZipFile"/> this status applies to.</param>

public TestStatus(ZipFile file)

{

file_ = file;

}

#endregion Constructors

#region Properties

/// <summary>

/// Get the current <see cref="TestOperation"/> in progress.

/// </summary>

public TestOperation Operation

{

get { return operation_; }

}

/// <summary>

/// Get the <see cref="ZipFile"/> this status is applicable to.

/// </summary>

public ZipFile File

{

get { return file_; }

}

/// <summary>

/// Get the current/last entry tested.

/// </summary>

public ZipEntry Entry

{

get { return entry_; }

}

/// <summary>

/// Get the number of errors detected so far.

/// </summary>

public int ErrorCount

{

get { return errorCount_; }

}

/// <summary>

/// Get the number of bytes tested so far for the current entry.

/// </summary>

public long BytesTested

{

get { return bytesTested_; }

}

/// <summary>

/// Get a value indicating whether the last entry test was valid.

/// </summary>

public bool EntryValid

{

get { return entryValid_; }

}

#endregion Properties

#region Internal API

internal void AddError()

{

errorCount_++;

entryValid_ = false;

}

internal void SetOperation(TestOperation operation)

{

operation_ = operation;

}

internal void SetEntry(ZipEntry entry)

{

entry_ = entry;

entryValid_ = true;

bytesTested_ = 0;

}

internal void SetBytesTested(long value)

{

bytesTested_ = value;

}

#endregion Internal API

#region Instance Fields

private readonly ZipFile file_;

private ZipEntry entry_;

private bool entryValid_;

private int errorCount_;

private long bytesTested_;

private TestOperation operation_;

#endregion Instance Fields

}

/// <summary>

/// Delegate invoked during <see cref="ZipFile.TestArchive(bool, TestStrategy, ZipTestResultHandler)">testing</see> if supplied indicating current progress and status.

/// </summary>

/// <remarks>If the message is non-null an error has occured. If the message is null

/// the operation as found in <see cref="TestStatus">status</see> has started.</remarks>

public delegate void ZipTestResultHandler(TestStatus status, string message);

#endregion Test Definitions

#region Update Definitions

/// <summary>

/// The possible ways of <see cref="ZipFile.CommitUpdate()">applying updates</see> to an archive.

/// </summary>

public enum FileUpdateMode

{

/// <summary>

/// Perform all updates on temporary files ensuring that the original file is saved.

/// </summary>

Safe,

/// <summary>

/// Update the archive directly, which is faster but less safe.

/// </summary>

Direct,

}

#endregion Update Definitions

#region ZipFile Class

/// <summary>

/// This class represents a Zip archive. You can ask for the contained

/// entries, or get an input stream for a file entry. The entry is

/// automatically decompressed.

///

/// You can also update the archive adding or deleting entries.

///

/// This class is thread safe for input: You can open input streams for arbitrary

/// entries in different threads.

/// <br/>

/// <br/>Author of the original java version : Jochen Hoenicke

/// </summary>

/// <example>

/// <code>

/// using System;

/// using System.Text;

/// using System.Collections;

/// using System.IO;

///

/// using ICSharpCode.SharpZipLib.Zip;

///

/// class MainClass

/// {

/// static public void Main(string[] args)

/// {

/// using (ZipFile zFile = new ZipFile(args[0])) {

/// Console.WriteLine("Listing of : " + zFile.Name);

/// Console.WriteLine("");

/// Console.WriteLine("Raw Size Size Date Time Name");

/// Console.WriteLine("-------- -------- -------- ------ ---------");

/// foreach (ZipEntry e in zFile) {

/// if ( e.IsFile ) {

/// DateTime d = e.DateTime;

/// Console.WriteLine("{0, -10}{1, -10}{2} {3} {4}", e.Size, e.CompressedSize,

/// d.ToString("dd-MM-yy"), d.ToString("HH:mm"),

/// e.Name);

/// }

/// }

/// }

/// }

/// }

/// </code>

/// </example>

public class ZipFile : IEnumerable, IDisposable

{

#region KeyHandling

/// <summary>

/// Delegate for handling keys/password setting during compression/decompression.

/// </summary>

public delegate void KeysRequiredEventHandler(

object sender,

KeysRequiredEventArgs e

);

/// <summary>

/// Event handler for handling encryption keys.

/// </summary>

public KeysRequiredEventHandler KeysRequired;

/// <summary>

/// Handles getting of encryption keys when required.

/// </summary>

/// <param name="fileName">The file for which encryption keys are required.</param>

private void OnKeysRequired(string fileName)

{

if (KeysRequired != null)

{

var krea = new KeysRequiredEventArgs(fileName, key);

KeysRequired(this, krea);

key = krea.Key;

}

}

/// <summary>

/// Password to be used for encrypting/decrypting files.

/// </summary>

/// <remarks>Set to null if no password is required.</remarks>

public string Password

{

set

{

key = string.IsNullOrEmpty(value) ? null : PkzipClassic.GenerateKeys(ZipStrings.ConvertToArray(value));

rawPassword_ = value;

}

}

/// <summary>

/// Get a value indicating whether encryption keys are currently available.

/// </summary>

private bool HaveKeys

{

get { return key != null; }

}

#endregion KeyHandling

#region Constructors

/// <summary>

/// Opens a Zip file with the given name for reading.

/// </summary>

/// <param name="name">The name of the file to open.</param>

/// <exception cref="ArgumentNullException">The argument supplied is null.</exception>

/// <exception cref="IOException">

/// An i/o error occurs

/// </exception>

/// <exception cref="ZipException">

/// The file doesn't contain a valid zip archive.

/// </exception>

public ZipFile(string name)

{

name_ = name ?? throw new ArgumentNullException(nameof(name));

baseStream_ = File.Open(name, FileMode.Open, FileAccess.Read, FileShare.Read);

isStreamOwner = true;

try

{

ReadEntries();

}

catch

{

DisposeInternal(true);

throw;

}

}

/// <summary>

/// Opens a Zip file reading the given <see cref="FileStream"/>.

/// </summary>

/// <param name="file">The <see cref="FileStream"/> to read archive data from.</param>

/// <exception cref="ArgumentNullException">The supplied argument is null.</exception>

/// <exception cref="IOException">

/// An i/o error occurs.

/// </exception>

/// <exception cref="ZipException">

/// The file doesn't contain a valid zip archive.

/// </exception>

public ZipFile(FileStream file) :

this(file, false)

{

}

/// <summary>

/// Opens a Zip file reading the given <see cref="FileStream"/>.

/// </summary>

/// <param name="file">The <see cref="FileStream"/> to read archive data from.</param>

/// <param name="leaveOpen">true to leave the <see cref="FileStream">file</see> open when the ZipFile is disposed, false to dispose of it</param>

/// <exception cref="ArgumentNullException">The supplied argument is null.</exception>

/// <exception cref="IOException">

/// An i/o error occurs.

/// </exception>

/// <exception cref="ZipException">

/// The file doesn't contain a valid zip archive.

/// </exception>

public ZipFile(FileStream file, bool leaveOpen)

{

if (file == null)

{

throw new ArgumentNullException(nameof(file));

}

if (!file.CanSeek)

{

throw new ArgumentException("Stream is not seekable", nameof(file));

}

baseStream_ = file;

name_ = file.Name;

isStreamOwner = !leaveOpen;

try

{

ReadEntries();

}

catch

{

DisposeInternal(true);

throw;

}

}

/// <summary>

/// Opens a Zip file reading the given <see cref="Stream"/>.

/// </summary>

/// <param name="stream">The <see cref="Stream"/> to read archive data from.</param>

/// <exception cref="IOException">

/// An i/o error occurs

/// </exception>

/// <exception cref="ZipException">

/// The stream doesn't contain a valid zip archive.<br/>

/// </exception>

/// <exception cref="ArgumentException">

/// The <see cref="Stream">stream</see> doesnt support seeking.

/// </exception>

/// <exception cref="ArgumentNullException">

/// The <see cref="Stream">stream</see> argument is null.

/// </exception>

public ZipFile(Stream stream) :

this(stream, false)

{

}

/// <summary>

/// Opens a Zip file reading the given <see cref="Stream"/>.

/// </summary>

/// <param name="stream">The <see cref="Stream"/> to read archive data from.</param>

/// <param name="leaveOpen">true to leave the <see cref="Stream">stream</see> open when the ZipFile is disposed, false to dispose of it</param>

/// <exception cref="IOException">

/// An i/o error occurs

/// </exception>

/// <exception cref="ZipException">

/// The stream doesn't contain a valid zip archive.<br/>

/// </exception>

/// <exception cref="ArgumentException">

/// The <see cref="Stream">stream</see> doesnt support seeking.

/// </exception>

/// <exception cref="ArgumentNullException">

/// The <see cref="Stream">stream</see> argument is null.

/// </exception>

public ZipFile(Stream stream, bool leaveOpen)

{

if (stream == null)

{

throw new ArgumentNullException(nameof(stream));

}

if (!stream.CanSeek)

{

throw new ArgumentException("Stream is not seekable", nameof(stream));

}

baseStream_ = stream;

isStreamOwner = !leaveOpen;

if (baseStream_.Length > 0)

{

try

{

ReadEntries();

}

catch

{

DisposeInternal(true);

throw;

}

}

else

{

entries_ = Empty.Array<ZipEntry>();

isNewArchive_ = true;

}

}

/// <summary>

/// Initialises a default <see cref="ZipFile"/> instance with no entries and no file storage.

/// </summary>

internal ZipFile()

{

entries_ = Empty.Array<ZipEntry>();

isNewArchive_ = true;

}

#endregion Constructors

#region Destructors and Closing

/// <summary>

/// Finalize this instance.

/// </summary>

~ZipFile()

{

Dispose(false);

}

/// <summary>

/// Closes the ZipFile. If the stream is <see cref="IsStreamOwner">owned</see> then this also closes the underlying input stream.

/// Once closed, no further instance methods should be called.

/// </summary>

/// <exception cref="IOException">

/// An i/o error occurs.

/// </exception>

public void Close()

{

DisposeInternal(true);

GC.SuppressFinalize(this);

}

#endregion Destructors and Closing

#region Creators

/// <summary>

/// Create a new <see cref="ZipFile"/> whose data will be stored in a file.

/// </summary>

/// <param name="fileName">The name of the archive to create.</param>

/// <returns>Returns the newly created <see cref="ZipFile"/></returns>

/// <exception cref="ArgumentNullException"><paramref name="fileName"></paramref> is null</exception>

public static ZipFile Create(string fileName)

{

if (fileName == null)

{

throw new ArgumentNullException(nameof(fileName));

}

FileStream fs = File.Create(fileName);

return new ZipFile

{

name_ = fileName,

baseStream_ = fs,

isStreamOwner = true

};

}

/// <summary>

/// Create a new <see cref="ZipFile"/> whose data will be stored on a stream.

/// </summary>

/// <param name="outStream">The stream providing data storage.</param>

/// <returns>Returns the newly created <see cref="ZipFile"/></returns>

/// <exception cref="ArgumentNullException"><paramref name="outStream"> is null</paramref></exception>

/// <exception cref="ArgumentException"><paramref name="outStream"> doesnt support writing.</paramref></exception>

public static ZipFile Create(Stream outStream)

{

if (outStream == null)

{

throw new ArgumentNullException(nameof(outStream));

}

if (!outStream.CanWrite)

{

throw new ArgumentException("Stream is not writeable", nameof(outStream));

}

if (!outStream.CanSeek)

{

throw new ArgumentException("Stream is not seekable", nameof(outStream));

}

var result = new ZipFile

{

baseStream_ = outStream

};

return result;

}

#endregion Creators

#region Properties

/// <summary>

/// Get/set a flag indicating if the underlying stream is owned by the ZipFile instance.

/// If the flag is true then the stream will be closed when <see cref="Close">Close</see> is called.

/// </summary>

/// <remarks>

/// The default value is true in all cases.

/// </remarks>

public bool IsStreamOwner

{

get => isStreamOwner;

set => isStreamOwner = value;

}

/// <summary>

/// Get a value indicating whether

/// this archive is embedded in another file or not.

/// </summary>

public bool IsEmbeddedArchive

{

// Not strictly correct in all circumstances currently

get { return offsetOfFirstEntry > 0; }

}

/// <summary>

/// Get a value indicating that this archive is a new one.

/// </summary>

public bool IsNewArchive

{

get { return isNewArchive_; }

}

/// <summary>

/// Gets the comment for the zip file.

/// </summary>

public string ZipFileComment

{

get { return comment_; }

}

/// <summary>

/// Gets the name of this zip file.

/// </summary>

public string Name

{

get { return name_; }

}

/// <summary>

/// Gets the number of entries in this zip file.

/// </summary>

/// <exception cref="InvalidOperationException">

/// The Zip file has been closed.

/// </exception>

[Obsolete("Use the Count property instead")]

public int Size

{

get

{

return entries_.Length;

}

}

/// <summary>

/// Get the number of entries contained in this <see cref="ZipFile"/>.

/// </summary>

public long Count

{

get

{

return entries_.Length;

}

}

/// <summary>

/// Indexer property for ZipEntries

/// </summary>

[System.Runtime.CompilerServices.IndexerName("EntryByIndex")]

public ZipEntry this[int index]

{

get

{

return (ZipEntry)entries_[index].Clone();

}

}

#endregion Properties

#region Input Handling

/// <summary>

/// Gets an enumerator for the Zip entries in this Zip file.

/// </summary>

/// <returns>Returns an <see cref="IEnumerator"/> for this archive.</returns>

/// <exception cref="ObjectDisposedException">

/// The Zip file has been closed.

/// </exception>

public IEnumerator GetEnumerator()

{

return isDisposed_ ? throw new ObjectDisposedException("ZipFile") : new ZipEntryEnumerator(entries_);

}

/// <summary>

/// Return the index of the entry with a matching name

/// </summary>

/// <param name="name">Entry name to find</param>

/// <param name="ignoreCase">If true the comparison is case insensitive</param>

/// <returns>The index position of the matching entry or -1 if not found</returns>

/// <exception cref="ObjectDisposedException">

/// The Zip file has been closed.

/// </exception>

public int FindEntry(string name, bool ignoreCase)

{

if (isDisposed_)

{

throw new ObjectDisposedException("ZipFile");

}

// TODO: This will be slow as the next ice age for huge archives!

for (int i = 0; i < entries_.Length; i++)

{

if (string.Compare(name, entries_[i].Name, ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal) == 0)

{

return i;

}

}

return -1;

}

/// <summary>

/// Searches for a zip entry in this archive with the given name.

/// String comparisons are case insensitive

/// </summary>

/// <param name="name">

/// The name to find. May contain directory components separated by slashes ('/').

/// </param>

/// <returns>

/// A clone of the zip entry, or null if no entry with that name exists.

/// </returns>

/// <exception cref="ObjectDisposedException">

/// The Zip file has been closed.

/// </exception>

public ZipEntry GetEntry(string name)

{

if (isDisposed_)

{

throw new ObjectDisposedException("ZipFile");

}

int index = FindEntry(name, true);

return (index >= 0) ? (ZipEntry)entries_[index].Clone() : null;

}

/// <summary>

/// Gets an input stream for reading the given zip entry data in an uncompressed form.

/// Normally the <see cref="ZipEntry"/> should be an entry returned by GetEntry().

/// </summary>

/// <param name="entry">The <see cref="ZipEntry"/> to obtain a data <see cref="Stream"/> for</param>

/// <returns>An input <see cref="Stream"/> containing data for this <see cref="ZipEntry"/></returns>

/// <exception cref="ObjectDisposedException">

/// The ZipFile has already been closed

/// </exception>

/// <exception cref="ZipException">

/// The compression method for the entry is unknown

/// </exception>

/// <exception cref="IndexOutOfRangeException">

/// The entry is not found in the ZipFile

/// </exception>

public Stream GetInputStream(ZipEntry entry)

{

if (entry == null)

{

throw new ArgumentNullException(nameof(entry));

}

if (isDisposed_)

{

throw new ObjectDisposedException("ZipFile");

}

long index = entry.ZipFileIndex;

if ((index < 0) || (index >= entries_.Length) || (entries_[index].Name != entry.Name))

{

index = FindEntry(entry.Name, true);

if (index < 0)

{

throw new ZipException("Entry cannot be found");

}

}

return GetInputStream(index);

}

/// <summary>

/// Creates an input stream reading a zip entry

/// </summary>

/// <param name="entryIndex">The index of the entry to obtain an input stream for.</param>

/// <returns>

/// An input <see cref="Stream"/> containing data for this <paramref name="entryIndex"/>

/// </returns>

/// <exception cref="ObjectDisposedException">

/// The ZipFile has already been closed

/// </exception>

/// <exception cref="ZipException">

/// The compression method for the entry is unknown

/// </exception>

/// <exception cref="IndexOutOfRangeException">

/// The entry is not found in the ZipFile

/// </exception>

public Stream GetInputStream(long entryIndex)

{

if (isDisposed_)

{

throw new ObjectDisposedException("ZipFile");

}

long start = LocateEntry(entries_[entryIndex]);

CompressionMethod method = entries_[entryIndex].CompressionMethod;

Stream result = new PartialInputStream(this, start, entries_[entryIndex].CompressedSize);

if (entries_[entryIndex].IsCrypted == true)

{

result = CreateAndInitDecryptionStream(result, entries_[entryIndex]);

if (result == null)

{

throw new ZipException("Unable to decrypt this entry");

}

}

switch (method)

{

case CompressionMethod.Stored:

// read as is.

break;

case CompressionMethod.Deflated:

// No need to worry about ownership and closing as underlying stream close does nothing.

result = new InflaterInputStream(result, new Inflater(true));

break;

case CompressionMethod.BZip2:

result = new BZip2.BZip2InputStream(result);

break;

default:

throw new ZipException("Unsupported compression method " + method);

}

return result;

}

#endregion Input Handling

#region Archive Testing

/// <summary>

/// Test an archive for integrity/validity

/// </summary>

/// <param name="testData">Perform low level data Crc check</param>

/// <returns>true if all tests pass, false otherwise</returns>

/// <remarks>Testing will terminate on the first error found.</remarks>

public bool TestArchive(bool testData)

{

return TestArchive(testData, TestStrategy.FindFirstError, null);

}

/// <summary>

/// Test an archive for integrity/validity

/// </summary>

/// <param name="testData">Perform low level data Crc check</param>

/// <param name="strategy">The <see cref="TestStrategy"></see> to apply.</param>

/// <param name="resultHandler">The <see cref="ZipTestResultHandler"></see> handler to call during testing.</param>

/// <returns>true if all tests pass, false otherwise</returns>

/// <exception cref="ObjectDisposedException">The object has already been closed.</exception>

public bool TestArchive(bool testData, TestStrategy strategy, ZipTestResultHandler resultHandler)

{

if (isDisposed_)

throw new ObjectDisposedException("ZipFile");

var status = new TestStatus(this);

resultHandler?.Invoke(status, null);

HeaderTest test = testData ? (HeaderTest.Header | HeaderTest.Extract) : HeaderTest.Header;

bool testing = true;

try

{

int entryIndex = 0;

while (testing && (entryIndex < Count))

{

if (resultHandler != null)

{

status.SetEntry(this[entryIndex]);

status.SetOperation(TestOperation.EntryHeader);

resultHandler(status, null);

}

try

{

TestLocalHeader(this[entryIndex], test);

}

catch (ZipException ex)

{

status.AddError();

resultHandler?.Invoke(status, $"Exception during test - '{ex.Message}'");

testing &= strategy != TestStrategy.FindFirstError;

}

if (testing && testData && this[entryIndex].IsFile)

{

var checkCRC = this[entryIndex].AESKeySize == 0;

if (resultHandler != null)

{

status.SetOperation(TestOperation.EntryData);

resultHandler(status, null);

}

var crc = new Crc32();

using (Stream entryStream = GetInputStream(this[entryIndex]))

{

byte[] buffer = new byte[4096];

long totalBytes = 0;

int bytesRead;

while ((bytesRead = entryStream.Read(buffer, 0, buffer.Length)) > 0)

{

if (checkCRC)

crc.Update(new ArraySegment<byte>(buffer, 0, bytesRead));

if (resultHandler != null)

{

totalBytes += bytesRead;

status.SetBytesTested(totalBytes);

resultHandler(status, null);

}

}

}

if (checkCRC)

{

if (this[entryIndex].Crc != crc.Value)

{

status.AddError();

resultHandler?.Invoke(status, "CRC mismatch");

testing &= strategy != TestStrategy.FindFirstError;

}

}

if ((this[entryIndex].Flags & (int)GeneralBitFlags.Descriptor) != 0)

{

var helper = new ZipHelperStream(baseStream_);

var data = new DescriptorData();

helper.ReadDataDescriptor(this[entryIndex].LocalHeaderRequiresZip64, data);

if (checkCRC)

{

if (this[entryIndex].Crc != data.Crc)

{

status.AddError();

resultHandler?.Invoke(status, "Descriptor CRC mismatch");

}

}

if (this[entryIndex].CompressedSize != data.CompressedSize)

{

status.AddError();

resultHandler?.Invoke(status, "Descriptor Compressed Size mismatch");