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);
}