Пример #1
0
		internal IRAssembly(IRAppDomain pAppDomain, CLIFile pCLIFile, bool pCORLibrary, bool pRuntimeLibrary)
		{
			AppDomain = pAppDomain;
			File = pCLIFile;
			CORLibrary = pCORLibrary;
			RuntimeLibrary = pRuntimeLibrary;
		}
Пример #2
0
		public void LoadData(CLIFile pFile)
		{
			int token = 0;
			if (pFile.FieldTable.Length > HasConstantTypeMax16BitRows ||
				pFile.ParamTable.Length > HasConstantTypeMax16BitRows ||
				pFile.PropertyTable.Length > HasConstantTypeMax16BitRows) token = pFile.ReadInt32();
			else token = pFile.ReadUInt16();
			Type = (HasConstantType)(token & HasConstantTypeMask);
			token = (token >> HasConstantTypeBits) - 1;
			if (token >= 0)
			{
				switch (Type)
				{
					case HasConstantType.Field: Field = pFile.FieldTable[token]; break;
					case HasConstantType.Param: Param = pFile.ParamTable[token]; break;
					case HasConstantType.Property: Property = pFile.PropertyTable[token]; break;
					default: throw new BadImageFormatException("HasConstant Type");
				}
			}
		}
Пример #3
0
			public void Read(CLIFile pFile)
			{
				Offset = pFile.ReadUInt32();
				Size = pFile.ReadUInt32();
				Name = pFile.ReadString();
				uint headerSize = (uint)(sizeof(uint) * 2 + (Name.Length + 1));
				if ((headerSize & 0x03) != 0) pFile.mCursor += (int)(4 - (headerSize & 0x03));
			}
Пример #4
0
			public void Read(CLIFile pFile)
			{
				SizeOfHeader = pFile.ReadUInt32();
				MajorRuntimeVersion = pFile.ReadUInt16();
				MinorRuntimeVersion = pFile.ReadUInt16();
				Metadata.Read(pFile);
				Flags = pFile.ReadUInt32();
				EntryPointToken = pFile.ReadUInt32();
				EntryPointRVA = pFile.ReadUInt16();
				Resources.Read(pFile);
				StrongNameSignature.Read(pFile);
				CodeManagerTable.Read(pFile);
				VTableFixups.Read(pFile);
				ExportAddressTableJumps.Read(pFile);
				ManagedNativeHeader.Read(pFile);
			}
Пример #5
0
			public void Read(CLIFile pFile)
			{
				Name = pFile.ReadString(8);
				PhysicalAddress = VirtualSize = pFile.ReadUInt32();
				VirtualAddress = pFile.ReadUInt32();
				SizeOfRawData = pFile.ReadUInt32();
				PointerToRawData = pFile.ReadUInt32();
				PointerToRelocations = pFile.ReadUInt32();
				PointerToLineNumbers = pFile.ReadUInt32();
				NumberOfRelocations = pFile.ReadUInt16();
				NumberOfLineNumbers = pFile.ReadUInt16();
				Characteristics = pFile.ReadUInt32();
			}
Пример #6
0
			public bool Read(CLIFile pFile)
			{
				Magic = pFile.ReadUInt16();
				MajorLinkerVersion = pFile.ReadByte();
				MinorLinkerVersion = pFile.ReadByte();
				SizeOfCode = pFile.ReadUInt32();
				SizeOfInitializedData = pFile.ReadUInt32();
				SizeOfUninitializedData = pFile.ReadUInt32();
				AddressOfEntryPoint = pFile.ReadUInt32();
				BaseOfCode = pFile.ReadUInt32();
				BaseOfData = pFile.ReadUInt32();
				ImageBase = pFile.ReadUInt32();
				SectionAlignment = pFile.ReadUInt32();
				FileAlignment = pFile.ReadUInt32();
				MajorOperatingSystemVersion = pFile.ReadUInt16();
				MinorOperatingSystemVersion = pFile.ReadUInt16();
				MajorImageVersion = pFile.ReadUInt16();
				MinorImageVersion = pFile.ReadUInt16();
				MajorSubsystemVersion = pFile.ReadUInt16();
				MinorSubsystemVersion = pFile.ReadUInt16();
				Reserved = pFile.ReadUInt32();
				SizeOfImage = pFile.ReadUInt32();
				SizeOfHeaders = pFile.ReadUInt32();
				Checksum = pFile.ReadUInt32();
				Subsystem = pFile.ReadUInt16();
				DllCharacteristics = pFile.ReadUInt16();
				SizeOfStackReserve = pFile.ReadUInt32();
				SizeOfStackCommit = pFile.ReadUInt32();
				SizeOfHeapReserve = pFile.ReadUInt32();
				SizeOfHeapCommit = pFile.ReadUInt32();
				LoaderFlags = pFile.ReadUInt32();
				NumberOfRVAAndSizes = pFile.ReadUInt32();
				for (int index = 0; index < DataDirectories.Length; ++index)
				{
					DataDirectories[index] = new DataDirectory();
					DataDirectories[index].Read(pFile);
				}
				return true;
			}
