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 static ParameterSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
return(new ParameterSignature
{
ParameterType = TypeSignature.FromReader(header, reader),
});
}
public static CustomAttributeArgument FromReader(MetadataHeader header, TypeSignature typeSignature, IBinaryStreamReader reader)
{
var signature = new CustomAttributeArgument()
{
StartOffset = reader.Position,
ArgumentType = typeSignature
};
if (typeSignature.ElementType != ElementType.SzArray)
{
signature.Elements.Add(ElementSignature.FromReader(header, typeSignature, reader));
}
else
{
var arrayType = ((SzArrayTypeSignature)typeSignature).BaseType;
var elementCount = reader.CanRead(sizeof (uint)) ? reader.ReadUInt32() : uint.MaxValue;
if (elementCount != uint.MaxValue)
{
for (uint i = 0; i < elementCount; i++)
{
signature.Elements.Add(ElementSignature.FromReader(header, arrayType, reader));
}
}
}
return signature;
}
/// <summary>
/// Reads a single custom attribute argument at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the argument was defined in.</param>
/// <param name="typeSignature">The type of the argument to read.</param>
/// <param name="reader">The reader to use.</param>
/// <returns>The read argument.</returns>
public static CustomAttributeArgument FromReader(
MetadataImage image,
TypeSignature typeSignature,
IBinaryStreamReader reader)
{
var signature = new CustomAttributeArgument
{
ArgumentType = typeSignature
};
if (typeSignature.ElementType != ElementType.SzArray)
{
signature.Elements.Add(ElementSignature.FromReader(image, typeSignature, reader));
}
else
{
var arrayType = ((SzArrayTypeSignature)typeSignature).BaseType;
var elementCount = reader.CanRead(sizeof(uint)) ? reader.ReadUInt32() : uint.MaxValue;
if (elementCount != uint.MaxValue)
{
for (uint i = 0; i < elementCount; i++)
{
signature.Elements.Add(ElementSignature.FromReader(image, arrayType, reader));
}
}
}
return(signature);
}
public static CustomAttributeSignature FromReader(CustomAttribute parent, IBinaryStreamReader reader)
{
long position = reader.Position;
if (!reader.CanRead(sizeof (ushort)) || reader.ReadUInt16() != 0x0001)
throw new ArgumentException("Signature doesn't refer to a valid custom attribute signature.");
var signature = new CustomAttributeSignature()
{
StartOffset = position,
};
if (parent.Constructor != null)
{
var methodSignature = parent.Constructor.Signature as MethodSignature;
if (methodSignature != null)
{
foreach (var parameter in methodSignature.Parameters)
{
signature.FixedArguments.Add(CustomAttributeArgument.FromReader(parent.Header,
parameter.ParameterType, reader));
}
}
}
var namedElementCount = reader.CanRead(sizeof (ushort)) ? reader.ReadUInt16() : 0;
for (uint i = 0; i < namedElementCount; i++)
{
signature.NamedArguments.Add(CustomAttributeNamedArgument.FromReader(parent.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;
}
public new static OptionalModifierSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
long position = reader.Position;
return(new OptionalModifierSignature(ReadTypeDefOrRef(image, reader),
TypeSignature.FromReader(image, reader)));
}
/// <summary>
/// Reads a single custom attribute row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the custom attribute table.</param>
/// <returns>The row.</returns>
public static CustomAttributeRow FromReader(IBinaryStreamReader reader, TableLayout layout)
{
return(new CustomAttributeRow(
reader.ReadIndex((IndexSize)layout.Columns[0].Size),
reader.ReadIndex((IndexSize)layout.Columns[1].Size),
reader.ReadIndex((IndexSize)layout.Columns[2].Size)));
}
/// <summary>
/// Reads a single security attribute 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>
/// <returns>The read attribute.</returns>
public static SecurityAttributeSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
var signature = new SecurityAttributeSignature
{
TypeName = reader.ReadSerString(),
};
reader.ReadCompressedUInt32();
if (!reader.TryReadCompressedUInt32(out uint argumentCount))
{
return(signature);
}
if (argumentCount == 0)
{
return(signature);
}
for (int i = 0; i < argumentCount; i++)
{
signature.NamedArguments.Add(CustomAttributeNamedArgument.FromReader(image, reader));
}
return(signature);
}
protected string ReadString(IBinaryStreamReader reader)
{
var offset = (uint)(reader.Position - reader.StartPosition);
string value;
if (_cachedStrings.TryGetValue(offset, out value))
{
reader.Position += 1 + Encoding.Unicode.GetByteCount(value) + 1;
}
else
{
var length = reader.ReadCompressedUInt32();
if (length <= 0)
{
return(string.Empty);
}
value = Encoding.Unicode.GetString(reader.ReadBytes((int)length - 1));
reader.Position++;
_cachedStrings.Add(offset, value);
}
return(value);
}
/// <summary>
/// Reads a module import entry from an input stream.
/// </summary>
/// <param name="context">The reader context.</param>
/// <param name="reader">The input stream.</param>
public SerializedImportedModule(PEReaderContext context, IBinaryStreamReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
_context = context ?? throw new ArgumentNullException(nameof(context));
_lookupRva = reader.ReadUInt32();
TimeDateStamp = reader.ReadUInt32();
ForwarderChain = reader.ReadUInt32();
uint nameRva = reader.ReadUInt32();
_addressRva = reader.ReadUInt32();
if (nameRva != 0)
{
if (_context.File.TryCreateReaderAtRva(nameRva, out var nameReader))
{
Name = nameReader.ReadAsciiString();
}
else
{
_context.BadImage("Import module contains an invalid name RVA.");
}
}
}
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);
}
/// <summary>
/// Reads a new resource directory entry from the reader.
/// </summary>
/// <param name="context">The containing PE file.</param>
/// <param name="reader">The input stream to read from.</param>
public ResourceDirectoryEntry(PEReaderContext context, IBinaryStreamReader reader)
{
_idOrNameOffset = reader.ReadUInt32();
_dataOrSubDirOffset = reader.ReadUInt32();
Name = null;
if (IsByName)
{
uint baseRva = context.File.OptionalHeader
.GetDataDirectory(DataDirectoryIndex.ResourceDirectory)
.VirtualAddress;
if (!context.File.TryCreateReaderAtRva(baseRva + IdOrNameOffset, out var nameReader))
{
context.Parameters.ErrorListener.BadImage("Resource directory entry contains an invalid name RVA.");
return;
}
int length = nameReader.ReadUInt16() * 2;
var data = new byte[length];
length = nameReader.ReadBytes(data, 0, length);
Name = Encoding.Unicode.GetString(data, 0, length);
}
}
/// <summary>
/// Reads a single field definition row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the field definition table.</param>
/// <returns>The row.</returns>
public static FieldDefinitionRow FromReader(IBinaryStreamReader reader, TableLayout layout)
{
return(new FieldDefinitionRow(
(FieldAttributes)reader.ReadUInt16(),
reader.ReadIndex((IndexSize)layout.Columns[1].Size),
reader.ReadIndex((IndexSize)layout.Columns[2].Size)));
}
/// <summary>
/// Reads a single assembly operating system row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the assembly operating system table.</param>
/// <returns>The row.</returns>
public static AssemblyOSRow FromReader(IBinaryStreamReader reader, TableLayout layout)
{
return(new AssemblyOSRow(
reader.ReadUInt32(),
reader.ReadUInt32(),
reader.ReadUInt32()));
}
/// <summary>
/// Reads a DOS header structure at the current position of the provided input stream.
/// </summary>
/// <param name="reader">The input stream to read from.</param>
/// <returns>The read DOS header.</returns>
/// <exception cref="BadImageFormatException">Occurs when the input stream does not point to a valid DOS header.</exception>
public static DosHeader FromReader(IBinaryStreamReader reader)
{
ulong offset = reader.Offset;
uint rva = reader.Rva;
var stub = new byte[DefaultNewHeaderOffset];
ushort magic = reader.ReadUInt16();
if (magic != ValidPEMagic)
{
throw new BadImageFormatException();
}
reader.Offset += NextHeaderFieldOffset - 2;
uint nextHeaderOffset = reader.ReadUInt32();
if (nextHeaderOffset != DefaultNewHeaderOffset)
{
Array.Resize(ref stub, (int)nextHeaderOffset);
}
reader.Offset -= NextHeaderFieldOffset + 4;
reader.ReadBytes(stub, 0, stub.Length);
return(new DosHeader(stub)
{
Offset = offset,
Rva = rva,
NextHeaderOffset = nextHeaderOffset
});
}
/// <summary>
/// Reads a .NET directory from an input stream.
/// </summary>
/// <param name="peFile">The PE file containing the .NET directory.</param>
/// <param name="reader">The input stream.</param>
/// <param name="metadataStreamReader"></param>
/// <exception cref="ArgumentNullException">Occurs when any of the arguments are <c>null</c>.</exception>
public SerializedDotNetDirectory(IPEFile peFile, IBinaryStreamReader reader,
IMetadataStreamReader metadataStreamReader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
_peFile = peFile ?? throw new ArgumentNullException(nameof(peFile));
_metadataStreamReader = metadataStreamReader;
Offset = reader.Offset;
uint cb = reader.ReadUInt32();
MajorRuntimeVersion = reader.ReadUInt16();
MinorRuntimeVersion = reader.ReadUInt16();
_metadataDirectory = DataDirectory.FromReader(reader);
Flags = (DotNetDirectoryFlags)reader.ReadUInt32();
Entrypoint = reader.ReadUInt32();
_resourcesDirectory = DataDirectory.FromReader(reader);
_strongNameDirectory = DataDirectory.FromReader(reader);
_codeManagerDirectory = DataDirectory.FromReader(reader);
_vtableFixupsDirectory = DataDirectory.FromReader(reader);
_exportsDirectory = DataDirectory.FromReader(reader);
_nativeHeaderDirectory = DataDirectory.FromReader(reader);
}
public new static CilRawFatMethodBody FromReader(IBinaryStreamReader reader)
{
var body = new CilRawFatMethodBody
{
_header = reader.ReadUInt16(),
MaxStack = reader.ReadUInt16()
};
int codeSize = reader.ReadInt32();
body.LocalVarSigToken = reader.ReadUInt32();
body.Code = reader.ReadBytes(codeSize);
if (body.HasSections)
{
reader.Align(4);
CilExtraSection section;
do
{
section = CilExtraSection.FromReader(reader);
body.ExtraSections.Add(section);
} while (section.HasMoreSections);
}
return(body);
}
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 pinned type 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="protection">The recursion protection that is used to detect malicious loops in the metadata.</param>
/// <returns>The read signature.</returns>
public static PinnedTypeSignature FromReader(
MetadataImage image,
IBinaryStreamReader reader,
RecursionProtection protection)
{
return(new PinnedTypeSignature(TypeSignature.FromReader(image, reader, false, protection)));
}
/// <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 TypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
long position = reader.Position;
var signature = ReadTypeSignature(header, reader);
signature.StartOffset = position;
return signature;
}
public X86Disassembler(IBinaryStreamReader reader, long baseAddress)
{
if (reader == null)
throw new ArgumentNullException("reader");
_reader = reader;
BaseAddress = baseAddress;
}
/// <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 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 CustomAttributeSignature FromReader(CustomAttribute parent, IBinaryStreamReader reader)
{
if (!reader.CanRead(sizeof(ushort)) || reader.ReadUInt16() != 0x0001)
{
throw new ArgumentException("Signature doesn't refer to a valid custom attribute signature.");
}
var signature = new CustomAttributeSignature();
if (parent.Constructor != null)
{
var methodSignature = parent.Constructor.Signature as MethodSignature;
if (methodSignature != null)
{
foreach (var parameter in methodSignature.Parameters)
{
signature.FixedArguments.Add(CustomAttributeArgument.FromReader(parent.Image, parameter.ParameterType, reader));
}
}
}
var namedElementCount = reader.CanRead(sizeof(ushort)) ? reader.ReadUInt16() : 0;
for (uint i = 0; i < namedElementCount; i++)
{
signature.NamedArguments.Add(CustomAttributeNamedArgument.FromReader(parent.Image, reader));
}
return(signature);
}
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();
}
/// <summary>
/// Reads a single file row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the file table.</param>
/// <returns>The row.</returns>
public static FileReferenceRow FromReader(IBinaryStreamReader reader, TableLayout layout)
{
return(new FileReferenceRow(
(FileAttributes)reader.ReadUInt32(),
reader.ReadIndex((IndexSize)layout.Columns[1].Size),
reader.ReadIndex((IndexSize)layout.Columns[2].Size)));
}
/// <summary>
/// Reads a single class layout row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the class layout table.</param>
/// <returns>The row.</returns>
public static ClassLayoutRow FromReader(IBinaryStreamReader reader, TableLayout layout)
{
return(new ClassLayoutRow(
reader.ReadUInt16(),
reader.ReadUInt32(),
reader.ReadIndex((IndexSize)layout.Columns[2].Size)));
}
/// <summary>
/// Reads a single security declaration row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the security declaration table.</param>
/// <returns>The row.</returns>
public static SecurityDeclarationRow FromReader(IBinaryStreamReader reader, TableLayout layout)
{
return(new SecurityDeclarationRow(
(SecurityAction)reader.ReadUInt16(),
reader.ReadIndex((IndexSize)layout.Columns[1].Size),
reader.ReadIndex((IndexSize)layout.Columns[2].Size)));
}
/// <summary>
/// Reads a version resource from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <returns>The parsed version resource.</returns>
/// <exception cref="FormatException">
/// Occurs when the input stream does not point to a valid version resource.
/// </exception>
public static VersionInfoResource FromReader(IBinaryStreamReader reader)
{
uint start = reader.FileOffset;
// Read header.
var header = VersionTableEntryHeader.FromReader(reader);
if (header.Key != VsVersionInfoKey)
{
throw new FormatException($"Input stream does not point to a {VsVersionInfoKey} entry.");
}
var result = new VersionInfoResource();
// Read fixed version info.
reader.Align(4);
result.FixedVersionInfo = FixedVersionInfo.FromReader(reader);
// Read children.
while (reader.FileOffset - start < header.Length)
{
reader.Align(4);
result.AddEntry(ReadNextEntry(reader));
}
return(result);
}
/// <summary>
/// Reads a single fixed version info structure from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <returns>The read structure.</returns>
public static FixedVersionInfo FromReader(IBinaryStreamReader reader)
{
var result = new FixedVersionInfo();
result.UpdateOffsets(reader.FileOffset, reader.Rva);
uint signature = reader.ReadUInt32();
if (signature != Signature)
{
throw new FormatException($"Input stream does not point to a valid FixedVersionInfo structure.");
}
uint structVersion = reader.ReadUInt32();
result.FileVersion = ReadVersion(reader);
result.ProductVersion = ReadVersion(reader);
result.FileFlagsMask = (FileFlags)reader.ReadUInt32();
result.FileFlags = (FileFlags)reader.ReadUInt32();
result.FileOS = (FileOS)reader.ReadUInt32();
result.FileType = (FileType)reader.ReadUInt32();
result.FileSubType = (FileSubType)reader.ReadUInt32();
result.FileDate = reader.ReadUInt64();
return(result);
}
/// <summary>
/// Reads a single type reference row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the type reference table.</param>
/// <returns>The row.</returns>
public static TypeReferenceRow FromReader(IBinaryStreamReader reader, TableLayout layout)
{
return(new TypeReferenceRow(
reader.ReadIndex((IndexSize)layout.Columns[0].Size),
reader.ReadIndex((IndexSize)layout.Columns[1].Size),
reader.ReadIndex((IndexSize)layout.Columns[2].Size)));
}
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);
}
/// <summary>
/// Reads a single resource directory from an input stream.
/// </summary>
/// <param name="peFile">The PE file containing the resource.</param>
/// <param name="entry">The entry to read. If this value is <c>null</c>, the root directory is assumed.</param>
/// <param name="directoryReader">The input stream.</param>
/// <param name="depth">
/// The current depth of the resource directory tree structure.
/// If this value exceeds <see cref="MaxDepth"/>, this class will not initialize any entries.
/// </param>
public SerializedResourceDirectory(IPEFile peFile, ResourceDirectoryEntry?entry,
IBinaryStreamReader directoryReader, int depth = 0)
{
_peFile = peFile ?? throw new ArgumentNullException(nameof(peFile));
_depth = depth;
if (entry.HasValue)
{
var value = entry.Value;
if (value.IsByName)
{
Name = value.Name;
}
else
{
Id = value.IdOrNameOffset;
}
}
if (directoryReader != null)
{
Characteristics = directoryReader.ReadUInt32();
TimeDateStamp = directoryReader.ReadUInt32();
MajorVersion = directoryReader.ReadUInt16();
MinorVersion = directoryReader.ReadUInt16();
_namedEntries = directoryReader.ReadUInt16();
_idEntries = directoryReader.ReadUInt16();
_entriesRva = directoryReader.Rva;
directoryReader.Offset =
(directoryReader.Offset + (ulong)((_namedEntries + _idEntries) * ResourceDirectoryEntry.EntrySize));
}
}
/// <summary>
/// Reads a single method semantics row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the method semantics table.</param>
/// <returns>The row.</returns>
public static MethodSemanticsRow FromReader(IBinaryStreamReader reader, TableLayout layout)
{
return(new MethodSemanticsRow(
(MethodSemanticsAttributes)reader.ReadUInt16(),
reader.ReadIndex((IndexSize)layout.Columns[1].Size),
reader.ReadIndex((IndexSize)layout.Columns[2].Size)));
}
public static VariableSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
long position = reader.Position;
return new VariableSignature(TypeSignature.FromReader(header, reader))
{
StartOffset = position
};
}
public static DataBlobSignature FromReader(IBinaryStreamReader reader)
{
long position = reader.Position;
return new DataBlobSignature(reader.ReadBytes((int) reader.Length))
{
StartOffset = position
};
}
public static ElementSignature FromReader(MetadataHeader header, TypeSignature typeSignature, IBinaryStreamReader reader)
{
long position = reader.Position;
return new ElementSignature(ReadValue(header, typeSignature, reader))
{
StartOffset = position
};
}
public static new PinnedTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
long position = reader.StartPosition;
return new PinnedTypeSignature(TypeSignature.FromReader(header, reader))
{
StartOffset = reader.Position,
};
}
public static new FunctionPointerTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
long position = reader.Position;
return new FunctionPointerTypeSignature(MethodSignature.FromReader(header, reader))
{
StartOffset = position
};
}
public static ParameterSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
return new ParameterSignature
{
StartOffset = reader.Position,
ParameterType = TypeSignature.FromReader(header, reader),
};
}
public static new TypeDefOrRefSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
long position = reader.Position;
var type = ReadTypeDefOrRef(header, reader);
return type == null ? null : new TypeDefOrRefSignature(type)
{
StartOffset = position
};
}
public static new OptionalModifierSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
long position = reader.Position;
return new OptionalModifierSignature(ReadTypeDefOrRef(header, reader),
TypeSignature.FromReader(header, reader))
{
StartOffset = position
};
}
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 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;
}
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 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 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 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 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 CustomMarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var descriptor = new CustomMarshalDescriptor()
{
StartOffset = reader.Position
};
Guid guid;
Guid.TryParse(reader.ReadSerString(), out guid);
descriptor.Guid = guid;
descriptor.UnmanagedType = reader.ReadSerString();
descriptor.ManagedType = reader.ReadSerString();
descriptor.Cookie = reader.ReadSerString();
return descriptor;
}
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);
}
}
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 new ArrayTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
long position = reader.Position;
var signature = new ArrayTypeSignature(TypeSignature.FromReader(header, reader))
{
StartOffset = position
};
uint rank;
if (!reader.TryReadCompressedUInt32(out rank))
return signature;
uint numSizes;
if (!reader.TryReadCompressedUInt32(out numSizes))
return signature;
var sizes = new uint[numSizes];
for (int i = 0; i < numSizes; i++)
{
if (!reader.TryReadCompressedUInt32(out sizes[i]))
return signature;
}
uint numLoBounds;
if (!reader.TryReadCompressedUInt32(out numLoBounds))
return signature;
var loBounds = new uint[numLoBounds];
for (int i = 0; i < numLoBounds; i++)
{
if (!reader.TryReadCompressedUInt32(out loBounds[i]))
return signature;
}
for (int i = 0; i < rank; i++)
{
var dimension = new ArrayDimension();
if (i < numSizes)
dimension.Size = (int)sizes[i];
if (i < numLoBounds)
dimension.LowerBound = (int)loBounds[i];
signature.Dimensions.Add(dimension);
}
return signature;
}
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 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;
}
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 SecurityAttributeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new SecurityAttributeSignature()
{
StartOffset = reader.Position,
TypeName = reader.ReadSerString(),
};
reader.ReadCompressedUInt32();
uint argumentCount;
if (!reader.TryReadCompressedUInt32(out argumentCount))
return signature;
if (argumentCount == 0)
return signature;
for (int i = 0; i < argumentCount; i++)
signature.NamedArguments.Add(CustomAttributeNamedArgument.FromReader(header, reader));
return signature;
}
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;
}
