/// <summary>
/// Reads a single extra section from the provided input stream.
/// </summary>
/// <param name="reader">The input stream to read from.</param>
/// <returns>The extra section that was read.</returns>
public static CilExtraSection FromReader(IBinaryStreamReader reader)
{
var section = new CilExtraSection
{
Attributes = (CilExtraSectionAttributes)reader.ReadByte()
};
int dataSize;
if (section.IsFat)
{
dataSize = reader.ReadByte() |
(reader.ReadByte() << 0x08) |
(reader.ReadByte() << 0x10);
}
else
{
dataSize = reader.ReadByte();
reader.ReadUInt16();
}
section.Data = new byte[dataSize];
reader.ReadBytes(section.Data, 0, dataSize);
return(section);
}
/// <summary>
/// Disassembles the next instruction of the input stream.
/// </summary>
/// <returns>The disassembled instruction.</returns>
public X86Instruction ReadNextInstruction()
{
long offset = BaseAddress + _reader.Position;
byte code1 = _reader.ReadByte();
var instruction = new X86Instruction(offset)
{
OpCode = ReadOpcode(code1)
};
if (instruction.OpCode.Mnemonics == null)
{
instruction.Operand1 = new X86Operand(code1);
return(instruction);
}
var registerToken = instruction.OpCode.HasRegisterToken ? _reader.ReadByte() : (byte)0;
var mnemonicIndex = instruction.OpCode.HasOpCodeModifier ? (registerToken >> 3) & 7 : 0;
instruction.Mnemonic = instruction.OpCode.Mnemonics[mnemonicIndex];
instruction.Operand1 = ReadOperand(instruction.OpCode.OperandTypes1[mnemonicIndex],
instruction.OpCode.OperandSizes1[mnemonicIndex], instruction.OpCode.Op1, registerToken);
instruction.Operand2 = ReadOperand(instruction.OpCode.OperandTypes2[mnemonicIndex],
instruction.OpCode.OperandSizes2[mnemonicIndex], instruction.OpCode.Op1, registerToken);
return(instruction);
}
public static CilExtraSection FromReader(IBinaryStreamReader reader)
{
var section = new CilExtraSection
{
Attributes = (CilExtraSectionAttributes)reader.ReadByte()
};
if (!section.IsExceptionHandler)
{
throw new NotSupportedException("Invalid or unsupported extra section.");
}
int dataSize;
if (section.IsFat)
{
dataSize = reader.ReadByte() |
(reader.ReadByte() << 0x08) |
(reader.ReadByte() << 0x10);
}
else
{
dataSize = reader.ReadByte();
reader.ReadUInt16();
}
section.Data = reader.ReadBytes(dataSize);
return(section);
}
public static ExceptionHandler FromReader(MethodBody methodBody, IBinaryStreamReader reader, bool fatFormat)
{
var offset = reader.Position;
var handerType = fatFormat ? reader.ReadUInt32() : reader.ReadUInt16();
var tryOffset = fatFormat ? reader.ReadInt32() : reader.ReadUInt16();
var tryLength = fatFormat ? reader.ReadInt32() : reader.ReadByte();
var handlerOffset = fatFormat ? reader.ReadInt32() : reader.ReadUInt16();
var handlerLength = fatFormat ? reader.ReadInt32() : reader.ReadByte();
var classTokenOrFilterOffset = reader.ReadUInt32();
var handler = new ExceptionHandler((ExceptionHandlerType)handerType)
{
StartOffset = offset,
IsFat = fatFormat,
MethodBody = methodBody,
TryStart = methodBody.GetInstructionByOffset(tryOffset),
TryEnd = methodBody.GetInstructionByOffset(tryOffset + tryLength),
HandlerStart = methodBody.GetInstructionByOffset(handlerOffset),
HandlerEnd = methodBody.GetInstructionByOffset(handlerOffset + handlerLength),
};
switch (handler.HandlerType)
{
case ExceptionHandlerType.Exception:
handler.CatchType = (ITypeDefOrRef)((IOperandResolver)methodBody).ResolveMember(new MetadataToken(classTokenOrFilterOffset));
break;
case ExceptionHandlerType.Filter:
handler.FilterStart = methodBody.GetInstructionByOffset((int)classTokenOrFilterOffset);
break;
}
return(handler);
}
/// <summary>
/// Reads a single exception handler from the given input stream.
/// </summary>
/// <param name="cilMethodBody">The method body that contains the exception handler.</param>
/// <param name="reader">The input stream to read from.</param>
/// <param name="fatFormat">A value indicating whether the fat format or the small format should be used.</param>
/// <returns>The exception handler.</returns>
public static ExceptionHandler FromReader(CilMethodBody cilMethodBody, IBinaryStreamReader reader, bool fatFormat)
{
var handlerType = (ExceptionHandlerType)(fatFormat ? reader.ReadUInt32() : reader.ReadUInt16());
int tryOffset = fatFormat ? reader.ReadInt32() : reader.ReadUInt16();
int tryLength = fatFormat ? reader.ReadInt32() : reader.ReadByte();
int handlerOffset = fatFormat ? reader.ReadInt32() : reader.ReadUInt16();
int handlerLength = fatFormat ? reader.ReadInt32() : reader.ReadByte();
uint classTokenOrFilterOffset = reader.ReadUInt32();
var handler = new ExceptionHandler(handlerType)
{
IsFat = fatFormat,
TryStart = cilMethodBody.Instructions.GetByOffset(tryOffset),
TryEnd = cilMethodBody.Instructions.GetByOffset(tryOffset + tryLength),
HandlerStart = cilMethodBody.Instructions.GetByOffset(handlerOffset),
HandlerEnd = cilMethodBody.Instructions.GetByOffset(handlerOffset + handlerLength),
};
switch (handler.HandlerType)
{
case ExceptionHandlerType.Exception:
handler.CatchType = (ITypeDefOrRef)((IOperandResolver)cilMethodBody).ResolveMember(
new MetadataToken(classTokenOrFilterOffset));
break;
case ExceptionHandlerType.Filter:
handler.FilterStart = cilMethodBody.Instructions.GetByOffset((int)classTokenOrFilterOffset);
break;
}
return(handler);
}
private CilOpCode ReadOpCode()
{
byte op = _reader.ReadByte();
return(op == 0xFE
? CilOpCodes.MultiByteOpCodes[_reader.ReadByte()]
: CilOpCodes.SingleByteOpCodes[op]);
}
/// <summary>
/// Reads a single constant row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the constants table.</param>
/// <returns>The row.</returns>
public static ConstantRow FromReader(IBinaryStreamReader reader, TableLayout layout)
{
return(new ConstantRow(
(ElementType)reader.ReadByte(),
reader.ReadByte(),
reader.ReadIndex((IndexSize)layout.Columns[2].Size),
reader.ReadIndex((IndexSize)layout.Columns[3].Size)));
}
/// <summary>
/// Reads a single exception handler from the provided input stream.
/// </summary>
/// <param name="body">The method body containing the exception handler.</param>
/// <param name="reader">The input stream.</param>
/// <param name="isFat"><c>true</c> if the fat format should be used, <c>false</c> otherwise.</param>
/// <returns>The exception handler.</returns>
public static CilExceptionHandler FromReader(CilMethodBody body, IBinaryStreamReader reader, bool isFat)
{
CilExceptionHandlerType handlerType;
int tryStartOffset;
int tryEndOffset;
int handlerStartOffset;
int handlerEndOffset;
// Read raw structure.
if (isFat)
{
handlerType = (CilExceptionHandlerType)reader.ReadUInt32();
tryStartOffset = reader.ReadInt32();
tryEndOffset = tryStartOffset + reader.ReadInt32();
handlerStartOffset = reader.ReadInt32();
handlerEndOffset = handlerStartOffset + reader.ReadInt32();
}
else
{
handlerType = (CilExceptionHandlerType)reader.ReadUInt16();
tryStartOffset = reader.ReadUInt16();
tryEndOffset = tryStartOffset + reader.ReadByte();
handlerStartOffset = reader.ReadUInt16();
handlerEndOffset = handlerStartOffset + reader.ReadByte();
}
int exceptionTokenOrFilterStart = reader.ReadInt32();
// Create handler.
var handler = new CilExceptionHandler
{
HandlerType = handlerType,
TryStart = body.Instructions.GetByOffset(tryStartOffset)?.CreateLabel() ??
new CilOffsetLabel(tryStartOffset),
TryEnd = body.Instructions.GetByOffset(tryEndOffset)?.CreateLabel() ?? new CilOffsetLabel(tryEndOffset),
HandlerStart = body.Instructions.GetByOffset(handlerStartOffset)?.CreateLabel() ??
new CilOffsetLabel(handlerStartOffset),
HandlerEnd = body.Instructions.GetByOffset(handlerEndOffset)?.CreateLabel() ??
new CilOffsetLabel(handlerEndOffset),
};
// Interpret last field.
switch (handler.HandlerType)
{
case CilExceptionHandlerType.Exception when body.Owner.Module.TryLookupMember(exceptionTokenOrFilterStart, out var member):
handler.ExceptionType = member as ITypeDefOrRef;
break;
case CilExceptionHandlerType.Filter:
handler.FilterStart = body.Instructions.GetByOffset(exceptionTokenOrFilterStart)?.CreateLabel()
?? new CilOffsetLabel(exceptionTokenOrFilterStart);
break;;
}
return(handler);
}
/// <summary>
/// Disassembles the next instruction of the input stream.
/// </summary>
/// <returns>The disassembled instruction.</returns>
public X86Instruction ReadNextInstruction()
{
long offset = BaseAddress + _reader.Position;
var instruction = new X86Instruction(offset);
byte nextCode = ReadNextOpCode(out var prefixBytes);
instruction.OpCode = InterpretOpCodeByte(prefixBytes, nextCode);
if (instruction.OpCode.Mnemonics == null)
{
if (prefixBytes.Count > 0)
{
nextCode = prefixBytes[0];
_reader.Position = offset + 1;
}
instruction.Operand1 = new X86Operand(nextCode);
return(instruction);
}
var registerToken = instruction.OpCode.HasRegisterToken ? _reader.ReadByte() : (byte)0;
var mnemonicIndex = instruction.OpCode.HasOpCodeModifier ? (registerToken >> 3) & 7 : 0;
instruction.Mnemonic = instruction.OpCode.Mnemonics[mnemonicIndex];
foreach (var prefixByte in prefixBytes)
{
var prefix = X86Prefixes.PrefixesByByte[prefixByte]
.FirstOrDefault(x => x.CanPrecedeOpCode(instruction.OpCode));
if (Equals(prefix, default(X86Prefix)))
{
instruction.Prefixes.Clear();
instruction.OpCode = default(X86OpCode);
instruction.Operand1 = new X86Operand(prefixBytes[0]);
_reader.Position = offset + 1;
return(instruction);
}
instruction.Prefixes.Add(prefix);
}
instruction.Operand1 = ReadOperand(instruction.Prefixes, instruction.OpCode.OperandTypes1[mnemonicIndex],
instruction.OpCode.OperandSizes1[mnemonicIndex], instruction.OpCode.Op1, registerToken);
instruction.Operand2 = ReadOperand(instruction.Prefixes, instruction.OpCode.OperandTypes2[mnemonicIndex],
instruction.OpCode.OperandSizes2[mnemonicIndex], instruction.OpCode.Op1, registerToken);
instruction.Operand3 = ReadOperand(instruction.Prefixes, instruction.OpCode.OperandType3,
instruction.OpCode.OperandSize3, instruction.OpCode.Op1, registerToken);
return(instruction);
}
private MsilInstruction ReadNextInstruction()
{
var offset = (int)(_reader.Position - _reader.StartPosition);
var b = _reader.ReadByte();
var code = b == 0xFE
? MsilOpCodes.MultiByteOpCodes[_reader.ReadByte()]
: MsilOpCodes.SingleByteOpCodes[b];
var operand = ReadRawOperand(_reader, code.OperandType);
return(new MsilInstruction(offset, code, operand));
}
public new static GenericInstanceTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
if (!reader.CanRead(sizeof(byte)))
{
return(null);
}
var elementType = (ElementType)reader.ReadByte();
var type = ReadTypeDefOrRef(header, reader);
var signature = new GenericInstanceTypeSignature(type)
{
IsValueType = elementType == ElementType.ValueType
};
uint count;
if (!reader.TryReadCompressedUInt32(out count))
{
return(signature);
}
for (int i = 0; i < count; i++)
{
signature.GenericArguments.Add(TypeSignature.FromReader(header, reader));
}
return(signature);
}
/// <summary>
/// Reads a single property signature at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the signature resides in.</param>
/// <param name="reader">The reader to use.</param>
/// <param name="readToEnd">Determines whether any extra data after the signature should be read and
/// put into the <see cref="ExtendableBlobSignature.ExtraData"/> property.</param>
/// <param name="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read signature.</returns>
public new static PropertySignature FromReader(
MetadataImage image,
IBinaryStreamReader reader,
bool readToEnd,
RecursionProtection protection)
{
var signature = new PropertySignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte(),
};
if (!reader.TryReadCompressedUInt32(out uint paramCount))
{
return(null);
}
signature.PropertyType = TypeSignature.FromReader(image, reader, false, protection);
for (int i = 0; i < paramCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(image, reader, protection));
}
if (readToEnd)
{
signature.ExtraData = reader.ReadToEnd();
}
return(signature);
}
private static CallingConventionSignature ReadSignature(
ModuleDefinition module,
IBinaryStreamReader reader,
RecursionProtection protection)
{
byte flag = reader.ReadByte();
reader.FileOffset--;
switch ((CallingConventionAttributes)flag & SignatureTypeMask)
{
case CallingConventionAttributes.Default:
case CallingConventionAttributes.C:
case CallingConventionAttributes.ExplicitThis:
case CallingConventionAttributes.FastCall:
case CallingConventionAttributes.StdCall:
case CallingConventionAttributes.ThisCall:
case CallingConventionAttributes.VarArg:
return(MethodSignature.FromReader(module, reader, protection));
case CallingConventionAttributes.Property:
return(PropertySignature.FromReader(module, reader, protection));
case CallingConventionAttributes.Local:
return(LocalVariablesSignature.FromReader(module, reader, protection));
case CallingConventionAttributes.GenericInstance:
return(GenericInstanceMethodSignature.FromReader(module, reader, protection));
case CallingConventionAttributes.Field:
return(FieldSignature.FromReader(module, reader, protection));
}
throw new NotSupportedException();
}
/// <summary>
/// Reads a single generic instance type signature at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the signature was defined in.</param>
/// <param name="reader">The reader to use.</param>
/// <param name="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read signature.</returns>
public static GenericInstanceTypeSignature FromReader(
MetadataImage image,
IBinaryStreamReader reader,
RecursionProtection protection)
{
if (!reader.CanRead(sizeof(byte)))
{
return(null);
}
var elementType = (ElementType)reader.ReadByte();
var type = ReadTypeDefOrRef(image, reader, protection);
var signature = new GenericInstanceTypeSignature(type)
{
IsValueType = elementType == ElementType.ValueType
};
if (!reader.TryReadCompressedUInt32(out uint count))
{
return(signature);
}
for (int i = 0; i < count; i++)
{
signature.GenericArguments.Add(TypeSignature.FromReader(image, reader, false, protection));
}
return(signature);
}
public static new MethodSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
if (!reader.CanRead(sizeof (byte)))
return null;
var signature = new MethodSignature
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte()
};
if (signature.IsGeneric)
{
uint genericParameterCount;
if (!reader.TryReadCompressedUInt32(out genericParameterCount))
return signature;
signature.GenericParameterCount = (int)genericParameterCount;
}
uint parameterCount;
if (!reader.TryReadCompressedUInt32(out parameterCount))
return signature;
signature.ReturnType = TypeSignature.FromReader(header, reader);
for (int i = 0; i < parameterCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(header, reader));
}
return signature;
}
public static PermissionSetSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new PermissionSetSignature()
{
StartOffset = reader.Position
};
var signatureHeader = reader.ReadByte();
if (signatureHeader != '.')
{
throw new ArgumentException("Signature doesn't refer to a valid permission set signature.");
}
uint attributeCount;
if (!reader.TryReadCompressedUInt32(out attributeCount))
{
return(signature);
}
for (int i = 0; i < attributeCount; i++)
{
signature.Attributes.Add(SecurityAttributeSignature.FromReader(header, reader));
}
return(signature);
}
public static new GenericInstanceTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
if (!reader.CanRead(sizeof (byte)))
return null;
long position = reader.Position;
var elementType = (ElementType)reader.ReadByte();
var type = ReadTypeDefOrRef(header, reader);
var signature = new GenericInstanceTypeSignature(type)
{
StartOffset = position,
IsValueType = elementType == ElementType.ValueType
};
uint count;
if (!reader.TryReadCompressedUInt32(out count))
return signature;
for (int i = 0; i < count; i++)
signature.GenericArguments.Add(TypeSignature.FromReader(header, reader));
return signature;
}
/// <summary>
/// Reads a single field signature from an input stream.
/// </summary>
/// <param name="module">The module containing the signature.</param>
/// <param name="reader">The blob input stream.</param>
/// <param name="protection">The object responsible for detecting infinite recursion.</param>
/// <returns>The field signature.</returns>
public static FieldSignature FromReader(ModuleDefinition module, IBinaryStreamReader reader,
RecursionProtection protection)
{
return(new FieldSignature(
(CallingConventionAttributes)reader.ReadByte(),
TypeSignature.FromReader(module, reader, protection)));
}
public static CallingConventionSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
var flag = reader.ReadByte();
reader.Position--;
switch ((CallingConventionAttributes)flag & SignatureTypeMask)
{
case CallingConventionAttributes.Default:
case CallingConventionAttributes.C:
case CallingConventionAttributes.ExplicitThis:
case CallingConventionAttributes.FastCall:
case CallingConventionAttributes.StdCall:
case CallingConventionAttributes.ThisCall:
case CallingConventionAttributes.VarArg:
return(MethodSignature.FromReader(image, reader));
case CallingConventionAttributes.Property:
return(PropertySignature.FromReader(image, reader));
case CallingConventionAttributes.Local:
return(LocalVariableSignature.FromReader(image, reader));
case CallingConventionAttributes.GenericInstance:
return(GenericInstanceMethodSignature.FromReader(image, reader));
case CallingConventionAttributes.Field:
return(FieldSignature.FromReader(image, reader));
}
throw new NotSupportedException();
}
private static TypeSignature ReadTypeSignature(
MetadataImage image,
IBinaryStreamReader reader,
RecursionProtection protection)
{
var elementType = (ElementType)reader.ReadByte();
switch (elementType)
{
case ElementType.Array:
return(ArrayTypeSignature.FromReader(image, reader, protection));
case ElementType.Boxed:
return(BoxedTypeSignature.FromReader(image, reader, protection));
case ElementType.ByRef:
return(ByReferenceTypeSignature.FromReader(image, reader, protection));
case ElementType.CModOpt:
return(OptionalModifierSignature.FromReader(image, reader, protection));
case ElementType.CModReqD:
return(RequiredModifierSignature.FromReader(image, reader, protection));
case ElementType.Class:
return(TypeDefOrRefSignature.FromReader(image, reader, protection));
case ElementType.FnPtr:
return(FunctionPointerTypeSignature.FromReader(image, reader, protection));
case ElementType.GenericInst:
return(GenericInstanceTypeSignature.FromReader(image, reader, protection));
case ElementType.MVar:
return(GenericParameterSignature.FromReader(image, reader, GenericParameterType.Method));
case ElementType.Pinned:
return(PinnedTypeSignature.FromReader(image, reader, protection));
case ElementType.Ptr:
return(PointerTypeSignature.FromReader(image, reader, protection));
case ElementType.Sentinel:
return(SentinelTypeSignature.FromReader(image, reader, protection));
case ElementType.SzArray:
return(SzArrayTypeSignature.FromReader(image, reader, protection));
case ElementType.ValueType:
var type = TypeDefOrRefSignature.FromReader(image, reader, protection);
type.IsValueType = true;
return(type);
case ElementType.Var:
return(GenericParameterSignature.FromReader(image, reader, GenericParameterType.Type));
default:
return(MsCorLibTypeSignature.FromElementType(image, elementType));
}
}
public new static FieldSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
return(new FieldSignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte(),
FieldType = TypeSignature.FromReader(image, reader),
});
}
public static TypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var elementType = (ElementType)reader.ReadByte();
switch (elementType)
{
case ElementType.Array:
return(ArrayTypeSignature.FromReader(header, reader));
case ElementType.Boxed:
return(BoxedTypeSignature.FromReader(header, reader));
case ElementType.ByRef:
return(ByReferenceTypeSignature.FromReader(header, reader));
case ElementType.CModOpt:
return(OptionalModifierSignature.FromReader(header, reader));
case ElementType.CModReqD:
return(RequiredModifierSignature.FromReader(header, reader));
case ElementType.Class:
return(TypeDefOrRefSignature.FromReader(header, reader));
case ElementType.FnPtr:
return(FunctionPointerTypeSignature.FromReader(header, reader));
case ElementType.GenericInst:
return(GenericInstanceTypeSignature.FromReader(header, reader));
case ElementType.MVar:
return(GenericParameterSignature.FromReader(header, reader, GenericParameterType.Method));
case ElementType.Pinned:
return(PinnedTypeSignature.FromReader(header, reader));
case ElementType.Ptr:
return(PointerTypeSignature.FromReader(header, reader));
case ElementType.Sentinel:
return(SentinelTypeSignature.FromReader(header, reader));
case ElementType.SzArray:
return(SzArrayTypeSignature.FromReader(header, reader));
case ElementType.ValueType:
var type = TypeDefOrRefSignature.FromReader(header, reader);
type.IsValueType = true;
return(type);
case ElementType.Var:
return(GenericParameterSignature.FromReader(header, reader, GenericParameterType.Type));
default:
return(MsCorLibTypeSignature.FromElementType(header, elementType));
}
throw new NotSupportedException();
}
/// <summary>
/// Reads an icon group resource entry from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <returns>The parsed group icon resource entry.</returns>
public static IconGroupDirectoryEntry FromReader(IBinaryStreamReader reader)
{
var entry = new IconGroupDirectoryEntry
{
Offset = reader.Offset,
Rva = reader.Rva,
Width = reader.ReadByte(),
Height = reader.ReadByte(),
ColorCount = reader.ReadByte(),
Reserved = reader.ReadByte(),
ColorPlanes = reader.ReadUInt16(),
PixelBitCount = reader.ReadUInt16(),
BytesInRes = reader.ReadUInt32(),
Id = reader.ReadUInt16()
};
return(entry);
}
public static new FieldSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
return new FieldSignature
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte(),
FieldType = TypeSignature.FromReader(header, reader),
};
}
public new static FieldSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
return(new FieldSignature
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte(),
FieldType = TypeSignature.FromReader(header, reader),
});
}
public new static CilRawSmallMethodBody FromReader(IBinaryStreamReader reader)
{
int codeSize = reader.ReadByte() >> 2;
return(new CilRawSmallMethodBody
{
Code = reader.ReadBytes(codeSize)
});
}
/// <summary>
/// Reads a compressed unsigned integer from the stream.
/// </summary>
/// <param name="reader">The reader to use for reading the data.</param>
/// <returns>The unsigned integer that was read from the stream.</returns>
public static uint ReadCompressedUInt32(this IBinaryStreamReader reader)
{
var firstByte = reader.ReadByte();
if ((firstByte & 0x80) == 0)
{
return(firstByte);
}
if ((firstByte & 0x40) == 0)
{
return((uint)(((firstByte & 0x7F) << 8) | reader.ReadByte()));
}
return((uint)(((firstByte & 0x3F) << 0x18) |
(reader.ReadByte() << 0x10) |
(reader.ReadByte() << 0x08) |
reader.ReadByte()));
}
public new static SafeArrayMarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var descriptor = new SafeArrayMarshalDescriptor();
if (reader.CanRead((sizeof(byte))))
{
descriptor.ElementType = (VariantType)reader.ReadByte();
}
return(descriptor);
}
/// <summary>
/// Reads and verifies the blob header at the provided input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="expectedType">The expected structure type to read.</param>
/// <param name="expectedVersion">The expected structure version to read.</param>
/// <param name="expectedAlgorithm">The expected algorithm.</param>
/// <exception cref="FormatException">Occurs when the input stream is not in the correct format.</exception>
/// <exception cref="NotSupportedException">Occurs when an invalid or unsupported algorithm is specified.</exception>
protected static void ReadBlobHeader(IBinaryStreamReader reader,
StrongNameKeyStructureType expectedType,
byte expectedVersion,
SignatureAlgorithm expectedAlgorithm)
{
// Read RSAPUBKEY
if ((StrongNameKeyStructureType)reader.ReadByte() != expectedType)
{
throw new FormatException("Input stream does not contain the expected structure type.");
}
if (reader.ReadByte() != expectedVersion)
{
throw new NotSupportedException("Invalid or unsupported public/private key pair structure version number.");
}
reader.ReadUInt16();
if ((SignatureAlgorithm)reader.ReadUInt32() != expectedAlgorithm)
{
throw new NotSupportedException("Invalid or unsupported public key algorithm.");
}
}
/// <summary>
/// Reads a single named argument from the input stream.
/// </summary>
/// <param name="parentModule">The module the argument is residing in.</param>
/// <param name="reader">The input stream.</param>
/// <returns>The argument.</returns>
public static CustomAttributeNamedArgument FromReader(ModuleDefinition parentModule, IBinaryStreamReader reader)
{
var result = new CustomAttributeNamedArgument
{
MemberType = (CustomAttributeArgumentMemberType)reader.ReadByte(),
ArgumentType = TypeSignature.ReadFieldOrPropType(parentModule, reader),
MemberName = reader.ReadSerString(),
};
result.Argument = CustomAttributeArgument.FromReader(parentModule, result.ArgumentType, reader);
return(result);
}
public static new SafeArrayMarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var descriptor = new SafeArrayMarshalDescriptor()
{
StartOffset = reader.Position,
};
if (reader.CanRead((sizeof (byte))))
descriptor.ElementType = (VariantType)reader.ReadByte();
return descriptor;
}
/// <summary>
/// Reads a single field signature at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the field is defined in.</param>
/// <param name="reader">The reader to use.</param>
/// <param name="readToEnd">Determines whether any extra data after the signature should be read and
/// put into the <see cref="ExtendableBlobSignature.ExtraData"/> property.</param>
/// <param name="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read signature.</returns>
public new static FieldSignature FromReader(
MetadataImage image,
IBinaryStreamReader reader,
bool readToEnd,
RecursionProtection protection)
{
return(new FieldSignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte(),
FieldType = TypeSignature.FromReader(image, reader, false, protection),
ExtraData = readToEnd ? reader.ReadToEnd() : null
});
}
public static new ArrayMarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var descriptor = new ArrayMarshalDescriptor((NativeType) reader.ReadByte());
uint value;
if (!reader.TryReadCompressedUInt32(out value))
return descriptor;
descriptor.ParameterIndex = (int)value;
if (!reader.TryReadCompressedUInt32(out value))
return descriptor;
descriptor.NumberOfElements = (int)value;
return descriptor;
}
public static uint ReadCompressedUInt(IBinaryStreamReader reader)
{
uint num = 0;
var shift = 0;
byte current;
do
{
current = reader.ReadByte();
num |= (current & 0x7fu) << shift;
shift += 7;
} while((current & 0x80) != 0);
return(num);
}
private static object ReadRawOperand(IBinaryStreamReader reader, CilOperandType cilOperandType)
{
switch (cilOperandType)
{
case CilOperandType.InlineNone:
return(null);
case CilOperandType.InlineArgument:
case CilOperandType.InlineVar:
return(reader.ReadUInt16());
case CilOperandType.InlineI:
case CilOperandType.InlineBrTarget:
return(reader.ReadInt32());
case CilOperandType.ShortInlineArgument:
case CilOperandType.ShortInlineVar:
return(reader.ReadByte());
case CilOperandType.ShortInlineBrTarget:
case CilOperandType.ShortInlineI:
return(reader.ReadSByte());
case CilOperandType.ShortInlineR:
return(reader.ReadSingle());
case CilOperandType.InlineR:
return(reader.ReadDouble());
case CilOperandType.InlineI8:
return(reader.ReadInt64());
case CilOperandType.InlineField:
case CilOperandType.InlineMethod:
case CilOperandType.InlineSig:
case CilOperandType.InlineTok:
case CilOperandType.InlineType:
case CilOperandType.InlineString:
return(new MetadataToken(reader.ReadUInt32()));
case CilOperandType.InlineSwitch:
var offsets = new int[reader.ReadUInt32()];
for (int i = 0; i < offsets.Length; i++)
{
offsets[i] = reader.ReadInt32();
}
return(offsets);
}
throw new NotSupportedException();
}
public static new LocalVariableSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new LocalVariableSignature()
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte()
};
var count = reader.ReadCompressedUInt32();
for (int i = 0; i < count; i++)
signature.Variables.Add(VariableSignature.FromReader(header, reader));
return signature;
}
public static CustomAttributeNamedArgument FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new CustomAttributeNamedArgument
{
StartOffset = reader.Position,
ArgumentMemberType =
(reader.CanRead(sizeof (byte))
? (CustomAttributeArgumentMemberType)reader.ReadByte()
: CustomAttributeArgumentMemberType.Field),
ArgumentType = TypeSignature.ReadFieldOrPropType(header, reader),
MemberName = reader.ReadSerString(),
};
signature.Argument = CustomAttributeArgument.FromReader(header, signature.ArgumentType, reader);
return signature;
}
public static TypeSignature ReadFieldOrPropType(MetadataHeader header, IBinaryStreamReader reader)
{
var elementType = (ElementType)reader.ReadByte();
switch (elementType)
{
case ElementType.Boxed:
return header.TypeSystem.Object;
case ElementType.SzArray:
return new SzArrayTypeSignature(ReadFieldOrPropType(header, reader));
case ElementType.Enum:
return FromAssemblyQualifiedName(header, reader.ReadSerString());
default:
return MsCorLibTypeSignature.FromElementType(header, elementType);
}
}
public static new FixedArrayMarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var descriptor = new FixedArrayMarshalDescriptor()
{
StartOffset = reader.Position,
};
uint value;
if (!reader.TryReadCompressedUInt32(out value))
return descriptor;
descriptor.NumberOfElements = (int)value;
if (reader.CanRead(sizeof(byte)))
descriptor.ElementType = (NativeType)reader.ReadByte();
return descriptor;
}
public static new GenericInstanceMethodSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new GenericInstanceMethodSignature()
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte()
};
uint count;
if (!reader.TryReadCompressedUInt32(out count))
return signature;
for (int i = 0; i < count; i++)
signature.GenericArguments.Add(TypeSignature.FromReader(header, reader));
return signature;
}
public static MarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var type = (NativeType)reader.ReadByte();
switch (type)
{
case NativeType.Array:
return ArrayMarshalDescriptor.FromReader(reader);
case NativeType.FixedArray:
return FixedArrayMarshalDescriptor.FromReader(reader);
case NativeType.SafeArray:
return SafeArrayMarshalDescriptor.FromReader(reader);
case NativeType.CustomMarshaler:
return CustomMarshalDescriptor.FromReader(reader);
default:
return new SimpleMarshalDescriptor(type);
}
}
private static object ReadRawOperand(IBinaryStreamReader reader, MsilOperandType msilOperandType)
{
switch (msilOperandType)
{
case MsilOperandType.InlineNone:
return null;
case MsilOperandType.InlineArgument:
case MsilOperandType.InlineVar:
return reader.ReadUInt16();
case MsilOperandType.InlineI:
case MsilOperandType.InlineBrTarget:
return reader.ReadInt32();
case MsilOperandType.ShortInlineArgument:
case MsilOperandType.ShortInlineVar:
return reader.ReadByte();
case MsilOperandType.ShortInlineBrTarget:
case MsilOperandType.ShortInlineI:
return reader.ReadSByte();
case MsilOperandType.ShortInlineR:
return reader.ReadSingle();
case MsilOperandType.InlineR:
return reader.ReadDouble();
case MsilOperandType.InlineI8:
return reader.ReadInt64();
case MsilOperandType.InlineField :
case MsilOperandType.InlineMethod :
case MsilOperandType.InlineSig:
case MsilOperandType.InlineTok:
case MsilOperandType.InlineType:
case MsilOperandType.InlineString:
return new MetadataToken(reader.ReadUInt32());
case MsilOperandType.InlineSwitch:
var offsets = new int[reader.ReadUInt32()];
for (int i = 0; i < offsets.Length; i++)
offsets[i] = reader.ReadInt32();
return offsets;
}
throw new NotSupportedException();
}
public static PermissionSetSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new PermissionSetSignature()
{
StartOffset = reader.Position
};
var signatureHeader = reader.ReadByte();
if (signatureHeader != '.')
throw new ArgumentException("Signature doesn't refer to a valid permission set signature.");
uint attributeCount;
if (!reader.TryReadCompressedUInt32(out attributeCount))
return signature;
for (int i = 0; i < attributeCount; i++)
signature.Attributes.Add(SecurityAttributeSignature.FromReader(header, reader));
return signature;
}
public static new PropertySignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new PropertySignature
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte(),
};
uint paramCount;
if (!reader.TryReadCompressedUInt32(out paramCount))
return null;
signature.PropertyType = TypeSignature.FromReader(header, reader);
for (int i = 0; i < paramCount; i++)
signature.Parameters.Add(ParameterSignature.FromReader(header, reader));
return signature;
}
private static TypeSignature ReadTypeSignature(MetadataHeader header, IBinaryStreamReader reader)
{
var elementType = (ElementType) reader.ReadByte();
switch (elementType)
{
case ElementType.Array:
return ArrayTypeSignature.FromReader(header, reader);
case ElementType.Boxed:
return BoxedTypeSignature.FromReader(header, reader);
case ElementType.ByRef:
return ByReferenceTypeSignature.FromReader(header, reader);
case ElementType.CModOpt:
return OptionalModifierSignature.FromReader(header, reader);
case ElementType.CModReqD:
return RequiredModifierSignature.FromReader(header, reader);
case ElementType.Class:
return TypeDefOrRefSignature.FromReader(header, reader);
case ElementType.FnPtr:
return FunctionPointerTypeSignature.FromReader(header, reader);
case ElementType.GenericInst:
return GenericInstanceTypeSignature.FromReader(header, reader);
case ElementType.MVar:
return GenericParameterSignature.FromReader(header, reader, GenericParameterType.Method);
case ElementType.Pinned:
return PinnedTypeSignature.FromReader(header, reader);
case ElementType.Ptr:
return PointerTypeSignature.FromReader(header, reader);
case ElementType.Sentinel:
return SentinelTypeSignature.FromReader(header, reader);
case ElementType.SzArray:
return SzArrayTypeSignature.FromReader(header, reader);
case ElementType.ValueType:
var type = TypeDefOrRefSignature.FromReader(header, reader);
type.IsValueType = true;
return type;
case ElementType.Var:
return GenericParameterSignature.FromReader(header, reader, GenericParameterType.Type);
default:
return MsCorLibTypeSignature.FromElementType(header, elementType);
}
}
private static object ReadValue(MetadataHeader header, TypeSignature typeSignature, IBinaryStreamReader reader)
{
switch (typeSignature.ElementType)
{
case ElementType.Boolean:
return reader.ReadByte() == 1;
case ElementType.Char:
return (char)reader.ReadUInt16();
case ElementType.R4:
return reader.ReadSingle();
case ElementType.R8:
return reader.ReadDouble();
case ElementType.I1:
return reader.ReadSByte();
case ElementType.I2:
return reader.ReadInt16();
case ElementType.I4:
return reader.ReadInt32();
case ElementType.I8:
return reader.ReadInt64();
case ElementType.U1:
return reader.ReadByte();
case ElementType.U2:
return reader.ReadUInt16();
case ElementType.U4:
return reader.ReadUInt32();
case ElementType.U8:
return reader.ReadUInt64();
case ElementType.String:
return reader.ReadSerString();
case ElementType.Object:
return ReadValue(header, TypeSignature.ReadFieldOrPropType(header, reader), reader);
case ElementType.Class:
case ElementType.Enum:
case ElementType.ValueType:
var enumTypeDef = header.MetadataResolver.ResolveType(typeSignature);
if (enumTypeDef == null)
throw new MemberResolutionException(typeSignature);
if (enumTypeDef.IsEnum)
return ReadValue(header, enumTypeDef.GetEnumUnderlyingType(), reader);
break;
}
if (typeSignature.IsTypeOf("System", "Type"))
return TypeSignature.FromAssemblyQualifiedName(header, reader.ReadSerString());
throw new NotSupportedException("Unsupported element type " + typeSignature.ElementType);
}
public static CallingConventionSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var flag = reader.ReadByte();
reader.Position--;
switch ((CallingConventionAttributes)flag & SignatureTypeMask)
{
case CallingConventionAttributes.Default:
case CallingConventionAttributes.C:
case CallingConventionAttributes.ExplicitThis:
case CallingConventionAttributes.FastCall:
case CallingConventionAttributes.StdCall:
case CallingConventionAttributes.ThisCall:
case CallingConventionAttributes.VarArg:
return MethodSignature.FromReader(header, reader);
case CallingConventionAttributes.Property:
return PropertySignature.FromReader(header, reader);
case CallingConventionAttributes.Local:
return LocalVariableSignature.FromReader(header, reader);
case CallingConventionAttributes.GenericInstance:
return GenericInstanceMethodSignature.FromReader(header, reader);
case CallingConventionAttributes.Field:
return FieldSignature.FromReader(header, reader);
}
throw new NotSupportedException();
}
public static ExceptionHandler FromReader(MethodBody methodBody, IBinaryStreamReader reader, bool fatFormat)
{
var offset = reader.Position;
var handerType = fatFormat ? reader.ReadUInt32() : reader.ReadUInt16();
var tryOffset = fatFormat ? reader.ReadInt32() : reader.ReadUInt16();
var tryLength = fatFormat ? reader.ReadInt32() : reader.ReadByte();
var handlerOffset = fatFormat ? reader.ReadInt32() : reader.ReadUInt16();
var handlerLength = fatFormat ? reader.ReadInt32() : reader.ReadByte();
var classTokenOrFilterOffset = reader.ReadUInt32();
var handler = new ExceptionHandler((ExceptionHandlerType)handerType)
{
StartOffset = offset,
IsFat = fatFormat,
TryStart = methodBody.GetInstructionByOffset(tryOffset),
TryEnd = methodBody.GetInstructionByOffset(tryOffset + tryLength),
HandlerStart = methodBody.GetInstructionByOffset(handlerOffset),
HandlerEnd = methodBody.GetInstructionByOffset(handlerOffset + handlerLength),
};
switch (handler.HandlerType)
{
case ExceptionHandlerType.Exception:
handler.CatchType = (ITypeDefOrRef)((IOperandResolver)methodBody).ResolveMember(new MetadataToken(classTokenOrFilterOffset));
break;
case ExceptionHandlerType.Filter:
handler.FilterStart = methodBody.GetInstructionByOffset((int)classTokenOrFilterOffset);
break;
}
return handler;
}
