Merge Dtf

12 files changed, 2759 insertions, 0 deletions

diff --git a/src/dtf/WixToolset.Dtf.Compression.Zip/AssemblyInfo.cs b/src/dtf/WixToolset.Dtf.Compression.Zip/AssemblyInfo.cs
new file mode 100644
index 00000000..f782bbb8
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression.Zip/AssemblyInfo.cs
@@ -0,0 +1,5 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "WixToolset.Dtf.Compression.Zip")]
diff --git a/src/dtf/WixToolset.Dtf.Compression.Zip/ConcatStream.cs b/src/dtf/WixToolset.Dtf.Compression.Zip/ConcatStream.cs
new file mode 100644
index 00000000..20d675d9
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression.Zip/ConcatStream.cs
@@ -0,0 +1,157 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression.Zip
+{
+    using System;
+    using System.IO;
+
+    /// <summary>
+    /// Used to trick a DeflateStream into reading from or writing to
+    /// a series of (chunked) streams instead of a single steream.
+    /// </summary>
+    internal class ConcatStream : Stream
+    {
+        private Stream source;
+        private long position;
+        private long length;
+        private Action<ConcatStream> nextStreamHandler;
+
+        public ConcatStream(Action<ConcatStream> nextStreamHandler)
+        {
+            if (nextStreamHandler == null)
+            {
+                throw new ArgumentNullException("nextStreamHandler");
+            }
+
+            this.nextStreamHandler = nextStreamHandler;
+            this.length = Int64.MaxValue;
+        }
+
+        public Stream Source
+        {
+            get { return this.source; }
+            set { this.source = value; }
+        }
+
+        public override bool CanRead
+        {
+            get { return true; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return true; }
+        }
+
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        public override long Length
+        {
+            get
+            {
+                return this.length;
+            }
+        }
+
+        public override long Position
+        {
+            get { return this.position; }
+            set { throw new NotSupportedException(); }
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (this.source == null)
+            {
+                this.nextStreamHandler(this);
+            }
+
+            count = (int) Math.Min(count, this.length - this.position);
+
+            int bytesRemaining = count;
+            while (bytesRemaining > 0)
+            {
+                if (this.source == null)
+                {
+                    throw new InvalidOperationException();
+                }
+
+                int partialCount = (int) Math.Min(bytesRemaining,
+                    this.source.Length - this.source.Position);
+
+                if (partialCount == 0)
+                {
+                    this.nextStreamHandler(this);
+                    continue;
+                }
+
+                partialCount = this.source.Read(
+                    buffer, offset + count - bytesRemaining, partialCount);
+                bytesRemaining -= partialCount;
+                this.position += partialCount;
+            }
+
+            return count;
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (this.source == null)
+            {
+                this.nextStreamHandler(this);
+            }
+
+            int bytesRemaining = count;
+            while (bytesRemaining > 0)
+            {
+                if (this.source == null)
+                {
+                    throw new InvalidOperationException();
+                }
+
+                int partialCount = (int) Math.Min(bytesRemaining,
+                    Math.Max(0, this.length - this.source.Position));
+
+                if (partialCount == 0)
+                {
+                    this.nextStreamHandler(this);
+                    continue;
+                }
+
+                this.source.Write(
+                    buffer, offset + count - bytesRemaining, partialCount);
+                bytesRemaining -= partialCount;
+                this.position += partialCount;
+            }
+        }
+
+        public override void Flush()
+        {
+            if (this.source != null)
+            {
+                this.source.Flush();
+            }
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            this.length = value;
+        }
+
+        public override void Close()
+        {
+            if (this.source != null)
+            {
+                this.source.Close();
+            }
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression.Zip/CrcStream.cs b/src/dtf/WixToolset.Dtf.Compression.Zip/CrcStream.cs
new file mode 100644
index 00000000..c645ecc1
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression.Zip/CrcStream.cs
@@ -0,0 +1,250 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression.Zip
+{
+    using System;
+    using System.IO;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Wraps a source stream and calcaluates a CRC over all bytes that are read or written.
+    /// </summary>
+    /// <remarks>
+    /// The CRC algorithm matches that used in the standard ZIP file format.
+    /// </remarks>
+    [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Crc")]
+    public class CrcStream : Stream
+    {
+        private Stream source;
+        private uint crc;
+
+        /// <summary>
+        /// Creates a new CrcStream instance from a source stream.
+        /// </summary>
+        /// <param name="source">Underlying stream where bytes will be read from or written to.</param>
+        public CrcStream(Stream source)
+        {
+            this.source = source;
+        }
+
+        /// <summary>
+        /// Gets the current CRC over all bytes that have been read or written
+        /// since this instance was created.
+        /// </summary>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Crc")]
+        public uint Crc
+        {
+            get
+            {
+                return this.crc;
+            }
+        }
+
+        /// <summary>
+        /// Gets the underlying stream that this stream reads from or writes to.
+        /// </summary>
+        public Stream Source
+        {
+            get
+            {
+                return this.source;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the source stream supports reading.
+        /// </summary>
+        /// <value>true if the stream supports reading; otherwise, false.</value>
+        public override bool CanRead
+        {
+            get
+            {
+                return this.source.CanRead;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the source stream supports writing.
+        /// </summary>
+        /// <value>true if the stream supports writing; otherwise, false.</value>
+        public override bool CanWrite
+        {
+            get
+            {
+                return this.source.CanWrite;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the source stream supports seeking.
+        /// </summary>
+        /// <value>true if the stream supports seeking; otherwise, false.</value>
+        public override bool CanSeek
+        {
+            get
+            {
+                return this.source.CanSeek;
+            }
+        }
+
+        /// <summary>
+        /// Gets the length of the source stream.
+        /// </summary>
+        public override long Length
+        {
+            get
+            {
+                return this.source.Length;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the position of the source stream.
+        /// </summary>
+        public override long Position
+        {
+            get
+            {
+                return this.source.Position;
+            }
+
+            set
+            {
+                this.source.Position = value;
+            }
+        }
+
+        /// <summary>
+        /// Sets the position within the source stream.
+        /// </summary>
+        /// <param name="offset">A byte offset relative to the origin parameter.</param>
+        /// <param name="origin">A value of type SeekOrigin indicating
+        /// the reference point used to obtain the new position.</param>
+        /// <returns>The new position within the source stream.</returns>
+        /// <remarks>
+        /// Note the CRC is only calculated over bytes that are actually read or
+        /// written, so any bytes skipped by seeking will not contribute to the CRC.
+        /// </remarks>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            return this.source.Seek(offset, origin);
+        }
+
+        /// <summary>
+        /// Sets the length of the source stream.
+        /// </summary>
+        /// <param name="value">The desired length of the
+        /// stream in bytes.</param>
+        public override void SetLength(long value)
+        {
+            this.source.SetLength(value);
+        }
+
+        /// <summary>
+        /// Reads a sequence of bytes from the source stream and advances
+        /// the position within the stream by the number of bytes read.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. When this method returns, the buffer
+        /// contains the specified byte array with the values between offset and
+        /// (offset + count - 1) replaced by the bytes read from the current source.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin
+        /// storing the data read from the current stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+        /// <returns>The total number of bytes read into the buffer. This can be less
+        /// than the number of bytes requested if that many bytes are not currently available,
+        /// or zero (0) if the end of the stream has been reached.</returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            count = this.source.Read(buffer, offset, count);
+            this.UpdateCrc(buffer, offset, count);
+            return count;
+        }
+
+        /// <summary>
+        /// Writes a sequence of bytes to the source stream and advances the
+        /// current position within this stream by the number of bytes written.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. This method copies count
+        /// bytes from buffer to the current stream.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which
+        /// to begin copying bytes to the current stream.</param>
+        /// <param name="count">The number of bytes to be written to the
+        /// current stream.</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            this.source.Write(buffer, offset, count);
+            this.UpdateCrc(buffer, offset, count);
+        }
+
+        /// <summary>
+        /// Flushes the source stream.
+        /// </summary>
+        public override void Flush()
+        {
+            this.source.Flush();
+        }
+
+        /// <summary>
+        /// Closes the underlying stream.
+        /// </summary>
+        public override void Close()
+        {
+            this.source.Close();
+            base.Close();
+        }
+
+        /// <summary>
+        /// Updates the CRC with a range of bytes that were read or written.
+        /// </summary>
+        private void UpdateCrc(byte[] buffer, int offset, int count)
+        {
+            this.crc = ~this.crc;
+            for( ; count > 0; count--, offset++)
+            {
+                this.crc = (this.crc >> 8) ^
+                    CrcStream.crcTable[(this.crc  & 0xFF) ^ buffer[offset]];
+            }
+            this.crc = ~this.crc;
+        }
+
+        private static uint[] crcTable = MakeCrcTable();
+
+        /// <summary>
+        /// Computes a table that speeds up calculation of the CRC.
+        /// </summary>
+        private static uint[] MakeCrcTable()
+        {
+            const uint poly = 0x04C11DB7u;
+            uint[] crcTable = new uint[256];
+            for(uint n = 0; n < 256; n++)
+            {
+                uint c = CrcStream.Reflect(n, 8);
+                c = c << 24;
+                for(uint k = 0; k < 8; k++)
+                {
+                    c = (c << 1) ^ ((c & 0x80000000u) != 0 ? poly : 0);
+                }
+                crcTable[n] = CrcStream.Reflect(c, 32);
+            }
+            return crcTable;
+        }
+
+        /// <summary>
+        /// Reflects the ordering of certain number of bits. For exmample when reflecting
+        /// one byte, bit one is swapped with bit eight, bit two with bit seven, etc.
+        /// </summary>
+        private static uint Reflect(uint value, int bits)
+        {
+            for (int i = 0; i < bits / 2; i++)
+            {
+                uint leftBit = 1u << (bits - 1 - i);
+                uint rightBit = 1u << i;
+                if (((value & leftBit) != 0) != ((value & rightBit) != 0))
+                {
+                    value ^= leftBit | rightBit;
+                }
+            }
+            return value;
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression.Zip/WixToolset.Dtf.Compression.Zip.csproj b/src/dtf/WixToolset.Dtf.Compression.Zip/WixToolset.Dtf.Compression.Zip.csproj
new file mode 100644
index 00000000..2f5f2f27
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression.Zip/WixToolset.Dtf.Compression.Zip.csproj
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. -->
+
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <RootNamespace>WixToolset.Dtf.Compression.Zip</RootNamespace>
+    <AssemblyName>WixToolset.Dtf.Compression.Zip</AssemblyName>
+    <TargetFrameworks>netstandard2.0;net20</TargetFrameworks>
+    <Description>Managed libraries for zip archive packing and unpacking</Description>
+    <CreateDocumentationFile>true</CreateDocumentationFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WixToolset.Dtf.Compression\WixToolset.Dtf.Compression.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+    <PackageReference Include="Nerdbank.GitVersioning" Version="3.3.37" PrivateAssets="All" />
+  </ItemGroup>
+</Project>
diff --git a/src/dtf/WixToolset.Dtf.Compression.Zip/ZipCompressionMethod.cs b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipCompressionMethod.cs
new file mode 100644
index 00000000..2e1c7567
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipCompressionMethod.cs
@@ -0,0 +1,80 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression.Zip
+{
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Identifies the compression method or &quot;algorithm&quot;
+    /// used for a single file within a zip archive.
+    /// </summary>
+    /// <remarks>
+    /// Proprietary zip implementations may define additional compression
+    /// methods outside of those included here.
+    /// </remarks>
+    public enum ZipCompressionMethod
+    {
+        /// <summary>
+        /// The file is stored (no compression)
+        /// </summary>
+        Store = 0,
+        
+        /// <summary>
+        /// The file is Shrunk
+        /// </summary>
+        Shrink = 1,
+        
+        /// <summary>
+        /// The file is Reduced with compression factor 1
+        /// </summary>
+        Reduce1 = 2,
+
+        /// <summary>
+        /// The file is Reduced with compression factor 2
+        /// </summary>
+        Reduce2 = 3,
+
+        /// <summary>
+        /// The file is Reduced with compression factor 3
+        /// </summary>
+        Reduce3 = 4,
+
+        /// <summary>
+        /// The file is Reduced with compression factor 4
+        /// </summary>
+        Reduce4 = 5,
+        
+        /// <summary>
+        /// The file is Imploded
+        /// </summary>
+        Implode = 6,
+        
+        /// <summary>
+        /// The file is Deflated;
+        /// the most common and widely-compatible form of zip compression.
+        /// </summary>
+        Deflate = 8,
+        
+        /// <summary>
+        /// The file is Deflated using the enhanced Deflate64 method.
+        /// </summary>
+        Deflate64 = 9,
+
+        /// <summary>
+        /// The file is compressed using the BZIP2 algorithm.
+        /// </summary>
+        BZip2 = 12,
+
+        /// <summary>
+        /// The file is compressed using the LZMA algorithm.
+        /// </summary>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Lzma")]
+        Lzma = 14,
+
+        /// <summary>
+        /// The file is compressed using the PPMd algorithm.
+        /// </summary>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Ppmd")]
+        Ppmd = 98
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression.Zip/ZipEngine.cs b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipEngine.cs
new file mode 100644
index 00000000..36b4db89
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipEngine.cs
@@ -0,0 +1,478 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression.Zip
+{
+    using System;
+    using System.IO;
+    using System.IO.Compression;
+    using System.Collections.Generic;
+    using System.Reflection;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Engine capable of packing and unpacking archives in the zip format.
+    /// </summary>
+    public partial class ZipEngine : CompressionEngine
+    {
+        private static Dictionary<ZipCompressionMethod, Converter<Stream, Stream>>
+            compressionStreamCreators;
+        private static Dictionary<ZipCompressionMethod, Converter<Stream, Stream>>
+            decompressionStreamCreators;
+
+        private static void InitCompressionStreamCreators()
+        {
+            if (ZipEngine.compressionStreamCreators == null)
+            {
+                ZipEngine.compressionStreamCreators = new
+                    Dictionary<ZipCompressionMethod, Converter<Stream, Stream>>();
+                ZipEngine.decompressionStreamCreators = new
+                    Dictionary<ZipCompressionMethod, Converter<Stream, Stream>>();
+
+                ZipEngine.RegisterCompressionStreamCreator(
+                    ZipCompressionMethod.Store,
+                    CompressionMode.Compress,
+                    delegate(Stream stream) {
+                        return stream;
+                    });
+                ZipEngine.RegisterCompressionStreamCreator(
+                    ZipCompressionMethod.Deflate,
+                    CompressionMode.Compress,
+                    delegate(Stream stream) {
+                        return new DeflateStream(stream, CompressionMode.Compress, true);
+                    });
+                ZipEngine.RegisterCompressionStreamCreator(
+                    ZipCompressionMethod.Store,
+                    CompressionMode.Decompress,
+                    delegate(Stream stream) {
+                        return stream;
+                    });
+                ZipEngine.RegisterCompressionStreamCreator(
+                    ZipCompressionMethod.Deflate,
+                    CompressionMode.Decompress,
+                    delegate(Stream stream) {
+                        return new DeflateStream(stream, CompressionMode.Decompress, true);
+                    });
+            }
+        }
+
+        /// <summary>
+        /// Registers a delegate that can create a warpper stream for
+        /// compressing or uncompressing the data of a source stream.
+        /// </summary>
+        /// <param name="compressionMethod">Compression method being registered.</param>
+        /// <param name="compressionMode">Indicates registration for ether
+        /// compress or decompress mode.</param>
+        /// <param name="creator">Delegate being registered.</param>
+        /// <remarks>
+        /// For compression, the delegate accepts a stream that writes to the archive
+        /// and returns a wrapper stream that compresses bytes as they are written.
+        /// For decompression, the delegate accepts a stream that reads from the archive
+        /// and returns a wrapper stream that decompresses bytes as they are read.
+        /// This wrapper stream model follows the design used by
+        /// System.IO.Compression.DeflateStream, and indeed that class is used
+        /// to implement the Deflate compression method by default.
+        /// <para>To unregister a delegate, call this method again and pass
+        /// null for the delegate parameter.</para>
+        /// </remarks>
+        /// <example>
+        /// When the ZipEngine class is initialized, the Deflate compression method
+        /// is automatically registered like this:
+        /// <code>
+        ///        ZipEngine.RegisterCompressionStreamCreator(
+        ///            ZipCompressionMethod.Deflate,
+        ///            CompressionMode.Compress,
+        ///            delegate(Stream stream) {
+        ///                return new DeflateStream(stream, CompressionMode.Compress, true);
+        ///            });
+        ///        ZipEngine.RegisterCompressionStreamCreator(
+        ///            ZipCompressionMethod.Deflate,
+        ///            CompressionMode.Decompress,
+        ///            delegate(Stream stream) {
+        ///                return new DeflateStream(stream, CompressionMode.Decompress, true);
+        ///            });
+        /// </code></example>
+        public static void RegisterCompressionStreamCreator(
+            ZipCompressionMethod compressionMethod,
+            CompressionMode compressionMode,
+            Converter<Stream, Stream> creator)
+        {
+            ZipEngine.InitCompressionStreamCreators();
+            if (compressionMode == CompressionMode.Compress)
+            {
+                ZipEngine.compressionStreamCreators[compressionMethod] = creator;
+            }
+            else
+            {
+                ZipEngine.decompressionStreamCreators[compressionMethod] = creator;
+            }
+        }
+
+        // Progress data
+        private string currentFileName;
+        private int currentFileNumber;
+        private int totalFiles;
+        private long currentFileBytesProcessed;
+        private long currentFileTotalBytes;
+        private string mainArchiveName;
+        private string currentArchiveName;
+        private short currentArchiveNumber;
+        private short totalArchives;
+        private long currentArchiveBytesProcessed;
+        private long currentArchiveTotalBytes;
+        private long fileBytesProcessed;
+        private long totalFileBytes;
+        private string comment;
+
+        /// <summary>
+        /// Creates a new instance of the zip engine.
+        /// </summary>
+        public ZipEngine()
+            : base()
+        {
+            ZipEngine.InitCompressionStreamCreators();
+        }
+
+        /// <summary>
+        /// Gets the comment from the last-examined archive,
+        /// or sets the comment to be added to any created archives.
+        /// </summary>
+        public string ArchiveComment
+        {
+            get
+            {
+                return this.comment;
+            }
+            set
+            {
+                this.comment = value;
+            }
+        }
+
+        /// <summary>
+        /// Checks whether a Stream begins with a header that indicates
+        /// it is a valid archive file.
+        /// </summary>
+        /// <param name="stream">Stream for reading the archive file.</param>
+        /// <returns>True if the stream is a valid zip archive
+        /// (with no offset); false otherwise.</returns>
+        public override bool IsArchive(Stream stream)
+        {
+            if (stream == null)
+            {
+                throw new ArgumentNullException("stream");
+            }
+
+            if (stream.Length - stream.Position < 4)
+            {
+                return false;
+            }
+
+            BinaryReader reader = new BinaryReader(stream);
+            uint sig = reader.ReadUInt32();
+            switch (sig)
+            {
+                case ZipFileHeader.LFHSIG:
+                case ZipEndOfCentralDirectory.EOCDSIG:
+                case ZipEndOfCentralDirectory.EOCD64SIG:
+                case ZipFileHeader.SPANSIG:
+                case ZipFileHeader.SPANSIG2:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets the offset of an archive that is positioned 0 or more bytes
+        /// from the start of the Stream.
+        /// </summary>
+        /// <param name="stream">A stream for reading the archive.</param>
+        /// <returns>The offset in bytes of the archive,
+        /// or -1 if no archive is found in the Stream.</returns>
+        /// <remarks>The archive must begin on a 4-byte boundary.</remarks>
+        public override long FindArchiveOffset(Stream stream)
+        {
+            long offset = base.FindArchiveOffset(stream);
+            if (offset > 0)
+            {
+                // Some self-extract packages include the exe stub in file offset calculations.
+                // Check the first header directory offset to decide whether the entire
+                // archive needs to be offset or not.
+
+                ZipEndOfCentralDirectory eocd = this.GetEOCD(null, stream);
+                if (eocd != null && eocd.totalEntries > 0)
+                {
+                    stream.Seek(eocd.dirOffset, SeekOrigin.Begin);
+
+                    ZipFileHeader header = new ZipFileHeader();
+                    if (header.Read(stream, true) && header.localHeaderOffset < stream.Length)
+                    {
+                        stream.Seek(header.localHeaderOffset, SeekOrigin.Begin);
+                        if (header.Read(stream, false))
+                        {
+                            return 0;
+                        }
+                    }
+                }
+            }
+
+            return offset;
+        }
+
+        /// <summary>
+        /// Gets information about files in a zip archive or archive chain.
+        /// </summary>
+        /// <param name="streamContext">A context interface to handle opening
+        /// and closing of archive and file streams.</param>
+        /// <param name="fileFilter">A predicate that can determine
+        /// which files to process, optional.</param>
+        /// <returns>Information about files in the archive stream.</returns>
+        /// <exception cref="ArchiveException">The archive provided
+        /// by the stream context is not valid.</exception>
+        /// <remarks>
+        /// The <paramref name="fileFilter"/> predicate takes an internal file
+        /// path and returns true to include the file or false to exclude it.
+        /// </remarks>
+        public override IList<ArchiveFileInfo> GetFileInfo(
+            IUnpackStreamContext streamContext,
+            Predicate<string> fileFilter)
+        {
+            if (streamContext == null)
+            {
+                throw new ArgumentNullException("streamContext");
+            }
+
+            lock (this)
+            {
+                IList<ZipFileHeader> headers = this.GetCentralDirectory(streamContext);
+                if (headers == null)
+                {
+                    throw new ZipException("Zip central directory not found.");
+                }
+
+                List<ArchiveFileInfo> files = new List<ArchiveFileInfo>(headers.Count);
+                foreach (ZipFileHeader header in headers)
+                {
+                    if (!header.IsDirectory &&
+                        (fileFilter == null || fileFilter(header.fileName)))
+                    {
+                        files.Add(header.ToZipFileInfo());
+                    }
+                }
+
+                return files.AsReadOnly();
+            }
+        }
+
+        /// <summary>
+        /// Reads all the file headers from the central directory in the main archive.
+        /// </summary>
+        private IList<ZipFileHeader> GetCentralDirectory(IUnpackStreamContext streamContext)
+        {
+            Stream archiveStream = null;
+            this.currentArchiveNumber = 0;
+            try
+            {
+                List<ZipFileHeader> headers = new List<ZipFileHeader>();
+                archiveStream = this.OpenArchive(streamContext, 0);
+
+                ZipEndOfCentralDirectory eocd = this.GetEOCD(streamContext, archiveStream);
+                if (eocd == null)
+                {
+                    return null;
+                }
+                else if (eocd.totalEntries == 0)
+                {
+                    return headers;
+                }
+
+                headers.Capacity = (int) eocd.totalEntries;
+
+                if (eocd.dirOffset > archiveStream.Length - ZipFileHeader.CFH_FIXEDSIZE)
+                {
+                    streamContext.CloseArchiveReadStream(
+                        this.currentArchiveNumber, String.Empty, archiveStream);
+                    archiveStream = null;
+                }
+                else
+                {
+                    archiveStream.Seek(eocd.dirOffset, SeekOrigin.Begin);
+                    uint sig = new BinaryReader(archiveStream).ReadUInt32();
+                    if (sig != ZipFileHeader.CFHSIG)
+                    {
+                        streamContext.CloseArchiveReadStream(
+                            this.currentArchiveNumber, String.Empty, archiveStream);
+                        archiveStream = null;
+                    }
+                }
+
+                if (archiveStream == null)
+                {
+                    this.currentArchiveNumber = (short) (eocd.dirStartDiskNumber + 1);
+                    archiveStream = streamContext.OpenArchiveReadStream(
+                        this.currentArchiveNumber, String.Empty, this);
+
+                    if (archiveStream == null)
+                    {
+                        return null;
+                    }
+                }
+
+                archiveStream.Seek(eocd.dirOffset, SeekOrigin.Begin);
+
+                while (headers.Count < eocd.totalEntries)
+                {
+                    ZipFileHeader header = new ZipFileHeader();
+                    if (!header.Read(archiveStream, true))
+                    {
+                        throw new ZipException(
+                            "Missing or invalid central directory file header");
+                    }
+
+                    headers.Add(header);
+
+                    if (headers.Count < eocd.totalEntries &&
+                        archiveStream.Position == archiveStream.Length)
+                    {
+                        streamContext.CloseArchiveReadStream(
+                            this.currentArchiveNumber, String.Empty, archiveStream);
+                        this.currentArchiveNumber++;
+                        archiveStream = streamContext.OpenArchiveReadStream(
+                            this.currentArchiveNumber, String.Empty, this);
+                        if (archiveStream == null)
+                        {
+                            this.currentArchiveNumber = 0;
+                            archiveStream = streamContext.OpenArchiveReadStream(
+                                this.currentArchiveNumber, String.Empty, this);
+                        }
+                    }
+                }
+
+                return headers;
+            }
+            finally
+            {
+                if (archiveStream != null)
+                {
+                    streamContext.CloseArchiveReadStream(
+                        this.currentArchiveNumber, String.Empty, archiveStream);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Locates and reads the end of central directory record near the
+        /// end of the archive.
+        /// </summary>
+        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic")]
+        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "streamContext")]
+        private ZipEndOfCentralDirectory GetEOCD(
+            IUnpackStreamContext streamContext, Stream archiveStream)
+        {
+            BinaryReader reader = new BinaryReader(archiveStream);
+            long offset = archiveStream.Length
+                - ZipEndOfCentralDirectory.EOCD_RECORD_FIXEDSIZE;
+            while (offset >= 0)
+            {
+                archiveStream.Seek(offset, SeekOrigin.Begin);
+
+                uint sig = reader.ReadUInt32();
+                if (sig == ZipEndOfCentralDirectory.EOCDSIG)
+                {
+                    break;
+                }
+
+                offset--;
+            }
+
+            if (offset < 0)
+            {
+                return null;
+            }
+
+            ZipEndOfCentralDirectory eocd = new ZipEndOfCentralDirectory();
+            archiveStream.Seek(offset, SeekOrigin.Begin);
+            if (!eocd.Read(archiveStream))
+            {
+                throw new ZipException("Invalid end of central directory record");
+            }
+
+            if (eocd.dirOffset == (long) UInt32.MaxValue)
+            {
+                string saveComment = eocd.comment;
+
+                archiveStream.Seek(
+                    offset - Zip64EndOfCentralDirectoryLocator.EOCDL64_SIZE,
+                    SeekOrigin.Begin);
+
+                Zip64EndOfCentralDirectoryLocator eocdl =
+                    new Zip64EndOfCentralDirectoryLocator();
+                if (!eocdl.Read(archiveStream))
+                {
+                    throw new ZipException("Missing or invalid end of " +
+                        "central directory record locator");
+                }
+
+                if (eocdl.dirStartDiskNumber == eocdl.totalDisks - 1)
+                {
+                    // ZIP64 eocd is entirely in current stream.
+                    archiveStream.Seek(eocdl.dirOffset, SeekOrigin.Begin);
+                    if (!eocd.Read(archiveStream))
+                    {
+                        throw new ZipException("Missing or invalid ZIP64 end of " +
+                            "central directory record");
+                    }
+                }
+                else if (streamContext == null)
+                {
+                    return null;
+                }
+                else
+                {
+                    // TODO: handle EOCD64 spanning archives!
+                    throw new NotImplementedException("Zip implementation does not " +
+                        "handle end of central directory record that spans archives.");
+                }
+
+                eocd.comment = saveComment;
+            }
+
+            return eocd;
+        }
+
+        private void ResetProgressData()
+        {
+            this.currentFileName = null;
+            this.currentFileNumber = 0;
+            this.totalFiles = 0;
+            this.currentFileBytesProcessed = 0;
+            this.currentFileTotalBytes = 0;
+            this.currentArchiveName = null;
+            this.currentArchiveNumber = 0;
+            this.totalArchives = 0;
+            this.currentArchiveBytesProcessed = 0;
+            this.currentArchiveTotalBytes = 0;
+            this.fileBytesProcessed = 0;
+            this.totalFileBytes = 0;
+        }
+
+        private void OnProgress(ArchiveProgressType progressType)
+        {
+            ArchiveProgressEventArgs e = new ArchiveProgressEventArgs(
+                progressType,
+                this.currentFileName,
+                this.currentFileNumber >= 0 ? this.currentFileNumber : 0,
+                this.totalFiles,
+                this.currentFileBytesProcessed,
+                this.currentFileTotalBytes,
+                this.currentArchiveName,
+                this.currentArchiveNumber,
+                this.totalArchives,
+                this.currentArchiveBytesProcessed,
+                this.currentArchiveTotalBytes,
+                this.fileBytesProcessed,
+                this.totalFileBytes);
+            this.OnProgress(e);
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression.Zip/ZipException.cs b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipException.cs
new file mode 100644
index 00000000..50fd6156
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipException.cs
@@ -0,0 +1,60 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression.Zip
+{
+    using System;
+    using System.IO;
+    using System.Resources;
+    using System.Globalization;
+    using System.Runtime.Serialization;
+
+    /// <summary>
+    /// Exception class for zip operations.
+    /// </summary>
+    [Serializable]
+    public class ZipException : ArchiveException
+    {
+        /// <summary>
+        /// Creates a new ZipException with a specified error message and a reference to the
+        /// inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception. If the
+        /// innerException parameter is not a null reference (Nothing in Visual Basic), the current exception
+        /// is raised in a catch block that handles the inner exception.</param>
+        public ZipException(string message, Exception innerException)
+            : base(message, innerException) { }
+
+        /// <summary>
+        /// Creates a new ZipException with a specified error message.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        public ZipException(string message)
+            : this(message, null) { }
+
+        /// <summary>
+        /// Creates a new ZipException.
+        /// </summary>
+        public ZipException()
+            : this(null, null) { }
+
+        /// <summary>
+        /// Initializes a new instance of the ZipException class with serialized data.
+        /// </summary>
+        /// <param name="info">The SerializationInfo that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The StreamingContext that contains contextual information about the source or destination.</param>
+        protected ZipException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+        }
+
+        /// <summary>
+        /// Sets the SerializationInfo with information about the exception.
+        /// </summary>
+        /// <param name="info">The SerializationInfo that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The StreamingContext that contains contextual information about the source or destination.</param>
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            base.GetObjectData(info, context);
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression.Zip/ZipFileInfo.cs b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipFileInfo.cs
new file mode 100644
index 00000000..d865bbba
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipFileInfo.cs
@@ -0,0 +1,104 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression.Zip
+{
+    using System;
+    using System.IO;
+    using System.Runtime.Serialization;
+
+    /// <summary>
+    /// Object representing a compressed file within a zip package; provides operations for getting
+    /// the file properties and extracting the file.
+    /// </summary>
+    [Serializable]
+    public class ZipFileInfo : ArchiveFileInfo
+    {
+        private long compressedLength;
+        private ZipCompressionMethod compressionMethod;
+
+        /// <summary>
+        /// Creates a new ZipFileInfo object representing a file within a zip in a specified path.
+        /// </summary>
+        /// <param name="zipInfo">An object representing the zip archive containing the file.</param>
+        /// <param name="filePath">The path to the file within the zip archive. Usually, this is a simple file
+        /// name, but if the zip archive contains a directory structure this may include the directory.</param>
+        public ZipFileInfo(ZipInfo zipInfo, string filePath)
+            : base(zipInfo, filePath)
+        {
+            if (zipInfo == null)
+            {
+                throw new ArgumentNullException("zipInfo");
+            }
+        }
+
+        /// <summary>
+        /// Creates a new ZipFileInfo object with all parameters specified,
+        /// used internally when reading the metadata out of a zip archive.
+        /// </summary>
+        /// <param name="filePath">The internal path and name of the file in the zip archive.</param>
+        /// <param name="zipNumber">The zip archive number where the file starts.</param>
+        /// <param name="attributes">The stored attributes of the file.</param>
+        /// <param name="lastWriteTime">The stored last write time of the file.</param>
+        /// <param name="length">The uncompressed size of the file.</param>
+        /// <param name="compressedLength">The compressed size of the file.</param>
+        /// <param name="compressionMethod">Compression algorithm used for this file.</param>
+        internal ZipFileInfo(
+            string filePath,
+            int zipNumber,
+            FileAttributes attributes,
+            DateTime lastWriteTime,
+            long length,
+            long compressedLength,
+            ZipCompressionMethod compressionMethod)
+            : base(filePath, zipNumber, attributes, lastWriteTime, length)
+        {
+            this.compressedLength = compressedLength;
+            this.compressionMethod = compressionMethod;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the ZipFileInfo class with serialized data.
+        /// </summary>
+        /// <param name="info">The SerializationInfo that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The StreamingContext that contains contextual information about the source or destination.</param>
+        protected ZipFileInfo(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+            this.compressedLength = info.GetInt64("compressedLength");
+        }
+
+        /// <summary>
+        /// Gets the compressed size of the file in bytes.
+        /// </summary>
+        public long CompressedLength
+        {
+            get
+            {
+                return this.compressedLength;
+            }
+        }
+
+        /// <summary>
+        /// Gets the method used to compress this file.
+        /// </summary>
+        public ZipCompressionMethod CompressionMethod
+        {
+            get
+            {
+                return this.compressionMethod;
+            }
+        }
+
+        /// <summary>
+        /// Sets the SerializationInfo with information about the archive.
+        /// </summary>
+        /// <param name="info">The SerializationInfo that holds the serialized object data.</param>
+        /// <param name="context">The StreamingContext that contains contextual information
+        /// about the source or destination.</param>
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            base.GetObjectData(info, context);
+            info.AddValue("compressedLength", this.compressedLength);
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression.Zip/ZipFormat.cs b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipFormat.cs
new file mode 100644
index 00000000..dc5e1137
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipFormat.cs
@@ -0,0 +1,697 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression.Zip
+{
+    using System;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+
+    [Flags]
+    internal enum ZipFileFlags : ushort
+    {
+        None            = 0x0000,
+        Encrypt         = 0x0001,
+        CompressOption1 = 0x0002,
+        CompressOption2 = 0x0004,
+        DataDescriptor  = 0x0008,
+        StrongEncrypt   = 0x0040,
+        UTF8            = 0x0800
+    }
+
+    internal enum ZipExtraFileFieldType : ushort
+    {
+        ZIP64 = 0x0001,
+        NTFS_TIMES = 0x000A,
+        NTFS_ACLS = 0x4453,
+        EXTIME = 0x5455
+    }
+
+    internal class ZipFileHeader
+    {
+        public const uint LFHSIG = 0x04034B50;
+        public const uint CFHSIG = 0x02014B50;
+
+        public const uint SPANSIG  = 0x08074b50;
+        public const uint SPANSIG2 = 0x30304b50;
+        
+        public const uint LFH_FIXEDSIZE = 30;
+        public const uint CFH_FIXEDSIZE = 46;
+
+        public ushort versionMadeBy;
+        public ushort versionNeeded;
+        public ZipFileFlags flags;
+        public ZipCompressionMethod compressionMethod;
+        public short lastModTime;
+        public short lastModDate;
+        public uint crc32;
+        public uint compressedSize;
+        public uint uncompressedSize;
+        public ushort diskStart;
+        public ushort internalFileAttrs;
+        public uint externalFileAttrs;
+        public uint localHeaderOffset;
+        public string fileName;
+        public ZipExtraFileField[] extraFields;
+        public string fileComment;
+        public bool zip64;
+
+        public ZipFileHeader()
+        {
+            this.versionMadeBy = 20;
+            this.versionNeeded = 20;
+        }
+
+        public ZipFileHeader(ZipFileInfo fileInfo, bool zip64)
+            : this()
+        {
+            this.flags = ZipFileFlags.None;
+            this.compressionMethod = fileInfo.CompressionMethod;
+            this.fileName = Path.Combine(fileInfo.Path, fileInfo.Name);
+            CompressionEngine.DateTimeToDosDateAndTime(
+                fileInfo.LastWriteTime, out this.lastModDate, out this.lastModTime);
+            this.zip64 = zip64;
+
+            if (this.zip64)
+            {
+                this.compressedSize = UInt32.MaxValue;
+                this.uncompressedSize = UInt32.MaxValue;
+                this.diskStart = UInt16.MaxValue;
+                this.versionMadeBy = 45;
+                this.versionNeeded = 45;
+                ZipExtraFileField field = new ZipExtraFileField();
+                field.fieldType = ZipExtraFileFieldType.ZIP64;
+                field.SetZip64Data(
+                    fileInfo.CompressedLength,
+                    fileInfo.Length,
+                    0,
+                    fileInfo.ArchiveNumber);
+                this.extraFields = new ZipExtraFileField[] { field };
+            }
+            else
+            {
+                this.compressedSize = (uint) fileInfo.CompressedLength;
+                this.uncompressedSize = (uint) fileInfo.Length;
+                this.diskStart = (ushort) fileInfo.ArchiveNumber;
+            }
+        }
+
+        [SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "compressedSize")]
+        [SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "uncompressedSize")]
+        [SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "crc32")]
+        [SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "localHeaderOffset")]
+        public void Update(
+            long compressedSize,
+            long uncompressedSize,
+            uint crc32,
+            long localHeaderOffset,
+            int archiveNumber)
+        {
+            this.crc32 = crc32;
+
+            if (this.zip64)
+            {
+                this.compressedSize = UInt32.MaxValue;
+                this.uncompressedSize = UInt32.MaxValue;
+                this.localHeaderOffset = UInt32.MaxValue;
+                this.diskStart = UInt16.MaxValue;
+
+                if (this.extraFields != null)
+                {
+                    foreach (ZipExtraFileField field in this.extraFields)
+                    {
+                        if (field.fieldType == ZipExtraFileFieldType.ZIP64)
+                        {
+                            field.SetZip64Data(
+                                compressedSize,
+                                uncompressedSize,
+                                localHeaderOffset,
+                                archiveNumber);
+                        }
+                    }
+                }
+            }
+            else
+            {
+                this.compressedSize = (uint) compressedSize;
+                this.uncompressedSize = (uint) uncompressedSize;
+                this.localHeaderOffset = (uint) localHeaderOffset;
+                this.diskStart = (ushort) archiveNumber;
+            }
+        }
+
+        public bool Read(Stream stream, bool central)
+        {
+            long startPos = stream.Position;
+
+            if (stream.Length - startPos <
+                (central ? CFH_FIXEDSIZE : LFH_FIXEDSIZE))
+            {
+                return false;
+            }
+
+            BinaryReader reader = new BinaryReader(stream);
+            uint sig = reader.ReadUInt32();
+
+            if (sig == SPANSIG || sig == SPANSIG2)
+            {
+                // Spanned zip files may optionally begin with a special marker.
+                // Just ignore it and move on.
+                sig = reader.ReadUInt32();
+            }
+
+            if (sig != (central ? CFHSIG : LFHSIG))
+            {
+                return false;
+            }
+
+            this.versionMadeBy = (central ? reader.ReadUInt16() : (ushort) 0);
+            this.versionNeeded = reader.ReadUInt16();
+            this.flags = (ZipFileFlags) reader.ReadUInt16();
+            this.compressionMethod = (ZipCompressionMethod) reader.ReadUInt16();
+            this.lastModTime = reader.ReadInt16();
+            this.lastModDate = reader.ReadInt16();
+            this.crc32 = reader.ReadUInt32();
+            this.compressedSize = reader.ReadUInt32();
+            this.uncompressedSize = reader.ReadUInt32();
+            
+            this.zip64 = this.uncompressedSize == UInt32.MaxValue;
+
+            int fileNameLength = reader.ReadUInt16();
+            int extraFieldLength = reader.ReadUInt16();
+            int fileCommentLength;
+
+            if (central)
+            {
+                fileCommentLength = reader.ReadUInt16();
+
+                this.diskStart = reader.ReadUInt16();
+                this.internalFileAttrs = reader.ReadUInt16();
+                this.externalFileAttrs = reader.ReadUInt32();
+                this.localHeaderOffset = reader.ReadUInt32();
+            }
+            else
+            {
+                fileCommentLength = 0;
+                this.diskStart = 0;
+                this.internalFileAttrs = 0;
+                this.externalFileAttrs = 0;
+                this.localHeaderOffset = 0;
+            }
+
+            if (stream.Length - stream.Position <
+                fileNameLength + extraFieldLength + fileCommentLength)
+            {
+                return false;
+            }
+
+            Encoding headerEncoding = ((this.flags | ZipFileFlags.UTF8) != 0 ?
+                Encoding.UTF8 : Encoding.GetEncoding(CultureInfo.CurrentCulture.TextInfo.OEMCodePage));
+
+            byte[] fileNameBytes = reader.ReadBytes(fileNameLength);
+            this.fileName = headerEncoding.GetString(fileNameBytes).Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+
+            List<ZipExtraFileField> fields = new List<ZipExtraFileField>();
+            while (extraFieldLength > 0)
+            {
+                ZipExtraFileField field = new ZipExtraFileField();
+                if (!field.Read(stream, ref extraFieldLength))
+                {
+                    return false;
+                }
+                fields.Add(field);
+                if (field.fieldType == ZipExtraFileFieldType.ZIP64)
+                {
+                    this.zip64 = true;
+                }
+            }
+            this.extraFields = fields.ToArray();
+
+            byte[] fileCommentBytes = reader.ReadBytes(fileCommentLength);
+            this.fileComment = headerEncoding.GetString(fileCommentBytes);
+
+            return true;
+        }
+
+        public void Write(Stream stream, bool central)
+        {
+            byte[] fileNameBytes = (this.fileName != null
+                ? Encoding.UTF8.GetBytes(this.fileName) : new byte[0]);
+            byte[] fileCommentBytes = (this.fileComment != null
+                ? Encoding.UTF8.GetBytes(this.fileComment) : new byte[0]);
+            bool useUtf8 =
+                (this.fileName != null && fileNameBytes.Length > this.fileName.Length) ||
+                (this.fileComment != null && fileCommentBytes.Length > this.fileComment.Length);
+            if (useUtf8)
+            {
+                this.flags |= ZipFileFlags.UTF8;
+            }
+
+            BinaryWriter writer = new BinaryWriter(stream);
+            writer.Write(central ? CFHSIG : LFHSIG);
+            if (central)
+            {
+                writer.Write(this.versionMadeBy);
+            }
+            writer.Write(this.versionNeeded);
+            writer.Write((ushort) this.flags);
+            writer.Write((ushort) this.compressionMethod);
+            writer.Write(this.lastModTime);
+            writer.Write(this.lastModDate);
+            writer.Write(this.crc32);
+            writer.Write(this.compressedSize);
+            writer.Write(this.uncompressedSize);
+            
+            ushort extraFieldLength = 0;
+            if (this.extraFields != null)
+            {
+                foreach (ZipExtraFileField field in this.extraFields)
+                {
+                    if (field.data != null)
+                    {
+                        extraFieldLength += (ushort) (4 + field.data.Length);
+                    }
+                }
+            }
+
+            writer.Write((ushort) fileNameBytes.Length);
+            writer.Write(extraFieldLength);
+
+            if (central)
+            {
+                writer.Write((ushort) fileCommentBytes.Length);
+
+                writer.Write(this.diskStart);
+                writer.Write(this.internalFileAttrs);
+                writer.Write(this.externalFileAttrs);
+                writer.Write(this.localHeaderOffset);
+            }
+
+            writer.Write(fileNameBytes);
+
+            if (this.extraFields != null)
+            {
+                foreach (ZipExtraFileField field in this.extraFields)
+                {
+                    if (field.data != null)
+                    {
+                        field.Write(stream);
+                    }
+                }
+            }
+
+            if (central)
+            {
+                writer.Write(fileCommentBytes);
+            }
+        }
+
+        [SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "compressedSize")]
+        [SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "uncompressedSize")]
+        [SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "crc32")]
+        [SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "localHeaderOffset")]
+        public void GetZip64Fields(
+            out long compressedSize,
+            out long uncompressedSize,
+            out long localHeaderOffset,
+            out int archiveNumber,
+            out uint crc)
+        {
+            compressedSize = this.compressedSize;
+            uncompressedSize = this.uncompressedSize;
+            localHeaderOffset = this.localHeaderOffset;
+            archiveNumber = this.diskStart;
+            crc = this.crc32;
+
+            foreach (ZipExtraFileField field in this.extraFields)
+            {
+                if (field.fieldType == ZipExtraFileFieldType.ZIP64)
+                {
+                    field.GetZip64Data(
+                        out compressedSize,
+                        out uncompressedSize,
+                        out localHeaderOffset,
+                        out archiveNumber);
+                }
+            }
+        }
+
+        public ZipFileInfo ToZipFileInfo()
+        {
+            string name = this.fileName;
+            
+            long compressedSizeL;
+            long uncompressedSizeL;
+            long localHeaderOffsetL;
+            int archiveNumberL;
+            uint crc;
+            this.GetZip64Fields(
+                out compressedSizeL,
+                out uncompressedSizeL,
+                out localHeaderOffsetL,
+                out archiveNumberL,
+                out crc);
+
+            DateTime dateTime;
+            CompressionEngine.DosDateAndTimeToDateTime(
+                this.lastModDate,
+                this.lastModTime,
+                out dateTime);
+            FileAttributes attrs = FileAttributes.Normal;
+            // TODO: look for attrs or times in extra fields
+
+            return new ZipFileInfo(name, archiveNumberL, attrs, dateTime,
+                uncompressedSizeL, compressedSizeL, this.compressionMethod);
+        }
+
+        public bool IsDirectory
+        {
+            get
+            {
+                return this.fileName != null &&
+                    (this.fileName.EndsWith("/", StringComparison.Ordinal) ||
+                    this.fileName.EndsWith("\\", StringComparison.Ordinal));
+            }
+        }
+
+        public int GetSize(bool central)
+        {
+            int size = 30;
+
+            int fileNameSize = (this.fileName != null
+                ? Encoding.UTF8.GetByteCount(this.fileName) : 0);
+            size += fileNameSize;
+
+            if (this.extraFields != null)
+            {
+                foreach (ZipExtraFileField field in this.extraFields)
+                {
+                    if (field.data != null)
+                    {
+                        size += 4 + field.data.Length;
+                    }
+                }
+            }
+
+            if (central)
+            {
+                size += 16;
+
+                int fileCommentSize = (this.fileComment != null
+                    ? Encoding.UTF8.GetByteCount(this.fileComment) : 0);
+                size += fileCommentSize;
+            }
+
+            return size;
+        }
+    }
+
+    internal class ZipExtraFileField
+    {
+        public ZipExtraFileFieldType fieldType;
+        public byte[] data;
+
+        public bool Read(Stream stream, ref int bytesRemaining)
+        {
+            if (bytesRemaining < 4)
+            {
+                return false;
+            }
+
+            BinaryReader reader = new BinaryReader(stream);
+
+            this.fieldType = (ZipExtraFileFieldType) reader.ReadUInt16();
+            ushort dataSize = reader.ReadUInt16();
+            bytesRemaining -= 4;
+
+            if (bytesRemaining < dataSize)
+            {
+                return false;
+            }
+
+            this.data = reader.ReadBytes(dataSize);
+            bytesRemaining -= dataSize;
+
+            return true;
+        }
+
+        public void Write(Stream stream)
+        {
+            BinaryWriter writer = new BinaryWriter(stream);
+            writer.Write((ushort) this.fieldType);
+
+            byte[] dataBytes = (this.data != null ? this.data : new byte[0]);
+            writer.Write((ushort) dataBytes.Length);
+            writer.Write(dataBytes);
+        }
+
+        public bool GetZip64Data(
+            out long compressedSize,
+            out long uncompressedSize,
+            out long localHeaderOffset,
+            out int diskStart)
+        {
+            uncompressedSize = 0;
+            compressedSize = 0;
+            localHeaderOffset = 0;
+            diskStart = 0;
+
+            if (this.fieldType != ZipExtraFileFieldType.ZIP64 ||
+                this.data == null || this.data.Length != 28)
+            {
+                return false;
+            }
+
+            using (MemoryStream dataStream = new MemoryStream(this.data))
+            {
+                BinaryReader reader = new BinaryReader(dataStream);
+                uncompressedSize = reader.ReadInt64();
+                compressedSize = reader.ReadInt64();
+                localHeaderOffset = reader.ReadInt64();
+                diskStart = reader.ReadInt32();
+            }
+
+            return true;
+        }
+
+        public bool SetZip64Data(
+            long compressedSize,
+            long uncompressedSize,
+            long localHeaderOffset,
+            int diskStart)
+        {
+            if (this.fieldType != ZipExtraFileFieldType.ZIP64)
+            {
+                return false;
+            }
+
+            using (MemoryStream dataStream = new MemoryStream())
+            {
+                BinaryWriter writer = new BinaryWriter(dataStream);
+                writer.Write(uncompressedSize);
+                writer.Write(compressedSize);
+                writer.Write(localHeaderOffset);
+                writer.Write(diskStart);
+                this.data = dataStream.ToArray();
+            }
+
+            return true;
+        }
+    }
+
+    internal class ZipEndOfCentralDirectory
+    {
+        public const uint EOCDSIG = 0x06054B50;
+        public const uint EOCD64SIG = 0x06064B50;
+
+        public const uint EOCD_RECORD_FIXEDSIZE = 22;
+        public const uint EOCD64_RECORD_FIXEDSIZE = 56;
+
+        public ushort versionMadeBy;
+        public ushort versionNeeded;
+        public uint diskNumber;
+        public uint dirStartDiskNumber;
+        public long entriesOnDisk;
+        public long totalEntries;
+        public long dirSize;
+        public long dirOffset;
+        public string comment;
+        public bool zip64;
+
+        public ZipEndOfCentralDirectory()
+        {
+            this.versionMadeBy = 20;
+            this.versionNeeded = 20;
+        }
+
+        public bool Read(Stream stream)
+        {
+            long startPos = stream.Position;
+
+            if (stream.Length - startPos < EOCD_RECORD_FIXEDSIZE)
+            {
+                return false;
+            }
+
+            BinaryReader reader = new BinaryReader(stream);
+            uint sig = reader.ReadUInt32();
+
+            this.zip64 = false;
+            if (sig != EOCDSIG)
+            {
+                if (sig == EOCD64SIG)
+                {
+                    this.zip64 = true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            if (this.zip64)
+            {
+                if (stream.Length - startPos < EOCD64_RECORD_FIXEDSIZE)
+                {
+                    return false;
+                }
+
+                long recordSize = reader.ReadInt64();
+                this.versionMadeBy = reader.ReadUInt16();
+                this.versionNeeded = reader.ReadUInt16();
+                this.diskNumber = reader.ReadUInt32();
+                this.dirStartDiskNumber = reader.ReadUInt32();
+                this.entriesOnDisk = reader.ReadInt64();
+                this.totalEntries = reader.ReadInt64();
+                this.dirSize = reader.ReadInt64();
+                this.dirOffset = reader.ReadInt64();
+
+                // Ignore any extended zip64 eocd data.
+                long exDataSize = recordSize + 12 - EOCD64_RECORD_FIXEDSIZE;
+
+                if (stream.Length - stream.Position < exDataSize)
+                {
+                    return false;
+                }
+
+                stream.Seek(exDataSize, SeekOrigin.Current);
+
+                this.comment = null;
+            }
+            else
+            {
+                this.diskNumber = reader.ReadUInt16();
+                this.dirStartDiskNumber = reader.ReadUInt16();
+                this.entriesOnDisk = reader.ReadUInt16();
+                this.totalEntries = reader.ReadUInt16();
+                this.dirSize = reader.ReadUInt32();
+                this.dirOffset = reader.ReadUInt32();
+
+                int commentLength = reader.ReadUInt16();
+
+                if (stream.Length - stream.Position < commentLength)
+                {
+                    return false;
+                }
+
+                byte[] commentBytes = reader.ReadBytes(commentLength);
+                this.comment = Encoding.UTF8.GetString(commentBytes);
+            }
+
+            return true;
+        }
+
+        public void Write(Stream stream)
+        {
+            BinaryWriter writer = new BinaryWriter(stream);
+
+            if (this.zip64)
+            {
+                writer.Write(EOCD64SIG);
+                writer.Write((long) EOCD64_RECORD_FIXEDSIZE);
+                writer.Write(this.versionMadeBy);
+                writer.Write(this.versionNeeded);
+                writer.Write(this.diskNumber);
+                writer.Write(this.dirStartDiskNumber);
+                writer.Write(this.entriesOnDisk);
+                writer.Write(this.totalEntries);
+                writer.Write(this.dirSize);
+                writer.Write(this.dirOffset);
+            }
+            else
+            {
+                writer.Write(EOCDSIG);
+                writer.Write((ushort) Math.Min((int) UInt16.MaxValue, this.diskNumber));
+                writer.Write((ushort) Math.Min((int) UInt16.MaxValue, this.dirStartDiskNumber));
+                writer.Write((ushort) Math.Min((int) UInt16.MaxValue, this.entriesOnDisk));
+                writer.Write((ushort) Math.Min((int) UInt16.MaxValue, this.totalEntries));
+                writer.Write((uint) Math.Min((long) UInt32.MaxValue, this.dirSize));
+                writer.Write((uint) Math.Min((long) UInt32.MaxValue, this.dirOffset));
+
+                byte[] commentBytes = (this.comment != null
+                    ? Encoding.UTF8.GetBytes(this.comment) : new byte[0]);
+                writer.Write((ushort) commentBytes.Length);
+                writer.Write(commentBytes);
+            }
+        }
+
+        public int GetSize(bool zip64Size)
+        {
+            if (zip64Size)
+            {
+                return 56;
+            }
+            else
+            {
+                int commentSize = (this.comment != null
+                    ? Encoding.UTF8.GetByteCount(this.comment) : 0);
+                return 22 + commentSize;
+            }
+        }
+    }
+
+    internal class Zip64EndOfCentralDirectoryLocator
+    {
+        public const uint EOCDL64SIG = 0x07064B50;
+
+        public const uint EOCDL64_SIZE = 20;
+
+        public uint dirStartDiskNumber;
+        public long dirOffset;
+        public uint totalDisks;
+
+        public bool Read(Stream stream)
+        {
+            long startPos = stream.Position;
+            if (stream.Length - startPos < EOCDL64_SIZE)
+            {
+                return false;
+            }
+
+            BinaryReader reader = new BinaryReader(stream);
+            uint sig = reader.ReadUInt32();
+
+            if (sig != EOCDL64SIG)
+            {
+                return false;
+            }
+
+            this.dirStartDiskNumber = reader.ReadUInt32();
+            this.dirOffset = reader.ReadInt64();
+            this.totalDisks = reader.ReadUInt32();
+
+            return true;
+        }
+
+        public void Write(Stream stream)
+        {
+            BinaryWriter writer = new BinaryWriter(stream);
+            writer.Write(EOCDL64SIG);
+            writer.Write(this.dirStartDiskNumber);
+            writer.Write(this.dirOffset);
+            writer.Write(this.totalDisks);
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression.Zip/ZipInfo.cs b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipInfo.cs
new file mode 100644
index 00000000..73f65fa0
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipInfo.cs
@@ -0,0 +1,82 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression.Zip
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Runtime.Serialization;
+
+    /// <summary>
+    /// Object representing a zip file on disk; provides access to
+    /// file-based operations on the zip file.
+    /// </summary>
+    /// <remarks>
+    /// Generally, the methods on this class are much easier to use than the
+    /// stream-based interfaces provided by the <see cref="ZipEngine"/> class.
+    /// </remarks>
+    [Serializable]
+    public class ZipInfo : ArchiveInfo
+    {
+        /// <summary>
+        /// Creates a new CabinetInfo object representing a zip file in a specified path.
+        /// </summary>
+        /// <param name="path">The path to the zip file. When creating a zip file, this file does not
+        /// necessarily exist yet.</param>
+        public ZipInfo(string path)
+            : base(path)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the CabinetInfo class with serialized data.
+        /// </summary>
+        /// <param name="info">The SerializationInfo that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The StreamingContext that contains contextual information about the source or destination.</param>
+        protected ZipInfo(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+
+        /// <summary>
+        /// Creates a compression engine that does the low-level work for
+        /// this object.
+        /// </summary>
+        /// <returns>A new <see cref="ZipEngine"/> instance.</returns>
+        /// <remarks>
+        /// Each instance will be <see cref="CompressionEngine.Dispose()"/>d
+        /// immediately after use.
+        /// </remarks>
+        protected override CompressionEngine CreateCompressionEngine()
+        {
+            return new ZipEngine();
+        }
+
+        /// <summary>
+        /// Gets information about the files contained in the archive.
+        /// </summary>
+        /// <returns>A list of <see cref="ZipFileInfo"/> objects, each
+        /// containing information about a file in the archive.</returns>
+        public new IList<ZipFileInfo> GetFiles()
+        {
+            IList<ArchiveFileInfo> files = base.GetFiles();
+            List<ZipFileInfo> zipFiles = new List<ZipFileInfo>(files.Count);
+            foreach (ZipFileInfo zipFile in files) zipFiles.Add(zipFile);
+            return zipFiles.AsReadOnly();
+        }
+
+        /// <summary>
+        /// Gets information about the certain files contained in the archive file.
+        /// </summary>
+        /// <param name="searchPattern">The search string, such as
+        /// &quot;*.txt&quot;.</param>
+        /// <returns>A list of <see cref="ZipFileInfo"/> objects, each containing
+        /// information about a file in the archive.</returns>
+        public new IList<ZipFileInfo> GetFiles(string searchPattern)
+        {
+            IList<ArchiveFileInfo> files = base.GetFiles(searchPattern);
+            List<ZipFileInfo> zipFiles = new List<ZipFileInfo>(files.Count);
+            foreach (ZipFileInfo zipFile in files) zipFiles.Add(zipFile);
+            return zipFiles.AsReadOnly();
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression.Zip/ZipPacker.cs b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipPacker.cs
new file mode 100644
index 00000000..b9c183d3
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipPacker.cs
@@ -0,0 +1,489 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression.Zip
+{
+    using System;
+    using System.IO;
+    using System.IO.Compression;
+    using System.Collections.Generic;
+    using System.Globalization;
+
+    public partial class ZipEngine
+    {
+        /// <summary>
+        /// Creates a zip archive or chain of zip archives.
+        /// </summary>
+        /// <param name="streamContext">A context interface to handle opening
+        /// and closing of archive and file streams.</param>
+        /// <param name="files">An array of file lists.  Each list is
+        /// compressed into one stream in the archive.</param>
+        /// <param name="maxArchiveSize">The maximum number of bytes for one archive
+        /// before the contents are chained to the next archive, or zero for unlimited
+        /// archive size.</param>
+        /// <exception cref="ArchiveException">The archive could not be
+        /// created.</exception>
+        /// <remarks>
+        /// The stream context implementation may provide a mapping from the file
+        /// paths within the archive to the external file paths.
+        /// </remarks>
+        public override void Pack(
+            IPackStreamContext streamContext,
+            IEnumerable<string> files,
+            long maxArchiveSize)
+        {
+            if (streamContext == null)
+            {
+                throw new ArgumentNullException("streamContext");
+            }
+
+            if (files == null)
+            {
+                throw new ArgumentNullException("files");
+            }
+
+            lock (this)
+            {
+                Stream archiveStream = null;
+                try
+                {
+                    this.ResetProgressData();
+                    this.totalArchives = 1;
+
+                    object forceZip64Value = streamContext.GetOption("forceZip64", null);
+                    bool forceZip64 = Convert.ToBoolean(
+                        forceZip64Value, CultureInfo.InvariantCulture);
+
+                    // Count the total number of files and bytes to be compressed.
+                    foreach (string file in files)
+                    {
+                        FileAttributes attributes;
+                        DateTime lastWriteTime;
+                        Stream fileStream = streamContext.OpenFileReadStream(
+                            file,
+                            out attributes,
+                            out lastWriteTime);
+                        if (fileStream != null)
+                        {
+                            this.totalFileBytes += fileStream.Length;
+                            this.totalFiles++;
+                            streamContext.CloseFileReadStream(file, fileStream);
+                        }
+                    }
+
+                    List<ZipFileHeader> fileHeaders = new List<ZipFileHeader>();
+                    this.currentFileNumber = -1;
+
+                    if (this.currentArchiveName == null)
+                    {
+                        this.mainArchiveName = streamContext.GetArchiveName(0);
+                        this.currentArchiveName = this.mainArchiveName;
+
+                        if (String.IsNullOrEmpty(this.currentArchiveName))
+                        {
+                            throw new FileNotFoundException("No name provided for archive.");
+                        }
+                    }
+
+                    this.OnProgress(ArchiveProgressType.StartArchive);
+
+                    // Compress files one by one, saving header info for each.
+                    foreach (string file in files)
+                    {
+                        ZipFileHeader fileHeader = this.PackOneFile(
+                                streamContext,
+                                file,
+                                maxArchiveSize,
+                                forceZip64,
+                                ref archiveStream);
+
+                        if (fileHeader != null)
+                        {
+                            fileHeaders.Add(fileHeader);
+                        }
+
+                        this.currentArchiveTotalBytes = (archiveStream != null ?
+                            archiveStream.Position : 0);
+                        this.currentArchiveBytesProcessed = this.currentArchiveTotalBytes;
+                    }
+
+                    bool zip64 = forceZip64 || this.totalFiles > UInt16.MaxValue;
+
+                    // Write the central directory composed of all the file headers.
+                    uint centralDirStartArchiveNumber = 0;
+                    long centralDirStartPosition = 0;
+                    long centralDirSize = 0;
+                    for (int i = 0; i < fileHeaders.Count; i++)
+                    {
+                        ZipFileHeader fileHeader = fileHeaders[i];
+
+                        int headerSize = fileHeader.GetSize(true);
+                        centralDirSize += headerSize;
+
+                        this.CheckArchiveWriteStream(
+                            streamContext,
+                            maxArchiveSize,
+                            headerSize,
+                            ref archiveStream);
+
+                        if (i == 0)
+                        {
+                            centralDirStartArchiveNumber = (uint) this.currentArchiveNumber;
+                            centralDirStartPosition = archiveStream.Position;
+                        }
+
+                        fileHeader.Write(archiveStream, true);
+                        if (fileHeader.zip64)
+                        {
+                            zip64 = true;
+                        }
+                    }
+
+                    this.currentArchiveTotalBytes =
+                        (archiveStream != null ? archiveStream.Position : 0);
+                    this.currentArchiveBytesProcessed = this.currentArchiveTotalBytes;
+
+                    ZipEndOfCentralDirectory eocd = new ZipEndOfCentralDirectory();
+                    eocd.dirStartDiskNumber = centralDirStartArchiveNumber;
+                    eocd.entriesOnDisk = fileHeaders.Count;
+                    eocd.totalEntries = fileHeaders.Count;
+                    eocd.dirSize = centralDirSize;
+                    eocd.dirOffset = centralDirStartPosition;
+                    eocd.comment = this.comment;
+
+                    Zip64EndOfCentralDirectoryLocator eocdl =
+                        new Zip64EndOfCentralDirectoryLocator();
+
+                    int maxFooterSize = eocd.GetSize(false);
+                    if (archiveStream != null && (zip64 || archiveStream.Position >
+                        ((long) UInt32.MaxValue) - eocd.GetSize(false)))
+                    {
+                        maxFooterSize += eocd.GetSize(true) + (int)
+                            Zip64EndOfCentralDirectoryLocator.EOCDL64_SIZE;
+                        zip64 = true;
+                    }
+
+                    this.CheckArchiveWriteStream(
+                        streamContext,
+                        maxArchiveSize,
+                        maxFooterSize,
+                        ref archiveStream);
+                    eocd.diskNumber = (uint) this.currentArchiveNumber;
+
+                    if (zip64)
+                    {
+                        eocd.versionMadeBy = 45;
+                        eocd.versionNeeded = 45;
+                        eocd.zip64 = true;
+                        eocdl.dirOffset = archiveStream.Position;
+                        eocdl.dirStartDiskNumber = (uint) this.currentArchiveNumber;
+                        eocdl.totalDisks = (uint) this.currentArchiveNumber + 1;
+                        eocd.Write(archiveStream);
+                        eocdl.Write(archiveStream);
+
+                        eocd.dirOffset = UInt32.MaxValue;
+                        eocd.dirStartDiskNumber = UInt16.MaxValue;
+                    }
+
+                    eocd.zip64 = false;
+                    eocd.Write(archiveStream);
+
+                    this.currentArchiveTotalBytes = archiveStream.Position;
+                    this.currentArchiveBytesProcessed = this.currentArchiveTotalBytes;
+                }
+                finally
+                {
+                    if (archiveStream != null)
+                    {
+                        streamContext.CloseArchiveWriteStream(
+                            this.currentArchiveNumber, this.mainArchiveName, archiveStream);
+                        this.OnProgress(ArchiveProgressType.FinishArchive);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Moves to the next archive in the sequence if necessary.
+        /// </summary>
+        private void CheckArchiveWriteStream(
+            IPackStreamContext streamContext,
+            long maxArchiveSize,
+            long requiredSize,
+            ref Stream archiveStream)
+        {
+            if (archiveStream != null &&
+                archiveStream.Length > 0 && maxArchiveSize > 0)
+            {
+                long sizeRemaining = maxArchiveSize - archiveStream.Length;
+                if (sizeRemaining < requiredSize)
+                {
+                    string nextArchiveName = streamContext.GetArchiveName(
+                        this.currentArchiveNumber + 1);
+
+                    if (String.IsNullOrEmpty(nextArchiveName))
+                    {
+                        throw new FileNotFoundException("No name provided for archive #" +
+                            this.currentArchiveNumber + 1);
+                    }
+
+                    this.currentArchiveTotalBytes = archiveStream.Position;
+                    this.currentArchiveBytesProcessed = this.currentArchiveTotalBytes;
+
+                    streamContext.CloseArchiveWriteStream(
+                        this.currentArchiveNumber,
+                        nextArchiveName,
+                        archiveStream);
+                    archiveStream = null;
+
+                    this.OnProgress(ArchiveProgressType.FinishArchive);
+
+                    this.currentArchiveNumber++;
+                    this.totalArchives++;
+                    this.currentArchiveBytesProcessed = 0;
+                    this.currentArchiveTotalBytes = 0;
+                }
+            }
+
+            if (archiveStream == null)
+            {
+                if (this.currentArchiveNumber > 0)
+                {
+                    this.OnProgress(ArchiveProgressType.StartArchive);
+                }
+
+                archiveStream = streamContext.OpenArchiveWriteStream(
+                    this.currentArchiveNumber, this.mainArchiveName, true, this);
+
+                if (archiveStream == null)
+                {
+                    throw new FileNotFoundException("Stream not provided for archive #" +
+                        this.currentArchiveNumber);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Adds one file to a zip archive in the process of being created.
+        /// </summary>
+        private ZipFileHeader PackOneFile(
+            IPackStreamContext streamContext,
+            string file,
+            long maxArchiveSize,
+            bool forceZip64,
+            ref Stream archiveStream)
+        {
+            Stream fileStream = null;
+            int headerArchiveNumber = 0;
+            try
+            {
+                // TODO: call GetOption to get compression method for the specific file
+                ZipCompressionMethod compressionMethod = ZipCompressionMethod.Deflate;
+                if (this.CompressionLevel == WixToolset.Dtf.Compression.CompressionLevel.None)
+                {
+                    compressionMethod = ZipCompressionMethod.Store;
+                }
+
+                Converter<Stream, Stream> compressionStreamCreator;
+                if (!ZipEngine.compressionStreamCreators.TryGetValue(
+                    compressionMethod, out compressionStreamCreator))
+                {
+                    return null;
+                }
+
+                FileAttributes attributes;
+                DateTime lastWriteTime;
+                fileStream = streamContext.OpenFileReadStream(
+                    file, out attributes, out lastWriteTime);
+                if (fileStream == null)
+                {
+                    return null;
+                }
+
+                this.currentFileName = file;
+                this.currentFileNumber++;
+
+                this.currentFileTotalBytes = fileStream.Length;
+                this.currentFileBytesProcessed = 0;
+                this.OnProgress(ArchiveProgressType.StartFile);
+
+                ZipFileInfo fileInfo = new ZipFileInfo(
+                    file,
+                    this.currentArchiveNumber,
+                    attributes,
+                    lastWriteTime,
+                    fileStream.Length,
+                    0,
+                    compressionMethod);
+
+                bool zip64 = forceZip64 || fileStream.Length >= (long) UInt32.MaxValue;
+                ZipFileHeader fileHeader = new ZipFileHeader(fileInfo, zip64);
+
+                this.CheckArchiveWriteStream(
+                    streamContext,
+                    maxArchiveSize,
+                    fileHeader.GetSize(false),
+                    ref archiveStream);
+
+                long headerPosition = archiveStream.Position;
+                fileHeader.Write(archiveStream, false);
+                headerArchiveNumber = this.currentArchiveNumber;
+
+                uint crc;
+                long bytesWritten = this.PackFileBytes(
+                    streamContext,
+                    fileStream,
+                    maxArchiveSize,
+                    compressionStreamCreator,
+                    ref archiveStream,
+                    out crc);
+
+                fileHeader.Update(
+                    bytesWritten,
+                    fileStream.Length,
+                    crc,
+                    headerPosition,
+                    headerArchiveNumber);
+
+                streamContext.CloseFileReadStream(file, fileStream);
+                fileStream = null;
+
+                // Go back and rewrite the updated file header.
+                if (this.currentArchiveNumber == headerArchiveNumber)
+                {
+                    long fileEndPosition = archiveStream.Position;
+                    archiveStream.Seek(headerPosition, SeekOrigin.Begin);
+                    fileHeader.Write(archiveStream, false);
+                    archiveStream.Seek(fileEndPosition, SeekOrigin.Begin);
+                }
+                else
+                {
+                    // The file spanned archives, so temporarily reopen
+                    // the archive where it started.
+                    string headerArchiveName = streamContext.GetArchiveName(
+                        headerArchiveNumber + 1);
+                    Stream headerStream = null;
+                    try
+                    {
+                        headerStream = streamContext.OpenArchiveWriteStream(
+                            headerArchiveNumber, headerArchiveName, false, this);
+                        headerStream.Seek(headerPosition, SeekOrigin.Begin);
+                        fileHeader.Write(headerStream, false);
+                    }
+                    finally
+                    {
+                        if (headerStream != null)
+                        {
+                            streamContext.CloseArchiveWriteStream(
+                                headerArchiveNumber, headerArchiveName, headerStream);
+                        }
+                    }
+                }
+
+                this.OnProgress(ArchiveProgressType.FinishFile);
+
+                return fileHeader;
+            }
+            finally
+            {
+                if (fileStream != null)
+                {
+                    streamContext.CloseFileReadStream(
+                        this.currentFileName, fileStream);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Writes compressed bytes of one file to the archive,
+        /// keeping track of the CRC and number of bytes written.
+        /// </summary>
+        private long PackFileBytes(
+            IPackStreamContext streamContext,
+            Stream fileStream,
+            long maxArchiveSize,
+            Converter<Stream, Stream> compressionStreamCreator,
+            ref Stream archiveStream,
+            out uint crc)
+        {
+            long writeStartPosition = archiveStream.Position;
+            long bytesWritten = 0;
+            CrcStream fileCrcStream = new CrcStream(fileStream);
+
+            ConcatStream concatStream = new ConcatStream(
+                delegate(ConcatStream s)
+                {
+                    Stream sourceStream = s.Source;
+                    bytesWritten += sourceStream.Position - writeStartPosition;
+
+                    this.CheckArchiveWriteStream(
+                        streamContext,
+                        maxArchiveSize,
+                        1,
+                        ref sourceStream);
+
+                    writeStartPosition = sourceStream.Position;
+                    s.Source = sourceStream;
+                });
+
+            concatStream.Source = archiveStream;
+
+            if (maxArchiveSize > 0)
+            {
+                concatStream.SetLength(maxArchiveSize);
+            }
+
+            Stream compressionStream = compressionStreamCreator(concatStream);
+
+            try
+            {
+                byte[] buf = new byte[4096];
+                long bytesRemaining = fileStream.Length;
+                int counter = 0;
+                while (bytesRemaining > 0)
+                {
+                    int count = (int) Math.Min(
+                        bytesRemaining, (long) buf.Length);
+
+                    count = fileCrcStream.Read(buf, 0, count);
+                    if (count <= 0)
+                    {
+                        throw new ZipException(
+                            "Failed to read file: " + this.currentFileName);
+                    }
+
+                    compressionStream.Write(buf, 0, count);
+                    bytesRemaining -= count;
+
+                    this.fileBytesProcessed += count;
+                    this.currentFileBytesProcessed += count;
+                    this.currentArchiveTotalBytes = concatStream.Source.Position;
+                    this.currentArchiveBytesProcessed = this.currentArchiveTotalBytes;
+
+                    if (++counter % 16 == 0) // Report every 64K
+                    {
+                        this.OnProgress(ArchiveProgressType.PartialFile);
+                    }
+                }
+
+                if (compressionStream is DeflateStream)
+                {
+                    compressionStream.Close();
+                }
+                else
+                {
+                    compressionStream.Flush();
+                }
+            }
+            finally
+            {
+                archiveStream = concatStream.Source;
+            }
+
+            bytesWritten += archiveStream.Position - writeStartPosition;
+
+            crc = fileCrcStream.Crc;
+
+            return bytesWritten;
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.Compression.Zip/ZipUnpacker.cs b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipUnpacker.cs
new file mode 100644
index 00000000..681c0e46
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.Compression.Zip/ZipUnpacker.cs
@@ -0,0 +1,336 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Dtf.Compression.Zip
+{
+    using System;
+    using System.IO;
+    using System.IO.Compression;
+    using System.Collections.Generic;
+
+    public partial class ZipEngine
+    {
+        /// <summary>
+        /// Extracts files from a zip archive or archive chain.
+        /// </summary>
+        /// <param name="streamContext">A context interface to handle opening
+        /// and closing of archive and file streams.</param>
+        /// <param name="fileFilter">An optional predicate that can determine
+        /// which files to process.</param>
+        /// <exception cref="ArchiveException">The archive provided
+        /// by the stream context is not valid.</exception>
+        /// <remarks>
+        /// The <paramref name="fileFilter"/> predicate takes an internal file
+        /// path and returns true to include the file or false to exclude it.
+        /// </remarks>
+        public override void Unpack(
+            IUnpackStreamContext streamContext,
+            Predicate<string> fileFilter)
+        {
+            if (streamContext == null)
+            {
+                throw new ArgumentNullException("streamContext");
+            }
+
+            lock (this)
+            {
+                IList<ZipFileHeader> allHeaders = this.GetCentralDirectory(streamContext);
+                if (allHeaders == null)
+                {
+                    throw new ZipException("Zip central directory not found.");
+                }
+
+                IList<ZipFileHeader> headers = new List<ZipFileHeader>(allHeaders.Count);
+                foreach (ZipFileHeader header in allHeaders)
+                {
+                    if (!header.IsDirectory &&
+                        (fileFilter == null || fileFilter(header.fileName)))
+                    {
+                        headers.Add(header);
+                    }
+                }
+
+                this.ResetProgressData();
+
+                // Count the total number of files and bytes to be compressed.
+                this.totalFiles = headers.Count;
+                foreach (ZipFileHeader header in headers)
+                {
+                    long compressedSize;
+                    long uncompressedSize;
+                    long localHeaderOffset;
+                    int archiveNumber;
+                    uint crc;
+                    header.GetZip64Fields(
+                        out compressedSize,
+                        out uncompressedSize,
+                        out localHeaderOffset,
+                        out archiveNumber,
+                        out crc);
+
+                    this.totalFileBytes += uncompressedSize;
+                    if (archiveNumber >= this.totalArchives)
+                    {
+                        this.totalArchives = (short) (archiveNumber + 1);
+                    }
+                }
+
+                this.currentArchiveNumber = -1;
+                this.currentFileNumber = -1;
+                Stream archiveStream = null;
+                try
+                {
+                    foreach (ZipFileHeader header in headers)
+                    {
+                        this.currentFileNumber++;
+                        this.UnpackOneFile(streamContext, header, ref archiveStream);
+                    }
+                }
+                finally
+                {
+                    if (archiveStream != null)
+                    {
+                        streamContext.CloseArchiveReadStream(
+                            0, String.Empty, archiveStream);
+                        this.currentArchiveNumber--;
+                        this.OnProgress(ArchiveProgressType.FinishArchive);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Unpacks a single file from an archive or archive chain.
+        /// </summary>
+        private void UnpackOneFile(
+            IUnpackStreamContext streamContext,
+            ZipFileHeader header,
+            ref Stream archiveStream)
+        {
+            ZipFileInfo fileInfo = null;
+            Stream fileStream = null;
+            try
+            {
+                Converter<Stream, Stream> compressionStreamCreator;
+                if (!ZipEngine.decompressionStreamCreators.TryGetValue(
+                    header.compressionMethod, out compressionStreamCreator))
+                {
+                    // Silently skip files of an unsupported compression method.
+                    return;
+                }
+
+                long compressedSize;
+                long uncompressedSize;
+                long localHeaderOffset;
+                int archiveNumber;
+                uint crc;
+                header.GetZip64Fields(
+                    out compressedSize,
+                    out uncompressedSize,
+                    out localHeaderOffset,
+                    out archiveNumber,
+                    out crc);
+
+                if (this.currentArchiveNumber != archiveNumber + 1)
+                {
+                    if (archiveStream != null)
+                    {
+                        streamContext.CloseArchiveReadStream(
+                            this.currentArchiveNumber,
+                            String.Empty,
+                            archiveStream);
+                        archiveStream = null;
+
+                        this.OnProgress(ArchiveProgressType.FinishArchive);
+                        this.currentArchiveName = null;
+                    }
+
+                    this.currentArchiveNumber = (short) (archiveNumber + 1);
+                    this.currentArchiveBytesProcessed = 0;
+                    this.currentArchiveTotalBytes = 0;
+
+                    archiveStream = this.OpenArchive(
+                        streamContext, this.currentArchiveNumber);
+
+                    FileStream archiveFileStream = archiveStream as FileStream;
+                    this.currentArchiveName = (archiveFileStream != null ?
+                        Path.GetFileName(archiveFileStream.Name) : null);
+
+                    this.currentArchiveTotalBytes = archiveStream.Length;
+                    this.currentArchiveNumber--;
+                    this.OnProgress(ArchiveProgressType.StartArchive);
+                    this.currentArchiveNumber++;
+                }
+
+                archiveStream.Seek(localHeaderOffset, SeekOrigin.Begin);
+
+                ZipFileHeader localHeader = new ZipFileHeader();
+                if (!localHeader.Read(archiveStream, false) ||
+                    !ZipEngine.AreFilePathsEqual(localHeader.fileName, header.fileName))
+                {
+                    string msg = "Could not read file: " + header.fileName;
+                    throw new ZipException(msg);
+                }
+
+                fileInfo = header.ToZipFileInfo();
+
+                fileStream = streamContext.OpenFileWriteStream(
+                    fileInfo.FullName,
+                    fileInfo.Length,
+                    fileInfo.LastWriteTime);
+
+                if (fileStream != null)
+                {
+                    this.currentFileName = header.fileName;
+                    this.currentFileBytesProcessed = 0;
+                    this.currentFileTotalBytes = fileInfo.Length;
+                    this.currentArchiveNumber--;
+                    this.OnProgress(ArchiveProgressType.StartFile);
+                    this.currentArchiveNumber++;
+
+                    this.UnpackFileBytes(
+                        streamContext,
+                        fileInfo.FullName,
+                        fileInfo.CompressedLength,
+                        fileInfo.Length,
+                        header.crc32,
+                        fileStream,
+                        compressionStreamCreator,
+                        ref archiveStream);
+                }
+            }
+            finally
+            {
+                if (fileStream != null)
+                {
+                    streamContext.CloseFileWriteStream(
+                        fileInfo.FullName,
+                        fileStream,
+                        fileInfo.Attributes,
+                        fileInfo.LastWriteTime);
+
+                    this.currentArchiveNumber--;
+                    this.OnProgress(ArchiveProgressType.FinishFile);
+                    this.currentArchiveNumber++;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Compares two internal file paths while ignoring case and slash differences.
+        /// </summary>
+        /// <param name="path1">The first path to compare.</param>
+        /// <param name="path2">The second path to compare.</param>
+        /// <returns>True if the paths are equivalent.</returns>
+        private static bool AreFilePathsEqual(string path1, string path2)
+        {
+            path1 = path1.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+            path2 = path2.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+            return String.Compare(path1, path2, StringComparison.OrdinalIgnoreCase) == 0;
+        }
+
+        private Stream OpenArchive(IUnpackStreamContext streamContext, int archiveNumber)
+        {
+            Stream archiveStream = streamContext.OpenArchiveReadStream(
+                archiveNumber, String.Empty, this);
+            if (archiveStream == null && archiveNumber != 0)
+            {
+                archiveStream = streamContext.OpenArchiveReadStream(
+                    0, String.Empty, this);
+            }
+
+            if (archiveStream == null)
+            {
+                throw new FileNotFoundException("Archive stream not provided.");
+            }
+
+            return archiveStream;
+        }
+
+        /// <summary>
+        /// Decompresses bytes for one file from an archive or archive chain,
+        /// checking the crc at the end.
+        /// </summary>
+        private void UnpackFileBytes(
+            IUnpackStreamContext streamContext,
+            string fileName,
+            long compressedSize,
+            long uncompressedSize,
+            uint crc,
+            Stream fileStream,
+            Converter<Stream, Stream> compressionStreamCreator,
+            ref Stream archiveStream)
+        {
+            CrcStream crcStream = new CrcStream(fileStream);
+
+            ConcatStream concatStream = new ConcatStream(
+                delegate(ConcatStream s)
+                {
+                    this.currentArchiveBytesProcessed = s.Source.Position;
+                    streamContext.CloseArchiveReadStream(
+                        this.currentArchiveNumber,
+                        String.Empty,
+                        s.Source);
+
+                    this.currentArchiveNumber--;
+                    this.OnProgress(ArchiveProgressType.FinishArchive);
+                    this.currentArchiveNumber += 2;
+                    this.currentArchiveName = null;
+                    this.currentArchiveBytesProcessed = 0;
+                    this.currentArchiveTotalBytes = 0;
+
+                    s.Source = this.OpenArchive(streamContext, this.currentArchiveNumber);
+
+                    FileStream archiveFileStream = s.Source as FileStream;
+                    this.currentArchiveName = (archiveFileStream != null ?
+                        Path.GetFileName(archiveFileStream.Name) : null);
+
+                    this.currentArchiveTotalBytes = s.Source.Length;
+                    this.currentArchiveNumber--;
+                    this.OnProgress(ArchiveProgressType.StartArchive);
+                    this.currentArchiveNumber++;
+                });
+
+            concatStream.Source = archiveStream;
+            concatStream.SetLength(compressedSize);
+
+            Stream decompressionStream = compressionStreamCreator(concatStream);
+
+            try
+            {
+                byte[] buf = new byte[4096];
+                long bytesRemaining = uncompressedSize;
+                int counter = 0;
+                while (bytesRemaining > 0)
+                {
+                    int count = (int) Math.Min(buf.Length, bytesRemaining);
+                    count = decompressionStream.Read(buf, 0, count);
+                    crcStream.Write(buf, 0, count);
+                    bytesRemaining -= count;
+
+                    this.fileBytesProcessed += count;
+                    this.currentFileBytesProcessed += count;
+                    this.currentArchiveBytesProcessed = concatStream.Source.Position;
+
+                    if (++counter % 16 == 0) // Report every 64K
+                    {
+                        this.currentArchiveNumber--;
+                        this.OnProgress(ArchiveProgressType.PartialFile);
+                        this.currentArchiveNumber++;
+                    }
+                }
+            }
+            finally
+            {
+                archiveStream = concatStream.Source;
+            }
+
+            crcStream.Flush();
+
+            if (crcStream.Crc != crc)
+            {
+                throw new ZipException("CRC check failed for file: " + fileName);
+            }
+        }
+    }
+}
+