Пример #7
0
			public void Read(CLIFile pFile)
			{
				VirtualAddress = pFile.ReadUInt32();
				Size = pFile.ReadUInt32();
			}
Пример #8
0
			public void Read(CLIFile pFile)
			{
				Signature = pFile.ReadUInt32();
				Machine = pFile.ReadUInt16();
				NumberOfSections = pFile.ReadUInt16();
				Timestamp = pFile.ReadUInt32();
				PointerToSymbolTable = pFile.ReadUInt32();
				NumberOfSymbols = pFile.ReadUInt32();
				SizeOfOptionalHeader = pFile.ReadUInt16();
				Characteristics = pFile.ReadUInt16();
			}
Пример #9
0
		public void LoadData(CLIFile pFile)
		{
			int token = 0;
			if (pFile.MethodDefTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.FieldTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.TypeRefTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.TypeDefTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.ParamTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.InterfaceImplTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.MemberRefTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.ModuleTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.DeclSecurityTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.PropertyTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.EventTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.StandAloneSigTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.ModuleRefTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.TypeSpecTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.AssemblyTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.AssemblyRefTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.FileTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.ExportedTypeTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.ManifestResourceTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.GenericParamTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.GenericParamConstraintTable.Length > HasCustomAttributeTypeMax16BitRows ||
				pFile.MethodSpecTable.Length > HasCustomAttributeTypeMax16BitRows) token = pFile.ReadInt32();
			else token = pFile.ReadUInt16();
			Type = (HasCustomAttributeType)(token & HasCustomAttributeTypeMask);
			token = (token >> HasCustomAttributeTypeBits) - 1;
			if (token >= 0)
			{
				switch (Type)
				{
					case HasCustomAttributeType.MethodDef: MethodDef = pFile.MethodDefTable[token]; break;
					case HasCustomAttributeType.Field: Field = pFile.FieldTable[token]; break;
					case HasCustomAttributeType.TypeRef: TypeRef = pFile.TypeRefTable[token]; break;
					case HasCustomAttributeType.TypeDef: TypeDef = pFile.TypeDefTable[token]; break;
					case HasCustomAttributeType.Param: Param = pFile.ParamTable[token]; break;
					case HasCustomAttributeType.InterfaceImpl: InterfaceImpl = pFile.InterfaceImplTable[token]; break;
					case HasCustomAttributeType.MemberRef: MemberRef = pFile.MemberRefTable[token]; break;
					case HasCustomAttributeType.Module: Module = pFile.ModuleTable[token]; break;
					case HasCustomAttributeType.DeclSecurity: DeclSecurity = pFile.DeclSecurityTable[token]; break;
					case HasCustomAttributeType.Property: Property = pFile.PropertyTable[token]; break;
					case HasCustomAttributeType.Event: Event = pFile.EventTable[token]; break;
					case HasCustomAttributeType.StandAloneSig: StandAloneSig = pFile.StandAloneSigTable[token]; break;
					case HasCustomAttributeType.ModuleRef: ModuleRef = pFile.ModuleRefTable[token]; break;
					case HasCustomAttributeType.TypeSpec: TypeSpec = pFile.TypeSpecTable[token]; break;
					case HasCustomAttributeType.Assembly: Assembly = pFile.AssemblyTable[token]; break;
					case HasCustomAttributeType.AssemblyRef: AssemblyRef = pFile.AssemblyRefTable[token]; break;
					case HasCustomAttributeType.File: File = pFile.FileTable[token]; break;
					case HasCustomAttributeType.ExportedType: ExportedType = pFile.ExportedTypeTable[token]; break;
					case HasCustomAttributeType.ManifestResource: ManifestResource = pFile.ManifestResourceTable[token]; break;
					case HasCustomAttributeType.GenericParam: GenericParam = pFile.GenericParamTable[token]; break;
					case HasCustomAttributeType.GenericParamConstraint: GenericParamConstraint = pFile.GenericParamConstraintTable[token]; break;
					case HasCustomAttributeType.MethodSpec: MethodSpec = pFile.MethodSpecTable[token]; break;
					default: throw new BadImageFormatException("HasCustomAttribute Type");
				}
			}
		}
