void ExtractEntry(ZipEntry entry)
{
bool doExtraction = NameIsValid(entry.Name) && entry.IsCompressionMethodSupported();
// TODO: Fire delegate were compression method not supported.
string dirName = null;
string targetName = null;
if (doExtraction)
{
string entryFileName;
if (Path.IsPathRooted(entry.Name))
{
string workName = Path.GetPathRoot(entry.Name);
workName = entry.Name.Substring(workName.Length);
entryFileName = Path.Combine(Path.GetDirectoryName(workName), Path.GetFileName(entry.Name));
}
else
{
entryFileName = entry.Name;
}
targetName = Path.Combine(targetDirectory_, entryFileName);
dirName = Path.GetDirectoryName(Path.GetFullPath(targetName));
doExtraction = (entryFileName.Length > 0);
}
if (doExtraction && !Directory.Exists(dirName))
{
if (!entry.IsDirectory || CreateEmptyDirectories)
{
try {
Directory.CreateDirectory(dirName);
}
catch {
doExtraction = false;
}
}
}
if (doExtraction && entry.IsFile)
{
ExtractFileEntry(entry, targetName);
}
}
private void ExtractEntry(ZipEntry entry)
{
bool flag = FastZip.NameIsValid(entry.Name) && entry.IsCompressionMethodSupported();
string path = null;
string text = null;
if (flag)
{
string text3;
if (Path.IsPathRooted(entry.Name))
{
string text2 = Path.GetPathRoot(entry.Name);
text2 = entry.Name.Substring(text2.Length);
text3 = Path.Combine(Path.GetDirectoryName(text2), Path.GetFileName(entry.Name));
}
else
{
text3 = entry.Name;
}
text = Path.Combine(this.targetDirectory_, text3);
path = Path.GetDirectoryName(Path.GetFullPath(text));
flag = (text3.Length > 0);
}
if (flag && !Directory.Exists(path))
{
if (entry.IsDirectory)
{
if (!this.CreateEmptyDirectories)
{
goto IL_B9;
}
}
try
{
Directory.CreateDirectory(path);
}
catch
{
flag = false;
}
}
IL_B9:
if (flag && entry.IsFile)
{
this.ExtractFileEntry(entry, text);
}
}
/// <summary>
/// Advances to the next entry in the archive
/// </summary>
/// <returns>
/// The next <see cref="ZipEntry">entry</see> in the archive or null if there are no more entries.
/// </returns>
/// <remarks>
/// If the previous entry is still open <see cref="CloseEntry">CloseEntry</see> is called.
/// </remarks>
/// <exception cref="InvalidOperationException">
/// Input stream is closed
/// </exception>
/// <exception cref="ZipException">
/// Password is not set, password is invalid, compression method is invalid,
/// version required to extract is not supported
/// </exception>
public ZipEntry GetNextEntry()
{
if (crc == null) {
throw new InvalidOperationException("Closed.");
}
if (entry != null) {
CloseEntry();
}
int header = inputBuffer.ReadLeInt();
if (header == ZipConstants.CentralHeaderSignature ||
header == ZipConstants.EndOfCentralDirectorySignature ||
header == ZipConstants.CentralHeaderDigitalSignature ||
header == ZipConstants.ArchiveExtraDataSignature ||
header == ZipConstants.Zip64CentralFileHeaderSignature) {
// No more individual entries exist
Close();
return null;
}
// -jr- 07-Dec-2003 Ignore spanning temporary signatures if found
// Spanning signature is same as descriptor signature and is untested as yet.
if ( (header == ZipConstants.SpanningTempSignature) || (header == ZipConstants.SpanningSignature) ) {
header = inputBuffer.ReadLeInt();
}
if (header != ZipConstants.LocalHeaderSignature) {
throw new ZipException("Wrong Local header signature: 0x" + String.Format("{0:X}", header));
}
short versionRequiredToExtract = (short)inputBuffer.ReadLeShort();
flags = inputBuffer.ReadLeShort();
method = inputBuffer.ReadLeShort();
uint dostime = (uint)inputBuffer.ReadLeInt();
int crc2 = inputBuffer.ReadLeInt();
csize = inputBuffer.ReadLeInt();
size = inputBuffer.ReadLeInt();
int nameLen = inputBuffer.ReadLeShort();
int extraLen = inputBuffer.ReadLeShort();
bool isCrypted = (flags & 1) == 1;
byte[] buffer = new byte[nameLen];
inputBuffer.ReadRawBuffer(buffer);
string name = ZipConstants.ConvertToStringExt(flags, buffer);
entry = new ZipEntry(name, versionRequiredToExtract);
entry.Flags = flags;
entry.CompressionMethod = (CompressionMethod)method;
if ((flags & 8) == 0) {
entry.Crc = crc2 & 0xFFFFFFFFL;
entry.Size = size & 0xFFFFFFFFL;
entry.CompressedSize = csize & 0xFFFFFFFFL;
entry.CryptoCheckValue = (byte)(crc2 >> 24);
} else {
// This allows for GNU, WinZip and possibly other archives, the PKZIP spec
// says these values are zero under these circumstances.
if (crc2 != 0) {
entry.Crc = crc2 & 0xFFFFFFFFL;
}
if (size != 0) {
entry.Size = size & 0xFFFFFFFFL;
}
if (csize != 0) {
entry.CompressedSize = csize & 0xFFFFFFFFL;
}
entry.CryptoCheckValue = (byte)((dostime >> 8) & 0xff);
}
entry.DosTime = dostime;
// If local header requires Zip64 is true then the extended header should contain
// both values.
// Handle extra data if present. This can set/alter some fields of the entry.
if (extraLen > 0) {
byte[] extra = new byte[extraLen];
inputBuffer.ReadRawBuffer(extra);
entry.ExtraData = extra;
}
entry.ProcessExtraData(true);
if ( entry.CompressedSize >= 0 ) {
csize = entry.CompressedSize;
}
if ( entry.Size >= 0 ) {
size = entry.Size;
}
if (method == (int)CompressionMethod.Stored && (!isCrypted && csize != size || (isCrypted && csize - ZipConstants.CryptoHeaderSize != size))) {
throw new ZipException("Stored, but compressed != uncompressed");
}
// Determine how to handle reading of data if this is attempted.
if (entry.IsCompressionMethodSupported()) {
internalReader = new ReaderDelegate(InitialRead);
} else {
internalReader = new ReaderDelegate(ReadingNotSupported);
}
return entry;
}
void ExtractEntry(ZipEntry entry)
{
bool doExtraction = false;
string nameText = entry.Name;
if ( entry.IsFile ) {
// TODO: Translate invalid names allowing extraction still.
doExtraction = NameIsValid(nameText) && entry.IsCompressionMethodSupported();
}
else if ( entry.IsDirectory ) {
doExtraction = NameIsValid(nameText);
}
// TODO: Fire delegate were compression method not supported, or name is invalid?
string dirName = null;
string targetName = null;
if ( doExtraction ) {
// Handle invalid entry names by chopping of path root.
if (Path.IsPathRooted(nameText)) {
string workName = Path.GetPathRoot(nameText);
nameText = nameText.Substring(workName.Length);
}
if ( nameText.Length > 0 ) {
targetName = Path.Combine(targetDirectory_, nameText);
if ( entry.IsDirectory ) {
dirName = targetName;
}
else {
dirName = Path.GetDirectoryName(Path.GetFullPath(targetName));
}
}
else {
doExtraction = false;
}
}
if ( doExtraction && !Directory.Exists(dirName) ) {
if ( !entry.IsDirectory || CreateEmptyDirectories ) {
try {
Directory.CreateDirectory(dirName);
}
catch (Exception ex) {
doExtraction = false;
if ( events_ != null ) {
if ( entry.IsDirectory ) {
continueRunning_ = events_.OnDirectoryFailure(targetName, ex);
}
else {
continueRunning_ = events_.OnFileFailure(targetName, ex);
}
}
else {
continueRunning_ = false;
}
}
}
}
if ( doExtraction && entry.IsFile ) {
ExtractFileEntry(entry, targetName);
}
}
/// <summary>
/// Advances to the next entry in the archive
/// </summary>
/// <returns>
/// The next <see cref="ZipEntry">entry</see> in the archive or null if there are no more entries.
/// </returns>
/// <remarks>
/// If the previous entry is still open <see cref="CloseEntry">CloseEntry</see> is called.
/// </remarks>
/// <exception cref="InvalidOperationException">
/// Input stream is closed
/// </exception>
/// <exception cref="ZipException">
/// Password is not set, password is invalid, compression method is invalid,
/// version required to extract is not supported
/// </exception>
public ZipEntry GetNextEntry()
{
if (crc == null)
{
throw new InvalidOperationException("Closed.");
}
if (entry != null)
{
CloseEntry();
}
int header = inputBuffer.ReadLeInt();
if (header == ZipConstants.CentralHeaderSignature ||
header == ZipConstants.EndOfCentralDirectorySignature ||
header == ZipConstants.CentralHeaderDigitalSignature ||
header == ZipConstants.ArchiveExtraDataSignature ||
header == ZipConstants.Zip64CentralFileHeaderSignature)
{
// No more individual entries exist
Close();
return(null);
}
// -jr- 07-Dec-2003 Ignore spanning temporary signatures if found
// Spanning signature is same as descriptor signature and is untested as yet.
if ((header == ZipConstants.SpanningTempSignature) || (header == ZipConstants.SpanningSignature))
{
header = inputBuffer.ReadLeInt();
}
if (header != ZipConstants.LocalHeaderSignature)
{
throw new ZipException("Wrong Local header signature: 0x" + String.Format("{0:X}", header));
}
short versionRequiredToExtract = (short)inputBuffer.ReadLeShort();
flags = inputBuffer.ReadLeShort();
method = inputBuffer.ReadLeShort();
uint dostime = (uint)inputBuffer.ReadLeInt();
int crc2 = inputBuffer.ReadLeInt();
csize = inputBuffer.ReadLeInt();
size = inputBuffer.ReadLeInt();
int nameLen = inputBuffer.ReadLeShort();
int extraLen = inputBuffer.ReadLeShort();
bool isCrypted = (flags & 1) == 1;
byte[] buffer = new byte[nameLen];
inputBuffer.ReadRawBuffer(buffer);
string name = ZipConstants.ConvertToStringExt(flags, buffer);
entry = new ZipEntry(name, versionRequiredToExtract);
entry.Flags = flags;
entry.CompressionMethod = (CompressionMethod)method;
if ((flags & 8) == 0)
{
entry.Crc = crc2 & 0xFFFFFFFFL;
entry.Size = size & 0xFFFFFFFFL;
entry.CompressedSize = csize & 0xFFFFFFFFL;
entry.CryptoCheckValue = (byte)(crc2 >> 24);
}
else
{
// This allows for GNU, WinZip and possibly other archives, the PKZIP spec
// says these values are zero under these circumstances.
if (crc2 != 0)
{
entry.Crc = crc2 & 0xFFFFFFFFL;
}
if (size != 0)
{
entry.Size = size & 0xFFFFFFFFL;
}
if (csize != 0)
{
entry.CompressedSize = csize & 0xFFFFFFFFL;
}
entry.CryptoCheckValue = (byte)((dostime >> 8) & 0xff);
}
entry.DosTime = dostime;
// If local header requires Zip64 is true then the extended header should contain
// both values.
// Handle extra data if present. This can set/alter some fields of the entry.
if (extraLen > 0)
{
byte[] extra = new byte[extraLen];
inputBuffer.ReadRawBuffer(extra);
entry.ExtraData = extra;
}
entry.ProcessExtraData(true);
if (entry.CompressedSize >= 0)
{
csize = entry.CompressedSize;
}
if (entry.Size >= 0)
{
size = entry.Size;
}
if (method == (int)CompressionMethod.Stored && (!isCrypted && csize != size || (isCrypted && csize - ZipConstants.CryptoHeaderSize != size)))
{
throw new ZipException("Stored, but compressed != uncompressed");
}
// Determine how to handle reading of data if this is attempted.
if (entry.IsCompressionMethodSupported())
{
internalReader = new ReaderDelegate(InitialRead);
}
else
{
internalReader = new ReaderDelegate(ReadingNotSupported);
}
return(entry);
}
/// <summary>
/// Test a local header against that provided from the central directory
/// </summary>
/// <param name="entry">
/// The entry to test against
/// </param>
/// <param name="tests">The type of <see cref="HeaderTest">tests</see> to carry out.</param>
/// <returns>The offset of the entries data in the file</returns>
long TestLocalHeader(ZipEntry entry, HeaderTest tests)
{
lock(baseStream_)
{
bool testHeader = (tests & HeaderTest.Header) != 0;
bool testData = (tests & HeaderTest.Extract) != 0;
baseStream_.Seek(offsetOfFirstEntry + entry.Offset, SeekOrigin.Begin);
if ((int)ReadLEUint() != ZipConstants.LocalHeaderSignature) {
throw new ZipException(string.Format("Wrong local header signature @{0:X}", offsetOfFirstEntry + entry.Offset));
}
short extractVersion = ( short )ReadLEUshort();
short localFlags = ( short )ReadLEUshort();
short compressionMethod = ( short )ReadLEUshort();
short fileTime = ( short )ReadLEUshort();
short fileDate = ( short )ReadLEUshort();
uint crcValue = ReadLEUint();
long size = ReadLEUint();
long compressedSize = ReadLEUint();
int storedNameLength = ReadLEUshort();
int extraDataLength = ReadLEUshort();
// eliminate system id from version (use version only)
extractVersion &= 0x00FF;
if ( testData ) {
if ( entry.IsFile ) {
if ( !entry.IsCompressionMethodSupported() ) {
throw new ZipException("Compression method not supported");
}
if ( (extractVersion > ZipConstants.VersionMadeBy)
|| ((extractVersion > 20) && (extractVersion < ZipConstants.VersionZip64)) ) {
throw new ZipException(string.Format("Version required to extract this entry not supported ({0})", extractVersion));
}
if ( (localFlags & ( int )(GeneralBitFlags.Patched | GeneralBitFlags.StrongEncryption | GeneralBitFlags.EnhancedCompress | GeneralBitFlags.HeaderMasked)) != 0 ) {
throw new ZipException("The library does not support the zip version required to extract this entry");
}
}
}
if ( testHeader ) {
if ((extractVersion <= 63) && // Ignore later versions as we dont know about them..
(extractVersion != 10) &&
(extractVersion != 11) &&
(extractVersion != 20) &&
(extractVersion != 21) &&
(extractVersion != 25) &&
(extractVersion != 27) &&
(extractVersion != 45) &&
(extractVersion != 46) &&
(extractVersion != 50) &&
(extractVersion != 51) &&
(extractVersion != 52) &&
(extractVersion != 61) &&
(extractVersion != 62) &&
(extractVersion != 63)
) {
throw new ZipException(string.Format("Version required to extract this entry is invalid ({0})", extractVersion));
}
// Local entry flags dont have reserved bit set on.
if ( (localFlags & ( int )(GeneralBitFlags.ReservedPKware4 | GeneralBitFlags.ReservedPkware14 | GeneralBitFlags.ReservedPkware15)) != 0 ) {
throw new ZipException("Reserved bit flags cannot be set.");
}
// Encryption requires extract version >= 20
if ( ((localFlags & ( int )GeneralBitFlags.Encrypted) != 0) && (extractVersion < 20) ) {
throw new ZipException(string.Format("Version required to extract this entry is too low for encryption ({0})", extractVersion));
}
// Strong encryption requires encryption flag to be set and extract version >= 50.
if ( (localFlags & (int)GeneralBitFlags.StrongEncryption) != 0 ) {
if ( (localFlags & (int)GeneralBitFlags.Encrypted) == 0 ) {
throw new ZipException("Strong encryption flag set but encryption flag is not set");
}
if ( extractVersion < 50 ) {
throw new ZipException(string.Format("Version required to extract this entry is too low for encryption ({0})", extractVersion));
}
}
// Patched entries require extract version >= 27
if ( ((localFlags & ( int )GeneralBitFlags.Patched) != 0) && (extractVersion < 27) ) {
throw new ZipException(string.Format("Patched data requires higher version than ({0})", extractVersion));
}
// Central header flags match local entry flags.
if ( localFlags != entry.Flags ) {
throw new ZipException("Central header/local header flags mismatch");
}
// Central header compression method matches local entry
if ( entry.CompressionMethod != ( CompressionMethod )compressionMethod ) {
throw new ZipException("Central header/local header compression method mismatch");
}
// Strong encryption and extract version match
if ( (localFlags & ( int )GeneralBitFlags.StrongEncryption) != 0 ) {
if ( extractVersion < 62 ) {
throw new ZipException("Strong encryption flag set but version not high enough");
}
}
if ( (localFlags & ( int )GeneralBitFlags.HeaderMasked) != 0 ) {
if ( (fileTime != 0) || (fileDate != 0) ) {
throw new ZipException("Header masked set but date/time values non-zero");
}
}
if ( (localFlags & ( int )GeneralBitFlags.Descriptor) == 0 ) {
if ( crcValue != (uint)entry.Crc ) {
throw new ZipException("Central header/local header crc mismatch");
}
}
// Crc valid for empty entry.
if ( (size == 0) && (compressedSize == 0) ) {
if ( crcValue != 0 ) {
throw new ZipException("Invalid CRC for empty entry");
}
}
// TODO: make test more correct... can't compare lengths as was done originally as this can fail for MBCS strings
// Assuming a code page at this point is not valid? Best is to store the name length in the ZipEntry probably
if ( entry.Name.Length > storedNameLength ) {
throw new ZipException("File name length mismatch");
}
byte[] nameData = new byte[storedNameLength];
StreamUtils.ReadFully(baseStream_, nameData);
string localName = ZipConstants.ConvertToStringExt(localFlags, nameData);
// Central directory and local entry name match
if ( localName != entry.Name ) {
throw new ZipException("Central header and local header file name mismatch");
}
// Directories have zero size.
if ( entry.IsDirectory ) {
if ( (compressedSize != 0) || (size != 0) ) {
throw new ZipException("Directory cannot have size");
}
}
if ( !ZipNameTransform.IsValidName(localName, true) ) {
throw new ZipException("Name is invalid");
}
byte[] data = new byte[extraDataLength];
StreamUtils.ReadFully(baseStream_, data);
ZipExtraData ed = new ZipExtraData(data);
// Extra data / zip64 checks
if ( ed.Find(1) ) {
// Zip64 extra data but 'extract version' is too low
if ( extractVersion < ZipConstants.VersionZip64 ) {
throw new ZipException(
string.Format("Extra data contains Zip64 information but version {0}.{1} is not high enough",
extractVersion / 10, extractVersion % 10));
}
// Zip64 extra data but size fields dont indicate its required.
if ( (( uint )size != uint.MaxValue) && (( uint )compressedSize != uint.MaxValue) ) {
throw new ZipException("Entry sizes not correct for Zip64");
}
size = ed.ReadLong();
compressedSize = ed.ReadLong();
}
else {
// No zip64 extra data but entry requires it.
if ( (extractVersion >= ZipConstants.VersionZip64) &&
((( uint )size == uint.MaxValue) || (( uint )compressedSize == uint.MaxValue)) ) {
throw new ZipException("Required Zip64 extended information missing");
}
}
}
int extraLength = storedNameLength + extraDataLength;
return offsetOfFirstEntry + entry.Offset + ZipConstants.LocalHeaderBaseSize + extraLength;
}
}
private void ExtractEntry(ZipEntry entry)
{
bool flag = entry.IsCompressionMethodSupported();
string name = entry.Name;
if (flag)
{
if (entry.IsFile)
{
name = _extractNameTransform.TransformFile(name);
}
else if (entry.IsDirectory)
{
name = _extractNameTransform.TransformDirectory(name);
}
flag = (name != null) && (name.Length != 0);
}
string path = null;
if (flag)
{
if (entry.IsDirectory)
{
path = name;
}
else
{
path = Path.GetDirectoryName(Path.GetFullPath(name));
}
}
if ((flag && !Directory.Exists(path)) && (!entry.IsDirectory || CreateEmptyDirectories))
{
try
{
Directory.CreateDirectory(path);
}
catch (Exception exception)
{
flag = false;
if (_events != null)
{
if (entry.IsDirectory)
{
_continueRunning = _events.OnDirectoryFailure(name, exception);
}
else
{
_continueRunning = _events.OnFileFailure(name, exception);
}
}
else
{
_continueRunning = false;
throw;
}
}
}
if (flag && entry.IsFile)
{
ExtractFileEntry(entry, name);
}
}
private void ExtractEntry(ZipEntry entry)
{
bool flag = entry.IsCompressionMethodSupported();
string name = entry.Name;
if (flag)
{
if (entry.IsFile)
{
name = _extractNameTransform.TransformFile(name);
}
else if (entry.IsDirectory)
{
name = _extractNameTransform.TransformDirectory(name);
}
flag = (name != null) && (name.Length != 0);
}
string path = null;
if (flag)
{
if (entry.IsDirectory)
{
path = name;
}
else
{
path = Path.GetDirectoryName(Path.GetFullPath(name));
}
}
if ((flag && !Directory.Exists(path)) && (!entry.IsDirectory || CreateEmptyDirectories))
{
try
{
Directory.CreateDirectory(path);
}
catch (Exception exception)
{
flag = false;
if (_events != null)
{
if (entry.IsDirectory)
{
_continueRunning = _events.OnDirectoryFailure(name, exception);
}
else
{
_continueRunning = _events.OnFileFailure(name, exception);
}
}
else
{
_continueRunning = false;
throw;
}
}
}
if (flag && entry.IsFile)
{
ExtractFileEntry(entry, name);
}
}
public bool IsCompressionMethodSupported()
{
return(ZipEntry.IsCompressionMethodSupported(this.CompressionMethod));
}
void ExtractEntry(ZipEntry entry)
{
bool doExtraction = NameIsValid(entry.Name) && entry.IsCompressionMethodSupported();
// TODO: Fire delegate were compression method not supported.
string dirName = null;
string targetName = null;
if ( doExtraction ) {
string entryFileName;
if (Path.IsPathRooted(entry.Name)) {
string workName = Path.GetPathRoot(entry.Name);
workName = entry.Name.Substring(workName.Length);
entryFileName = Path.Combine(Path.GetDirectoryName(workName), Path.GetFileName(entry.Name));
}
else {
entryFileName = entry.Name;
}
targetName = Path.Combine(targetDirectory_, entryFileName);
dirName = Path.GetDirectoryName(Path.GetFullPath(targetName));
doExtraction = (entryFileName.Length > 0);
}
if ( doExtraction && !Directory.Exists(dirName) ) {
if ( !entry.IsDirectory || CreateEmptyDirectories ) {
try {
Directory.CreateDirectory(dirName);
}
catch {
doExtraction = false;
}
}
}
if ( doExtraction && entry.IsFile ) {
ExtractFileEntry(entry, targetName);
}
}
public ZipEntry GetNextEntry()
{
if (_crc == null)
{
throw new InvalidOperationException("Closed.");
}
if (_entry != null)
{
CloseEntry();
}
var num = InputBuffer.ReadLeInt();
switch (num)
{
case ZipConstants.CentralHeaderSignature:
case ZipConstants.EndOfCentralDirectorySignature:
case ZipConstants.CentralHeaderDigitalSignature:
case ZipConstants.ArchiveExtraDataSignature:
case 0x6064b50:
Close();
return null;
case 0x30304b50:
case ZipConstants.SpanningSignature:
num = InputBuffer.ReadLeInt();
break;
}
if (num != ZipConstants.LocalHeaderSignature)
{
throw new ZipException("Wrong Local header signature: 0x" + $"{num:X}");
}
var versionRequiredToExtract = (short)InputBuffer.ReadLeShort();
_flags = InputBuffer.ReadLeShort();
_method = InputBuffer.ReadLeShort();
var num3 = (uint)InputBuffer.ReadLeInt();
var num4 = InputBuffer.ReadLeInt();
Csize = InputBuffer.ReadLeInt();
_size = InputBuffer.ReadLeInt();
var num5 = InputBuffer.ReadLeShort();
var num6 = InputBuffer.ReadLeShort();
var flag = (_flags & 1) == 1;
var buffer = new byte[num5];
InputBuffer.ReadRawBuffer(buffer);
var name = ZipConstants.ConvertToStringExt(_flags, buffer);
_entry = new ZipEntry(name, versionRequiredToExtract)
{
Flags = _flags,
CompressionMethod = (CompressionMethod) _method
};
if ((_flags & 8) == 0)
{
_entry.Crc = num4 & 0xffffffffL;
_entry.Size = _size & 0xffffffffL;
_entry.CompressedSize = Csize & 0xffffffffL;
_entry.CryptoCheckValue = (byte)((num4 >> 0x18) & 0xff);
}
else
{
if (num4 != 0)
{
_entry.Crc = num4 & 0xffffffffL;
}
if (_size != 0L)
{
_entry.Size = _size & 0xffffffffL;
}
if (Csize != 0L)
{
_entry.CompressedSize = Csize & 0xffffffffL;
}
_entry.CryptoCheckValue = (byte)((num3 >> 8) & 0xff);
}
_entry.DosTime = num3;
if (num6 > 0)
{
var buffer2 = new byte[num6];
InputBuffer.ReadRawBuffer(buffer2);
_entry.ExtraData = buffer2;
}
_entry.ProcessExtraData(true);
if (_entry.CompressedSize >= 0L)
{
Csize = _entry.CompressedSize;
}
if (_entry.Size >= 0L)
{
_size = _entry.Size;
}
if ((_method == 0) && ((!flag && (Csize != _size)) || (flag && ((Csize - 12L) != _size))))
{
throw new ZipException("Stored, but compressed != uncompressed");
}
if (_entry.IsCompressionMethodSupported())
{
_internalReader = InitialRead;
}
else
{
_internalReader = ReadingNotSupported;
}
return _entry;
}
public ZipEntry GetNextEntry()
{
if (_crc == null)
{
throw new InvalidOperationException("Closed.");
}
if (_entry != null)
{
CloseEntry();
}
var num = InputBuffer.ReadLeInt();
switch (num)
{
case ZipConstants.CentralHeaderSignature:
case ZipConstants.EndOfCentralDirectorySignature:
case ZipConstants.CentralHeaderDigitalSignature:
case ZipConstants.ArchiveExtraDataSignature:
case 0x6064b50:
Close();
return(null);
case 0x30304b50:
case ZipConstants.SpanningSignature:
num = InputBuffer.ReadLeInt();
break;
}
if (num != ZipConstants.LocalHeaderSignature)
{
throw new ZipException("Wrong Local header signature: 0x" + $"{num:X}");
}
var versionRequiredToExtract = (short)InputBuffer.ReadLeShort();
_flags = InputBuffer.ReadLeShort();
_method = InputBuffer.ReadLeShort();
var num3 = (uint)InputBuffer.ReadLeInt();
var num4 = InputBuffer.ReadLeInt();
Csize = InputBuffer.ReadLeInt();
_size = InputBuffer.ReadLeInt();
var num5 = InputBuffer.ReadLeShort();
var num6 = InputBuffer.ReadLeShort();
var flag = (_flags & 1) == 1;
var buffer = new byte[num5];
InputBuffer.ReadRawBuffer(buffer);
var name = ZipConstants.ConvertToStringExt(_flags, buffer);
_entry = new ZipEntry(name, versionRequiredToExtract)
{
Flags = _flags,
CompressionMethod = (CompressionMethod)_method
};
if ((_flags & 8) == 0)
{
_entry.Crc = num4 & 0xffffffffL;
_entry.Size = _size & 0xffffffffL;
_entry.CompressedSize = Csize & 0xffffffffL;
_entry.CryptoCheckValue = (byte)((num4 >> 0x18) & 0xff);
}
else
{
if (num4 != 0)
{
_entry.Crc = num4 & 0xffffffffL;
}
if (_size != 0L)
{
_entry.Size = _size & 0xffffffffL;
}
if (Csize != 0L)
{
_entry.CompressedSize = Csize & 0xffffffffL;
}
_entry.CryptoCheckValue = (byte)((num3 >> 8) & 0xff);
}
_entry.DosTime = num3;
if (num6 > 0)
{
var buffer2 = new byte[num6];
InputBuffer.ReadRawBuffer(buffer2);
_entry.ExtraData = buffer2;
}
_entry.ProcessExtraData(true);
if (_entry.CompressedSize >= 0L)
{
Csize = _entry.CompressedSize;
}
if (_entry.Size >= 0L)
{
_size = _entry.Size;
}
if ((_method == 0) && ((!flag && (Csize != _size)) || (flag && ((Csize - 12L) != _size))))
{
throw new ZipException("Stored, but compressed != uncompressed");
}
if (_entry.IsCompressionMethodSupported())
{
_internalReader = InitialRead;
}
else
{
_internalReader = ReadingNotSupported;
}
return(_entry);
}
private long TestLocalHeader(ZipEntry entry, HeaderTest tests)
{
lock (_baseStream)
{
var flag = (tests & HeaderTest.Header) != 0;
var flag2 = (tests & HeaderTest.Extract) != 0;
_baseStream.Seek(_offsetOfFirstEntry + entry.Offset, SeekOrigin.Begin);
if (ReadLeUint() != ZipConstants.LocalHeaderSignature)
{
throw new ZipException($"Wrong local header signature @{_offsetOfFirstEntry + entry.Offset:X}");
}
var num = (short)ReadLeUshort();
var flags = (short)ReadLeUshort();
var num3 = (short)ReadLeUshort();
var num4 = (short)ReadLeUshort();
var num5 = (short)ReadLeUshort();
var num6 = ReadLeUint();
long num7 = ReadLeUint();
long num8 = ReadLeUint();
int num9 = ReadLeUshort();
int num10 = ReadLeUshort();
var buffer = new byte[num9];
StreamUtils.ReadFully(_baseStream, buffer);
var buffer2 = new byte[num10];
StreamUtils.ReadFully(_baseStream, buffer2);
var data = new ZipExtraData(buffer2);
if (data.Find(1))
{
num8 = data.ReadLong();
num7 = data.ReadLong();
if ((flags & 8) != 0)
{
if ((num8 != -1L) && (num8 != entry.Size))
{
throw new ZipException("Size invalid for descriptor");
}
if ((num7 != -1L) && (num7 != entry.CompressedSize))
{
throw new ZipException("Compressed size invalid for descriptor");
}
}
}
else if ((num >= 0x2d) && ((((uint)num8) == uint.MaxValue) || (((uint)num7) == uint.MaxValue)))
{
throw new ZipException("Required Zip64 extended information missing");
}
if (flag2 && entry.IsFile)
{
if (!entry.IsCompressionMethodSupported())
{
throw new ZipException("Compression method not supported");
}
if ((num > 0x33) || ((num > 20) && (num < 0x2d)))
{
throw new ZipException($"Version required to extract this entry not supported ({num})");
}
if ((flags & 0x3060) != 0)
{
throw new ZipException("The library does not support the zip version required to extract this entry");
}
}
if (flag)
{
if (((((num <= 0x3f) && (num != 10)) && ((num != 11) && (num != 20))) &&
(((num != 0x15) && (num != 0x19)) && ((num != 0x1b) && (num != 0x2d)))) &&
((((num != ZipConstants.CentralHeaderBaseSize) && (num != 50)) && ((num != 0x33) && (num != 0x34))) &&
(((num != 0x3d) && (num != 0x3e)) && (num != 0x3f))))
{
throw new ZipException($"Version required to extract this entry is invalid ({num})");
}
if ((flags & 0xc010) != 0)
{
throw new ZipException("Reserved bit flags cannot be set.");
}
if (((flags & 1) != 0) && (num < 20))
{
throw new ZipException(
$"Version required to extract this entry is too low for encryption ({num})");
}
if ((flags & 0x40) != 0)
{
if ((flags & 1) == 0)
{
throw new ZipException("Strong encryption flag set but encryption flag is not set");
}
if (num < 50)
{
throw new ZipException(
$"Version required to extract this entry is too low for encryption ({num})");
}
}
if (((flags & 0x20) != 0) && (num < 0x1b))
{
throw new ZipException($"Patched data requires higher version than ({num})");
}
if (flags != entry.Flags)
{
throw new ZipException("Central header/local header flags mismatch");
}
if (entry.CompressionMethod != ((CompressionMethod)num3))
{
throw new ZipException("Central header/local header compression method mismatch");
}
if (entry.Version != num)
{
throw new ZipException("Extract version mismatch");
}
if (((flags & 0x40) != 0) && (num < 0x3e))
{
throw new ZipException("Strong encryption flag set but version not high enough");
}
if (((flags & 0x2000) != 0) && ((num4 != 0) || (num5 != 0)))
{
throw new ZipException("Header masked set but date/time values non-zero");
}
if (((flags & 8) == 0) && (num6 != ((uint)entry.Crc)))
{
throw new ZipException("Central header/local header crc mismatch");
}
if (((num8 == 0L) && (num7 == 0L)) && (num6 != 0))
{
throw new ZipException("Invalid CRC for empty entry");
}
if (entry.Name.Length > num9)
{
throw new ZipException("File name length mismatch");
}
var name = ZipConstants.ConvertToStringExt(flags, buffer);
if (name != entry.Name)
{
throw new ZipException("Central header and local header file name mismatch");
}
if (entry.IsDirectory)
{
if (num8 > 0L)
{
throw new ZipException("Directory cannot have size");
}
if (entry.IsCrypted)
{
if (num7 > 14L)
{
throw new ZipException("Directory compressed size invalid");
}
}
else if (num7 > 2L)
{
throw new ZipException("Directory compressed size invalid");
}
}
if (!ZipNameTransform.IsValidName(name, true))
{
throw new ZipException("Name is invalid");
}
}
if ((((flags & 8) == 0) || (num8 > 0L)) || (num7 > 0L))
{
if (num8 != entry.Size)
{
throw new ZipException(
$"Size mismatch between central header({entry.Size}) and local header({num8})");
}
if (((num7 != entry.CompressedSize) && (num7 != 0xffffffffL)) && (num7 != -1L))
{
throw new ZipException(
$"Compressed size mismatch between central header({entry.CompressedSize}) and local header({num7})");
}
}
var num11 = num9 + num10;
return (((_offsetOfFirstEntry + entry.Offset) + 30L) + num11);
}
}