private int DecompressTable(MemoryStream output, BigEndianReader reader, WoffTableEntry table, uint length) { int pos = (int)output.Position; using (var streamIn = new MemoryStream(reader.Read((int)table.CompressedLength))) { #if NET6_0 using (var compress = new System.IO.Compression.ZLibStream(streamIn, System.IO.Compression.CompressionMode.Decompress)) { compress.CopyTo(output); } #else using (InflaterInputStream decompressor = new InflaterInputStream(streamIn)) { decompressor.CopyTo(output); } #endif } int len = (int)(output.Position - pos); if (len != length) { return(-1); } else { return(len); } }
/// <summary> /// 使用zlib解压一段数据 /// </summary> /// <param name="input"></param> /// <returns></returns> private byte[] uncompressBuffer(byte[] input) { byte[] result = null; using (MemoryStream outputStream = new MemoryStream()) { using (MemoryStream inputStream = new MemoryStream(input)) { using (InflaterInputStream inputZStream = new InflaterInputStream(inputStream)) { try { inputZStream.CopyTo(outputStream); outputStream.Flush(); } finally { outputStream.Seek(0, SeekOrigin.Begin); result = new byte[outputStream.Length]; outputStream.Read(result, 0, (int)outputStream.Length); } } } } return(result); }
public byte[] Unpack() { var memory = new BinaryStream(1024); using (var bs = new BinaryStream(Data)) { for (int i = 1; i < Blocks.Count; i++) { var block = Blocks[i - 1]; var next = Blocks[i]; var size = (int)(next.VirtualOffset - block.VirtualOffset); bs.Seek(block.FileOffset - 4, SeekOrigin.Begin); memory.Seek(block.VirtualOffset, SeekOrigin.Begin); if (block.IsCompressed == true) { var zlib = new InflaterInputStream(bs); zlib.CopyTo(memory); } else { var buffer = bs.ReadBytes(size); memory.Write(buffer, 0, size); } } } return(memory.ToArray()); }
public static IOfficeDocument Open(XDocTemplate template, bool openAsTemplate = false) { byte[] unzippedTemplate; using (var stream = new MemoryStream(template.FileBinary)) { //using (var zipStream = new DeflateStream(stream, CompressionMode.Decompress)) // .NET class doesn't work, so use SharpZipLib using (var zipStream = new InflaterInputStream(stream)) { using (var unzippedStream = new MemoryStream()) { zipStream.CopyTo(unzippedStream); unzippedTemplate = unzippedStream.ToArray(); } } } switch (template.DocFormatCode) { case DocFormat.Word: return(new WordDocument(unzippedTemplate, openAsTemplate)); //case DocFormat.Excel: // return new ExcelDocument(template.FileBinary, openAsTemplate); //case DocFormat.Powerpoint: // return new PowerpointDocument(template.FileBinary, openAsTemplate); default: return(null); } }
public static string DecryptCdn(string content, string key) { content = content.Substring(8).Trim(); var decrypted = RawDecrypt(content, key); var transformed = ""; foreach (var t in decrypted) { transformed += (char)(t + 1); } transformed = transformed.Replace("\x01", ""); if (!transformed.StartsWith("DbdDAQEB")) { return(transformed); } var b64Decoded = Convert.FromBase64String(transformed.Substring(8)); var decoded = b64Decoded.Subset(4, b64Decoded.Length - 4); var stream = new MemoryStream(); var inputStream = new InflaterInputStream(new MemoryStream(decoded)); inputStream.CopyTo(stream); stream.Position = 0; return(Encoding.Unicode.GetString(ReadToEnd(stream))); }
public void Decode(Stream input, Stream output) { using var zlib = new InflaterInputStream(input) { IsStreamOwner = false }; zlib.CopyTo(output); }
internal static byte[] Inflate(byte[] buffer) { InflaterInputStream inflaterStream = new InflaterInputStream(new MemoryStream(buffer)); MemoryStream outputStream = new MemoryStream(); inflaterStream.CopyTo(outputStream); return(outputStream.ToArray()); }
public static byte[] Decompress(byte[] bytes) { using var compressedStream = new MemoryStream(bytes); using var decompressionStream = new InflaterInputStream(compressedStream); using var resultStream = new MemoryStream(); decompressionStream.CopyTo(resultStream); return(resultStream.ToArray()); }
/// <summary> /// decompresses a zlib file /// </summary> /// <param name="stream"></param> /// <returns>decompressed byte array</returns> public byte[] Decompress(Stream stream, int CompressionStartOffset) { using var decompressionStream = new InflaterInputStream(stream); using var decompressedFileStream = new MemoryStream(); stream.Position = CompressionStartOffset; decompressionStream.CopyTo(decompressedFileStream); return(decompressedFileStream.ToArray()); }
public static byte[] Uncompress(byte[] data) { using var outputStream = new MemoryStream(); using var compressedStream = new MemoryStream(data); using var inputStream = new InflaterInputStream(compressedStream); inputStream.CopyTo(outputStream); outputStream.Position = 0; return(outputStream.ToArray()); }
protected void unzip(Stream src, Stream dest) { InflaterInputStream inputStream = new InflaterInputStream( src, new Inflater(false) ); inputStream.CopyTo(dest); }
public override MemoryStream DecompressData(byte[] compressedData) { InflaterInputStream inflaterStream = new InflaterInputStream(new MemoryStream(compressedData)); MemoryStream outputStream = new MemoryStream(); inflaterStream.CopyTo(outputStream); outputStream.Position = 0; return(outputStream); }
public async Task <IDataAccessDataResponse> GetResponse(HttpContext httpContext, XDocument xml) { uint userId = httpContext.IsAuthenicatedPr3User(); if (userId > 0) { XElement data = xml.Element("Params"); if (data != null) { uint levelId = (uint?)data.Element("p_level_id") ?? throw new DataAccessProcedureMissingData(); uint levelVersion = (uint?)data.Element("p_level_version") ?? throw new DataAccessProcedureMissingData(); string recordRun = (string)data.Element("p_recorded_run") ?? throw new DataAccessProcedureMissingData(); int finishTime = (int?)data.Element("p_finish_time") ?? throw new DataAccessProcedureMissingData(); CampaignRun campaignRun = null; using (MemoryStream compressedMemoryStream = new MemoryStream(Convert.FromBase64String(recordRun))) { using (InflaterInputStream inflater = new InflaterInputStream(compressedMemoryStream)) { using (MemoryStream uncompressedMemoryStream = new MemoryStream()) { inflater.CopyTo(uncompressedMemoryStream); campaignRun = JsonConvert.DeserializeObject <CampaignRun>(Encoding.UTF8.GetString(uncompressedMemoryStream.ToArray())); } } } if (campaignRun != null) { PlayerUserData playerUserData = await UserManager.TryGetUserDataByIdAsync(userId); if (campaignRun.Username != playerUserData.Username) { return(new DataAccessErrorResponse("Invalid username")); } await CampaignManager.SaveCampaignRun(userId, levelId, levelVersion, recordRun, finishTime); return(new DataAccessSaveCampaignRun3Response()); } else { throw new DataAccessProcedureMissingData(); } } else { throw new DataAccessProcedureMissingData(); } } else { return(new DataAccessErrorResponse("You are not logged in!")); } }
public byte[] Decode(byte[] encoded, int uncompressedSize) { var outputStream = new MemoryStream(); using var compressedStream = new MemoryStream(encoded); using var inputStream = new InflaterInputStream(compressedStream); inputStream.CopyTo(outputStream); outputStream.Position = 0; return(outputStream.ToArray()); }
//public void uncompressFile(string inFile, string outFile) //{ // int data = 0; // int stopByte = -1; // System.IO.FileStream outFileStream = new System.IO.FileStream(outFile, System.IO.FileMode.Create); // zlib.ZInputStream inZStream = new zlib.ZInputStream(System.IO.File.Open(inFile, System.IO.FileMode.Open, System.IO.FileAccess.Read)); // while (stopByte != (data = inZStream.Read())) // { // byte _dataByte = (byte)data; // outFileStream.WriteByte(_dataByte); // } // inZStream.Close(); // outFileStream.Close(); //} internal static MemoryStream DecompressZlib(this IStream stream) { MemoryStream outStream = new MemoryStream(); using (InflaterInputStream inf = new InflaterInputStream(stream.ToMemoryStream())) { inf.CopyTo(outStream); } return(outStream); }
private void UncompressAndWrite <T>(T outputStream, byte[] decryptedData, TArray <FCompressedChunkInfo> chunkInfo) where T : Stream { using (var binaryReader = new BinaryReader(File.OpenRead(FilePath))) { //Copy original data to fileBuf var fileBuf = new byte[binaryReader.BaseStream.Length]; binaryReader.BaseStream.Position = 0; binaryReader.Read(fileBuf, 0, fileBuf.Length); outputStream.Write(fileBuf, 0, fileBuf.Length); // Write decrypted data outputStream.Seek(Header.NameOffset, SeekOrigin.Begin); outputStream.Write(decryptedData, 0, decryptedData.Length); if (!IsCompresionTypeSupported) { return; //throw new InvalidDataException($"Unsupported CompressionFlags: {Header.CompressionFlags}"); } // Decompress compressed chunks foreach (var chunk in chunkInfo) { binaryReader.BaseStream.Position = chunk.CompressedOffset; var chunkHeader = new FCompressedChunkHeader(); chunkHeader.Deserialize(binaryReader); var totalBlockSize = 0; var blocks = new List <FCompressedChunkBlock>(); while (totalBlockSize < chunkHeader.Sum.UncompressedSize) { var block = new FCompressedChunkBlock(); block.Deserialize(binaryReader); blocks.Add(block); totalBlockSize += block.UncompressedSize; } outputStream.Position = chunk.UncompressedOffset; foreach (var block in blocks) { var compressedData = new byte[block.CompressedSize]; binaryReader.Read(compressedData, 0, compressedData.Length); using (var zlibStream = new InflaterInputStream(new MemoryStream(compressedData))) { zlibStream.CopyTo(outputStream); } } } } }
public void decompressFile(string inFile, string outFile) { var outputStream = new MemoryStream(); using (var compressedStream = new MemoryStream(File.ReadAllBytes(inFile))) using (var inputStream = new InflaterInputStream(compressedStream)) { inputStream.CopyTo(outputStream); outputStream.Position = 0; File.WriteAllBytes("test.txt", ReadToEnd(outputStream)); } }
private MemoryStream DecompressData(byte[] data, int length) { MemoryStream decompressedStream = new MemoryStream(length); using MemoryStream memory = new MemoryStream(data); using InflaterInputStream inflater = new InflaterInputStream(memory); inflater.CopyTo(decompressedStream); decompressedStream.Seek(0, SeekOrigin.Begin); return(decompressedStream); }
static MemoryStream DeflateZippedPvrImage(string path) { var result = new MemoryStream(); using (var zippedPvrFile = File.OpenRead(path)) { zippedPvrFile.Seek("ZPVR".Length, SeekOrigin.Begin); using (var zippedPvrStream = new InflaterInputStream(zippedPvrFile)) zippedPvrStream.CopyTo(result); } result.Seek(0, SeekOrigin.Begin); return(result); }
public static byte[] DecompressZlib(Stream source) { byte[] result = null; using (MemoryStream outStream = new MemoryStream()) { using (InflaterInputStream inf = new InflaterInputStream(source)) { inf.CopyTo(outStream); } result = outStream.ToArray(); } return(result); }
/// <summary> /// 解压缩 /// </summary> /// <param name="data"></param> /// <returns></returns> private static byte[] Decompress(byte[] data) { byte[] outdata = null; using (var ms = new MemoryStream()) using (var inputStream = new InflaterInputStream(new MemoryStream(data), new Inflater(false))) { inputStream.CopyTo(ms); ms.Flush(); outdata = ms.ToArray(); ms.Close(); } return(outdata); }
public byte[] Decompress(byte[] data) { var outputStream = new MemoryStream(); byte[] decompressedData; using (var compressedStream = new MemoryStream(data)) using (var inputStream = new InflaterInputStream(compressedStream)) { inputStream.CopyTo(outputStream); outputStream.Position = 0; decompressedData = outputStream.ToArray(); return(decompressedData); } }
public byte[] SharpZipLib_Decompress(CompressedSize input) { var inf = new Inflater(true); using var decompressed = new MemoryStream(); using (var data = new MemoryStream(input.Data)) using (var decompressor = new InflaterInputStream(data, inf)) { decompressor.CopyTo(decompressed); } return(decompressed.ToArray()); }
private void DecompressHeader() { Reader.Stream.Position = Result.HeaderPosition; Result.Header = Reader.ReadBytes(System.Convert.ToInt32(Reader.Stream.Length - Result.HeaderPosition)); Stream temp = new MemoryStream(); using (var dec = new InflaterInputStream(new MemoryStream(Result.Header))) { dec.CopyTo(temp); Result.HeaderStream = new DataStream(temp); } }
/// <summary> /// Uncompresses the provided input data using zlib inflater. /// </summary> /// <param name="inputData">The input data.</param> /// <returns></returns> /// <exception cref="System.ArgumentNullException"></exception> public static IEnumerable <byte> InflateUncompress(byte[] inputData) { inputData.ThrowIfNull(nameof(inputData)); using (MemoryStream inputStream = GetMemoryStream(inputData)) using (MemoryStream outputStream = GetMemoryStream()) { InflaterInputStream deflaterOutputStream = new InflaterInputStream(inputStream); deflaterOutputStream.CopyTo(outputStream); deflaterOutputStream.Flush(); return(outputStream.ToArray()); } }
private void ZLibDecompression() { byte[] data = Convert.FromBase64String(RawTileData); var outputStream = new MemoryStream(); using (var compressedStream = new MemoryStream(data)) using (var inputStream = new InflaterInputStream(compressedStream)) { inputStream.CopyTo(outputStream); ConvertRawDataFromByteArray(outputStream.ToArray()); } outputStream.Dispose(); }
private void WsOnDanmakuMessage(DanmakuMessage message) { Logger.Log?.Info("Get message."); switch (message.Operation) { case DanmakuOperation.GreetingAck: Logger.Log?.Info("Greeting packet has been sent."); break; case DanmakuOperation.HeartBeatAck: Logger.Log?.Info("HeartBeat packet has been sent."); break; case DanmakuOperation.ChatMessage: string jsonString; // Version 2 message is compressed by using GZIP. if (message.Version == 2) { var buffer = message.Buffer; var length = buffer.Length; const int headerLength = DanmakuPacket.HeaderLength; var rawContent = new byte[length - headerLength]; for (var i = headerLength; i < length; i++) { rawContent[i - headerLength] = buffer[i]; } byte[] inflatedBytes; using (var inflateStream = new InflaterInputStream(new MemoryStream(rawContent))) { using (var stream = new MemoryStream()) { inflateStream.CopyTo(stream); inflatedBytes = stream.ToArray(); } } var danmakuMessage = DanmakuMessage.ParseFirstPacket(inflatedBytes); jsonString = danmakuMessage.Body; } else { jsonString = message.Body; } this.DealWithChatMessage(jsonString); break; } }
static void WriteCompressedFile(Stream streamIn, long rootOffset, Stream streamOut, byte[] buffer) { byte[] temp4 = new byte[4]; streamIn.Position = rootOffset + 4; streamIn.Read(temp4, 0, 4); if (!BitConverter.IsLittleEndian) { Array.Reverse(temp4, 0, 4); } int count = BitConverter.ToInt32(temp4, 0); streamIn.Position = rootOffset + 8; streamIn.Read(temp4, 0, 4); if (!BitConverter.IsLittleEndian) { Array.Reverse(temp4, 0, 4); } int lastLength = BitConverter.ToUInt16(temp4, 0) & 0xffff; int offset = 0xC + count * 4; for (int i = 0; i < count; i++) { if (offset % 0x80 != 0) { offset = ((offset / 0x80) + 1) * 0x80; } streamIn.Position = rootOffset + 0xC + i * 4; streamIn.Read(temp4, 0, 4); if (!BitConverter.IsLittleEndian) { Array.Reverse(temp4, 0, 4); } int length = BitConverter.ToInt32(temp4, 0); if (i == count - 1 && lastLength == length) { ReadToStream(streamIn, streamOut, rootOffset + offset, length, buffer); } else if (length != 0) { streamIn.Position = rootOffset + offset + 4; using (InflaterInputStream ds = new InflaterInputStream(new PassthroughStream(streamIn, length - 4))) { Console.Write("."); ds.CopyTo(streamOut); } } offset += length; } }
public static byte[] DecryptAndDecompressFile(FileStream stream) { if (stream.Length < 4) { throw new SiiFormatException(SiiFormatException.ParseError.InvalidSize); } stream.Seek(0, SeekOrigin.Begin); using var binaryReader = new BinaryReader(stream, Encoding.UTF8, true); var signatureChars = binaryReader.ReadChars(4); string signature = new string(signatureChars); if (signature == "SiiN") // File is not encrypted or compressed { byte[] bytes = binaryReader.ReadBytes((int)stream.Length - 4); return(bytes); } if (signature != "ScsC") // ScsC is the only valid alternative (binary is not supported). { throw new SiiFormatException(SiiFormatException.ParseError.InvalidSignature); } ScsCHeader scscHeader = ScsCHeader.DeserializeFromStream(stream); byte[] decryptedBytes = new byte[scscHeader.DataSize]; using (Aes aes = AesManaged.Create()) { aes.IV = scscHeader.InitVector; aes.Key = Key; aes.Mode = CipherMode.CBC; using ICryptoTransform decryptor = aes.CreateDecryptor(); using CryptoStream cryptoStream = new CryptoStream(stream, decryptor, CryptoStreamMode.Read, true); cryptoStream.Read(decryptedBytes); } using (var outputMemoryStream = new MemoryStream()) using (var memoryStream = new MemoryStream(decryptedBytes)) using (var inflater = new InflaterInputStream(memoryStream)) { inflater.CopyTo(outputMemoryStream); byte[] decompressedBytes = outputMemoryStream.ToArray(); return(decompressedBytes); } }
/// <summary> /// Deserializes a given NBT file into a C# class of the provided type. /// </summary> /// <typeparam name="T">The type to return.</typeparam> /// <param name="data">The NBT file bytes to parse.</param> public static T Deserialize <T>(byte[] data, bool useZlib = false) { //Does the class in question have the "NBTCompound" tag? if (typeof(T).GetCustomAttribute(typeof(NBTCompound)) == null) { throw new Exception("Type to deserialize into must have the NBTCompound attribute."); } //Check if the data is gzip compressed, decompress if so. if (data[0] == 0x1F && data[1] == 0x8B && !useZlib) { //It's compressed. using (var outData = new MemoryStream()) { GZip.Decompress(new MemoryStream(data), outData, false); data = new byte[outData.Length]; outData.Seek(0, SeekOrigin.Begin); outData.Read(data); } } //Zlib decompress if flagged. if (useZlib) { using (var compressedStream = new MemoryStream(data)) using (var decompressStream = new InflaterInputStream(compressedStream)) { var outputStream = new MemoryStream(); decompressStream.CopyTo(outputStream); data = new byte[outputStream.Length]; outputStream.Seek(0, SeekOrigin.Begin); outputStream.Read(data); } } //Get valid property data for destination type. var nbtProps = typeof(T).GetProperties() .Where(x => x.GetCustomAttribute(typeof(NBTItem)) != null); //Recursively process NBT tags. T typeObj = (T)Activator.CreateInstance(typeof(T)); int index = 0; ProcessTag(data, ref index, typeObj, nbtProps.ToList()); //Return results. return(typeObj); }