Пример #10
0
		public void LoadData(CLIFile pFile)
		{
			int token = 0;
			if (pFile.ModuleTable.Length > ResolutionScopeTypeMax16BitRows ||
				pFile.ModuleRefTable.Length > ResolutionScopeTypeMax16BitRows ||
				pFile.AssemblyRefTable.Length > ResolutionScopeTypeMax16BitRows ||
				pFile.TypeRefTable.Length > ResolutionScopeTypeMax16BitRows) token = pFile.ReadInt32();
			else token = pFile.ReadUInt16();
			Type = (ResolutionScopeType)(token & ResolutionScopeTypeMask);
			token = (token >> ResolutionScopeTypeBits) - 1;
			if (token >= 0)
			{
				switch (Type)
				{
					case ResolutionScopeType.Module: Module = pFile.ModuleTable[token]; break;
					case ResolutionScopeType.ModuleRef: ModuleRef = pFile.ModuleRefTable[token]; break;
					case ResolutionScopeType.AssemblyRef: AssemblyRef = pFile.AssemblyRefTable[token]; break;
					case ResolutionScopeType.TypeRef: TypeRef = pFile.TypeRefTable[token]; break;
					default: throw new BadImageFormatException("ResolutionScope Type");
				}
			}
		}
Пример #11
0
		public void LoadData(CLIFile pFile)
		{
			int token = 0;
			if (pFile.MethodDefTable.Length > MethodDefOrRefTypeMax16BitRows ||
				pFile.MemberRefTable.Length > MethodDefOrRefTypeMax16BitRows) token = pFile.ReadInt32();
			else token = pFile.ReadUInt16();
			Type = (MethodDefOrRefType)(token & MethodDefOrRefTypeMask);
			token = (token >> MethodDefOrRefTypeBits) - 1;
			if (token >= 0)
			{
				switch (Type)
				{
					case MethodDefOrRefType.MethodDef: MethodDef = pFile.MethodDefTable[token]; break;
					case MethodDefOrRefType.MemberRef: MemberRef = pFile.MemberRefTable[token]; break;
					default: throw new BadImageFormatException("MethodDefOrRef Type");
				}
			}
		}
Пример #12
0
		public void LoadData(CLIFile pFile)
		{
			int token = 0;
			if (pFile.FileTable.Length > ImplementationTypeMax16BitRows ||
				pFile.AssemblyRefTable.Length > ImplementationTypeMax16BitRows ||
				pFile.ExportedTypeTable.Length > ImplementationTypeMax16BitRows) token = pFile.ReadInt32();
			else token = pFile.ReadUInt16();
			Type = (ImplementationType)(token & ImplementationTypeMask);
			token = (token >> ImplementationTypeBits) - 1;
			if (token >= 0)
			{
				switch (Type)
				{
					case ImplementationType.File: File = pFile.FileTable[token]; break;
					case ImplementationType.AssemblyRef: AssemblyRef = pFile.AssemblyRefTable[token]; break;
					case ImplementationType.ExportedType: ExportedType = pFile.ExportedTypeTable[token]; break;
					default: throw new BadImageFormatException("Implementation Type");
				}
			}
		}
