ch0ic3/MalwareSourceCode
1
0
Fork 0
mirror of https://github.com/vxunderground/MalwareSourceCode.git synced 2024-12-23 03:46:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
f2ac1ece55
MalwareSourceCode/MSIL/Trojan-Ransom/Win32/B/Trojan-Ransom.Win32.Blocker.kkro-82cd479bb60c59525668e5016b400a8cc48f04b14a5c6cad5e2c6046b301e79d/SmartAssembly/Zip/SimpleZip.cs

2390 lines
74 KiB
C#
Raw Normal View History

auto-decompiled msil via petikvx add
2022-08-18 11:28:56 +00:00
// Decompiled with JetBrains decompiler
// Type: SmartAssembly.Zip.SimpleZip
// Assembly: WinData, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: 162322D2-FE3A-45B9-99E4-3519564A1D4D
// Assembly location: C:\Users\Administrateur\Downloads\Virusshare.00004-msil\Trojan-Ransom.Win32.Blocker.kkro-82cd479bb60c59525668e5016b400a8cc48f04b14a5c6cad5e2c6046b301e79d.exe
using System;
using System.IO;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
namespace SmartAssembly.Zip
{
public sealed class SimpleZip
{
public static string ExceptionMessage;
private static bool PublicKeysMatch(Assembly executingAssembly, Assembly callingAssembly)
{
byte[] publicKey1 = executingAssembly.GetName().GetPublicKey();
byte[] publicKey2 = callingAssembly.GetName().GetPublicKey();
if (publicKey2 == null != (publicKey1 == null))
return false;
if (publicKey2 != null)
{
for (int index = 0; index < publicKey2.Length; ++index)
{
if ((int) publicKey2[index] != (int) publicKey1[index])
return false;
}
}
return true;
}
public static byte[] Unzip(byte[] buffer)
{
Assembly callingAssembly = Assembly.GetCallingAssembly();
Assembly executingAssembly = Assembly.GetExecutingAssembly();
if ((object) callingAssembly != (object) executingAssembly && !SimpleZip.PublicKeysMatch(executingAssembly, callingAssembly))
return (byte[]) null;
SimpleZip.ZipStream zipStream = new SimpleZip.ZipStream(buffer);
byte[] buf = new byte[0];
int num1 = zipStream.ReadInt();
if (num1 == 67324752)
{
short num2 = (short) zipStream.ReadShort();
int num3 = zipStream.ReadShort();
int num4 = zipStream.ReadShort();
if (num1 != 67324752 || num2 != (short) 20 || num3 != 0 || num4 != 8)
throw new FormatException("Wrong Header Signature");
zipStream.ReadInt();
zipStream.ReadInt();
zipStream.ReadInt();
int length = zipStream.ReadInt();
int count1 = zipStream.ReadShort();
int count2 = zipStream.ReadShort();
if (count1 > 0)
{
byte[] buffer1 = new byte[count1];
zipStream.Read(buffer1, 0, count1);
}
if (count2 > 0)
{
byte[] buffer2 = new byte[count2];
zipStream.Read(buffer2, 0, count2);
}
byte[] numArray = new byte[zipStream.Length - zipStream.Position];
zipStream.Read(numArray, 0, numArray.Length);
SimpleZip.Inflater inflater = new SimpleZip.Inflater(numArray);
buf = new byte[length];
inflater.Inflate(buf, 0, buf.Length);
}
else
{
int num5 = num1 >> 24;
if (num1 - (num5 << 24) != 8223355)
throw new FormatException("Unknown Header");
if (num5 == 1)
{
int length1 = zipStream.ReadInt();
buf = new byte[length1];
int len;
for (int offset = 0; offset < length1; offset += len)
{
int length2 = zipStream.ReadInt();
len = zipStream.ReadInt();
byte[] numArray = new byte[length2];
zipStream.Read(numArray, 0, numArray.Length);
new SimpleZip.Inflater(numArray).Inflate(buf, offset, len);
}
}
if (num5 == 2)
{
byte[] key = new byte[8]
{
(byte) 85,
(byte) 240,
(byte) 125,
(byte) 197,
(byte) 120,
(byte) 224,
(byte) 53,
(byte) 165
};
byte[] iv = new byte[8]
{
(byte) 169,
(byte) 210,
(byte) 146,
(byte) 41,
(byte) 1,
(byte) 34,
(byte) 222,
(byte) 163
};
using (DESCryptoIndirector cryptoIndirector = new DESCryptoIndirector())
{
using (ICryptoTransform desCryptoTransform = cryptoIndirector.GetDESCryptoTransform(key, iv, true))
buf = SimpleZip.Unzip(desCryptoTransform.TransformFinalBlock(buffer, 4, buffer.Length - 4));
}
}
if (num5 == 3)
{
byte[] key = new byte[16]
{
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1,
(byte) 1
};
byte[] iv = new byte[16]
{
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2,
(byte) 2
};
using (AESCryptoIndirector cryptoIndirector = new AESCryptoIndirector())
{
using (ICryptoTransform aesCryptoTransform = cryptoIndirector.GetAESCryptoTransform(key, iv, true))
buf = SimpleZip.Unzip(aesCryptoTransform.TransformFinalBlock(buffer, 4, buffer.Length - 4));
}
}
}
zipStream.Close();
return buf;
}
public static byte[] Zip(byte[] buffer) => SimpleZip.Zip(buffer, 1, (byte[]) null, (byte[]) null);
public static byte[] ZipAndEncrypt(byte[] buffer, byte[] key, byte[] iv) => SimpleZip.Zip(buffer, 2, key, iv);
public static byte[] ZipAndAES(byte[] buffer, byte[] key, byte[] iv) => SimpleZip.Zip(buffer, 3, key, iv);
private static byte[] Zip(byte[] buffer, int version, byte[] key, byte[] iv)
{
try
{
SimpleZip.ZipStream zipStream = new SimpleZip.ZipStream();
switch (version)
{
case 0:
SimpleZip.Deflater deflater1 = new SimpleZip.Deflater();
DateTime now = DateTime.Now;
long num1 = (long) ((uint) ((now.Year - 1980 & (int) sbyte.MaxValue) << 25 | now.Month << 21 | now.Day << 16 | now.Hour << 11 | now.Minute << 5) | (uint) now.Second >> 1);
uint[] numArray1 = new uint[256]
{
0U,
1996959894U,
3993919788U,
2567524794U,
124634137U,
1886057615U,
3915621685U,
2657392035U,
249268274U,
2044508324U,
3772115230U,
2547177864U,
162941995U,
2125561021U,
3887607047U,
2428444049U,
498536548U,
1789927666U,
4089016648U,
2227061214U,
450548861U,
1843258603U,
4107580753U,
2211677639U,
325883990U,
1684777152U,
4251122042U,
2321926636U,
335633487U,
1661365465U,
4195302755U,
2366115317U,
997073096U,
1281953886U,
3579855332U,
2724688242U,
1006888145U,
1258607687U,
3524101629U,
2768942443U,
901097722U,
1119000684U,
3686517206U,
2898065728U,
853044451U,
1172266101U,
3705015759U,
2882616665U,
651767980U,
1373503546U,
3369554304U,
3218104598U,
565507253U,
1454621731U,
3485111705U,
3099436303U,
671266974U,
1594198024U,
3322730930U,
2970347812U,
795835527U,
1483230225U,
3244367275U,
3060149565U,
1994146192U,
31158534U,
2563907772U,
4023717930U,
1907459465U,
112637215U,
2680153253U,
3904427059U,
2013776290U,
251722036U,
2517215374U,
3775830040U,
2137656763U,
141376813U,
2439277719U,
3865271297U,
1802195444U,
476864866U,
2238001368U,
4066508878U,
1812370925U,
453092731U,
2181625025U,
4111451223U,
1706088902U,
314042704U,
2344532202U,
4240017532U,
1658658271U,
366619977U,
2362670323U,
4224994405U,
1303535960U,
984961486U,
2747007092U,
3569037538U,
1256170817U,
1037604311U,
2765210733U,
3554079995U,
1131014506U,
879679996U,
2909243462U,
3663771856U,
1141124467U,
855842277U,
2852801631U,
3708648649U,
1342533948U,
654459306U,
3188396048U,
3373015174U,
1466479909U,
544179635U,
3110523913U,
3462522015U,
1591671054U,
702138776U,
2966460450U,
3352799412U,
1504918807U,
783551873U,
3082640443U,
3233442989U,
3988292384U,
2596254646U,
62317068U,
1957810842U,
3939845945U,
2647816111U,
81470997U,
1943803523U,
3814918930U,
2489596804U,
225274430U,
2053790376U,
3826175755U,
2466906013U,
167816743U,
2097651377U,
4027552580U,
2265490386U,
503444072U,
1762050814U,
4150417245U,
2154129355U,
426522225U,
1852507879U,
4275313526U,
2312317920U,
282753626U,
1742555852U,
4189708143U,
2394877945U,
397917763U,
1622183637U,
3604390888U,
2714866558U,
953729732U,
1340076626U,
3518719985U,
2797360999U,
1068828381U,
1219638859U,
3624741850U,
2936675148U,
906185462U,
1090812512U,
3747672003U,
2825379669U,
829329135U,
1181335161U,
3412177804U,
3160834842U,
628085408U,
1382605366U,
3423369109U,
3138078467U,
570562233U,
1426400815U,
3317316542U,
2998733608U,
733239954U,
1555261956U,
3268935591U,
3050360625U,
752459403U,
1541320221U,
2607071920U,
3965973030U,
1969922972U,
40735498U,
2617837225U,
3943577151U,
1913087877U,
83908371U,
2512341634U,
3803740692U,
2075208622U,
213261112U,
2463272603U,
3855990285U,
2094854071U,
198958881U,
2262029012U,
4057260610U,
1759359992U,
534414190U,
2176718541U,
4139329115U,
1873836001U,
414664567U,
2282248934U,
4279200368U,
1711684554U,
285281116U,
2405801727U,
4167216745U,
1634467795U,
376229701U,
2685067896U,
3608007406U,
1308918612U,
956543938U,
2808555105U,
3495958263U,
1231636301U,
1047427035U,
2932959818U,
3654703836U,
1088359270U,
936918000U,
2847714899U,
3736837829U,
1202900863U,
817233897U,
3183342108U,
3401237130U,
1404277552U,
615818150U,
3134207493U,
3453421203U,
1423857449U,
601450431U,
3009837614U,
3294710456U,
1567103746U,
711928724U,
3020668471U,
3272380065U,
1510334235U,
755167117U
};
uint maxValue = uint.MaxValue;
uint num2 = maxValue;
int num3 = 0;
int length = buffer.Length;
while (--length >= 0)
num2 = numArray1[(IntPtr) (uint) (((int) num2 ^ (int) buffer[num3++]) & (int) byte.MaxValue)] ^ num2 >> 8;
uint num4 = num2 ^ maxValue;
zipStream.WriteInt(67324752);
zipStream.WriteShort(20);
zipStream.WriteShort(0);
zipStream.WriteShort(8);
zipStream.WriteInt((int) num1);
zipStream.WriteInt((int) num4);
long position1 = zipStream.Position;
zipStream.WriteInt(0);
zipStream.WriteInt(buffer.Length);
byte[] bytes = Encoding.UTF8.GetBytes("{data}");
zipStream.WriteShort(bytes.Length);
zipStream.WriteShort(0);
zipStream.Write(bytes, 0, bytes.Length);
deflater1.SetInput(buffer);
while (!deflater1.IsNeedingInput)
{
byte[] numArray2 = new byte[512];
int count = deflater1.Deflate(numArray2);
if (count > 0)
zipStream.Write(numArray2, 0, count);
else
break;
}
deflater1.Finish();
while (!deflater1.IsFinished)
{
byte[] numArray3 = new byte[512];
int count = deflater1.Deflate(numArray3);
if (count > 0)
zipStream.Write(numArray3, 0, count);
else
break;
}
long totalOut = deflater1.TotalOut;
zipStream.WriteInt(33639248);
zipStream.WriteShort(20);
zipStream.WriteShort(20);
zipStream.WriteShort(0);
zipStream.WriteShort(8);
zipStream.WriteInt((int) num1);
zipStream.WriteInt((int) num4);
zipStream.WriteInt((int) totalOut);
zipStream.WriteInt(buffer.Length);
zipStream.WriteShort(bytes.Length);
zipStream.WriteShort(0);
zipStream.WriteShort(0);
zipStream.WriteShort(0);
zipStream.WriteShort(0);
zipStream.WriteInt(0);
zipStream.WriteInt(0);
zipStream.Write(bytes, 0, bytes.Length);
zipStream.WriteInt(101010256);
zipStream.WriteShort(0);
zipStream.WriteShort(0);
zipStream.WriteShort(1);
zipStream.WriteShort(1);
zipStream.WriteInt(46 + bytes.Length);
zipStream.WriteInt((int) ((long) (30 + bytes.Length) + totalOut));
zipStream.WriteShort(0);
zipStream.Seek(position1, SeekOrigin.Begin);
zipStream.WriteInt((int) totalOut);
break;
case 1:
zipStream.WriteInt(25000571);
zipStream.WriteInt(buffer.Length);
byte[] numArray4;
for (int srcOffset = 0; srcOffset < buffer.Length; srcOffset += numArray4.Length)
{
numArray4 = new byte[Math.Min(2097151, buffer.Length - srcOffset)];
Buffer.BlockCopy((Array) buffer, srcOffset, (Array) numArray4, 0, numArray4.Length);
long position2 = zipStream.Position;
zipStream.WriteInt(0);
zipStream.WriteInt(numArray4.Length);
SimpleZip.Deflater deflater2 = new SimpleZip.Deflater();
deflater2.SetInput(numArray4);
while (!deflater2.IsNeedingInput)
{
byte[] numArray5 = new byte[512];
int count = deflater2.Deflate(numArray5);
if (count > 0)
zipStream.Write(numArray5, 0, count);
else
break;
}
deflater2.Finish();
while (!deflater2.IsFinished)
{
byte[] numArray6 = new byte[512];
int count = deflater2.Deflate(numArray6);
if (count > 0)
zipStream.Write(numArray6, 0, count);
else
break;
}
long position3 = zipStream.Position;
zipStream.Position = position2;
zipStream.WriteInt((int) deflater2.TotalOut);
zipStream.Position = position3;
}
break;
case 2:
zipStream.WriteInt(41777787);
byte[] inputBuffer1 = SimpleZip.Zip(buffer, 1, (byte[]) null, (byte[]) null);
using (DESCryptoIndirector cryptoIndirector = new DESCryptoIndirector())
{
using (ICryptoTransform desCryptoTransform = cryptoIndirector.GetDESCryptoTransform(key, iv, false))
{
byte[] buffer1 = desCryptoTransform.TransformFinalBlock(inputBuffer1, 0, inputBuffer1.Length);
zipStream.Write(buffer1, 0, buffer1.Length);
break;
}
}
case 3:
zipStream.WriteInt(58555003);
byte[] inputBuffer2 = SimpleZip.Zip(buffer, 1, (byte[]) null, (byte[]) null);
using (AESCryptoIndirector cryptoIndirector = new AESCryptoIndirector())
{
using (ICryptoTransform aesCryptoTransform = cryptoIndirector.GetAESCryptoTransform(key, iv, false))
{
byte[] buffer2 = aesCryptoTransform.TransformFinalBlock(inputBuffer2, 0, inputBuffer2.Length);
zipStream.Write(buffer2, 0, buffer2.Length);
break;
}
}
}
zipStream.Flush();
zipStream.Close();
return zipStream.ToArray();
}
catch (Exception ex)
{
SimpleZip.ExceptionMessage = "ERR 2003: " + ex.Message;
throw;
}
}
internal sealed class Inflater
{
private const int DECODE_HEADER = 0;
private const int DECODE_DICT = 1;
private const int DECODE_BLOCKS = 2;
private const int DECODE_STORED_LEN1 = 3;
private const int DECODE_STORED_LEN2 = 4;
private const int DECODE_STORED = 5;
private const int DECODE_DYN_HEADER = 6;
private const int DECODE_HUFFMAN = 7;
private const int DECODE_HUFFMAN_LENBITS = 8;
private const int DECODE_HUFFMAN_DIST = 9;
private const int DECODE_HUFFMAN_DISTBITS = 10;
private const int DECODE_CHKSUM = 11;
private const int FINISHED = 12;
private static readonly int[] CPLENS = new int[29]
{
3,
4,
5,
6,
7,
8,
9,
10,
11,
13,
15,
17,
19,
23,
27,
31,
35,
43,
51,
59,
67,
83,
99,
115,
131,
163,
195,
227,
258
};
private static readonly int[] CPLEXT = new int[29]
{
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
2,
2,
2,
2,
3,
3,
3,
3,
4,
4,
4,
4,
5,
5,
5,
5,
0
};
private static readonly int[] CPDIST = new int[30]
{
1,
2,
3,
4,
5,
7,
9,
13,
17,
25,
33,
49,
65,
97,
129,
193,
257,
385,
513,
769,
1025,
1537,
2049,
3073,
4097,
6145,
8193,
12289,
16385,
24577
};
private static readonly int[] CPDEXT = new int[30]
{
0,
0,
0,
0,
1,
1,
2,
2,
3,
3,
4,
4,
5,
5,
6,
6,
7,
7,
8,
8,
9,
9,
10,
10,
11,
11,
12,
12,
13,
13
};
private int mode;
private int neededBits;
private int repLength;
private int repDist;
private int uncomprLen;
private bool isLastBlock;
private SimpleZip.StreamManipulator input;
private SimpleZip.OutputWindow outputWindow;
private SimpleZip.InflaterDynHeader dynHeader;
private SimpleZip.InflaterHuffmanTree litlenTree;
private SimpleZip.InflaterHuffmanTree distTree;
public Inflater(byte[] bytes)
{
this.input = new SimpleZip.StreamManipulator();
this.outputWindow = new SimpleZip.OutputWindow();
this.mode = 2;
this.input.SetInput(bytes, 0, bytes.Length);
}
private bool DecodeHuffman()
{
int freeSpace = this.outputWindow.GetFreeSpace();
while (freeSpace >= 258)
{
switch (this.mode)
{
case 7:
int symbol1;
while (((symbol1 = this.litlenTree.GetSymbol(this.input)) & -256) == 0)
{
this.outputWindow.Write(symbol1);
if (--freeSpace < 258)
return true;
}
if (symbol1 < 257)
{
if (symbol1 < 0)
return false;
this.distTree = (SimpleZip.InflaterHuffmanTree) null;
this.litlenTree = (SimpleZip.InflaterHuffmanTree) null;
this.mode = 2;
return true;
}
this.repLength = SimpleZip.Inflater.CPLENS[symbol1 - 257];
this.neededBits = SimpleZip.Inflater.CPLEXT[symbol1 - 257];
goto case 8;
case 8:
if (this.neededBits > 0)
{
this.mode = 8;
int num = this.input.PeekBits(this.neededBits);
if (num < 0)
return false;
this.input.DropBits(this.neededBits);
this.repLength += num;
}
this.mode = 9;
goto case 9;
case 9:
int symbol2 = this.distTree.GetSymbol(this.input);
if (symbol2 < 0)
return false;
this.repDist = SimpleZip.Inflater.CPDIST[symbol2];
this.neededBits = SimpleZip.Inflater.CPDEXT[symbol2];
goto case 10;
case 10:
if (this.neededBits > 0)
{
this.mode = 10;
int num = this.input.PeekBits(this.neededBits);
if (num < 0)
return false;
this.input.DropBits(this.neededBits);
this.repDist += num;
}
this.outputWindow.Repeat(this.repLength, this.repDist);
freeSpace -= this.repLength;
this.mode = 7;
continue;
default:
continue;
}
}
return true;
}
private bool Decode()
{
switch (this.mode)
{
case 2:
if (this.isLastBlock)
{
this.mode = 12;
return false;
}
int num = this.input.PeekBits(3);
if (num < 0)
return false;
this.input.DropBits(3);
if ((num & 1) != 0)
this.isLastBlock = true;
switch (num >> 1)
{
case 0:
this.input.SkipToByteBoundary();
this.mode = 3;
break;
case 1:
this.litlenTree = SimpleZip.InflaterHuffmanTree.defLitLenTree;
this.distTree = SimpleZip.InflaterHuffmanTree.defDistTree;
this.mode = 7;
break;
case 2:
this.dynHeader = new SimpleZip.InflaterDynHeader();
this.mode = 6;
break;
}
return true;
case 3:
if ((this.uncomprLen = this.input.PeekBits(16)) < 0)
return false;
this.input.DropBits(16);
this.mode = 4;
goto case 4;
case 4:
if (this.input.PeekBits(16) < 0)
return false;
this.input.DropBits(16);
this.mode = 5;
goto case 5;
case 5:
this.uncomprLen -= this.outputWindow.CopyStored(this.input, this.uncomprLen);
if (this.uncomprLen != 0)
return !this.input.IsNeedingInput;
this.mode = 2;
return true;
case 6:
if (!this.dynHeader.Decode(this.input))
return false;
this.litlenTree = this.dynHeader.BuildLitLenTree();
this.distTree = this.dynHeader.BuildDistTree();
this.mode = 7;
goto case 7;
case 7:
case 8:
case 9:
case 10:
return this.DecodeHuffman();
case 12:
return false;
default:
return false;
}
}
public int Inflate(byte[] buf, int offset, int len)
{
int num1 = 0;
do
{
if (this.mode != 11)
{
int num2 = this.outputWindow.CopyOutput(buf, offset, len);
offset += num2;
num1 += num2;
len -= num2;
if (len == 0)
return num1;
}
}
while (this.Decode() || this.outputWindow.GetAvailable() > 0 && this.mode != 11);
return num1;
}
}
internal sealed class StreamManipulator
{
private byte[] window;
private int window_start = 0;
private int window_end = 0;
private uint buffer = 0;
private int bits_in_buffer = 0;
public int PeekBits(int n)
{
if (this.bits_in_buffer < n)
{
if (this.window_start == this.window_end)
return -1;
this.buffer |= (uint) (((int) this.window[this.window_start++] & (int) byte.MaxValue | ((int) this.window[this.window_start++] & (int) byte.MaxValue) << 8) << this.bits_in_buffer);
this.bits_in_buffer += 16;
}
return (int) ((long) this.buffer & (long) ((1 << n) - 1));
}
public void DropBits(int n)
{
this.buffer >>= n;
this.bits_in_buffer -= n;
}
public int AvailableBits => this.bits_in_buffer;
public int AvailableBytes => this.window_end - this.window_start + (this.bits_in_buffer >> 3);
public void SkipToByteBoundary()
{
this.buffer >>= this.bits_in_buffer & 7;
this.bits_in_buffer &= -8;
}
public bool IsNeedingInput => this.window_start == this.window_end;
public int CopyBytes(byte[] output, int offset, int length)
{
int num1 = 0;
while (this.bits_in_buffer > 0 && length > 0)
{
output[offset++] = (byte) this.buffer;
this.buffer >>= 8;
this.bits_in_buffer -= 8;
--length;
++num1;
}
if (length == 0)
return num1;
int num2 = this.window_end - this.window_start;
if (length > num2)
length = num2;
Array.Copy((Array) this.window, this.window_start, (Array) output, offset, length);
this.window_start += length;
if ((this.window_start - this.window_end & 1) != 0)
{
this.buffer = (uint) this.window[this.window_start++] & (uint) byte.MaxValue;
this.bits_in_buffer = 8;
}
return num1 + length;
}
public void Reset() => this.buffer = (uint) (this.window_start = this.window_end = this.bits_in_buffer = 0);
public void SetInput(byte[] buf, int off, int len)
{
if (this.window_start < this.window_end)
throw new InvalidOperationException();
int num = off + len;
if (0 > off || off > num || num > buf.Length)
throw new ArgumentOutOfRangeException();
if ((len & 1) != 0)
{
this.buffer |= (uint) (((int) buf[off++] & (int) byte.MaxValue) << this.bits_in_buffer);
this.bits_in_buffer += 8;
}
this.window = buf;
this.window_start = off;
this.window_end = num;
}
}
internal sealed class OutputWindow
{
private const int WINDOW_SIZE = 32768;
private const int WINDOW_MASK = 32767;
private byte[] window = new byte[32768];
private int windowEnd = 0;
private int windowFilled = 0;
public void Write(int abyte)
{
if (this.windowFilled++ == 32768)
throw new InvalidOperationException();
this.window[this.windowEnd++] = (byte) abyte;
this.windowEnd &= (int) short.MaxValue;
}
private void SlowRepeat(int repStart, int len, int dist)
{
while (len-- > 0)
{
this.window[this.windowEnd++] = this.window[repStart++];
this.windowEnd &= (int) short.MaxValue;
repStart &= (int) short.MaxValue;
}
}
public void Repeat(int len, int dist)
{
if ((this.windowFilled += len) > 32768)
throw new InvalidOperationException();
int num1 = this.windowEnd - dist & (int) short.MaxValue;
int num2 = 32768 - len;
if (num1 <= num2 && this.windowEnd < num2)
{
if (len <= dist)
{
Array.Copy((Array) this.window, num1, (Array) this.window, this.windowEnd, len);
this.windowEnd += len;
}
else
{
while (len-- > 0)
this.window[this.windowEnd++] = this.window[num1++];
}
}
else
this.SlowRepeat(num1, len, dist);
}
public int CopyStored(SimpleZip.StreamManipulator input, int len)
{
len = Math.Min(Math.Min(len, 32768 - this.windowFilled), input.AvailableBytes);
int length = 32768 - this.windowEnd;
int num;
if (len > length)
{
num = input.CopyBytes(this.window, this.windowEnd, length);
if (num == length)
num += input.CopyBytes(this.window, 0, len - length);
}
else
num = input.CopyBytes(this.window, this.windowEnd, len);
this.windowEnd = this.windowEnd + num & (int) short.MaxValue;
this.windowFilled += num;
return num;
}
public void CopyDict(byte[] dict, int offset, int len)
{
if (this.windowFilled > 0)
throw new InvalidOperationException();
if (len > 32768)
{
offset += len - 32768;
len = 32768;
}
Array.Copy((Array) dict, offset, (Array) this.window, 0, len);
this.windowEnd = len & (int) short.MaxValue;
}
public int GetFreeSpace() => 32768 - this.windowFilled;
public int GetAvailable() => this.windowFilled;
public int CopyOutput(byte[] output, int offset, int len)
{
int num1 = this.windowEnd;
if (len > this.windowFilled)
len = this.windowFilled;
else
num1 = this.windowEnd - this.windowFilled + len & (int) short.MaxValue;
int num2 = len;
int length = len - num1;
if (length > 0)
{
Array.Copy((Array) this.window, 32768 - length, (Array) output, offset, length);
offset += length;
len = num1;
}
Array.Copy((Array) this.window, num1 - len, (Array) output, offset, len);
this.windowFilled -= num2;
if (this.windowFilled < 0)
throw new InvalidOperationException();
return num2;
}
public void Reset() => this.windowFilled = this.windowEnd = 0;
}
internal sealed class InflaterHuffmanTree
{
private const int MAX_BITLEN = 15;
private short[] tree;
public static readonly SimpleZip.InflaterHuffmanTree defLitLenTree;
public static readonly SimpleZip.InflaterHuffmanTree defDistTree;
static InflaterHuffmanTree()
{
byte[] codeLengths1 = new byte[288];
int num1 = 0;
while (num1 < 144)
codeLengths1[num1++] = (byte) 8;
while (num1 < 256)
codeLengths1[num1++] = (byte) 9;
while (num1 < 280)
codeLengths1[num1++] = (byte) 7;
while (num1 < 288)
codeLengths1[num1++] = (byte) 8;
SimpleZip.InflaterHuffmanTree.defLitLenTree = new SimpleZip.InflaterHuffmanTree(codeLengths1);
byte[] codeLengths2 = new byte[32];
int num2 = 0;
while (num2 < 32)
codeLengths2[num2++] = (byte) 5;
SimpleZip.InflaterHuffmanTree.defDistTree = new SimpleZip.InflaterHuffmanTree(codeLengths2);
}
public InflaterHuffmanTree(byte[] codeLengths) => this.BuildTree(codeLengths);
private void BuildTree(byte[] codeLengths)
{
int[] numArray1 = new int[16];
int[] numArray2 = new int[16];
for (int index = 0; index < codeLengths.Length; ++index)
{
int codeLength = (int) codeLengths[index];
if (codeLength > 0)
++numArray1[codeLength];
}
int num1 = 0;
int length = 512;
for (int index = 1; index <= 15; ++index)
{
numArray2[index] = num1;
num1 += numArray1[index] << 16 - index;
if (index >= 10)
{
int num2 = numArray2[index] & 130944;
int num3 = num1 & 130944;
length += num3 - num2 >> 16 - index;
}
}
this.tree = new short[length];
int num4 = 512;
for (int index = 15; index >= 10; --index)
{
int num5 = num1 & 130944;
num1 -= numArray1[index] << 16 - index;
for (int toReverse = num1 & 130944; toReverse < num5; toReverse += 128)
{
this.tree[(int) SimpleZip.DeflaterHuffman.BitReverse(toReverse)] = (short) (-num4 << 4 | index);
num4 += 1 << index - 9;
}
}
for (int index1 = 0; index1 < codeLengths.Length; ++index1)
{
int codeLength = (int) codeLengths[index1];
if (codeLength != 0)
{
int toReverse = numArray2[codeLength];
int index2 = (int) SimpleZip.DeflaterHuffman.BitReverse(toReverse);
if (codeLength <= 9)
{
do
{
this.tree[index2] = (short) (index1 << 4 | codeLength);
index2 += 1 << codeLength;
}
while (index2 < 512);
}
else
{
int num6 = (int) this.tree[index2 & 511];
int num7 = 1 << (num6 & 15);
int num8 = -(num6 >> 4);
do
{
this.tree[num8 | index2 >> 9] = (short) (index1 << 4 | codeLength);
index2 += 1 << codeLength;
}
while (index2 < num7);
}
numArray2[codeLength] = toReverse + (1 << 16 - codeLength);
}
}
}
public int GetSymbol(SimpleZip.StreamManipulator input)
{
int index;
if ((index = input.PeekBits(9)) >= 0)
{
int num1;
if ((num1 = (int) this.tree[index]) >= 0)
{
input.DropBits(num1 & 15);
return num1 >> 4;
}
int num2 = -(num1 >> 4);
int n = num1 & 15;
int num3;
if ((num3 = input.PeekBits(n)) >= 0)
{
int num4 = (int) this.tree[num2 | num3 >> 9];
input.DropBits(num4 & 15);
return num4 >> 4;
}
int availableBits = input.AvailableBits;
int num5 = input.PeekBits(availableBits);
int num6 = (int) this.tree[num2 | num5 >> 9];
if ((num6 & 15) > availableBits)
return -1;
input.DropBits(num6 & 15);
return num6 >> 4;
}
int availableBits1 = input.AvailableBits;
int num = (int) this.tree[input.PeekBits(availableBits1)];
if (num < 0 || (num & 15) > availableBits1)
return -1;
input.DropBits(num & 15);
return num >> 4;
}
}
internal sealed class InflaterDynHeader
{
private const int LNUM = 0;
private const int DNUM = 1;
private const int BLNUM = 2;
private const int BLLENS = 3;
private const int LENS = 4;
private const int REPS = 5;
private static readonly int[] repMin = new int[3]
{
3,
3,
11
};
private static readonly int[] repBits = new int[3]
{
2,
3,
7
};
private byte[] blLens;
private byte[] litdistLens;
private SimpleZip.InflaterHuffmanTree blTree;
private int mode;
private int lnum;
private int dnum;
private int blnum;
private int num;
private int repSymbol;
private byte lastLen;
private int ptr;
private static readonly int[] BL_ORDER = new int[19]
{
16,
17,
18,
0,
8,
7,
9,
6,
10,
5,
11,
4,
12,
3,
13,
2,
14,
1,
15
};
public bool Decode(SimpleZip.StreamManipulator input)
{
while (true)
{
switch (this.mode)
{
case 0:
this.lnum = input.PeekBits(5);
if (this.lnum >= 0)
{
this.lnum += 257;
input.DropBits(5);
this.mode = 1;
goto case 1;
}
else
goto label_2;
case 1:
this.dnum = input.PeekBits(5);
if (this.dnum >= 0)
{
++this.dnum;
input.DropBits(5);
this.num = this.lnum + this.dnum;
this.litdistLens = new byte[this.num];
this.mode = 2;
goto case 2;
}
else
goto label_5;
case 2:
this.blnum = input.PeekBits(4);
if (this.blnum >= 0)
{
this.blnum += 4;
input.DropBits(4);
this.blLens = new byte[19];
this.ptr = 0;
this.mode = 3;
goto case 3;
}
else
goto label_8;
case 3:
for (; this.ptr < this.blnum; ++this.ptr)
{
int num = input.PeekBits(3);
if (num < 0)
return false;
input.DropBits(3);
this.blLens[SimpleZip.InflaterDynHeader.BL_ORDER[this.ptr]] = (byte) num;
}
this.blTree = new SimpleZip.InflaterHuffmanTree(this.blLens);
this.blLens = (byte[]) null;
this.ptr = 0;
this.mode = 4;
goto case 4;
case 4:
int symbol;
while (((symbol = this.blTree.GetSymbol(input)) & -16) == 0)
{
this.litdistLens[this.ptr++] = this.lastLen = (byte) symbol;
if (this.ptr == this.num)
return true;
}
if (symbol >= 0)
{
if (symbol >= 17)
this.lastLen = (byte) 0;
this.repSymbol = symbol - 16;
this.mode = 5;
goto case 5;
}
else
goto label_19;
case 5:
int repBit = SimpleZip.InflaterDynHeader.repBits[this.repSymbol];
int num1 = input.PeekBits(repBit);
if (num1 >= 0)
{
input.DropBits(repBit);
int num2 = num1 + SimpleZip.InflaterDynHeader.repMin[this.repSymbol];
while (num2-- > 0)
this.litdistLens[this.ptr++] = this.lastLen;
if (this.ptr != this.num)
{
this.mode = 4;
continue;
}
goto label_29;
}
else
goto label_24;
default:
continue;
}
}
label_2:
return false;
label_5:
return false;
label_8:
return false;
label_19:
return false;
label_24:
return false;
label_29:
return true;
}
public SimpleZip.InflaterHuffmanTree BuildLitLenTree()
{
byte[] numArray = new byte[this.lnum];
Array.Copy((Array) this.litdistLens, 0, (Array) numArray, 0, this.lnum);
return new SimpleZip.InflaterHuffmanTree(numArray);
}
public SimpleZip.InflaterHuffmanTree BuildDistTree()
{
byte[] numArray = new byte[this.dnum];
Array.Copy((Array) this.litdistLens, this.lnum, (Array) numArray, 0, this.dnum);
return new SimpleZip.InflaterHuffmanTree(numArray);
}
}
internal sealed class Deflater
{
private const int IS_FLUSHING = 4;
private const int IS_FINISHING = 8;
private const int BUSY_STATE = 16;
private const int FLUSHING_STATE = 20;
private const int FINISHING_STATE = 28;
private const int FINISHED_STATE = 30;
private int state = 16;
private long totalOut = 0;
private SimpleZip.DeflaterPending pending;
private SimpleZip.DeflaterEngine engine;
public Deflater()
{
this.pending = new SimpleZip.DeflaterPending();
this.engine = new SimpleZip.DeflaterEngine(this.pending);
}
public long TotalOut => this.totalOut;
public void Finish() => this.state |= 12;
public bool IsFinished => this.state == 30 && this.pending.IsFlushed;
public bool IsNeedingInput => this.engine.NeedsInput();
public void SetInput(byte[] buffer) => this.engine.SetInput(buffer);
public int Deflate(byte[] output)
{
int offset = 0;
int length = output.Length;
int num1 = length;
while (true)
{
do
{
do
{
int num2 = this.pending.Flush(output, offset, length);
offset += num2;
this.totalOut += (long) num2;
length -= num2;
if (length == 0 || this.state == 30)
goto label_12;
}
while (this.engine.Deflate((this.state & 4) != 0, (this.state & 8) != 0));
if (this.state == 16)
return num1 - length;
if (this.state == 20)
{
for (int index = 8 + (-this.pending.BitCount & 7); index > 0; index -= 10)
this.pending.WriteBits(2, 10);
this.state = 16;
}
}
while (this.state != 28);
this.pending.AlignToByte();
this.state = 30;
}
label_12:
return num1 - length;
}
}
internal sealed class DeflaterHuffman
{
private const int BUFSIZE = 16384;
private const int LITERAL_NUM = 286;
private const int DIST_NUM = 30;
private const int BITLEN_NUM = 19;
private const int REP_3_6 = 16;
private const int REP_3_10 = 17;
private const int REP_11_138 = 18;
private const int EOF_SYMBOL = 256;
private static readonly int[] BL_ORDER = new int[19]
{
16,
17,
18,
0,
8,
7,
9,
6,
10,
5,
11,
4,
12,
3,
13,
2,
14,
1,
15
};
private static readonly byte[] bit4Reverse = new byte[16]
{
(byte) 0,
(byte) 8,
(byte) 4,
(byte) 12,
(byte) 2,
(byte) 10,
(byte) 6,
(byte) 14,
(byte) 1,
(byte) 9,
(byte) 5,
(byte) 13,
(byte) 3,
(byte) 11,
(byte) 7,
(byte) 15
};
private SimpleZip.DeflaterPending pending;
private SimpleZip.DeflaterHuffman.Tree literalTree;
private SimpleZip.DeflaterHuffman.Tree distTree;
private SimpleZip.DeflaterHuffman.Tree blTree;
private short[] d_buf;
private byte[] l_buf;
private int last_lit;
private int extra_bits;
private static readonly short[] staticLCodes = new short[286];
private static readonly byte[] staticLLength = new byte[286];
private static readonly short[] staticDCodes;
private static readonly byte[] staticDLength;
public static short BitReverse(int toReverse) => (short) ((int) SimpleZip.DeflaterHuffman.bit4Reverse[toReverse & 15] << 12 | (int) SimpleZip.DeflaterHuffman.bit4Reverse[toReverse >> 4 & 15] << 8 | (int) SimpleZip.DeflaterHuffman.bit4Reverse[toReverse >> 8 & 15] << 4 | (int) SimpleZip.DeflaterHuffman.bit4Reverse[toReverse >> 12]);
static DeflaterHuffman()
{
int index1;
for (index1 = 0; index1 < 144; SimpleZip.DeflaterHuffman.staticLLength[index1++] = (byte) 8)
SimpleZip.DeflaterHuffman.staticLCodes[index1] = SimpleZip.DeflaterHuffman.BitReverse(48 + index1 << 8);
for (; index1 < 256; SimpleZip.DeflaterHuffman.staticLLength[index1++] = (byte) 9)
SimpleZip.DeflaterHuffman.staticLCodes[index1] = SimpleZip.DeflaterHuffman.BitReverse(256 + index1 << 7);
for (; index1 < 280; SimpleZip.DeflaterHuffman.staticLLength[index1++] = (byte) 7)
SimpleZip.DeflaterHuffman.staticLCodes[index1] = SimpleZip.DeflaterHuffman.BitReverse(index1 - 256 << 9);
for (; index1 < 286; SimpleZip.DeflaterHuffman.staticLLength[index1++] = (byte) 8)
SimpleZip.DeflaterHuffman.staticLCodes[index1] = SimpleZip.DeflaterHuffman.BitReverse(index1 - 88 << 8);
SimpleZip.DeflaterHuffman.staticDCodes = new short[30];
SimpleZip.DeflaterHuffman.staticDLength = new byte[30];
for (int index2 = 0; index2 < 30; ++index2)
{
SimpleZip.DeflaterHuffman.staticDCodes[index2] = SimpleZip.DeflaterHuffman.BitReverse(index2 << 11);
SimpleZip.DeflaterHuffman.staticDLength[index2] = (byte) 5;
}
}
public DeflaterHuffman(SimpleZip.DeflaterPending pending)
{
this.pending = pending;
this.literalTree = new SimpleZip.DeflaterHuffman.Tree(this, 286, 257, 15);
this.distTree = new SimpleZip.DeflaterHuffman.Tree(this, 30, 1, 15);
this.blTree = new SimpleZip.DeflaterHuffman.Tree(this, 19, 4, 7);
this.d_buf = new short[16384];
this.l_buf = new byte[16384];
}
public void Init()
{
this.last_lit = 0;
this.extra_bits = 0;
}
private int Lcode(int len)
{
if (len == (int) byte.MaxValue)
return 285;
int num = 257;
for (; len >= 8; len >>= 1)
num += 4;
return num + len;
}
private int Dcode(int distance)
{
int num = 0;
for (; distance >= 4; distance >>= 1)
num += 2;
return num + distance;
}
public void SendAllTrees(int blTreeCodes)
{
this.blTree.BuildCodes();
this.literalTree.BuildCodes();
this.distTree.BuildCodes();
this.pending.WriteBits(this.literalTree.numCodes - 257, 5);
this.pending.WriteBits(this.distTree.numCodes - 1, 5);
this.pending.WriteBits(blTreeCodes - 4, 4);
for (int index = 0; index < blTreeCodes; ++index)
this.pending.WriteBits((int) this.blTree.length[SimpleZip.DeflaterHuffman.BL_ORDER[index]], 3);
this.literalTree.WriteTree(this.blTree);
this.distTree.WriteTree(this.blTree);
}
public void CompressBlock()
{
for (int index = 0; index < this.last_lit; ++index)
{
int num1 = (int) this.l_buf[index] & (int) byte.MaxValue;
int num2 = (int) this.d_buf[index];
int distance = num2 - 1;
if (num2 != 0)
{
int code1 = this.Lcode(num1);
this.literalTree.WriteSymbol(code1);
int count1 = (code1 - 261) / 4;
if (count1 > 0 && count1 <= 5)
this.pending.WriteBits(num1 & (1 << count1) - 1, count1);
int code2 = this.Dcode(distance);
this.distTree.WriteSymbol(code2);
int count2 = code2 / 2 - 1;
if (count2 > 0)
this.pending.WriteBits(distance & (1 << count2) - 1, count2);
}
else
this.literalTree.WriteSymbol(num1);
}
this.literalTree.WriteSymbol(256);
}
public void FlushStoredBlock(
byte[] stored,
int storedOffset,
int storedLength,
bool lastBlock)
{
this.pending.WriteBits(lastBlock ? 1 : 0, 3);
this.pending.AlignToByte();
this.pending.WriteShort(storedLength);
this.pending.WriteShort(~storedLength);
this.pending.WriteBlock(stored, storedOffset, storedLength);
this.Init();
}
public void FlushBlock(byte[] stored, int storedOffset, int storedLength, bool lastBlock)
{
short[] freqs;
(freqs = this.literalTree.freqs)[256] = (short) ((int) freqs[256] + 1);
this.literalTree.BuildTree();
this.distTree.BuildTree();
this.literalTree.CalcBLFreq(this.blTree);
this.distTree.CalcBLFreq(this.blTree);
this.blTree.BuildTree();
int blTreeCodes = 4;
for (int index = 18; index > blTreeCodes; --index)
{
if (this.blTree.length[SimpleZip.DeflaterHuffman.BL_ORDER[index]] > (byte) 0)
blTreeCodes = index + 1;
}
int num = 14 + blTreeCodes * 3 + this.blTree.GetEncodedLength() + this.literalTree.GetEncodedLength() + this.distTree.GetEncodedLength() + this.extra_bits;
int extraBits = this.extra_bits;
for (int index = 0; index < 286; ++index)
extraBits += (int) this.literalTree.freqs[index] * (int) SimpleZip.DeflaterHuffman.staticLLength[index];
for (int index = 0; index < 30; ++index)
extraBits += (int) this.distTree.freqs[index] * (int) SimpleZip.DeflaterHuffman.staticDLength[index];
if (num >= extraBits)
num = extraBits;
if (storedOffset >= 0 && storedLength + 4 < num >> 3)
this.FlushStoredBlock(stored, storedOffset, storedLength, lastBlock);
else if (num == extraBits)
{
this.pending.WriteBits(2 + (lastBlock ? 1 : 0), 3);
this.literalTree.SetStaticCodes(SimpleZip.DeflaterHuffman.staticLCodes, SimpleZip.DeflaterHuffman.staticLLength);
this.distTree.SetStaticCodes(SimpleZip.DeflaterHuffman.staticDCodes, SimpleZip.DeflaterHuffman.staticDLength);
this.CompressBlock();
this.Init();
}
else
{
this.pending.WriteBits(4 + (lastBlock ? 1 : 0), 3);
this.SendAllTrees(blTreeCodes);
this.CompressBlock();
this.Init();
}
}
public bool IsFull() => this.last_lit >= 16384;
public bool TallyLit(int lit)
{
this.d_buf[this.last_lit] = (short) 0;
this.l_buf[this.last_lit++] = (byte) lit;
short[] freqs;
IntPtr index;
(freqs = this.literalTree.freqs)[(int) (index = (IntPtr) lit)] = (short) ((int) freqs[index] + 1);
return this.IsFull();
}
public bool TallyDist(int dist, int len)
{
this.d_buf[this.last_lit] = (short) dist;
this.l_buf[this.last_lit++] = (byte) (len - 3);
int num1 = this.Lcode(len - 3);
short[] freqs1;
IntPtr index1;
(freqs1 = this.literalTree.freqs)[(int) (index1 = (IntPtr) num1)] = (short) ((int) freqs1[index1] + 1);
if (num1 >= 265 && num1 < 285)
this.extra_bits += (num1 - 261) / 4;
int num2 = this.Dcode(dist - 1);
short[] freqs2;
IntPtr index2;
(freqs2 = this.distTree.freqs)[(int) (index2 = (IntPtr) num2)] = (short) ((int) freqs2[index2] + 1);
if (num2 >= 4)
this.extra_bits += num2 / 2 - 1;
return this.IsFull();
}
public sealed class Tree
{
public short[] freqs;
public byte[] length;
public int minNumCodes;
public int numCodes;
private short[] codes;
private int[] bl_counts;
private int maxLength;
private SimpleZip.DeflaterHuffman dh;
public Tree(SimpleZip.DeflaterHuffman dh, int elems, int minCodes, int maxLength)
{
this.dh = dh;
this.minNumCodes = minCodes;
this.maxLength = maxLength;
this.freqs = new short[elems];
this.bl_counts = new int[maxLength];
}
public void WriteSymbol(int code) => this.dh.pending.WriteBits((int) this.codes[code] & (int) ushort.MaxValue, (int) this.length[code]);
public void SetStaticCodes(short[] stCodes, byte[] stLength)
{
this.codes = stCodes;
this.length = stLength;
}
public void BuildCodes()
{
int length = this.freqs.Length;
int[] numArray = new int[this.maxLength];
int num1 = 0;
this.codes = new short[this.freqs.Length];
for (int index = 0; index < this.maxLength; ++index)
{
numArray[index] = num1;
num1 += this.bl_counts[index] << 15 - index;
}
for (int index = 0; index < this.numCodes; ++index)
{
int num2 = (int) this.length[index];
if (num2 > 0)
{
this.codes[index] = SimpleZip.DeflaterHuffman.BitReverse(numArray[num2 - 1]);
numArray[num2 - 1] += 1 << 16 - num2;
}
}
}
private void BuildLength(int[] childs)
{
this.length = new byte[this.freqs.Length];
int length = childs.Length / 2;
int num1 = (length + 1) / 2;
int num2 = 0;
for (int index = 0; index < this.maxLength; ++index)
this.bl_counts[index] = 0;
int[] numArray1 = new int[length];
numArray1[length - 1] = 0;
for (int index = length - 1; index >= 0; --index)
{
if (childs[2 * index + 1] != -1)
{
int num3 = numArray1[index] + 1;
if (num3 > this.maxLength)
{
num3 = this.maxLength;
++num2;
}
numArray1[childs[2 * index]] = numArray1[childs[2 * index + 1]] = num3;
}
else
{
++this.bl_counts[numArray1[index] - 1];
this.length[childs[2 * index]] = (byte) numArray1[index];
}
}
if (num2 == 0)
return;
int index1 = this.maxLength - 1;
do
{
do
;
while (this.bl_counts[--index1] == 0);
do
{
--this.bl_counts[index1];
int[] blCounts;
int[] numArray2 = blCounts = this.bl_counts;
int index2;
index1 = index2 = index1 + 1;
int index3 = index2;
int num4 = numArray2[(IntPtr) index3] + 1;
blCounts[index2] = num4;
num2 -= 1 << this.maxLength - 1 - index1;
}
while (num2 > 0 && index1 < this.maxLength - 1);
}
while (num2 > 0);
this.bl_counts[this.maxLength - 1] += num2;
this.bl_counts[this.maxLength - 2] -= num2;
int num5 = 2 * num1;
for (int maxLength = this.maxLength; maxLength != 0; --maxLength)
{
int blCount = this.bl_counts[maxLength - 1];
while (blCount > 0)
{
int index4 = 2 * childs[num5++];
if (childs[index4 + 1] == -1)
{
this.length[childs[index4]] = (byte) maxLength;
--blCount;
}
}
}
}
public void BuildTree()
{
int length = this.freqs.Length;
int[] numArray1 = new int[length];
int num1 = 0;
int num2 = 0;
for (int index1 = 0; index1 < length; ++index1)
{
int freq = (int) this.freqs[index1];
if (freq != 0)
{
int index2;
int index3;
for (index2 = num1++; index2 > 0 && (int) this.freqs[numArray1[index3 = (index2 - 1) / 2]] > freq; index2 = index3)
numArray1[index2] = numArray1[index3];
numArray1[index2] = index1;
num2 = index1;
}
}
int num3;
for (; num1 < 2; numArray1[num1++] = num3)
{
int num4;
if (num2 >= 2)
num4 = 0;
else
num2 = num4 = num2 + 1;
num3 = num4;
}
this.numCodes = Math.Max(num2 + 1, this.minNumCodes);
int num5 = num1;
int[] childs = new int[4 * num1 - 2];
int[] numArray2 = new int[2 * num1 - 1];
int num6 = num5;
for (int index4 = 0; index4 < num1; ++index4)
{
int index5 = numArray1[index4];
childs[2 * index4] = index5;
childs[2 * index4 + 1] = -1;
numArray2[index4] = (int) this.freqs[index5] << 8;
numArray1[index4] = index4;
}
do
{
int index6 = numArray1[0];
int index7 = numArray1[--num1];
int index8 = 0;
for (int index9 = 1; index9 < num1; index9 = index9 * 2 + 1)
{
if (index9 + 1 < num1 && numArray2[numArray1[index9]] > numArray2[numArray1[index9 + 1]])
++index9;
numArray1[index8] = numArray1[index9];
index8 = index9;
}
int num7 = numArray2[index7];
int index10;
while ((index10 = index8) > 0 && numArray2[numArray1[index8 = (index10 - 1) / 2]] > num7)
numArray1[index10] = numArray1[index8];
numArray1[index10] = index7;
int index11 = numArray1[0];
int index12 = num6++;
childs[2 * index12] = index6;
childs[2 * index12 + 1] = index11;
int num8 = Math.Min(numArray2[index6] & (int) byte.MaxValue, numArray2[index11] & (int) byte.MaxValue);
int num9;
numArray2[index12] = num9 = numArray2[index6] + numArray2[index11] - num8 + 1;
int index13 = 0;
for (int index14 = 1; index14 < num1; index14 = index13 * 2 + 1)
{
if (index14 + 1 < num1 && numArray2[numArray1[index14]] > numArray2[numArray1[index14 + 1]])
++index14;
numArray1[index13] = numArray1[index14];
index13 = index14;
}
int index15;
while ((index15 = index13) > 0 && numArray2[numArray1[index13 = (index15 - 1) / 2]] > num9)
numArray1[index15] = numArray1[index13];
numArray1[index15] = index12;
}
while (num1 > 1);
this.BuildLength(childs);
}
public int GetEncodedLength()
{
int encodedLength = 0;
for (int index = 0; index < this.freqs.Length; ++index)
encodedLength += (int) this.freqs[index] * (int) this.length[index];
return encodedLength;
}
public void CalcBLFreq(SimpleZip.DeflaterHuffman.Tree blTree)
{
int num1 = -1;
int index1 = 0;
while (index1 < this.numCodes)
{
int num2 = 1;
int num3 = (int) this.length[index1];
int num4;
int num5;
if (num3 == 0)
{
num4 = 138;
num5 = 3;
}
else
{
num4 = 6;
num5 = 3;
if (num1 != num3)
{
short[] freqs;
IntPtr index2;
(freqs = blTree.freqs)[(int) (index2 = (IntPtr) num3)] = (short) ((int) freqs[index2] + 1);
num2 = 0;
}
}
num1 = num3;
++index1;
while (index1 < this.numCodes && num1 == (int) this.length[index1])
{
++index1;
if (++num2 >= num4)
break;
}
if (num2 < num5)
{
short[] freqs;
IntPtr index3;
(freqs = blTree.freqs)[(int) (index3 = (IntPtr) num1)] = (short) ((int) freqs[index3] + (int) (short) num2);
}
else if (num1 != 0)
{
short[] freqs;
(freqs = blTree.freqs)[16] = (short) ((int) freqs[16] + 1);
}
else if (num2 <= 10)
{
short[] freqs;
(freqs = blTree.freqs)[17] = (short) ((int) freqs[17] + 1);
}
else
{
short[] freqs;
(freqs = blTree.freqs)[18] = (short) ((int) freqs[18] + 1);
}
}
}
public void WriteTree(SimpleZip.DeflaterHuffman.Tree blTree)
{
int code1 = -1;
int index = 0;
while (index < this.numCodes)
{
int num1 = 1;
int code2 = (int) this.length[index];
int num2;
int num3;
if (code2 == 0)
{
num2 = 138;
num3 = 3;
}
else
{
num2 = 6;
num3 = 3;
if (code1 != code2)
{
blTree.WriteSymbol(code2);
num1 = 0;
}
}
code1 = code2;
++index;
while (index < this.numCodes && code1 == (int) this.length[index])
{
++index;
if (++num1 >= num2)
break;
}
if (num1 < num3)
{
while (num1-- > 0)
blTree.WriteSymbol(code1);
}
else if (code1 != 0)
{
blTree.WriteSymbol(16);
this.dh.pending.WriteBits(num1 - 3, 2);
}
else if (num1 <= 10)
{
blTree.WriteSymbol(17);
this.dh.pending.WriteBits(num1 - 3, 3);
}
else
{
blTree.WriteSymbol(18);
this.dh.pending.WriteBits(num1 - 11, 7);
}
}
}
}
}
internal sealed class DeflaterEngine
{
private const int MAX_MATCH = 258;
private const int MIN_MATCH = 3;
private const int WSIZE = 32768;
private const int WMASK = 32767;
private const int HASH_SIZE = 32768;
private const int HASH_MASK = 32767;
private const int HASH_SHIFT = 5;
private const int MIN_LOOKAHEAD = 262;
private const int MAX_DIST = 32506;
private const int TOO_FAR = 4096;
private int ins_h;
private short[] head;
private short[] prev;
private int matchStart;
private int matchLen;
private bool prevAvailable;
private int blockStart;
private int strstart;
private int lookahead;
private byte[] window;
private byte[] inputBuf;
private int totalIn;
private int inputOff;
private int inputEnd;
private SimpleZip.DeflaterPending pending;
private SimpleZip.DeflaterHuffman huffman;
public DeflaterEngine(SimpleZip.DeflaterPending pending)
{
this.pending = pending;
this.huffman = new SimpleZip.DeflaterHuffman(pending);
this.window = new byte[65536];
this.head = new short[32768];
this.prev = new short[32768];
this.blockStart = this.strstart = 1;
}
private void UpdateHash() => this.ins_h = (int) this.window[this.strstart] << 5 ^ (int) this.window[this.strstart + 1];
private int InsertString()
{
int index = (this.ins_h << 5 ^ (int) this.window[this.strstart + 2]) & (int) short.MaxValue;
short num;
this.prev[this.strstart & (int) short.MaxValue] = num = this.head[index];
this.head[index] = (short) this.strstart;
this.ins_h = index;
return (int) num & (int) ushort.MaxValue;
}
private void SlideWindow()
{
Array.Copy((Array) this.window, 32768, (Array) this.window, 0, 32768);
this.matchStart -= 32768;
this.strstart -= 32768;
this.blockStart -= 32768;
for (int index = 0; index < 32768; ++index)
{
int num = (int) this.head[index] & (int) ushort.MaxValue;
this.head[index] = num >= 32768 ? (short) (num - 32768) : (short) 0;
}
for (int index = 0; index < 32768; ++index)
{
int num = (int) this.prev[index] & (int) ushort.MaxValue;
this.prev[index] = num >= 32768 ? (short) (num - 32768) : (short) 0;
}
}
public void FillWindow()
{
if (this.strstart >= 65274)
this.SlideWindow();
int length;
for (; this.lookahead < 262 && this.inputOff < this.inputEnd; this.lookahead += length)
{
length = 65536 - this.lookahead - this.strstart;
if (length > this.inputEnd - this.inputOff)
length = this.inputEnd - this.inputOff;
Array.Copy((Array) this.inputBuf, this.inputOff, (Array) this.window, this.strstart + this.lookahead, length);
this.inputOff += length;
this.totalIn += length;
}
if (this.lookahead < 3)
return;
this.UpdateHash();
}
private bool FindLongestMatch(int curMatch)
{
int num1 = 128;
int num2 = 128;
short[] prev = this.prev;
int strstart = this.strstart;
int index = this.strstart + this.matchLen;
int val1 = Math.Max(this.matchLen, 2);
int num3 = Math.Max(this.strstart - 32506, 0);
int num4 = this.strstart + 258 - 1;
byte num5 = this.window[index - 1];
byte num6 = this.window[index];
if (val1 >= 8)
num1 >>= 2;
if (num2 > this.lookahead)
num2 = this.lookahead;
do
{
if ((int) this.window[curMatch + val1] == (int) num6 && (int) this.window[curMatch + val1 - 1] == (int) num5 && (int) this.window[curMatch] == (int) this.window[strstart] && (int) this.window[curMatch + 1] == (int) this.window[strstart + 1])
{
int num7 = curMatch + 2;
int num8 = strstart + 2;
int num9;
int num10;
int num11;
int num12;
int num13;
int num14;
int num15;
do
;
while ((int) this.window[++num8] == (int) this.window[num9 = num7 + 1] && (int) this.window[++num8] == (int) this.window[num10 = num9 + 1] && (int) this.window[++num8] == (int) this.window[num11 = num10 + 1] && (int) this.window[++num8] == (int) this.window[num12 = num11 + 1] && (int) this.window[++num8] == (int) this.window[num13 = num12 + 1] && (int) this.window[++num8] == (int) this.window[num14 = num13 + 1] && (int) this.window[++num8] == (int) this.window[num15 = num14 + 1] && (int) this.window[++num8] == (int) this.window[num7 = num15 + 1] && num8 < num4);
if (num8 > index)
{
this.matchStart = curMatch;
index = num8;
val1 = num8 - this.strstart;
if (val1 < num2)
{
num5 = this.window[index - 1];
num6 = this.window[index];
}
else
break;
}
strstart = this.strstart;
}
}
while ((curMatch = (int) prev[curMatch & (int) short.MaxValue] & (int) ushort.MaxValue) > num3 && --num1 != 0);
this.matchLen = Math.Min(val1, this.lookahead);
return this.matchLen >= 3;
}
private bool DeflateSlow(bool flush, bool finish)
{
if (this.lookahead < 262 && !flush)
return false;
while (this.lookahead >= 262 || flush)
{
if (this.lookahead == 0)
{
if (this.prevAvailable)
this.huffman.TallyLit((int) this.window[this.strstart - 1] & (int) byte.MaxValue);
this.prevAvailable = false;
this.huffman.FlushBlock(this.window, this.blockStart, this.strstart - this.blockStart, finish);
this.blockStart = this.strstart;
return false;
}
if (this.strstart >= 65274)
this.SlideWindow();
int matchStart = this.matchStart;
int matchLen = this.matchLen;
if (this.lookahead >= 3)
{
int curMatch = this.InsertString();
if (curMatch != 0 && this.strstart - curMatch <= 32506 && this.FindLongestMatch(curMatch) && this.matchLen <= 5 && this.matchLen == 3 && this.strstart - this.matchStart > 4096)
this.matchLen = 2;
}
if (matchLen >= 3 && this.matchLen <= matchLen)
{
this.huffman.TallyDist(this.strstart - 1 - matchStart, matchLen);
int num = matchLen - 2;
do
{
++this.strstart;
--this.lookahead;
if (this.lookahead >= 3)
this.InsertString();
}
while (--num > 0);
++this.strstart;
--this.lookahead;
this.prevAvailable = false;
this.matchLen = 2;
}
else
{
if (this.prevAvailable)
this.huffman.TallyLit((int) this.window[this.strstart - 1] & (int) byte.MaxValue);
this.prevAvailable = true;
++this.strstart;
--this.lookahead;
}
if (this.huffman.IsFull())
{
int storedLength = this.strstart - this.blockStart;
if (this.prevAvailable)
--storedLength;
bool lastBlock = finish && this.lookahead == 0 && !this.prevAvailable;
this.huffman.FlushBlock(this.window, this.blockStart, storedLength, lastBlock);
this.blockStart += storedLength;
return !lastBlock;
}
}
return true;
}
public bool Deflate(bool flush, bool finish)
{
bool flag;
do
{
this.FillWindow();
flag = this.DeflateSlow(flush && this.inputOff == this.inputEnd, finish);
}
while (this.pending.IsFlushed && flag);
return flag;
}
public void SetInput(byte[] buffer)
{
this.inputBuf = buffer;
this.inputOff = 0;
this.inputEnd = buffer.Length;
}
public bool NeedsInput() => this.inputEnd == this.inputOff;
}
internal sealed class DeflaterPending
{
protected byte[] buf = new byte[65536];
private int start = 0;
private int end = 0;
private uint bits = 0;
private int bitCount = 0;
public void WriteShort(int s)
{
this.buf[this.end++] = (byte) s;
this.buf[this.end++] = (byte) (s >> 8);
}
public void WriteBlock(byte[] block, int offset, int len)
{
Array.Copy((Array) block, offset, (Array) this.buf, this.end, len);
this.end += len;
}
public int BitCount => this.bitCount;
public void AlignToByte()
{
if (this.bitCount > 0)
{
this.buf[this.end++] = (byte) this.bits;
if (this.bitCount > 8)
this.buf[this.end++] = (byte) (this.bits >> 8);
}
this.bits = 0U;
this.bitCount = 0;
}
public void WriteBits(int b, int count)
{
this.bits |= (uint) (b << this.bitCount);
this.bitCount += count;
if (this.bitCount < 16)
return;
this.buf[this.end++] = (byte) this.bits;
this.buf[this.end++] = (byte) (this.bits >> 8);
this.bits >>= 16;
this.bitCount -= 16;
}
public bool IsFlushed => this.end == 0;
public int Flush(byte[] output, int offset, int length)
{
if (this.bitCount >= 8)
{
this.buf[this.end++] = (byte) this.bits;
this.bits >>= 8;
this.bitCount -= 8;
}
if (length > this.end - this.start)
{
length = this.end - this.start;
Array.Copy((Array) this.buf, this.start, (Array) output, offset, length);
this.start = 0;
this.end = 0;
}
else
{
Array.Copy((Array) this.buf, this.start, (Array) output, offset, length);
this.start += length;
}
return length;
}
}
internal sealed class ZipStream : MemoryStream
{
public void WriteShort(int value)
{
this.WriteByte((byte) (value & (int) byte.MaxValue));
this.WriteByte((byte) (value >> 8 & (int) byte.MaxValue));
}
public void WriteInt(int value)
{
this.WriteShort(value);
this.WriteShort(value >> 16);
}
public int ReadShort() => this.ReadByte() | this.ReadByte() << 8;
public int ReadInt() => this.ReadShort() | this.ReadShort() << 16;
public ZipStream()
{
}
public ZipStream(byte[] buffer)
: base(buffer, false)
{
}
}
}
}
Reference in New Issue Copy Permalink