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