private void ReadNarrow(EndianAwareBinaryReader reader, ICliMetadataRoot metadataRoot, Action <byte[]> bodyBuilder)
{
var firstByte = reader.ReadByte();
this.codeSize = (byte)((firstByte & 0xFC) >> 2);
bodyBuilder(reader.ReadBytes((int)this.CodeSize));
}
public Archive(string filename)
{
ArchivePath = filename;
using var stream = File.OpenRead(ArchivePath);
using var reader = new EndianAwareBinaryReader(stream);
reader.AssertTag(BlockType.HEL, BlockType.HEB);
reader.IsBigEndian = reader.PeekChar() == 0;
// contains file offsets and a string block containing
// archive details. probably includes page size and offset
// to MAST block
Data = reader.ReadBytes(0x800 - 4);
reader.AssertTag(BlockType.MAST);
MAST = new MAST(reader);
// this is reversed to signify this is the section header
// for multi-sectioned files (which don't exist)
reader.AssertTag(BlockType.TCES, BlockType.SECT);
TCES = new TCES(reader);
// can't find references to this?
StringTable = reader.ReadString(MAST.StringTableSize);
reader.Seek(TCES.PageOffset << 11, SeekOrigin.Begin);
Section = new Section(reader);
}
/// <summary>
/// Reads elf header
/// </summary>
/// <param name="reader">The reader.</param>
public void Read32(EndianAwareBinaryReader reader)
{
Ident = reader.ReadBytes(16);
// Check for magic number
if (Ident[0] != MagicNumber[0] || Ident[1] != MagicNumber[1] || Ident[2] != MagicNumber[2] || Ident[3] != MagicNumber[3])
{
// Magic number not present, so it seems to be an invalid ELF file
throw new NotSupportedException("This is not a valid ELF file");
}
Type = (FileType)reader.ReadUInt16();
Machine = (MachineType)reader.ReadUInt16();
Version = (Version)reader.ReadUInt32();
EntryAddress = reader.ReadUInt32();
ProgramHeaderOffset = reader.ReadUInt32();
SectionHeaderOffset = reader.ReadUInt32();
Flags = reader.ReadUInt32();
//ElfHeaderSize = reader.ReadUInt16();
//ProgramHeaderEntrySize = reader.ReadUInt16();
ProgramHeaderNumber = reader.ReadUInt16();
//SectionHeaderEntrySize = reader.ReadUInt16();
SectionHeaderNumber = reader.ReadUInt16();
SectionHeaderStringIndex = reader.ReadUInt16();
}
public static string ReadLengthPrefixedString(EndianAwareBinaryReader reader)
{
var stringLength = reader.ReadInt32();
var stringBytes = reader.ReadBytes(stringLength);
return(RobloxEncoding.GetString(stringBytes));
}
public static TypeHeader Deserialize(EndianAwareBinaryReader reader)
{
var typeId = reader.ReadInt32();
var typeName = Util.ReadLengthPrefixedString(reader);
var containsExtraDataByte = reader.ReadByte();
var instanceCount = reader.ReadInt32();
var referentArray = Util.ReadReferentArray(reader, instanceCount);
var extraData = (containsExtraDataByte != 0) ? reader.ReadBytes(instanceCount) : null;
return(new TypeHeader(typeName, typeId, referentArray, extraData));
}
public static T[] ReadInterleavedPropertyDataArrayHelper <T>(EndianAwareBinaryReader reader, int count, int valueSize, Func <byte[], T> convertProc)
{
var values = new T[count];
var bytes = reader.ReadBytes(count * valueSize);
var deinterleaved = DeinterleaveBytes(bytes, valueSize);
var buffer = new byte[valueSize];
for (var i = 0; i < count; i++)
{
Array.Copy(deinterleaved, i * valueSize, buffer, 0, valueSize);
values[i] = convertProc(buffer);
}
return(values);
}
public static float[] ReadFloatArray(EndianAwareBinaryReader reader, int count, bool interleave = true)
{
var data = reader.ReadBytes(count * sizeof(float));
if (interleave)
{
data = DeinterleaveBytes(data, sizeof(float));
}
var values = new float[count];
for (var i = 0; i < count; i++)
{
values[i] = ReverseTransformFloat(data, i * sizeof(float));
}
return(values);
}
private string GetServerVersionFromResponse(Stream stream)
{
using (var reader = new EndianAwareBinaryReader(stream, Encoding.UTF8, true, false))
{
//Read Type (should be response = 4)
int type = reader.ReadByte();
if (type != 4)
{
throw new NAMEException($"{SupportedDependencies.SqlServer}: Server responded with wrong Type ({type}).", NAMEStatusLevel.Error);
}
//Skip Status bit mask
reader.ReadByte();
//Read the full message length
ushort length = reader.ReadUInt16();
//Skip Channel
reader.ReadUInt16();
//Skip Packet Number
reader.ReadByte();
//Skip Window
reader.ReadByte();
//Read the rest of the message
//preLoginBuffer = reader.ReadBytes(length - 2 - 1 - 1 - 2 - 1 - 1);
//Read first option token (should be Version = 0)
int token = reader.ReadByte();
if (token != 0)
{
throw new NAMEException($"{SupportedDependencies.SqlServer}: Server responded with wrong Token ({token}).", NAMEStatusLevel.Error);
}
//Read the offset
ushort offset = reader.ReadUInt16();
//Read the length (should be 6)
ushort optionlength = reader.ReadUInt16();
if (optionlength != 6)
{
throw new NAMEException($"{SupportedDependencies.SqlServer}: Server responded with an invalid version length ({length}).", NAMEStatusLevel.Error);
}
//Skip everything until the version.
reader.ReadBytes(offset - 2 - 2 - 1);
int major = reader.ReadByte();
int minor = reader.ReadByte();
int build = reader.ReadUInt16();
return($"{major}.{minor}.{build}");
}
}
protected virtual T FillHeader <T>() where T : SIDBasicHeader, new()
{
T retValue = new T();
if (HeaderLength > sidStream.Length)
{
return(null);
}
byte[] headerBuff = new byte[HeaderLength];
sidStream.Read(headerBuff, 0, HeaderLength);
binaryReader = new EndianAwareBinaryReader(new MemoryStream(headerBuff), encoding);
string fileType = Encoding.ASCII.GetString(binaryReader.ReadBytes(4));
retValue.FileType = (SIDByteType)(Enum.IsDefined(typeof(SIDByteType), fileType) ? Enum.Parse(typeof(SIDByteType), fileType) : SIDByteType.Unknown);
//if (retValue.FileType == SidByteType.Unknown) throw new Exception("Not a valid SID File"); // To throw or not to throw :P
retValue.Version = binaryReader.ReadUInt16BigEndian();
return(retValue);
}
public static int[] ReadReferentArray(EndianAwareBinaryReader reader, int count)
{
var values = new int[count];
var bytes = reader.ReadBytes(count * sizeof(int));
var deinterleaved = DeinterleaveBytes(bytes, sizeof(int));
var last = 0;
var buffer = new byte[sizeof(int)];
for (var i = 0; i < count; i++)
{
Array.Copy(deinterleaved, i * sizeof(int), buffer, 0, sizeof(int));
var value = EndianAwareBitConverter.ToInt32(buffer, Endianness.Big);
value = ReverseTransformInt32(value);
value += last;
values[i] = value;
last = value;
}
return(values);
}
/// <summary>
/// Initializes a new instance of the <see cref="PortableExecutableImage"/> class.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="codeBase">The code base.</param>
public PortableExecutableImage(Stream stream)
{
// Check preconditions
if (stream == null)
{
throw new ArgumentNullException("stream");
}
assemblyStream = stream;
assemblyReader = new EndianAwareBinaryReader(stream, Endianness.Little);
// Load all headers by visiting them sequentially
dosHeader.Read(assemblyReader);
assemblyReader.BaseStream.Seek(dosHeader.e_lfanew, SeekOrigin.Begin);
ntHeader.Read(assemblyReader);
if (CLI_HEADER_DATA_DIRECTORY >= ntHeader.OptionalHeader.NumberOfRvaAndSizes)
{
throw new BadImageFormatException();
}
sections = new ImageSectionHeader[ntHeader.FileHeader.NumberOfSections];
for (int i = 0; i < ntHeader.FileHeader.NumberOfSections; i++)
{
sections[i].Read(assemblyReader);
}
long position = ResolveVirtualAddress(ntHeader.OptionalHeader.DataDirectory[CLI_HEADER_DATA_DIRECTORY].VirtualAddress);
assemblyReader.BaseStream.Seek(position, SeekOrigin.Begin);
cliHeader.Read(assemblyReader);
// Load the provider...
position = ResolveVirtualAddress(cliHeader.Metadata.VirtualAddress);
assemblyReader.BaseStream.Position = position;
metadata = assemblyReader.ReadBytes(cliHeader.Metadata.Size);
metadataRoot = new MetadataRoot(metadata);
}
/// <summary>
/// Initializes a new instance of the <see cref="PortableExecutableImage"/> class.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="codeBase">The code base.</param>
public PortableExecutableImage(Stream stream)
{
// Check preconditions
if (stream == null)
throw new ArgumentNullException("stream");
assemblyStream = stream;
assemblyReader = new EndianAwareBinaryReader(stream, true);
// Load all headers by visiting them sequentially
dosHeader.Read(assemblyReader);
assemblyReader.BaseStream.Seek(dosHeader.e_lfanew, SeekOrigin.Begin);
ntHeader.Read(assemblyReader);
if (CLI_HEADER_DATA_DIRECTORY >= ntHeader.OptionalHeader.NumberOfRvaAndSizes)
throw new BadImageFormatException();
sections = new ImageSectionHeader[ntHeader.FileHeader.NumberOfSections];
for (int i = 0; i < ntHeader.FileHeader.NumberOfSections; i++)
sections[i].Read(assemblyReader);
long position = ResolveVirtualAddress(ntHeader.OptionalHeader.DataDirectory[CLI_HEADER_DATA_DIRECTORY].VirtualAddress);
assemblyReader.BaseStream.Seek(position, SeekOrigin.Begin);
cliHeader.Read(assemblyReader);
// Load the provider...
position = ResolveVirtualAddress(cliHeader.Metadata.VirtualAddress);
assemblyReader.BaseStream.Position = position;
metadata = assemblyReader.ReadBytes(cliHeader.Metadata.Size);
metadataRoot = new MetadataRoot(metadata);
}
private static string GetVersionFromServerReponse(TcpClient client)
{
EndianAwareBinaryReader reader = new EndianAwareBinaryReader(client.GetStream(), false);
try
{
byte type = reader.ReadByte();
if (type != 1)
{
throw new NAMEException($"{SupportedDependencies.RabbitMq}: Server responded with wrong type ({type}).");
}
//Skip channel
reader.ReadUInt16();
//Read Length
uint length = reader.ReadUInt32();
//Read the rest of the message into memory. The length of Connection.Start will never be bigger than int.max
byte[] buffer = reader.ReadBytes((int)length);
reader.Dispose();
reader = new EndianAwareBinaryReader(new MemoryStream(buffer), false);
//Read class (should be Connection (10))
ushort rClass = reader.ReadUInt16();
if (rClass != 10)
{
throw new NAMEException($"{SupportedDependencies.RabbitMq}: Server responded with wrong class ({rClass}).");
}
//Read method (should be Start (10))
ushort rMethod = reader.ReadUInt16();
if (rMethod != 10)
{
throw new NAMEException($"{SupportedDependencies.RabbitMq}: Server responded with wrong method ({rMethod}).");
}
//Read AMQP major version (should be 0)
byte major = reader.ReadByte();
if (major != 0)
{
throw new NAMEException($"{SupportedDependencies.RabbitMq}: Server responded with wrong AMQP major version ({major}).");
}
//Read AMQP minor version (should be 9)
byte minor = reader.ReadByte();
if (major != 0)
{
throw new NAMEException($"{SupportedDependencies.RabbitMq}: Server responded with wrong AMQP minor version ({minor}).");
}
IDictionary <string, object> serverProperties = AmqpTypesReader.ReadTable(reader);
if (!serverProperties.ContainsKey("version"))
{
throw new NAMEException($"{SupportedDependencies.RabbitMq}: Server did not send a server-properties table!");
}
if (!(serverProperties["version"] is byte[]))
{
throw new NAMEException($"{SupportedDependencies.RabbitMq}: Server returned a version which is not a string!");
}
var versionStr = Encoding.UTF8.GetString((byte[])serverProperties["version"]);
return(versionStr);
}
finally
{
if (reader != null)
{
reader.Dispose();
}
}
}
/// <summary>
/// Reads the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
public void Read(EndianAwareBinaryReader reader)
{
Ident = reader.ReadBytes(16);
// Check for magic number
if (Ident[0] != MagicNumber[0] || Ident[1] != MagicNumber[1] || Ident[2] != MagicNumber[2] || Ident[3] != MagicNumber[3])
{
// Magic number not present, so it seems to be an invalid ELF file
throw new NotSupportedException("This is not a valid ELF file");
}
Type = (FileType)reader.ReadUInt16();
Machine = (MachineType)reader.ReadUInt16();
Version = (Version)reader.ReadUInt32();
EntryAddress = reader.ReadUInt32();
ProgramHeaderOffset = reader.ReadUInt32();
SectionHeaderOffset = reader.ReadUInt32();
Flags = reader.ReadUInt32();
ElfHeaderSize = reader.ReadUInt16();
ProgramHeaderEntrySize = reader.ReadUInt16();
ProgramHeaderNumber = reader.ReadUInt16();
SectionHeaderEntrySize = reader.ReadUInt16();
SectionHeaderNumber = reader.ReadUInt16();
SectionHeaderStringIndex = reader.ReadUInt16();
}
private void ReadWide(EndianAwareBinaryReader reader, ICliMetadataRoot metadataRoot, Action <byte[]> bodyBuilder)
{
var flagsAndSize = reader.ReadUInt16();
this.flags = ((MethodHeaderFlags)(flagsAndSize & 0x0FFF)) & ~MethodHeaderFlags.WideFormat;
this.headerSize = (byte)((flagsAndSize & 0xF000) >> 0xA);
this.maxStack = reader.ReadUInt16();
this.codeSize = reader.ReadUInt32();
var localVarSigToken = reader.ReadUInt32();
if (localVarSigToken != 0)
{
var sigTableKind = (CliMetadataTableKinds)(1UL << (int)((localVarSigToken & 0xFF000000) >> 24));
var sigIndex = localVarSigToken & 0x00FFFFFF;
ICliMetadataTable table;
if (metadataRoot.TableStream.TryGetValue(sigTableKind, out table))
{
if (table is ICliMetadataStandAloneSigTable)
{
ICliMetadataStandAloneSigTable sigTable = (ICliMetadataStandAloneSigTable)table;
var entry = sigTable[(int)sigIndex];
if (entry.Signature is ICliMetadataLocalVarSignature)
{
var sigEntry = (ICliMetadataLocalVarSignature)entry.Signature;
this.locals = sigEntry;
}
}
}
long codePosition = reader.BaseStream.Position;
bodyBuilder(reader.ReadBytes((int)this.codeSize));
if ((reader.BaseStream.Position % 4) != 0)
{
reader.BaseStream.Position += 4 - reader.BaseStream.Position % 4;
}
var ehTable = new byte[0];
if ((flags & MethodHeaderFlags.ContainsMoreSections) == MethodHeaderFlags.ContainsMoreSections)
{
readSection:
MethodHeaderSectionFlags sectionFlags = (MethodHeaderSectionFlags)reader.ReadByte();
var smallFormat = ((sectionFlags & MethodHeaderSectionFlags.FatFormat) != MethodHeaderSectionFlags.FatFormat);
int dataSize = 0;
if (smallFormat)
{
dataSize = reader.ReadByte();
reader.ReadUInt16();
}
else
{
dataSize = (int)new BitVector(new byte[] { reader.ReadByte(), reader.ReadByte(), reader.ReadByte() }).GetUInt32Nibbits(0, 24);
}
if ((sectionFlags & MethodHeaderSectionFlags.ExceptionHandlerTable) == MethodHeaderSectionFlags.ExceptionHandlerTable)
{
ehTable = ehTable.AddInlineArray(reader.ReadBytes(dataSize - 4));
}
else
{
reader.BaseStream.Position += dataSize - 4;
}
if ((sectionFlags & MethodHeaderSectionFlags.ContainsMoreSections) == MethodHeaderSectionFlags.ContainsMoreSections)
{
goto readSection;
}
}
if (ehTable.Length > 0)
{
this.exceptionTable = new CliMetadataMethodExceptionTable(ehTable);
}
reader.BaseStream.Position = codePosition;
}
}
public object Deserialize(EndianAwareBinaryReader reader, SerializedType serializedType, int?length = null)
{
int?effectiveLength = null;
var typeParent = TypeNode.Parent as TypeNode;
if (length != null)
{
effectiveLength = length.Value;
}
else if (TypeNode.FieldLengthBinding != null)
{
object lengthValue = TypeNode.FieldLengthBinding.GetValue(this);
effectiveLength = Convert.ToInt32(lengthValue);
}
else if (typeParent != null && typeParent.ItemLengthBinding != null)
{
object lengthValue = typeParent.ItemLengthBinding.GetValue((ValueNode)Parent);
effectiveLength = Convert.ToInt32(lengthValue);
}
else if (TypeNode.FieldCountBinding != null)
{
object countValue = TypeNode.FieldCountBinding.GetValue(this);
effectiveLength = Convert.ToInt32(countValue);
}
else if (serializedType == SerializedType.ByteArray || serializedType == SerializedType.SizedString)
{
checked
{
effectiveLength = (int)_remainder;
}
}
object value;
switch (serializedType)
{
case SerializedType.Int1:
value = reader.ReadSByte();
break;
case SerializedType.UInt1:
value = reader.ReadByte(GetBitSize());
break;
case SerializedType.Int2:
value = reader.ReadInt16();
break;
case SerializedType.UInt2:
value = reader.ReadUInt16();
break;
case SerializedType.Int4:
value = reader.ReadInt32();
break;
case SerializedType.UInt4:
value = reader.ReadUInt32();
break;
case SerializedType.Int8:
value = reader.ReadInt64();
break;
case SerializedType.UInt8:
value = reader.ReadUInt64();
break;
case SerializedType.Float4:
value = reader.ReadSingle();
break;
case SerializedType.Float8:
value = reader.ReadDouble();
break;
case SerializedType.ByteArray:
{
Debug.Assert(effectiveLength != null, "effectiveLength != null");
value = reader.ReadBytes(effectiveLength.Value);
break;
}
case SerializedType.NullTerminatedString:
{
byte[] data = ReadNullTerminatedString(reader).ToArray();
value = Encoding.GetString(data, 0, data.Length);
break;
}
case SerializedType.SizedString:
{
Debug.Assert(effectiveLength != null, "effectiveLength != null");
byte[] data = reader.ReadBytes(effectiveLength.Value);
value = Encoding.GetString(data, 0, data.Length).TrimEnd('\0');
break;
}
case SerializedType.LengthPrefixedString:
{
value = reader.ReadString();
break;
}
default:
throw new NotSupportedException();
}
return(value);
}
public static int[] ReadInt32Array(EndianAwareBinaryReader reader, int count)
{
var bytes = reader.ReadBytes(count * sizeof(int));
return(ReverseTransformInt32Array(bytes));
}
