C# PE.Section类代码示例

 public CodeReader(Section section, MetadataReader reader, Dictionary<uint, DumpedMethod> dumpedMethods = null)
     : base(section.Data)
 {
     this.code_section = section;
     this.reader = reader;
     this.dumpedMethods = dumpedMethods;
 }

		public void MoveTo (int rva)
		{
			if (!IsInSection (rva)) {
				code_section = reader.image.GetSectionAtVirtualAddress ((uint) rva);
				Reset (code_section.Data);
			}

			base.position = rva - (int) code_section.VirtualAddress;
		}

        void BuildSections()
        {
            if (win32_resources != null || win32_resources_directory != null)
                sections++;

            text = CreateSection (".text", text_map.GetLength (), null);
            var previous = text;

            if (win32_resources != null) {
                rsrc = CreateSection (".rsrc", (uint) win32_resources.length, previous);

                PatchWin32Resources (win32_resources);
                previous = rsrc;
            } else if (win32_resources_directory != null) {
                rsrc = CreateSection(".rsrc", previous);

                WriteWin32ResourcesDirectory(win32_resources_directory);
                SetSectionSize(rsrc, (uint) win32_resources.length);
                previous = rsrc;
            }

            if (has_reloc)
                reloc = CreateSection (".reloc", 12u, previous);
        }

        public void MoveTo(int rva)
        {
            if (!IsInSection (rva)) {
                var new_section = reader.image.GetSectionAtVirtualAddress ((uint) rva);
                if (new_section == null)
                    throw new ArgumentException ();
                code_section = new_section;
                Reset (code_section.Data);
            }

            base.position = rva - (int) code_section.VirtualAddress;
        }

 public MetadataStream(Section section, uint start, uint size, string name)
     : base(section, start, size)
 {
     this.Name = name;
 }

        void ReadSections(ushort count)
        {
            var sections = new Section [count];

            for (int i = 0; i < count; i++) {
                var section = new Section ();

                // Name
                section.Name = ReadZeroTerminatedString (8);

                // VirtualSize		4
                Advance (4);

                // VirtualAddress	4
                section.VirtualAddress = ReadUInt32 ();
                // SizeOfRawData	4
                section.SizeOfRawData = ReadUInt32 ();
                // PointerToRawData	4
                section.PointerToRawData = ReadUInt32 ();

                // PointerToRelocations		4
                // PointerToLineNumbers		4
                // NumberOfRelocations		2
                // NumberOfLineNumbers		2
                // Characteristics			4
                Advance (16);

                sections [i] = section;

                ReadSectionData (section);
            }

            image.Sections = sections;
        }

        void ReadMetadataStream(Section section)
        {
            // Offset		4
            uint start = metadata.VirtualAddress - section.VirtualAddress + ReadUInt32 (); // relative to the section start

            // Size			4
            uint size = ReadUInt32 ();

            var name = ReadAlignedString (16);
            switch (name) {
            case "#~":
            case "#-":
                image.TableHeap = new TableHeap (section, start, size);
                break;
            case "#Strings":
                image.StringHeap = new StringHeap (section, start, size);
                break;
            case "#Blob":
                image.BlobHeap = new BlobHeap (section, start, size);
                break;
            case "#GUID":
                image.GuidHeap = new GuidHeap (section, start, size);
                break;
            case "#US":
                image.UserStringHeap = new UserStringHeap (section, start, size);
                break;
            }
        }

 public BlobHeap(Section section, uint start, uint size)
     : base(section, start, size)
 {
 }

        void WriteSection(Section section, uint characteristics)
        {
            var name = new byte [8];
            var sect_name = section.Name;
            for (int i = 0; i < sect_name.Length; i++)
                name [i] = (byte) sect_name [i];

            WriteBytes (name);
            WriteUInt32 (section.VirtualSize);
            WriteUInt32 (section.VirtualAddress);
            WriteUInt32 (section.SizeOfRawData);
            WriteUInt32 (section.PointerToRawData);
            WriteUInt32 (0);	// PointerToRelocations
            WriteUInt32 (0);	// PointerToLineNumbers
            WriteUInt16 (0);	// NumberOfRelocations
            WriteUInt16 (0);	// NumberOfLineNumbers
            WriteUInt32 (characteristics);
        }

 void MoveToRVA(Section section, RVA rva)
 {
     BaseStream.Seek (section.PointerToRawData + rva - section.VirtualAddress, SeekOrigin.Begin);
 }

        void BuildSections()
        {
            var has_win32_resources = win32_resources != null;
            if (has_win32_resources)
                sections++;

            text = CreateSection (".text", text_map.GetLength (), null);
            var previous = text;

            if (has_win32_resources) {
                rsrc = CreateSection (".rsrc", (uint) win32_resources.length, previous);

                PatchWin32Resources (win32_resources);
                previous = rsrc;
            }

            if (has_reloc)
                reloc = CreateSection (".reloc", 12u, previous);
        }

        internal void ResizeSection(Section section, uint newSize, bool update)
        {
            section.VirtualSize = newSize;
            section.SizeOfRawData = Align (newSize, file_alignment);
            byte[] newDat = new byte[section.SizeOfRawData];
            if (newDat.Length > section.Data.Length)
                Buffer.BlockCopy(section.Data, 0, newDat, 0, section.Data.Length);
            else
                Buffer.BlockCopy(section.Data, 0, newDat, 0, newDat.Length);
            section.Data = newDat;

            int sectIndex = sections.IndexOf(section);
            if (sectIndex != -1 && update)
                for (int i = sectIndex + 1; i < sections.Count; i++)
                {
                    sections[i].VirtualAddress = sections[i - 1].VirtualAddress + Align (sections[i - 1].VirtualSize, section_alignment);
                    sections[i].PointerToRawData = sections[i - 1].PointerToRawData + sections[i - 1].SizeOfRawData;
                }
        }

 internal Section CreateSection(string name, uint size, uint characteristics, Section previous)
 {
     return new Section {
         Name = name,
         VirtualAddress = previous != null
             ? previous.VirtualAddress + Align (previous.VirtualSize, section_alignment)
             : text_rva,
         VirtualSize = size,
         PointerToRawData = previous != null
             ? previous.PointerToRawData + previous.SizeOfRawData
             : 0,
         SizeOfRawData = Align (size, file_alignment),
         Data = new byte[Align(size, file_alignment)],
         Characteristics = characteristics
     };
 }

 static void PatchResourceDirectoryTable(ByteBuffer resources, Section old, Section @new)
 {
     resources.Advance(12);
     int num = resources.ReadUInt16() + resources.ReadUInt16();
     for (int i = 0; i < num; i++)
     {
         PatchResourceDirectoryEntry(resources, old, @new);
     }
 }

 static void PatchResourceDirectoryEntry(ByteBuffer resources, Section old, Section @new)
 {
     resources.Advance(4);
     uint num = resources.ReadUInt32();
     int position = resources.Position;
     resources.Position = ((int)num) & 0x7fffffff;
     if ((num & 0x80000000) != 0)
     {
         PatchResourceDirectoryTable(resources, old, @new);
     }
     else
     {
         PatchResourceDataEntry(resources, old, @new);
     }
     resources.Position = position;
 }