Пример #13
0
		public void LoadData(CLIFile pFile)
		{
			int token = 0;
			if (pFile.TypeDefTable.Length > TypeDefRefOrSpecTypeMax16BitRows ||
				pFile.TypeRefTable.Length > TypeDefRefOrSpecTypeMax16BitRows ||
				pFile.TypeSpecTable.Length > TypeDefRefOrSpecTypeMax16BitRows) token = pFile.ReadInt32();
			else token = pFile.ReadUInt16();
			Type = (TypeDefRefOrSpecType)(token & TypeDefRefOrSpecTypeMask);
			token = (token >> TypeDefRefOrSpecTypeBits) - 1;
			if (token >= 0)
			{
				switch (Type)
				{
					case TypeDefRefOrSpecType.TypeDef: TypeDef = pFile.TypeDefTable[token]; break;
					case TypeDefRefOrSpecType.TypeRef: TypeRef = pFile.TypeRefTable[token]; break;
					case TypeDefRefOrSpecType.TypeSpec: TypeSpec = pFile.TypeSpecTable[token]; break;
					default: throw new BadImageFormatException("TypeDefRefOrSpec Type");
				}
			}
		}
Пример #14
0
		public void LoadData(CLIFile pFile)
		{
			int token = 0;
			if (pFile.TypeDefTable.Length > HasDeclSecurityTypeMax16BitRows ||
				pFile.MethodDefTable.Length > HasDeclSecurityTypeMax16BitRows ||
				pFile.AssemblyTable.Length > HasDeclSecurityTypeMax16BitRows) token = pFile.ReadInt32();
			else token = pFile.ReadUInt16();
			Type = (HasDeclSecurityType)(token & HasDeclSecurityTypeMask);
			token = (token >> HasDeclSecurityTypeBits) - 1;
			if (token >= 0)
			{
				switch (Type)
				{
					case HasDeclSecurityType.TypeDef: TypeDef = pFile.TypeDefTable[token]; break;
					case HasDeclSecurityType.MethodDef: MethodDef = pFile.MethodDefTable[token]; break;
					case HasDeclSecurityType.Assembly: Assembly = pFile.AssemblyTable[token]; break;
					default: throw new BadImageFormatException("HasDeclSecurity Type");
				}
			}
		}
Пример #15
0
			public bool Read(CLIFile pFile)
			{
				Signature = pFile.ReadUInt32();
				MajorVersion = pFile.ReadUInt16();
				MinorVersion = pFile.ReadUInt16();
				Reserved = pFile.ReadUInt32();
				VersionLength = pFile.ReadUInt32();
				Version = pFile.ReadBytes((int)VersionLength);
				Flags = pFile.ReadUInt16();
				StreamCount = pFile.ReadUInt16();

				Streams = new CLIMetadataStreamHeader[StreamCount];
				for (int index = 0; index < Streams.Length; ++index)
				{
					Streams[index] = new CLIMetadataStreamHeader();
					Streams[index].Read(pFile);
				}
				return true;
			}
Пример #16
0
			public void Read(CLIFile pFile)
			{
				ReservedA = pFile.ReadUInt32();
				MajorVersion = pFile.ReadByte();
				MinorVersion = pFile.ReadByte();
				HeapOffsetSizes = pFile.ReadByte();
				ReservedB = pFile.ReadByte();
				PresentTables = pFile.ReadUInt64();
				SortedTables = pFile.ReadUInt64();
			}
Пример #17
0
			public void Read(CLIFile pFile)
			{
				Signature = pFile.ReadUInt16();
				LastPageByteCount = pFile.ReadUInt16();
				PageCount = pFile.ReadUInt16();
				RelocationCount = pFile.ReadUInt16();
				HeaderParagraphCount = pFile.ReadUInt16();
				MinimumParagraphCount = pFile.ReadUInt16();
				MaximumParagraphCount = pFile.ReadUInt16();
				RegisterSS = pFile.ReadUInt16();
				RegisterSP = pFile.ReadUInt16();
				Checksum = pFile.ReadUInt16();
				RegisterIP = pFile.ReadUInt16();
				RegisterCS = pFile.ReadUInt16();
				RelocationOffset = pFile.ReadUInt16();
				Overlay = pFile.ReadUInt16();
				for (int index = 0; index < ReservedA.Length; ++index) ReservedA[index] = pFile.ReadUInt16();
				OEMIdentifier = pFile.ReadUInt16();
				OEMInformation = pFile.ReadUInt16();
				for (int index = 0; index < ReservedB.Length; ++index) ReservedB[index] = pFile.ReadUInt16();
				NextHeaderOffset = pFile.ReadUInt32();
			}