public static bool ReadOperationRequest(IBinaryReader binaryReader, out object result)
{
OperationRequest request = new OperationRequest
{
OperationCode = binaryReader.ReadByte()
};
short capacity = binaryReader.ReadInt16();
if ((capacity < 0) || (capacity > ((binaryReader.BaseStream.Length - binaryReader.BaseStream.Position) / 2L)))
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Invalid parameter count: count={0}, bytesLeft={1}", new object[] { capacity, binaryReader.BaseStream.Length - binaryReader.BaseStream.Position });
}
result = null;
return(false);
}
request.Parameters = new Dictionary <byte, object>(capacity);
for (short i = 0; i < capacity; i = (short)(i + 1))
{
object obj2;
byte num3 = binaryReader.ReadByte();
if (Read(binaryReader, out obj2))
{
request.Parameters[num3] = obj2;
}
else
{
result = null;
return(false);
}
}
result = request;
return(true);
}
public static ErrorResponse Decode(byte id, IBinaryReader reader)
{
byte num1 = reader.ReadByte();
byte num2 = reader.ReadByte();
return(new ErrorResponse(id, num1, num2));
}
private static Type ReadDictionaryType(IBinaryReader reader)
{
Type clrArrayType;
Type dictArrayType;
GpType gpType = (GpType)reader.ReadByte();
GpType type2 = (GpType)reader.ReadByte();
if (gpType == GpType.Unknown)
{
clrArrayType = typeof(object);
}
else
{
clrArrayType = GpBinaryByteTypeConverter.GetClrArrayType(gpType);
}
switch (type2)
{
case GpType.Unknown:
dictArrayType = typeof(object);
break;
case GpType.Dictionary:
dictArrayType = ReadDictionaryType(reader);
break;
case GpType.Array:
dictArrayType = GetDictArrayType(reader);
break;
default:
dictArrayType = GpBinaryByteTypeConverter.GetClrArrayType(type2);
break;
}
return(typeof(Dictionary <,>).MakeGenericType(new Type[] { clrArrayType, dictArrayType }));
}
private static Type ReadDictionaryType(IBinaryReader reader, out ReadDelegate keyReadDelegate, out ReadDelegate valueReadDelegate)
{
Type clrArrayType;
Type type4;
GpType gpType = (GpType)reader.ReadByte();
GpType type2 = (GpType)reader.ReadByte();
if (gpType == GpType.Unknown)
{
clrArrayType = typeof(object);
keyReadDelegate = new ReadDelegate(GpBinaryByteReader.Read);
}
else
{
clrArrayType = GpBinaryByteTypeConverter.GetClrArrayType(gpType);
keyReadDelegate = GetReadDelegate(gpType);
}
if (type2 == GpType.Unknown)
{
type4 = typeof(object);
valueReadDelegate = new ReadDelegate(GpBinaryByteReader.Read);
}
else
{
type4 = GpBinaryByteTypeConverter.GetClrArrayType(type2);
valueReadDelegate = GetReadDelegate(type2);
}
return(typeof(Dictionary <,>).MakeGenericType(new Type[] { clrArrayType, type4 }));
}
void ReadSmallExceptionHandlers(IBinaryReader ehReader)
{
int num = GetNumberOfExceptionHandlers((uint)ehReader.ReadByte() / 12);
ehReader.Position += 2;
for (int i = 0; i < num; i++)
{
var eh = new ExceptionHandler((ExceptionHandlerType)ehReader.ReadUInt16());
uint offs = ehReader.ReadUInt16();
eh.TryStart = GetInstruction(offs);
eh.TryEnd = GetInstruction(offs + ehReader.ReadByte());
offs = ehReader.ReadUInt16();
eh.HandlerStart = GetInstruction(offs);
eh.HandlerEnd = GetInstruction(offs + ehReader.ReadByte());
if (eh.HandlerType == ExceptionHandlerType.Catch)
{
eh.CatchType = opResolver.ResolveToken(ehReader.ReadUInt32(), gpContext) as ITypeDefOrRef;
}
else if (eh.HandlerType == ExceptionHandlerType.Filter)
{
eh.FilterStart = GetInstruction(ehReader.ReadUInt32());
}
else
{
ehReader.ReadUInt32();
}
Add(eh);
}
}
static bool ReadHeader(IBinaryReader reader, out ushort flags, out uint codeSize) {
byte b = reader.ReadByte();
switch (b & 7) {
case 2:
case 6:
flags = 2;
codeSize = (uint)(b >> 2);
return true;
case 3:
flags = (ushort)((reader.ReadByte() << 8) | b);
uint headerSize = (byte)(flags >> 12);
ushort maxStack = reader.ReadUInt16();
codeSize = reader.ReadUInt32();
uint localVarSigTok = reader.ReadUInt32();
reader.Position += -12 + headerSize * 4;
if (headerSize < 3)
flags &= 0xFFF7;
return true;
default:
flags = 0;
codeSize = 0;
return false;
}
}
private IEnumerable <byte> ReadCustomMetadata(ManagedProcedureSymbol function)
{
foreach (OemSymbol oem in function.Children.OfType <OemSymbol>())
{
if (oem.Id == MsilMetadataGuid)
{
IBinaryReader reader = oem.UserDataReader;
string name = reader.ReadCStringWide().String;
if (name == "MD2")
{
byte version = reader.ReadByte();
if (version == 4)
{
int count = reader.ReadByte();
reader.Align(4);
for (int i = 0; i < count; i++)
{
long start = reader.Position;
byte entryVersion = reader.ReadByte();
byte kind = reader.ReadByte();
reader.Align(4);
yield return(kind);
uint numberOfBytesInItem = reader.ReadUint();
reader.Position = start + numberOfBytesInItem;
}
}
}
}
}
}
static bool ReadHeader(IBinaryReader reader, out ushort flags, out uint codeSize)
{
byte b = reader.ReadByte();
switch (b & 7)
{
case 2:
case 6:
flags = 2;
codeSize = (uint)(b >> 2);
return(true);
case 3:
flags = (ushort)((reader.ReadByte() << 8) | b);
uint headerSize = (byte)(flags >> 12);
ushort maxStack = reader.ReadUInt16();
codeSize = reader.ReadUInt32();
uint localVarSigTok = reader.ReadUInt32();
reader.Position += -12 + headerSize * 4;
if (headerSize < 3)
{
flags &= 0xFFF7;
}
return(true);
default:
flags = 0;
codeSize = 0;
return(false);
}
}
static void ParseSection(IBinaryReader reader)
{
byte flags;
do
{
Align(reader, 4);
flags = reader.ReadByte();
if ((flags & 1) == 0)
{
throw new InvalidMethodBody("Not an exception section");
}
if ((flags & 0x3E) != 0)
{
throw new InvalidMethodBody("Invalid bits set");
}
if ((flags & 0x40) != 0)
{
reader.Position--;
int num = (int)(reader.ReadUInt32() >> 8) / 24;
reader.Position += num * 24;
}
else
{
int num = reader.ReadByte() / 12;
reader.Position += 2 + num * 12;
}
} while ((flags & 0x80) != 0);
}
static byte[] TryCreateIcon(IBinaryReader reader, ResourceDirectory iconDir) {
try {
reader.Position = 0;
var outStream = new MemoryStream();
var writer = new BinaryWriter(outStream);
// Write GRPICONDIR
writer.Write(reader.ReadUInt16());
writer.Write(reader.ReadUInt16());
ushort numImages;
writer.Write(numImages = reader.ReadUInt16());
var entries = new List<GrpIconDirEntry>();
for (int i = 0; i < numImages; i++) {
var e = new GrpIconDirEntry();
entries.Add(e);
e.bWidth = reader.ReadByte();
e.bHeight = reader.ReadByte();
e.bColorCount = reader.ReadByte();
e.bReserved = reader.ReadByte();
e.wPlanes = reader.ReadUInt16();
e.wBitCount = reader.ReadUInt16();
e.dwBytesInRes = reader.ReadUInt32();
e.nID = reader.ReadUInt16();
}
uint dataOffset = 2 * 3 + (uint)entries.Count * 0x10;
foreach (var e in entries) {
writer.Write(e.bWidth);
writer.Write(e.bHeight);
writer.Write(e.bColorCount);
writer.Write(e.bReserved);
writer.Write(e.wPlanes);
writer.Write(e.wBitCount);
writer.Write(e.dwBytesInRes);
writer.Write(dataOffset);
dataOffset += e.dwBytesInRes;
}
foreach (var e in entries) {
var d = iconDir.Directories.FirstOrDefault(a => a.Name == new ResourceName(e.nID));
if (d == null || d.Data.Count == 0)
return null;
var r = d.Data[0].Data;
Debug.Assert(r.Length == e.dwBytesInRes);
if (r.Length < e.dwBytesInRes)
return null;
r.Position = 0;
writer.Write(r.ReadBytes((int)e.dwBytesInRes), 0, (int)e.dwBytesInRes);
}
return outStream.ToArray();
}
catch (IOException) {
}
return null;
}
/// <summary>
/// Reads <see cref="BitFieldRecord"/> from the stream.
/// </summary>
/// <param name="reader">Stream binary reader.</param>
/// <param name="kind">Type record kind.</param>
public static BitFieldRecord Read(IBinaryReader reader, TypeLeafKind kind)
{
return(new BitFieldRecord
{
Kind = kind,
Type = TypeIndex.Read(reader),
BitSize = reader.ReadByte(),
BitOffset = reader.ReadByte(),
});
}
/// <summary>
/// Reads the next OpCode from the current position
/// </summary>
OpCode ReadOpCode()
{
var op = reader.ReadByte();
if (op != 0xFE)
{
return(OpCodes.OneByteOpCodes[op]);
}
return(OpCodes.TwoByteOpCodes[reader.ReadByte()]);
}
private string ReadOfflineString(IBinaryReader binaryReader)
{
byte length = binaryReader.ReadByte();
string result = binaryReader.ReadBytes(length)
.Let(Encoding.ASCII.GetString);
// Read string termination character
binaryReader.ReadByte();
return(result);
}
/// <summary>
/// Reads <see cref="ProcedureRecord"/> from the stream.
/// </summary>
/// <param name="reader">Stream binary reader.</param>
/// <param name="kind">Type record kind.</param>
public static ProcedureRecord Read(IBinaryReader reader, TypeLeafKind kind)
{
return(new ProcedureRecord
{
Kind = kind,
ReturnType = TypeIndex.Read(reader),
CallingConvention = (CallingConvention)reader.ReadByte(),
Options = (FunctionOptions)reader.ReadByte(),
ParameterCount = reader.ReadUshort(),
ArgumentList = TypeIndex.Read(reader),
});
}
/** <inheritDoc /> */
void IBinarizable.ReadBinary(IBinaryReader reader)
{
Id = reader.ReadInt("id");
CompanyId = reader.ReadInt("companyId");
Age = reader.ReadInt("age");
Points = reader.ReadInt("points");
SexType = (Sex)reader.ReadByte("sex");
Department = (Department)reader.ReadByte("department");
Salary = reader.ReadLong("salary");
Payload = reader.ReadByteArray("payload");
Name = reader.ReadString("name");
Address = reader.ReadObject <Address>("address");
}
public static OpCode ReadOpCode(IBinaryReader binaryReader)
{
byte instruction = binaryReader.ReadByte();
if (instruction != DoubleByteInstructionPrefix)
{
return(singleByteOpCode[instruction]);
}
else
{
return(doubleByteOpCode[binaryReader.ReadByte()]);
}
}
/// <summary>
/// Reads <see cref="FrameCookieSymbol"/> from the stream.
/// </summary>
/// <param name="reader">Stream binary reader.</param>
/// <param name="symbolStream">Symbol stream that contains this symbol record.</param>
/// <param name="symbolStreamIndex">Index in symbol stream <see cref="SymbolStream.References"/> array.</param>
/// <param name="kind">Symbol record kind.</param>
public static FrameCookieSymbol Read(IBinaryReader reader, SymbolStream symbolStream, int symbolStreamIndex, SymbolRecordKind kind)
{
return(new FrameCookieSymbol
{
SymbolStream = symbolStream,
SymbolStreamIndex = symbolStreamIndex,
Kind = kind,
CodeOffset = reader.ReadUint(),
Register = (RegisterId)reader.ReadUshort(),
CookieKind = (FrameCookieKind)reader.ReadByte(),
Flags = reader.ReadByte(),
});
}
public static DecrypterV100 Create(IBinaryReader reader)
{
reader.Position = 0;
if (reader.Length < 12)
{
return(null);
}
if (reader.ReadUInt32() != RESOURCE_MAGIC)
{
return(null);
}
return(new DecrypterV100(new Version(reader.ReadByte(), reader.ReadByte(), reader.ReadByte(), reader.ReadByte())));
}
/// <summary>
/// Reads <see cref="SectionSymbol"/> from the stream.
/// </summary>
/// <param name="reader">Stream binary reader.</param>
/// <param name="kind">Symbol record kind.</param>
public static SectionSymbol Read(IBinaryReader reader, SymbolRecordKind kind)
{
return(new SectionSymbol
{
Kind = kind,
SectionNumber = reader.ReadUshort(),
Alignment = reader.ReadByte(),
Padding = reader.ReadByte(),
RelativeVirtualAddress = reader.ReadUint(),
Length = reader.ReadUint(),
Characteristics = (ImageSectionCharacteristics)reader.ReadUint(),
Name = reader.ReadCString(),
});
}
/// <summary>
/// Reads <see cref="FileChecksumSubsection"/> from the stream.
/// </summary>
/// <param name="reader">Stream binary reader.</param>
/// <param name="kind">Debug subsection kind.</param>
public static FileChecksumSubsection Read(IBinaryReader reader, DebugSubsectionKind kind)
{
uint nameIndex = reader.ReadUint();
byte hashLength = reader.ReadByte();
FileChecksumHashType hashType = (FileChecksumHashType)reader.ReadByte();
reader.Align(4);
return(new FileChecksumSubsection
{
Kind = kind,
NameIndex = nameIndex,
HashType = hashType,
HashReader = reader.ReadSubstream(hashLength),
});
}
public static DecrypterV105 Create(IBinaryReader reader)
{
reader.Position = 0;
if (reader.Length < 0xA4)
{
return(null);
}
var key = reader.ReadBytes(0x94);
if (!Utils.Compare(reader.ReadBytes(8), ilpPublicKeyToken))
{
return(null);
}
return(new DecrypterV105(new Version(reader.ReadByte(), reader.ReadByte(), reader.ReadByte(), reader.ReadByte()), key));
}
/// <summary>
/// Reads <see cref="MemberFunctionRecord"/> from the stream.
/// </summary>
/// <param name="reader">Stream binary reader.</param>
/// <param name="kind">Type record kind.</param>
public static MemberFunctionRecord Read(IBinaryReader reader, TypeLeafKind kind)
{
return(new MemberFunctionRecord
{
Kind = kind,
ReturnType = TypeIndex.Read(reader),
ClassType = TypeIndex.Read(reader),
ThisType = TypeIndex.Read(reader),
CallingConvention = (CallingConvention)reader.ReadByte(),
Options = (FunctionOptions)reader.ReadByte(),
ParameterCount = reader.ReadUshort(),
ArgumentList = TypeIndex.Read(reader),
ThisPointerAdjustment = reader.ReadInt(),
});
}
/** <inheritDoc /> */
void IBinarizable.ReadBinary(IBinaryReader reader)
{
Id = reader.ReadInt("id");
CompanyId = reader.ReadInt("companyId");
Age = reader.ReadInt("age");
Points = reader.ReadInt("points");
SexType = (Sex)reader.ReadByte("sex");
Department = (Department)reader.ReadByte("department");
Salary = reader.ReadLong("salary");
Payload = reader.ReadByteArray("payload");
Name = reader.ReadString("name");
Address = reader.ReadObject <Address>("address");
Birthday = reader.ReadObject <DateTime>("birthday");
Timestamp = reader.ReadTimestamp("timestamp").GetValueOrDefault();
}
static byte Peek(IBinaryReader reader)
{
byte b = reader.ReadByte();
reader.Position--;
return(b);
}
protected static byte[] Decompress(byte[] decrypted, IBinaryReader reader, byte[] key, int keyMod) {
int destIndex = 0;
while (reader.Position < reader.Length) {
if (destIndex >= decrypted.Length)
break;
byte flags = reader.ReadByte();
for (int mask = 1; mask != 0x100; mask <<= 1) {
if (reader.Position >= reader.Length)
break;
if (destIndex >= decrypted.Length)
break;
if ((flags & mask) != 0) {
int displ = (int)reader.Read7BitEncodedUInt32();
int size = (int)reader.Read7BitEncodedUInt32();
Copy(decrypted, destIndex - displ, decrypted, destIndex, size);
destIndex += size;
}
else {
byte b = reader.ReadByte();
if (key != null)
b ^= key[destIndex % keyMod];
decrypted[destIndex++] = b;
}
}
}
return decrypted;
}
/// <summary>
/// Reads encoded integer from the stream.
/// </summary>
/// <param name="reader">Stream binary reader.</param>
/// <returns>Integer, but also carries type info, so it is returned as object.</returns>
public static object ReadEncodedInteger(this IBinaryReader reader)
{
ushort type = reader.ReadUshort();
if (type < (ushort)TypeLeafKind.LF_NUMERIC)
{
return(type);
}
switch ((TypeLeafKind)type)
{
case TypeLeafKind.LF_CHAR:
return((sbyte)reader.ReadByte());
case TypeLeafKind.LF_SHORT:
return(reader.ReadShort());
case TypeLeafKind.LF_USHORT:
return(reader.ReadUshort());
case TypeLeafKind.LF_LONG:
return(reader.ReadInt());
case TypeLeafKind.LF_ULONG:
return(reader.ReadUint());
case TypeLeafKind.LF_QUADWORD:
return(reader.ReadLong());
case TypeLeafKind.LF_UQUADWORD:
return(reader.ReadUlong());
}
throw new NotImplementedException();
}
public void ReadByByteTooMuchDataFromShortArray()
{
var buffer = new byte[] { 0, 1, 2 };
IBinaryReader reader = BinaryHelper.CreateReader(buffer);
Assert.IsNotNull(reader);
for (int i = 0; i < 3; i++)
{
Assert.AreEqual((byte)i, reader.ReadByte());
}
// should trigger exception here
reader.ReadByte();
Assert.Fail("Expected exception before");
}
/** <inheritDoc /> */
public void ReadBinary(IBinaryReader reader)
{
Byte = reader.ReadByte("Byte");
ByteArray = reader.ReadByteArray("ByteArray");
Char = reader.ReadChar("Char");
CharArray = reader.ReadCharArray("CharArray");
Short = reader.ReadShort("Short");
ShortArray = reader.ReadShortArray("ShortArray");
Int = reader.ReadInt("Int");
IntArray = reader.ReadIntArray("IntArray");
Long = reader.ReadLong("Long");
LongArray = reader.ReadLongArray("LongArray");
Boolean = reader.ReadBoolean("Boolean");
BooleanArray = reader.ReadBooleanArray("BooleanArray");
Float = reader.ReadFloat("Float");
FloatArray = reader.ReadFloatArray("FloatArray");
Double = reader.ReadDouble("Double");
DoubleArray = reader.ReadDoubleArray("DoubleArray");
Decimal = reader.ReadDecimal("Decimal");
DecimalArray = reader.ReadDecimalArray("DecimalArray");
Date = reader.ReadTimestamp("Date");
DateArray = reader.ReadTimestampArray("DateArray");
String = reader.ReadString("String");
StringArray = reader.ReadStringArray("StringArray");
Guid = reader.ReadObject <Guid>("Guid");
GuidArray = reader.ReadGuidArray("GuidArray");
}
bool IsBytes(IList <byte> bytes)
{
long oldPos = reader.Position;
bool result = true;
for (int i = 0; i < bytes.Count; i++)
{
if (bytes[i] != reader.ReadByte())
{
result = false;
break;
}
}
reader.Position = oldPos;
return(result);
}
protected void readSdrAndBitStream(IBinaryReader reader)
{
// the kind of information contained in the structured data record will
// depend on the compression type
DataRecord = reader.ReadSDR();
if (CompressionType == CompressionType.BASELINE_JPEG || CompressionType == CompressionType.PNG)
{
Image = new MemoryStream(reader.ArgumentsCount - reader.CurrentArg);
while (reader.CurrentArg < reader.ArgumentsCount)
{
Image.WriteByte(reader.ReadByte());
}
}
else
{
switch (CompressionType)
{
case CompressionType.BITMAP:
ReadBitmap(reader);
break;
default:
reader.Unsupported("unsupported compression type " + CompressionType);
break;
}
}
}
private static MobileOriginatedLocation DecodeLocation(
IBinaryReader reader)
{
byte num1 = reader.ReadByte();
int num2 = (num1 & 2) >> 1;
byte num3 = reader.ReadByte();
ushort num4 = reader.ReadUInt16();
double latitude = (num2 == 0 ? 1 : -1) * num3 + num4 / 1000.0 / 60.0;
int num5 = num1 & 1;
byte num6 = reader.ReadByte();
ushort num7 = reader.ReadUInt16();
double longitude = (num5 == 0 ? 1 : -1) * num6 + num7 / 1000.0 / 60.0;
uint cepRadius = reader.ReadUInt32();
return(new MobileOriginatedLocation(latitude, longitude, cepRadius));
}
/** <inheritDoc /> */
public void ReadBinary(IBinaryReader reader)
{
Byte = reader.ReadByte("Byte");
ByteArray = reader.ReadByteArray("ByteArray");
Char = reader.ReadChar("Char");
CharArray = reader.ReadCharArray("CharArray");
Short = reader.ReadShort("Short");
ShortArray = reader.ReadShortArray("ShortArray");
Int = reader.ReadInt("Int");
IntArray = reader.ReadIntArray("IntArray");
Long = reader.ReadLong("Long");
LongArray = reader.ReadLongArray("LongArray");
Boolean = reader.ReadBoolean("Boolean");
BooleanArray = reader.ReadBooleanArray("BooleanArray");
Float = reader.ReadFloat("Float");
FloatArray = reader.ReadFloatArray("FloatArray");
Double = reader.ReadDouble("Double");
DoubleArray = reader.ReadDoubleArray("DoubleArray");
Decimal = reader.ReadDecimal("Decimal");
DecimalArray = reader.ReadDecimalArray("DecimalArray");
Date = reader.ReadTimestamp("Date");
DateArray = reader.ReadTimestampArray("DateArray");
String = reader.ReadString("String");
StringArray = reader.ReadStringArray("StringArray");
Guid = reader.ReadObject<Guid>("Guid");
GuidArray = reader.ReadGuidArray("GuidArray");
}
/// <summary>
/// Tries to read a custom type.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="result">The result.</param>
/// <returns>True if the custom type could be readed successfully; otherwise false.</returns>
public static bool ReadCustomType(IBinaryReader reader, out object result)
{
CustomTypeInfo info;
byte typeCode = reader.ReadByte();
if (!CustomTypeCache.TryGet(typeCode, out info) && !Protocol.AllowRawCustomValues)
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Could not find custom type for type code {0}", new object[] { typeCode });
}
result = null;
return(false);
}
short length = reader.ReadInt16();
if ((length < 0) || ((reader.BaseStream.Length - reader.BaseStream.Position) < length))
{
if (log.IsDebugEnabled)
{
log.DebugFormat("Invalid length for custom type: length={0}, bytesLeft={1}", new object[] { length, reader.BaseStream.Length - reader.BaseStream.Position });
}
result = null;
return(false);
}
byte[] arg = reader.ReadBytes(length);
result = (info != null) ? info.DeserializeFunction(arg) : new RawCustomValue(typeCode, arg);
return(true);
}
private static IEnumerable <IoProperty> ReadIoProperties(
IBinaryReader reader)
{
return(new IoProperty[9]
{
IoProperty.Create(10, reader.ReadInt16()),
IoProperty.Create(1, reader.ReadInt16()),
IoProperty.Create(2, reader.ReadInt16()),
IoProperty.Create(3, reader.ReadInt16()),
IoProperty.Create(12, reader.ReadInt16()),
IoProperty.Create(11, reader.ReadByte()),
IoProperty.Create(5, reader.ReadByte()),
IoProperty.Create(4, reader.ReadByte()),
IoProperty.Create(6, reader.ReadByte())
});
}
/// <summary>
/// Reads the column
/// </summary>
/// <param name="reader">A reader positioned on this column</param>
/// <returns>The column value</returns>
public uint Read(IBinaryReader reader) {
switch (size) {
case 1: return reader.ReadByte();
case 2: return reader.ReadUInt16();
case 4: return reader.ReadUInt32();
default: throw new InvalidOperationException("Invalid column size");
}
}
public virtual bool Decrypt(IBinaryReader fileDataReader, DumpedMethod dm) {
if (fileDataReader.ReadByte() != 0x2A)
return false; // Not a RET
methodsDataReader.Position = fileDataReader.ReadCompressedUInt32();
dm.mhCodeSize = methodsDataReader.ReadCompressedUInt32();
dm.code = methodsDataReader.ReadBytes((int)dm.mhCodeSize);
if ((dm.mhFlags & 8) != 0)
dm.extraSections = MethodBodyParser.ReadExtraSections(methodsDataReader);
if (!DecryptCode(dm))
return false;
return true;
}
static MethodBodyHeader ParseMethodBody2(IBinaryReader reader, out byte[] code, out byte[] extraSections) {
var mbHeader = new MethodBodyHeader();
uint codeOffset;
byte b = Peek(reader);
if ((b & 3) == 2) {
mbHeader.flags = 2;
mbHeader.maxStack = 8;
mbHeader.codeSize = (uint)(reader.ReadByte() >> 2);
mbHeader.localVarSigTok = 0;
codeOffset = 1;
}
else if ((b & 7) == 3) {
mbHeader.flags = reader.ReadUInt16();
codeOffset = (uint)(4 * (mbHeader.flags >> 12));
if (codeOffset != 12)
throw new InvalidMethodBody();
mbHeader.maxStack = reader.ReadUInt16();
mbHeader.codeSize = reader.ReadUInt32();
if (mbHeader.codeSize > int.MaxValue)
throw new InvalidMethodBody();
mbHeader.localVarSigTok = reader.ReadUInt32();
if (mbHeader.localVarSigTok != 0 && (mbHeader.localVarSigTok >> 24) != 0x11)
throw new InvalidMethodBody();
}
else
throw new InvalidMethodBody();
if (mbHeader.codeSize + codeOffset > reader.Length)
throw new InvalidMethodBody();
code = reader.ReadBytes((int)mbHeader.codeSize);
if ((mbHeader.flags & 8) != 0)
extraSections = ReadExtraSections2(reader);
else
extraSections = null;
return mbHeader;
}
void ReadSmallExceptionHandlers(IBinaryReader ehReader) {
int num = GetNumberOfExceptionHandlers((uint)ehReader.ReadByte() / 12);
ehReader.Position += 2;
for (int i = 0; i < num; i++) {
var eh = new ExceptionHandler((ExceptionHandlerType)ehReader.ReadUInt16());
uint offs = ehReader.ReadUInt16();
eh.TryStart = GetInstruction(offs);
eh.TryEnd = GetInstruction(offs + ehReader.ReadByte());
offs = ehReader.ReadUInt16();
eh.HandlerStart = GetInstruction(offs);
eh.HandlerEnd = GetInstruction(offs + ehReader.ReadByte());
if (eh.HandlerType == ExceptionHandlerType.Catch)
eh.CatchType = opResolver.ResolveToken(ehReader.ReadUInt32(), gpContext) as ITypeDefOrRef;
else if (eh.HandlerType == ExceptionHandlerType.Filter)
eh.FilterStart = GetInstruction(ehReader.ReadUInt32());
else
ehReader.ReadUInt32();
Add(eh);
}
}
/** <inheritDoc /> */
void IBinarizable.ReadBinary(IBinaryReader reader)
{
Id = reader.ReadInt("id");
CompanyId = reader.ReadInt("companyId");
Age = reader.ReadInt("age");
Points = reader.ReadInt("points");
SexType = (Sex)reader.ReadByte("sex");
Department = (Department)reader.ReadByte("department");
Salary = reader.ReadLong("salary");
Payload = reader.ReadByteArray("payload");
Name = reader.ReadString("name");
Address = reader.ReadObject<Address>("address");
}
static void ParseSection(IBinaryReader reader) {
byte flags;
do {
Align(reader, 4);
flags = reader.ReadByte();
if ((flags & 1) == 0)
throw new InvalidMethodBody("Not an exception section");
if ((flags & 0x3E) != 0)
throw new InvalidMethodBody("Invalid bits set");
if ((flags & 0x40) != 0) {
reader.Position--;
int num = (int)(reader.ReadUInt32() >> 8) / 24;
reader.Position += num * 24;
}
else {
int num = reader.ReadByte() / 12;
reader.Position += 2 + num * 12;
}
} while ((flags & 0x80) != 0);
}
static byte Peek(IBinaryReader reader) {
byte b = reader.ReadByte();
reader.Position--;
return b;
}
internal byte DecodeByte(IBinaryReader reader)
{
int pos = reader.Position + 0x8000000;
byte raw = reader.ReadByte();
if (encodingParameters == null)
{
return raw;
}
bool even = (pos & 1) == 0;
if (even)
{
int offset = ((pos >> 1) % encodingParameters.EvenPadModulus);
byte pad = encodingParameters.EvenPad[offset];
return (byte)(((raw + encodingParameters.EvenOffset1) ^ pad) + encodingParameters.EvenOffset2);
}
else
{
int offset = ((pos >> 1) % encodingParameters.OddPadModulus);
byte pad = encodingParameters.OddPad[offset];
return (byte)(((raw + encodingParameters.OddOffset1) ^ pad) + encodingParameters.OddOffset2);
}
}
public void ReadBinary(IBinaryReader reader)
{
Assert.AreEqual(1, reader.ReadByte("Byte"));
Assert.AreEqual(new byte[] {1}, reader.ReadByteArray("ByteArray"));
Assert.AreEqual('1', reader.ReadChar("Char"));
Assert.AreEqual(new[] {'1'}, reader.ReadCharArray("CharArray"));
Assert.AreEqual(1, reader.ReadShort("Short"));
Assert.AreEqual(new short[] {1}, reader.ReadShortArray("ShortArray"));
Assert.AreEqual(1, reader.ReadInt("Int"));
Assert.AreEqual(new[] {1}, reader.ReadIntArray("IntArray"));
Assert.AreEqual(1, reader.ReadLong("Long"));
Assert.AreEqual(new long[] {1}, reader.ReadLongArray("LongArray"));
Assert.AreEqual(true, reader.ReadBoolean("Boolean"));
Assert.AreEqual(new[] {true}, reader.ReadBooleanArray("BooleanArray"));
Assert.AreEqual(1, reader.ReadFloat("Float"));
Assert.AreEqual(new float[] {1}, reader.ReadFloatArray("FloatArray"));
Assert.AreEqual(1, reader.ReadDouble("Double"));
Assert.AreEqual(new double[] {1}, reader.ReadDoubleArray("DoubleArray"));
Assert.AreEqual(1, reader.ReadDecimal("Decimal"));
Assert.AreEqual(new decimal?[] {1}, reader.ReadDecimalArray("DecimalArray"));
Assert.AreEqual(Date, reader.ReadTimestamp("Timestamp"));
Assert.AreEqual(new DateTime?[] {Date}, reader.ReadTimestampArray("TimestampArray"));
Assert.AreEqual("1", reader.ReadString("String"));
Assert.AreEqual(new[] {"1"}, reader.ReadStringArray("StringArray"));
Assert.AreEqual(Guid, reader.ReadGuid("Guid"));
Assert.AreEqual(new Guid?[] {Guid}, reader.ReadGuidArray("GuidArray"));
Assert.AreEqual(MyEnum.Bar, reader.ReadEnum<MyEnum>("Enum"));
Assert.AreEqual(new[] {MyEnum.Bar}, reader.ReadEnumArray<MyEnum>("EnumArray"));
var raw = reader.GetRawReader();
Assert.AreEqual(1, raw.ReadByte());
Assert.AreEqual(new byte[] { 1 }, raw.ReadByteArray());
Assert.AreEqual('1', raw.ReadChar());
Assert.AreEqual(new[] { '1' }, raw.ReadCharArray());
Assert.AreEqual(1, raw.ReadShort());
Assert.AreEqual(new short[] { 1 }, raw.ReadShortArray());
Assert.AreEqual(1, raw.ReadInt());
Assert.AreEqual(new[] { 1 }, raw.ReadIntArray());
Assert.AreEqual(1, raw.ReadLong());
Assert.AreEqual(new long[] { 1 }, raw.ReadLongArray());
Assert.AreEqual(true, raw.ReadBoolean());
Assert.AreEqual(new[] { true }, raw.ReadBooleanArray());
Assert.AreEqual(1, raw.ReadFloat());
Assert.AreEqual(new float[] { 1 }, raw.ReadFloatArray());
Assert.AreEqual(1, raw.ReadDouble());
Assert.AreEqual(new double[] { 1 }, raw.ReadDoubleArray());
Assert.AreEqual(1, raw.ReadDecimal());
Assert.AreEqual(new decimal?[] { 1 }, raw.ReadDecimalArray());
Assert.AreEqual(Date, raw.ReadTimestamp());
Assert.AreEqual(new DateTime?[] { Date }, raw.ReadTimestampArray());
Assert.AreEqual("1", raw.ReadString());
Assert.AreEqual(new[] { "1" }, raw.ReadStringArray());
Assert.AreEqual(Guid, raw.ReadGuid());
Assert.AreEqual(new Guid?[] { Guid }, raw.ReadGuidArray());
Assert.AreEqual(MyEnum.Bar, raw.ReadEnum<MyEnum>());
Assert.AreEqual(new[] { MyEnum.Bar }, raw.ReadEnumArray<MyEnum>());
}
internal string ReadCodedStringInternal(IBinaryReader reader, int? maxLength)
{
StringBuilder sb = new StringBuilder();
int count = 0;
for (count = 0; (!maxLength.HasValue) ||
(maxLength.HasValue && count < maxLength);)
{
// Check for custom codes
ushort peek = reader.PeekUShort();
byte upper = (byte)((peek >> 8) & 0xFF);
if (upper == 0xEF)
{
// Custom code with one-byte argument inline
reader.ReadByte();
byte arg = reader.ReadByte();
count++;
sb.Append($"[EF{arg:X2}]");
}
else if (peek == 0xFEFF)
{
// Custom code (hot springs) with two-byte argument following
reader.ReadShort();
ushort arg = reader.ReadUShort();
count += 2;
sb.Append($"[HOTSPRING {arg:X4}]");
}
else
{
ControlCode code = ProcessChar(reader, sb, ref count);
if (code != null && code.Flags.HasFlag(ControlCodeFlags.Terminate))
{
break;
}
}
}
// Advance the position past the end of the string if applicable
while (maxLength.HasValue && count++ < maxLength)
{
reader.ReadShort();
}
return sb.ToString();
}
public static DecrypterV100 Create(IBinaryReader reader) {
reader.Position = 0;
if (reader.Length < 12)
return null;
if (reader.ReadUInt32() != RESOURCE_MAGIC)
return null;
return new DecrypterV100(new Version(reader.ReadByte(), reader.ReadByte(), reader.ReadByte(), reader.ReadByte()));
}
public static DecrypterV105 Create(IBinaryReader reader) {
reader.Position = 0;
if (reader.Length < 0xA4)
return null;
var key = reader.ReadBytes(0x94);
if (!Utils.Compare(reader.ReadBytes(8), ilpPublicKeyToken))
return null;
return new DecrypterV105(new Version(reader.ReadByte(), reader.ReadByte(), reader.ReadByte(), reader.ReadByte()), key);
}
static byte[] GetKey(IBinaryReader reader, byte[] sha1Sum, int offs) {
var key = (byte[])sha1Sum.Clone();
reader.Position = offs;
for (int i = 0; i < key.Length; i++)
key[i] ^= reader.ReadByte();
return key;
}
static byte ReadByteAt(IBinaryReader reader, int offs) {
reader.Position = offs;
return reader.ReadByte();
}
