niko
878 lines
21 KiB
C#
878 lines
21 KiB
C#
using System;
|
|
using System.IO;
|
|
|
|
namespace ICSharpCode.SharpZipLib.Zip
|
|
{
|
|
// Token: 0x02000056 RID: 86
|
|
public class ZipEntry : ICloneable
|
|
{
|
|
// Token: 0x0600032E RID: 814 RVA: 0x000115C0 File Offset: 0x000105C0
|
|
public ZipEntry(string name)
|
|
: this(name, 0, 51, CompressionMethod.Deflated)
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600032F RID: 815 RVA: 0x000115CD File Offset: 0x000105CD
|
|
internal ZipEntry(string name, int versionRequiredToExtract)
|
|
: this(name, versionRequiredToExtract, 51, CompressionMethod.Deflated)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000330 RID: 816 RVA: 0x000115DC File Offset: 0x000105DC
|
|
internal ZipEntry(string name, int versionRequiredToExtract, int madeByInfo, CompressionMethod method)
|
|
{
|
|
this.externalFileAttributes = -1;
|
|
this.method = CompressionMethod.Deflated;
|
|
this.zipFileIndex = -1L;
|
|
base..ctor();
|
|
if (name == null)
|
|
{
|
|
throw new ArgumentNullException("name");
|
|
}
|
|
if (name.Length > 65535)
|
|
{
|
|
throw new ArgumentException("Name is too long", "name");
|
|
}
|
|
if (versionRequiredToExtract != 0 && versionRequiredToExtract < 10)
|
|
{
|
|
throw new ArgumentOutOfRangeException("versionRequiredToExtract");
|
|
}
|
|
this.DateTime = DateTime.Now;
|
|
this.name = name;
|
|
this.versionMadeBy = (ushort)madeByInfo;
|
|
this.versionToExtract = (ushort)versionRequiredToExtract;
|
|
this.method = method;
|
|
}
|
|
|
|
// Token: 0x06000331 RID: 817 RVA: 0x00011670 File Offset: 0x00010670
|
|
[Obsolete("Use Clone instead")]
|
|
public ZipEntry(ZipEntry entry)
|
|
{
|
|
this.externalFileAttributes = -1;
|
|
this.method = CompressionMethod.Deflated;
|
|
this.zipFileIndex = -1L;
|
|
base..ctor();
|
|
if (entry == null)
|
|
{
|
|
throw new ArgumentNullException("entry");
|
|
}
|
|
this.known = entry.known;
|
|
this.name = entry.name;
|
|
this.size = entry.size;
|
|
this.compressedSize = entry.compressedSize;
|
|
this.crc = entry.crc;
|
|
this.dosTime = entry.dosTime;
|
|
this.method = entry.method;
|
|
this.comment = entry.comment;
|
|
this.versionToExtract = entry.versionToExtract;
|
|
this.versionMadeBy = entry.versionMadeBy;
|
|
this.externalFileAttributes = entry.externalFileAttributes;
|
|
this.flags = entry.flags;
|
|
this.zipFileIndex = entry.zipFileIndex;
|
|
this.offset = entry.offset;
|
|
this.forceZip64_ = entry.forceZip64_;
|
|
if (entry.extra != null)
|
|
{
|
|
this.extra = new byte[entry.extra.Length];
|
|
Array.Copy(entry.extra, 0, this.extra, 0, entry.extra.Length);
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000AA RID: 170
|
|
// (get) Token: 0x06000332 RID: 818 RVA: 0x00011791 File Offset: 0x00010791
|
|
public bool HasCrc
|
|
{
|
|
get
|
|
{
|
|
return (byte)(this.known & ZipEntry.Known.Crc) != 0;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000AB RID: 171
|
|
// (get) Token: 0x06000333 RID: 819 RVA: 0x000117A2 File Offset: 0x000107A2
|
|
// (set) Token: 0x06000334 RID: 820 RVA: 0x000117B2 File Offset: 0x000107B2
|
|
public bool IsCrypted
|
|
{
|
|
get
|
|
{
|
|
return (this.flags & 1) != 0;
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
{
|
|
this.flags |= 1;
|
|
return;
|
|
}
|
|
this.flags &= -2;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000AC RID: 172
|
|
// (get) Token: 0x06000335 RID: 821 RVA: 0x000117D5 File Offset: 0x000107D5
|
|
// (set) Token: 0x06000336 RID: 822 RVA: 0x000117E9 File Offset: 0x000107E9
|
|
public bool IsUnicodeText
|
|
{
|
|
get
|
|
{
|
|
return (this.flags & 2048) != 0;
|
|
}
|
|
set
|
|
{
|
|
if (value)
|
|
{
|
|
this.flags |= 2048;
|
|
return;
|
|
}
|
|
this.flags &= -2049;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000AD RID: 173
|
|
// (get) Token: 0x06000337 RID: 823 RVA: 0x00011813 File Offset: 0x00010813
|
|
// (set) Token: 0x06000338 RID: 824 RVA: 0x0001181B File Offset: 0x0001081B
|
|
internal byte CryptoCheckValue
|
|
{
|
|
get
|
|
{
|
|
return this.cryptoCheckValue_;
|
|
}
|
|
set
|
|
{
|
|
this.cryptoCheckValue_ = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000AE RID: 174
|
|
// (get) Token: 0x06000339 RID: 825 RVA: 0x00011824 File Offset: 0x00010824
|
|
// (set) Token: 0x0600033A RID: 826 RVA: 0x0001182C File Offset: 0x0001082C
|
|
public int Flags
|
|
{
|
|
get
|
|
{
|
|
return this.flags;
|
|
}
|
|
set
|
|
{
|
|
this.flags = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000AF RID: 175
|
|
// (get) Token: 0x0600033B RID: 827 RVA: 0x00011835 File Offset: 0x00010835
|
|
// (set) Token: 0x0600033C RID: 828 RVA: 0x0001183D File Offset: 0x0001083D
|
|
public long ZipFileIndex
|
|
{
|
|
get
|
|
{
|
|
return this.zipFileIndex;
|
|
}
|
|
set
|
|
{
|
|
this.zipFileIndex = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B0 RID: 176
|
|
// (get) Token: 0x0600033D RID: 829 RVA: 0x00011846 File Offset: 0x00010846
|
|
// (set) Token: 0x0600033E RID: 830 RVA: 0x0001184E File Offset: 0x0001084E
|
|
public long Offset
|
|
{
|
|
get
|
|
{
|
|
return this.offset;
|
|
}
|
|
set
|
|
{
|
|
this.offset = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B1 RID: 177
|
|
// (get) Token: 0x0600033F RID: 831 RVA: 0x00011857 File Offset: 0x00010857
|
|
// (set) Token: 0x06000340 RID: 832 RVA: 0x0001186D File Offset: 0x0001086D
|
|
public int ExternalFileAttributes
|
|
{
|
|
get
|
|
{
|
|
if ((byte)(this.known & ZipEntry.Known.ExternalAttributes) == 0)
|
|
{
|
|
return -1;
|
|
}
|
|
return this.externalFileAttributes;
|
|
}
|
|
set
|
|
{
|
|
this.externalFileAttributes = value;
|
|
this.known |= ZipEntry.Known.ExternalAttributes;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B2 RID: 178
|
|
// (get) Token: 0x06000341 RID: 833 RVA: 0x00011886 File Offset: 0x00010886
|
|
public int VersionMadeBy
|
|
{
|
|
get
|
|
{
|
|
return (int)(this.versionMadeBy & 255);
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B3 RID: 179
|
|
// (get) Token: 0x06000342 RID: 834 RVA: 0x00011894 File Offset: 0x00010894
|
|
public bool IsDOSEntry
|
|
{
|
|
get
|
|
{
|
|
return this.HostSystem == 0 || this.HostSystem == 10;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000343 RID: 835 RVA: 0x000118AC File Offset: 0x000108AC
|
|
private bool HasDosAttributes(int attributes)
|
|
{
|
|
bool flag = false;
|
|
if ((byte)(this.known & ZipEntry.Known.ExternalAttributes) != 0 && (this.HostSystem == 0 || this.HostSystem == 10) && (this.ExternalFileAttributes & attributes) == attributes)
|
|
{
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x170000B4 RID: 180
|
|
// (get) Token: 0x06000344 RID: 836 RVA: 0x000118E7 File Offset: 0x000108E7
|
|
// (set) Token: 0x06000345 RID: 837 RVA: 0x000118F7 File Offset: 0x000108F7
|
|
public int HostSystem
|
|
{
|
|
get
|
|
{
|
|
return (this.versionMadeBy >> 8) & 255;
|
|
}
|
|
set
|
|
{
|
|
this.versionMadeBy &= 255;
|
|
this.versionMadeBy |= (ushort)((value & 255) << 8);
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B5 RID: 181
|
|
// (get) Token: 0x06000346 RID: 838 RVA: 0x00011924 File Offset: 0x00010924
|
|
public int Version
|
|
{
|
|
get
|
|
{
|
|
if (this.versionToExtract != 0)
|
|
{
|
|
return (int)this.versionToExtract;
|
|
}
|
|
int num = 10;
|
|
if (this.AESKeySize > 0)
|
|
{
|
|
num = 51;
|
|
}
|
|
else if (this.CentralHeaderRequiresZip64)
|
|
{
|
|
num = 45;
|
|
}
|
|
else if (CompressionMethod.Deflated == this.method)
|
|
{
|
|
num = 20;
|
|
}
|
|
else if (this.IsDirectory)
|
|
{
|
|
num = 20;
|
|
}
|
|
else if (this.IsCrypted)
|
|
{
|
|
num = 20;
|
|
}
|
|
else if (this.HasDosAttributes(8))
|
|
{
|
|
num = 11;
|
|
}
|
|
return num;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B6 RID: 182
|
|
// (get) Token: 0x06000347 RID: 839 RVA: 0x00011994 File Offset: 0x00010994
|
|
public bool CanDecompress
|
|
{
|
|
get
|
|
{
|
|
return this.Version <= 51 && (this.Version == 10 || this.Version == 11 || this.Version == 20 || this.Version == 45 || this.Version == 51) && this.IsCompressionMethodSupported();
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000348 RID: 840 RVA: 0x000119E5 File Offset: 0x000109E5
|
|
public void ForceZip64()
|
|
{
|
|
this.forceZip64_ = true;
|
|
}
|
|
|
|
// Token: 0x06000349 RID: 841 RVA: 0x000119EE File Offset: 0x000109EE
|
|
public bool IsZip64Forced()
|
|
{
|
|
return this.forceZip64_;
|
|
}
|
|
|
|
// Token: 0x170000B7 RID: 183
|
|
// (get) Token: 0x0600034A RID: 842 RVA: 0x000119F8 File Offset: 0x000109F8
|
|
public bool LocalHeaderRequiresZip64
|
|
{
|
|
get
|
|
{
|
|
bool flag = this.forceZip64_;
|
|
if (!flag)
|
|
{
|
|
ulong num = this.compressedSize;
|
|
if (this.versionToExtract == 0 && this.IsCrypted)
|
|
{
|
|
num += 12UL;
|
|
}
|
|
flag = (this.size >= (ulong)(-1) || num >= (ulong)(-1)) && (this.versionToExtract == 0 || this.versionToExtract >= 45);
|
|
}
|
|
return flag;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B8 RID: 184
|
|
// (get) Token: 0x0600034B RID: 843 RVA: 0x00011A58 File Offset: 0x00010A58
|
|
public bool CentralHeaderRequiresZip64
|
|
{
|
|
get
|
|
{
|
|
return this.LocalHeaderRequiresZip64 || this.offset >= (long)((ulong)(-1));
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000B9 RID: 185
|
|
// (get) Token: 0x0600034C RID: 844 RVA: 0x00011A71 File Offset: 0x00010A71
|
|
// (set) Token: 0x0600034D RID: 845 RVA: 0x00011A88 File Offset: 0x00010A88
|
|
public long DosTime
|
|
{
|
|
get
|
|
{
|
|
if ((byte)(this.known & ZipEntry.Known.Time) == 0)
|
|
{
|
|
return 0L;
|
|
}
|
|
return (long)((ulong)this.dosTime);
|
|
}
|
|
set
|
|
{
|
|
this.dosTime = (uint)value;
|
|
this.known |= ZipEntry.Known.Time;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000BA RID: 186
|
|
// (get) Token: 0x0600034E RID: 846 RVA: 0x00011AA4 File Offset: 0x00010AA4
|
|
// (set) Token: 0x0600034F RID: 847 RVA: 0x00011B48 File Offset: 0x00010B48
|
|
public DateTime DateTime
|
|
{
|
|
get
|
|
{
|
|
uint num = Math.Min(59U, 2U * (this.dosTime & 31U));
|
|
uint num2 = Math.Min(59U, (this.dosTime >> 5) & 63U);
|
|
uint num3 = Math.Min(23U, (this.dosTime >> 11) & 31U);
|
|
uint num4 = Math.Max(1U, Math.Min(12U, (this.dosTime >> 21) & 15U));
|
|
uint num5 = ((this.dosTime >> 25) & 127U) + 1980U;
|
|
int num6 = Math.Max(1, Math.Min(DateTime.DaysInMonth((int)num5, (int)num4), (int)((this.dosTime >> 16) & 31U)));
|
|
return new DateTime((int)num5, (int)num4, num6, (int)num3, (int)num2, (int)num);
|
|
}
|
|
set
|
|
{
|
|
uint num = (uint)value.Year;
|
|
uint num2 = (uint)value.Month;
|
|
uint num3 = (uint)value.Day;
|
|
uint num4 = (uint)value.Hour;
|
|
uint num5 = (uint)value.Minute;
|
|
uint num6 = (uint)value.Second;
|
|
if (num < 1980U)
|
|
{
|
|
num = 1980U;
|
|
num2 = 1U;
|
|
num3 = 1U;
|
|
num4 = 0U;
|
|
num5 = 0U;
|
|
num6 = 0U;
|
|
}
|
|
else if (num > 2107U)
|
|
{
|
|
num = 2107U;
|
|
num2 = 12U;
|
|
num3 = 31U;
|
|
num4 = 23U;
|
|
num5 = 59U;
|
|
num6 = 59U;
|
|
}
|
|
this.DosTime = (long)((ulong)((((num - 1980U) & 127U) << 25) | (num2 << 21) | (num3 << 16) | (num4 << 11) | (num5 << 5) | (num6 >> 1)));
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000BB RID: 187
|
|
// (get) Token: 0x06000350 RID: 848 RVA: 0x00011BEF File Offset: 0x00010BEF
|
|
public string Name
|
|
{
|
|
get
|
|
{
|
|
return this.name;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000BC RID: 188
|
|
// (get) Token: 0x06000351 RID: 849 RVA: 0x00011BF7 File Offset: 0x00010BF7
|
|
// (set) Token: 0x06000352 RID: 850 RVA: 0x00011C0D File Offset: 0x00010C0D
|
|
public long Size
|
|
{
|
|
get
|
|
{
|
|
if ((byte)(this.known & ZipEntry.Known.Size) == 0)
|
|
{
|
|
return -1L;
|
|
}
|
|
return (long)this.size;
|
|
}
|
|
set
|
|
{
|
|
this.size = (ulong)value;
|
|
this.known |= ZipEntry.Known.Size;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000BD RID: 189
|
|
// (get) Token: 0x06000353 RID: 851 RVA: 0x00011C25 File Offset: 0x00010C25
|
|
// (set) Token: 0x06000354 RID: 852 RVA: 0x00011C3B File Offset: 0x00010C3B
|
|
public long CompressedSize
|
|
{
|
|
get
|
|
{
|
|
if ((byte)(this.known & ZipEntry.Known.CompressedSize) == 0)
|
|
{
|
|
return -1L;
|
|
}
|
|
return (long)this.compressedSize;
|
|
}
|
|
set
|
|
{
|
|
this.compressedSize = (ulong)value;
|
|
this.known |= ZipEntry.Known.CompressedSize;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000BE RID: 190
|
|
// (get) Token: 0x06000355 RID: 853 RVA: 0x00011C53 File Offset: 0x00010C53
|
|
// (set) Token: 0x06000356 RID: 854 RVA: 0x00011C6D File Offset: 0x00010C6D
|
|
public long Crc
|
|
{
|
|
get
|
|
{
|
|
if ((byte)(this.known & ZipEntry.Known.Crc) == 0)
|
|
{
|
|
return -1L;
|
|
}
|
|
return (long)((ulong)this.crc & (ulong)(-1));
|
|
}
|
|
set
|
|
{
|
|
if (((ulong)this.crc & 18446744069414584320UL) != 0UL)
|
|
{
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
this.crc = (uint)value;
|
|
this.known |= ZipEntry.Known.Crc;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000BF RID: 191
|
|
// (get) Token: 0x06000357 RID: 855 RVA: 0x00011CA6 File Offset: 0x00010CA6
|
|
// (set) Token: 0x06000358 RID: 856 RVA: 0x00011CAE File Offset: 0x00010CAE
|
|
public CompressionMethod CompressionMethod
|
|
{
|
|
get
|
|
{
|
|
return this.method;
|
|
}
|
|
set
|
|
{
|
|
if (!ZipEntry.IsCompressionMethodSupported(value))
|
|
{
|
|
throw new NotSupportedException("Compression method not supported");
|
|
}
|
|
this.method = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000C0 RID: 192
|
|
// (get) Token: 0x06000359 RID: 857 RVA: 0x00011CCA File Offset: 0x00010CCA
|
|
internal CompressionMethod CompressionMethodForHeader
|
|
{
|
|
get
|
|
{
|
|
if (this.AESKeySize <= 0)
|
|
{
|
|
return this.method;
|
|
}
|
|
return CompressionMethod.WinZipAES;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000C1 RID: 193
|
|
// (get) Token: 0x0600035A RID: 858 RVA: 0x00011CDE File Offset: 0x00010CDE
|
|
// (set) Token: 0x0600035B RID: 859 RVA: 0x00011CE8 File Offset: 0x00010CE8
|
|
public byte[] ExtraData
|
|
{
|
|
get
|
|
{
|
|
return this.extra;
|
|
}
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
this.extra = null;
|
|
return;
|
|
}
|
|
if (value.Length > 65535)
|
|
{
|
|
throw new ArgumentOutOfRangeException("value");
|
|
}
|
|
this.extra = new byte[value.Length];
|
|
Array.Copy(value, 0, this.extra, 0, value.Length);
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000C2 RID: 194
|
|
// (get) Token: 0x0600035C RID: 860 RVA: 0x00011D34 File Offset: 0x00010D34
|
|
// (set) Token: 0x0600035D RID: 861 RVA: 0x00011D90 File Offset: 0x00010D90
|
|
public int AESKeySize
|
|
{
|
|
get
|
|
{
|
|
switch (this._aesEncryptionStrength)
|
|
{
|
|
case 0:
|
|
return 0;
|
|
case 1:
|
|
return 128;
|
|
case 2:
|
|
return 192;
|
|
case 3:
|
|
return 256;
|
|
default:
|
|
throw new ZipException("Invalid AESEncryptionStrength " + this._aesEncryptionStrength);
|
|
}
|
|
}
|
|
set
|
|
{
|
|
if (value == 0)
|
|
{
|
|
this._aesEncryptionStrength = 0;
|
|
return;
|
|
}
|
|
if (value == 128)
|
|
{
|
|
this._aesEncryptionStrength = 1;
|
|
return;
|
|
}
|
|
if (value != 256)
|
|
{
|
|
throw new ZipException("AESKeySize must be 0, 128 or 256: " + value);
|
|
}
|
|
this._aesEncryptionStrength = 3;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000C3 RID: 195
|
|
// (get) Token: 0x0600035E RID: 862 RVA: 0x00011DE2 File Offset: 0x00010DE2
|
|
internal byte AESEncryptionStrength
|
|
{
|
|
get
|
|
{
|
|
return (byte)this._aesEncryptionStrength;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000C4 RID: 196
|
|
// (get) Token: 0x0600035F RID: 863 RVA: 0x00011DEB File Offset: 0x00010DEB
|
|
internal int AESSaltLen
|
|
{
|
|
get
|
|
{
|
|
return this.AESKeySize / 16;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000C5 RID: 197
|
|
// (get) Token: 0x06000360 RID: 864 RVA: 0x00011DF6 File Offset: 0x00010DF6
|
|
internal int AESOverheadSize
|
|
{
|
|
get
|
|
{
|
|
return 12 + this.AESSaltLen;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000361 RID: 865 RVA: 0x00011E04 File Offset: 0x00010E04
|
|
internal void ProcessExtraData(bool localHeader)
|
|
{
|
|
ZipExtraData zipExtraData = new ZipExtraData(this.extra);
|
|
if (zipExtraData.Find(1))
|
|
{
|
|
this.forceZip64_ = true;
|
|
if (zipExtraData.ValueLength < 4)
|
|
{
|
|
throw new ZipException("Extra data extended Zip64 information length is invalid");
|
|
}
|
|
if (localHeader || this.size == (ulong)(-1))
|
|
{
|
|
this.size = (ulong)zipExtraData.ReadLong();
|
|
}
|
|
if (localHeader || this.compressedSize == (ulong)(-1))
|
|
{
|
|
this.compressedSize = (ulong)zipExtraData.ReadLong();
|
|
}
|
|
if (!localHeader && this.offset == (long)((ulong)(-1)))
|
|
{
|
|
this.offset = zipExtraData.ReadLong();
|
|
}
|
|
}
|
|
else if ((this.versionToExtract & 255) >= 45 && (this.size == (ulong)(-1) || this.compressedSize == (ulong)(-1)))
|
|
{
|
|
throw new ZipException("Zip64 Extended information required but is missing.");
|
|
}
|
|
if (zipExtraData.Find(10))
|
|
{
|
|
if (zipExtraData.ValueLength < 4)
|
|
{
|
|
throw new ZipException("NTFS Extra data invalid");
|
|
}
|
|
zipExtraData.ReadInt();
|
|
while (zipExtraData.UnreadCount >= 4)
|
|
{
|
|
int num = zipExtraData.ReadShort();
|
|
int num2 = zipExtraData.ReadShort();
|
|
if (num == 1)
|
|
{
|
|
if (num2 >= 24)
|
|
{
|
|
long num3 = zipExtraData.ReadLong();
|
|
zipExtraData.ReadLong();
|
|
zipExtraData.ReadLong();
|
|
this.DateTime = DateTime.FromFileTime(num3);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
zipExtraData.Skip(num2);
|
|
}
|
|
}
|
|
}
|
|
else if (zipExtraData.Find(21589))
|
|
{
|
|
int valueLength = zipExtraData.ValueLength;
|
|
int num4 = zipExtraData.ReadByte();
|
|
if ((num4 & 1) != 0 && valueLength >= 5)
|
|
{
|
|
int num5 = zipExtraData.ReadInt();
|
|
this.DateTime = (new DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime() + new TimeSpan(0, 0, 0, num5, 0)).ToLocalTime();
|
|
}
|
|
}
|
|
if (this.method == CompressionMethod.WinZipAES)
|
|
{
|
|
this.ProcessAESExtraData(zipExtraData);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000362 RID: 866 RVA: 0x00011FAC File Offset: 0x00010FAC
|
|
private void ProcessAESExtraData(ZipExtraData extraData)
|
|
{
|
|
if (!extraData.Find(39169))
|
|
{
|
|
throw new ZipException("AES Extra Data missing");
|
|
}
|
|
this.versionToExtract = 51;
|
|
this.Flags |= 64;
|
|
int valueLength = extraData.ValueLength;
|
|
if (valueLength < 7)
|
|
{
|
|
throw new ZipException("AES Extra Data Length " + valueLength + " invalid.");
|
|
}
|
|
int num = extraData.ReadShort();
|
|
extraData.ReadShort();
|
|
int num2 = extraData.ReadByte();
|
|
int num3 = extraData.ReadShort();
|
|
this._aesVer = num;
|
|
this._aesEncryptionStrength = num2;
|
|
this.method = (CompressionMethod)num3;
|
|
}
|
|
|
|
// Token: 0x170000C6 RID: 198
|
|
// (get) Token: 0x06000363 RID: 867 RVA: 0x0001203F File Offset: 0x0001103F
|
|
// (set) Token: 0x06000364 RID: 868 RVA: 0x00012047 File Offset: 0x00011047
|
|
public string Comment
|
|
{
|
|
get
|
|
{
|
|
return this.comment;
|
|
}
|
|
set
|
|
{
|
|
if (value != null && value.Length > 65535)
|
|
{
|
|
throw new ArgumentOutOfRangeException("value", "cannot exceed 65535");
|
|
}
|
|
this.comment = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000C7 RID: 199
|
|
// (get) Token: 0x06000365 RID: 869 RVA: 0x00012070 File Offset: 0x00011070
|
|
public bool IsDirectory
|
|
{
|
|
get
|
|
{
|
|
int length = this.name.Length;
|
|
return (length > 0 && (this.name[length - 1] == '/' || this.name[length - 1] == '\\')) || this.HasDosAttributes(16);
|
|
}
|
|
}
|
|
|
|
// Token: 0x170000C8 RID: 200
|
|
// (get) Token: 0x06000366 RID: 870 RVA: 0x000120BE File Offset: 0x000110BE
|
|
public bool IsFile
|
|
{
|
|
get
|
|
{
|
|
return !this.IsDirectory && !this.HasDosAttributes(8);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000367 RID: 871 RVA: 0x000120D4 File Offset: 0x000110D4
|
|
public bool IsCompressionMethodSupported()
|
|
{
|
|
return ZipEntry.IsCompressionMethodSupported(this.CompressionMethod);
|
|
}
|
|
|
|
// Token: 0x06000368 RID: 872 RVA: 0x000120E4 File Offset: 0x000110E4
|
|
public object Clone()
|
|
{
|
|
ZipEntry zipEntry = (ZipEntry)base.MemberwiseClone();
|
|
if (this.extra != null)
|
|
{
|
|
zipEntry.extra = new byte[this.extra.Length];
|
|
Array.Copy(this.extra, 0, zipEntry.extra, 0, this.extra.Length);
|
|
}
|
|
return zipEntry;
|
|
}
|
|
|
|
// Token: 0x06000369 RID: 873 RVA: 0x00012134 File Offset: 0x00011134
|
|
public override string ToString()
|
|
{
|
|
return this.name;
|
|
}
|
|
|
|
// Token: 0x0600036A RID: 874 RVA: 0x0001213C File Offset: 0x0001113C
|
|
public static bool IsCompressionMethodSupported(CompressionMethod method)
|
|
{
|
|
return method == CompressionMethod.Deflated || method == CompressionMethod.Stored;
|
|
}
|
|
|
|
// Token: 0x0600036B RID: 875 RVA: 0x00012148 File Offset: 0x00011148
|
|
public static string CleanName(string name)
|
|
{
|
|
if (name == null)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
if (Path.IsPathRooted(name))
|
|
{
|
|
name = name.Substring(Path.GetPathRoot(name).Length);
|
|
}
|
|
name = name.Replace("\\", "/");
|
|
while (name.Length > 0 && name[0] == '/')
|
|
{
|
|
name = name.Remove(0, 1);
|
|
}
|
|
return name;
|
|
}
|
|
|
|
// Token: 0x04000286 RID: 646
|
|
private ZipEntry.Known known;
|
|
|
|
// Token: 0x04000287 RID: 647
|
|
private int externalFileAttributes;
|
|
|
|
// Token: 0x04000288 RID: 648
|
|
private ushort versionMadeBy;
|
|
|
|
// Token: 0x04000289 RID: 649
|
|
private string name;
|
|
|
|
// Token: 0x0400028A RID: 650
|
|
private ulong size;
|
|
|
|
// Token: 0x0400028B RID: 651
|
|
private ulong compressedSize;
|
|
|
|
// Token: 0x0400028C RID: 652
|
|
private ushort versionToExtract;
|
|
|
|
// Token: 0x0400028D RID: 653
|
|
private uint crc;
|
|
|
|
// Token: 0x0400028E RID: 654
|
|
private uint dosTime;
|
|
|
|
// Token: 0x0400028F RID: 655
|
|
private CompressionMethod method;
|
|
|
|
// Token: 0x04000290 RID: 656
|
|
private byte[] extra;
|
|
|
|
// Token: 0x04000291 RID: 657
|
|
private string comment;
|
|
|
|
// Token: 0x04000292 RID: 658
|
|
private int flags;
|
|
|
|
// Token: 0x04000293 RID: 659
|
|
private long zipFileIndex;
|
|
|
|
// Token: 0x04000294 RID: 660
|
|
private long offset;
|
|
|
|
// Token: 0x04000295 RID: 661
|
|
private bool forceZip64_;
|
|
|
|
// Token: 0x04000296 RID: 662
|
|
private byte cryptoCheckValue_;
|
|
|
|
// Token: 0x04000297 RID: 663
|
|
private int _aesVer;
|
|
|
|
// Token: 0x04000298 RID: 664
|
|
private int _aesEncryptionStrength;
|
|
|
|
// Token: 0x02000057 RID: 87
|
|
[Flags]
|
|
private enum Known : byte
|
|
{
|
|
// Token: 0x0400029A RID: 666
|
|
None = 0,
|
|
// Token: 0x0400029B RID: 667
|
|
Size = 1,
|
|
// Token: 0x0400029C RID: 668
|
|
CompressedSize = 2,
|
|
// Token: 0x0400029D RID: 669
|
|
Crc = 4,
|
|
// Token: 0x0400029E RID: 670
|
|
Time = 8,
|
|
// Token: 0x0400029F RID: 671
|
|
ExternalAttributes = 16
|
|
}
|
|
}
|
|
}
|