public ZipEntry(ZipEntry entry) { this.externalFileAttributes = -1; this.method = Maticsoft.ZipLib.Zip.CompressionMethod.Deflated; this.zipFileIndex = -1L; 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); } }
public ZipEntry MakeDirectoryEntry(string directoryName, bool useFileSystem) { ZipEntry entry = new ZipEntry(this.nameTransform_.TransformDirectory(directoryName)) { IsUnicodeText = this.isUnicodeText_, Size = 0L }; int num = 0; DirectoryInfo info = null; if (useFileSystem) { info = new DirectoryInfo(directoryName); } if ((info == null) || !info.Exists) { if (this.timeSetting_ == TimeSetting.Fixed) { entry.DateTime = this.fixedDateTime_; } } else { switch (this.timeSetting_) { case TimeSetting.LastWriteTime: entry.DateTime = info.LastWriteTime; break; case TimeSetting.LastWriteTimeUtc: entry.DateTime = info.LastWriteTimeUtc; break; case TimeSetting.CreateTime: entry.DateTime = info.CreationTime; break; case TimeSetting.CreateTimeUtc: entry.DateTime = info.CreationTimeUtc; break; case TimeSetting.LastAccessTime: entry.DateTime = info.LastAccessTime; break; case TimeSetting.LastAccessTimeUtc: entry.DateTime = info.LastAccessTimeUtc; break; case TimeSetting.Fixed: entry.DateTime = this.fixedDateTime_; break; default: throw new ZipException("Unhandled time setting in MakeDirectoryEntry"); } num = ((int) info.Attributes) & this.getAttributes_; } num |= this.setAttributes_ | 0x10; entry.ExternalFileAttributes = num; return entry; }
public Stream GetSource(ZipEntry entry, string name) { Stream stream = null; if (name != null) { stream = File.Open(name, FileMode.Open, FileAccess.Read, FileShare.Read); } return stream; }
public static void ZipFile(string fileToZip, string zipedFile, int compressionLevel, int blockSize) { if (!File.Exists(fileToZip)) { throw new FileNotFoundException("指定要压缩的文件: " + fileToZip + " 不存在!"); } using (FileStream stream = File.Create(zipedFile)) { using (ZipOutputStream stream2 = new ZipOutputStream(stream)) { using (FileStream stream3 = new FileStream(fileToZip, FileMode.Open, FileAccess.Read)) { ZipEntry entry = new ZipEntry(fileToZip.Substring(fileToZip.LastIndexOf(@"\") + 1)); stream2.PutNextEntry(entry); stream2.SetLevel(compressionLevel); byte[] buffer = new byte[blockSize]; int count = 0; try { do { count = stream3.Read(buffer, 0, buffer.Length); stream2.Write(buffer, 0, count); } while (count > 0); } catch (Exception exception) { throw exception; } stream3.Close(); } stream2.Finish(); stream2.Close(); } stream.Close(); } }
private static void ZipSetp(string strDirectory, ZipOutputStream s, string parentPath) { if (strDirectory[strDirectory.Length - 1] != Path.DirectorySeparatorChar) { strDirectory = strDirectory + Path.DirectorySeparatorChar; } Crc32 crc = new Crc32(); string[] fileSystemEntries = Directory.GetFileSystemEntries(strDirectory); foreach (string str in fileSystemEntries) { if (Directory.Exists(str)) { string str2 = parentPath; str2 = str2 + str.Substring(str.LastIndexOf(@"\") + 1) + @"\"; ZipSetp(str, s, str2); } else { using (FileStream stream = File.OpenRead(str)) { byte[] buffer = new byte[stream.Length]; stream.Read(buffer, 0, buffer.Length); ZipEntry entry = new ZipEntry(parentPath + str.Substring(str.LastIndexOf(@"\") + 1)) { DateTime = DateTime.Now, Size = stream.Length }; stream.Close(); crc.Reset(); crc.Update(buffer); entry.Crc = crc.Value; s.PutNextEntry(entry); s.Write(buffer, 0, buffer.Length); } } } }
public ZipUpdate(ZipFile.UpdateCommand command, ZipEntry entry) { this.sizePatchOffset_ = -1L; this.crcPatchOffset_ = -1L; this._offsetBasedSize = -1L; this.command_ = command; this.entry_ = (ZipEntry) entry.Clone(); }
public ZipUpdate(ZipEntry entry) : this(ZipFile.UpdateCommand.Copy, entry) { }
private void CompleteCloseEntry(bool testCrc) { base.StopDecrypting(); if ((this.flags & 8) != 0) { this.ReadDataDescriptor(); } this.size = 0L; if ((testCrc && ((((ulong) this.crc.Value) & 0xffffffffL) != this.entry.Crc)) && (this.entry.Crc != -1L)) { throw new ZipException("CRC mismatch"); } this.crc.Reset(); if (this.method == 8) { base.inf.Reset(); } this.entry = null; }
internal void SetEntry(ZipEntry entry) { this.entry_ = entry; this.entryValid_ = true; this.bytesTested_ = 0L; }
private Stream CreateAndInitEncryptionStream(Stream baseStream, ZipEntry entry) { CryptoStream stream = null; if ((entry.Version < 50) || ((entry.Flags & 0x40) == 0)) { PkzipClassicManaged managed = new PkzipClassicManaged(); this.OnKeysRequired(entry.Name); if (!this.HaveKeys) { throw new ZipException("No password available for encrypted stream"); } stream = new CryptoStream(new UncompressedStream(baseStream), managed.CreateEncryptor(this.key, null), CryptoStreamMode.Write); if ((entry.Crc < 0L) || ((entry.Flags & 8) != 0)) { WriteEncryptionHeader(stream, entry.DosTime << 0x10); return stream; } WriteEncryptionHeader(stream, entry.Crc); } return stream; }
protected void InitializeAESPassword(ZipEntry entry, string rawPassword, out byte[] salt, out byte[] pwdVerifier) { salt = new byte[entry.AESSaltLen]; if (_aesRnd == null) { _aesRnd = new RNGCryptoServiceProvider(); } _aesRnd.GetBytes(salt); int blockSize = entry.AESKeySize / 8; this.cryptoTransform_ = new ZipAESTransform(rawPassword, salt, blockSize, true); pwdVerifier = ((ZipAESTransform) this.cryptoTransform_).PwdVerifier; }
private static void CheckClassicPassword(CryptoStream classicCryptoStream, ZipEntry entry) { byte[] buffer = new byte[12]; StreamUtils.ReadFully(classicCryptoStream, buffer); if (buffer[11] != entry.CryptoCheckValue) { throw new ZipException("Invalid password"); } }
private Stream CreateAndInitDecryptionStream(Stream baseStream, ZipEntry entry) { CryptoStream classicCryptoStream = null; if ((entry.Version < 50) || ((entry.Flags & 0x40) == 0)) { PkzipClassicManaged managed = new PkzipClassicManaged(); this.OnKeysRequired(entry.Name); if (!this.HaveKeys) { throw new ZipException("No password available for encrypted stream"); } classicCryptoStream = new CryptoStream(baseStream, managed.CreateDecryptor(this.key, null), CryptoStreamMode.Read); CheckClassicPassword(classicCryptoStream, entry); return classicCryptoStream; } if (entry.Version != 0x33) { throw new ZipException("Decryption method not supported"); } this.OnKeysRequired(entry.Name); if (!this.HaveKeys) { throw new ZipException("No password available for AES encrypted stream"); } int aESSaltLen = entry.AESSaltLen; byte[] buffer = new byte[aESSaltLen]; int num2 = baseStream.Read(buffer, 0, aESSaltLen); if (num2 != aESSaltLen) { throw new ZipException(string.Concat(new object[] { "AES Salt expected ", aESSaltLen, " got ", num2 })); } byte[] buffer2 = new byte[2]; baseStream.Read(buffer2, 0, 2); int blockSize = entry.AESKeySize / 8; ZipAESTransform transform = new ZipAESTransform(this.rawPassword_, buffer, blockSize, false); byte[] pwdVerifier = transform.PwdVerifier; if ((pwdVerifier[0] != buffer2[0]) || (pwdVerifier[1] != buffer2[1])) { throw new Exception("Invalid password for AES"); } return new ZipAESStream(baseStream, transform, CryptoStreamMode.Read); }
public ZipUpdate(string fileName, string entryName, CompressionMethod compressionMethod) { this.sizePatchOffset_ = -1L; this.crcPatchOffset_ = -1L; this._offsetBasedSize = -1L; this.command_ = ZipFile.UpdateCommand.Add; this.entry_ = new ZipEntry(entryName); this.entry_.CompressionMethod = compressionMethod; this.filename_ = fileName; }
public ZipUpdate(IStaticDataSource dataSource, string entryName, CompressionMethod compressionMethod) { this.sizePatchOffset_ = -1L; this.crcPatchOffset_ = -1L; this._offsetBasedSize = -1L; this.command_ = ZipFile.UpdateCommand.Add; this.entry_ = new ZipEntry(entryName); this.entry_.CompressionMethod = compressionMethod; this.dataSource_ = dataSource; }
public ZipUpdate(string fileName, ZipEntry entry) { this.sizePatchOffset_ = -1L; this.crcPatchOffset_ = -1L; this._offsetBasedSize = -1L; this.command_ = ZipFile.UpdateCommand.Add; this.entry_ = entry; this.filename_ = fileName; }
public static void ZipFile(string fileToZip, string zipedFile) { if (!File.Exists(fileToZip)) { throw new FileNotFoundException("指定要压缩的文件: " + fileToZip + " 不存在!"); } using (FileStream stream = File.OpenRead(fileToZip)) { byte[] buffer = new byte[stream.Length]; stream.Read(buffer, 0, buffer.Length); stream.Close(); using (FileStream stream2 = File.Create(zipedFile)) { using (ZipOutputStream stream3 = new ZipOutputStream(stream2)) { ZipEntry entry = new ZipEntry(fileToZip.Substring(fileToZip.LastIndexOf(@"\") + 1)); stream3.PutNextEntry(entry); stream3.SetLevel(5); stream3.Write(buffer, 0, buffer.Length); stream3.Finish(); stream3.Close(); } } } }
public void Delete(ZipEntry entry) { if (entry == null) { throw new ArgumentNullException("entry"); } this.CheckUpdating(); int num = this.FindExistingUpdate(entry); if (num < 0) { throw new ZipException("Cannot find entry to delete"); } this.contentsEdited_ = true; this.updates_[num] = null; this.updateCount_ -= 1L; }
public ZipUpdate(IStaticDataSource dataSource, ZipEntry entry) { this.sizePatchOffset_ = -1L; this.crcPatchOffset_ = -1L; this._offsetBasedSize = -1L; this.command_ = ZipFile.UpdateCommand.Add; this.entry_ = entry; this.dataSource_ = dataSource; }
private int FindExistingUpdate(ZipEntry entry) { int num = -1; string transformedFileName = this.GetTransformedFileName(entry.Name); if (this.updateIndex_.ContainsKey(transformedFileName)) { num = (int) this.updateIndex_[transformedFileName]; } return num; }
public override void Close() { this.internalReader = new ReadDataHandler(this.ReadingNotAvailable); this.crc = null; this.entry = null; base.Close(); }
public ZipEntry MakeFileEntry(string fileName, bool useFileSystem) { ZipEntry entry = new ZipEntry(this.nameTransform_.TransformFile(fileName)) { IsUnicodeText = this.isUnicodeText_ }; int num = 0; bool flag = this.setAttributes_ != 0; FileInfo info = null; if (useFileSystem) { info = new FileInfo(fileName); } if ((info == null) || !info.Exists) { if (this.timeSetting_ == TimeSetting.Fixed) { entry.DateTime = this.fixedDateTime_; } } else { switch (this.timeSetting_) { case TimeSetting.LastWriteTime: entry.DateTime = info.LastWriteTime; break; case TimeSetting.LastWriteTimeUtc: entry.DateTime = info.LastWriteTimeUtc; break; case TimeSetting.CreateTime: entry.DateTime = info.CreationTime; break; case TimeSetting.CreateTimeUtc: entry.DateTime = info.CreationTimeUtc; break; case TimeSetting.LastAccessTime: entry.DateTime = info.LastAccessTime; break; case TimeSetting.LastAccessTimeUtc: entry.DateTime = info.LastAccessTimeUtc; break; case TimeSetting.Fixed: entry.DateTime = this.fixedDateTime_; break; default: throw new ZipException("Unhandled time setting in MakeFileEntry"); } entry.Size = info.Length; flag = true; num = ((int) info.Attributes) & this.getAttributes_; } if (flag) { num |= this.setAttributes_; entry.ExternalFileAttributes = num; } return entry; }
public ZipEntry GetNextEntry() { if (this.crc == null) { throw new InvalidOperationException("Closed."); } if (this.entry != null) { this.CloseEntry(); } int num = base.inputBuffer.ReadLeInt(); switch (num) { case 0x2014b50: case 0x6054b50: case 0x5054b50: case 0x7064b50: case 0x6064b50: this.Close(); return null; case 0x30304b50: case 0x8074b50: num = base.inputBuffer.ReadLeInt(); break; } if (num != 0x4034b50) { throw new ZipException("Wrong Local header signature: 0x" + string.Format("{0:X}", num)); } short versionRequiredToExtract = (short) base.inputBuffer.ReadLeShort(); this.flags = base.inputBuffer.ReadLeShort(); this.method = base.inputBuffer.ReadLeShort(); uint num3 = (uint) base.inputBuffer.ReadLeInt(); int num4 = base.inputBuffer.ReadLeInt(); base.csize = base.inputBuffer.ReadLeInt(); this.size = base.inputBuffer.ReadLeInt(); int num5 = base.inputBuffer.ReadLeShort(); int num6 = base.inputBuffer.ReadLeShort(); bool flag = (this.flags & 1) == 1; byte[] buffer = new byte[num5]; base.inputBuffer.ReadRawBuffer(buffer); string name = ZipConstants.ConvertToStringExt(this.flags, buffer); this.entry = new ZipEntry(name, versionRequiredToExtract); this.entry.Flags = this.flags; this.entry.CompressionMethod = (CompressionMethod) this.method; if ((this.flags & 8) == 0) { this.entry.Crc = num4 & ((long) 0xffffffffL); this.entry.Size = this.size & ((long) 0xffffffffL); this.entry.CompressedSize = base.csize & ((long) 0xffffffffL); this.entry.CryptoCheckValue = (byte) ((num4 >> 0x18) & 0xff); } else { if (num4 != 0) { this.entry.Crc = num4 & ((long) 0xffffffffL); } if (this.size != 0L) { this.entry.Size = this.size & ((long) 0xffffffffL); } if (base.csize != 0L) { this.entry.CompressedSize = base.csize & ((long) 0xffffffffL); } this.entry.CryptoCheckValue = (byte) ((num3 >> 8) & 0xff); } this.entry.DosTime = num3; if (num6 > 0) { byte[] buffer2 = new byte[num6]; base.inputBuffer.ReadRawBuffer(buffer2); this.entry.ExtraData = buffer2; } this.entry.ProcessExtraData(true); if (this.entry.CompressedSize >= 0L) { base.csize = this.entry.CompressedSize; } if (this.entry.Size >= 0L) { this.size = this.entry.Size; } if ((this.method == 0) && ((!flag && (base.csize != this.size)) || (flag && ((base.csize - 12L) != this.size)))) { throw new ZipException("Stored, but compressed != uncompressed"); } if (this.entry.IsCompressionMethodSupported()) { this.internalReader = new ReadDataHandler(this.InitialRead); } else { this.internalReader = new ReadDataHandler(this.ReadingNotSupported); } return this.entry; }
public int WriteDataDescriptor(ZipEntry entry) { if (entry == null) { throw new ArgumentNullException("entry"); } int num = 0; if ((entry.Flags & 8) == 0) { return num; } this.WriteLEInt(0x8074b50); this.WriteLEInt((int) entry.Crc); num += 8; if (entry.LocalHeaderRequiresZip64) { this.WriteLELong(entry.CompressedSize); this.WriteLELong(entry.Size); return (num + 0x10); } this.WriteLEInt((int) entry.CompressedSize); this.WriteLEInt((int) entry.Size); return (num + 8); }
public Stream GetInputStream(ZipEntry entry) { if (entry == null) { throw new ArgumentNullException("entry"); } if (this.isDisposed_) { throw new ObjectDisposedException("ZipFile"); } long zipFileIndex = entry.ZipFileIndex; if (((zipFileIndex < 0L) || (zipFileIndex >= this.entries_.Length)) || (this.entries_[(int) ((IntPtr) zipFileIndex)].Name != entry.Name)) { zipFileIndex = this.FindEntry(entry.Name, true); if (zipFileIndex < 0L) { throw new ZipException("Entry cannot be found"); } } return this.GetInputStream(zipFileIndex); }
public ZipUpdate(ZipEntry original, ZipEntry updated) { this.sizePatchOffset_ = -1L; this.crcPatchOffset_ = -1L; this._offsetBasedSize = -1L; throw new ZipException("Modify not currently supported"); }
private Stream GetOutputStream(ZipEntry entry) { Stream baseStream = this.baseStream_; if (entry.IsCrypted) { baseStream = this.CreateAndInitEncryptionStream(baseStream, entry); } CompressionMethod compressionMethod = entry.CompressionMethod; if (compressionMethod != CompressionMethod.Stored) { if (compressionMethod != CompressionMethod.Deflated) { throw new ZipException("Unknown compression method " + entry.CompressionMethod); } } else { return new UncompressedStream(baseStream); } return new DeflaterOutputStream(baseStream, new Deflater(9, true)) { IsStreamOwner = false }; }
private long LocateEntry(ZipEntry entry) { return this.TestLocalHeader(entry, HeaderTest.Extract); }
private void WriteLocalHeader(ZipEntry entry, EntryPatchData patchData) { CompressionMethod compressionMethod = entry.CompressionMethod; bool flag = true; bool flag2 = false; this.WriteLEInt(0x4034b50); this.WriteLEShort(entry.Version); this.WriteLEShort(entry.Flags); this.WriteLEShort((byte) compressionMethod); this.WriteLEInt((int) entry.DosTime); if (flag) { this.WriteLEInt((int) entry.Crc); if (entry.LocalHeaderRequiresZip64) { this.WriteLEInt(-1); this.WriteLEInt(-1); } else { this.WriteLEInt(entry.IsCrypted ? (((int) entry.CompressedSize) + 12) : ((int) entry.CompressedSize)); this.WriteLEInt((int) entry.Size); } } else { if (patchData != null) { patchData.CrcPatchOffset = this.stream_.Position; } this.WriteLEInt(0); if (patchData != null) { patchData.SizePatchOffset = this.stream_.Position; } if (entry.LocalHeaderRequiresZip64 && flag2) { this.WriteLEInt(-1); this.WriteLEInt(-1); } else { this.WriteLEInt(0); this.WriteLEInt(0); } } byte[] buffer = ZipConstants.ConvertToArray(entry.Flags, entry.Name); if (buffer.Length > 0xffff) { throw new ZipException("Entry name too long."); } ZipExtraData data = new ZipExtraData(entry.ExtraData); if (entry.LocalHeaderRequiresZip64 && (flag || flag2)) { data.StartNewEntry(); if (flag) { data.AddLeLong(entry.Size); data.AddLeLong(entry.CompressedSize); } else { data.AddLeLong(-1L); data.AddLeLong(-1L); } data.AddNewEntry(1); if (!data.Find(1)) { throw new ZipException("Internal error cant find extra data"); } if (patchData != null) { patchData.SizePatchOffset = data.CurrentReadIndex; } } else { data.Delete(1); } byte[] entryData = data.GetEntryData(); this.WriteLEShort(buffer.Length); this.WriteLEShort(entryData.Length); if (buffer.Length > 0) { this.stream_.Write(buffer, 0, buffer.Length); } if (entry.LocalHeaderRequiresZip64 && flag2) { patchData.SizePatchOffset += this.stream_.Position; } if (entryData.Length > 0) { this.stream_.Write(entryData, 0, entryData.Length); } }
public ZipEntryEnumerator(ZipEntry[] entries) { this.array = entries; }