using System;
using System.IO;
using System.Text;
using System.Runtime.InteropServices;
{
class AddSection
{
public bool AddSection(string sFilePath, string sSectionName, uint lSectionSize, uint lCharacteristics)
{
IMAGE_DOS_HEADER DHD = new IMAGE_DOS_HEADER();
IMAGE_NT_HEADERS NHD = new IMAGE_NT_HEADERS();
IMAGE_SECTION_HEADER[] SHD = new IMAGE_SECTION_HEADER[1];
int iPointer = 0;
byte[] fBytes = new byte[0];
byte[] bName = new byte[8];
GCHandle gHandle;
try
{
BinaryReader bReader = new BinaryReader(new FileStream(sFilePath, FileMode.Open, FileAccess.Read));
fBytes = bReader.ReadBytes((int)bReader.BaseStream.Length);
bReader.Close();
}
catch { }
if (fBytes.Length <= 0) { return false; }
gHandle = GCHandle.Alloc(fBytes, GCHandleType.Pinned);
iPointer = gHandle.AddrOfPinnedObject().ToInt32();
DHD = (IMAGE_DOS_HEADER)Marshal.PtrToStructure(new IntPtr(iPointer), typeof(IMAGE_DOS_HEADER));
NHD = (IMAGE_NT_HEADERS)Marshal.PtrToStructure(new IntPtr(iPointer + DHD.e_lfanew), typeof(IMAGE_NT_HEADERS));
if (NHD.Signature != 17744 || DHD.e_magic != 23117) { return false; }
Array.Resize(ref SHD, NHD.FileHeader.NumberOfSections);
int x = DHD.e_lfanew + 248;
for (int a = 0; a <= NHD.FileHeader.NumberOfSections - 1; a++)
{
SHD[a] = (IMAGE_SECTION_HEADER)Marshal.PtrToStructure(new IntPtr(iPointer + x), typeof(IMAGE_SECTION_HEADER));
x = x + 40;
}
gHandle.Free();
NHD.FileHeader.NumberOfSections++;
Array.Resize(ref SHD, NHD.FileHeader.NumberOfSections);
if (sSectionName.Length > 8) { sSectionName = sSectionName.Substring(0, 8); }
Array.Copy(Encoding.Default.GetBytes(sSectionName), 0, bName, 0, Encoding.Default.GetBytes(sSectionName).Length);
SHD[NHD.FileHeader.NumberOfSections - 1].Name = bName;
SHD[NHD.FileHeader.NumberOfSections - 1].Characteristics = lCharacteristics;
SHD[NHD.FileHeader.NumberOfSections - 1].PointerToRawData = Convert.ToUInt32(Align(getLastSectionRaw(SHD), NHD.OptionalHeader.FileAlignment));
SHD[NHD.FileHeader.NumberOfSections - 1].SizeOfRawData = Convert.ToUInt32(Align(lSectionSize, NHD.OptionalHeader.FileAlignment));
SHD[NHD.FileHeader.NumberOfSections - 1].VirtualAddress = Convert.ToUInt32(Align(getLastSectionVirtual(SHD), NHD.OptionalHeader.SectionAlignment));
SHD[NHD.FileHeader.NumberOfSections - 1].VirtualSize = Convert.ToUInt32(Align(lSectionSize, NHD.OptionalHeader.SectionAlignment));
NHD.OptionalHeader.DataDirectory[12].VirtualAddress = 0;
NHD.OptionalHeader.DataDirectory[12].Size = 0;
NHD.OptionalHeader.SizeOfImage = NHD.OptionalHeader.SizeOfImage + SHD[NHD.FileHeader.NumberOfSections - 1].VirtualSize;
byte[] bNHD = getBytes_(NHD);
byte[] bSHD = getBytes_(SHD[NHD.FileHeader.NumberOfSections - 1]);
byte[] bClear = Encoding.Default.GetBytes(Convert.ToChar(0x00).ToString());
if (fBytes.Length - (DHD.e_lfanew + bNHD.Length) <= 0) { Array.Resize(ref fBytes, (int)(fBytes.Length + bNHD.Length)); }
Array.Copy(bNHD, 0, fBytes, DHD.e_lfanew, bNHD.Length);
if (fBytes.Length - (x + bSHD.Length) <= 0) { Array.Resize(ref fBytes, (int)(fBytes.Length + bSHD.Length)); }
Array.Copy(bSHD, 0, fBytes, x, bSHD.Length);
if (fBytes.Length - (SHD[NHD.FileHeader.NumberOfSections - 1].PointerToRawData + SHD[NHD.FileHeader.NumberOfSections - 1].SizeOfRawData + (bClear.Length * 4)) <= 0)
{ Array.Resize(ref fBytes, (int)(fBytes.Length + ((SHD[NHD.FileHeader.NumberOfSections - 1].PointerToRawData + SHD[NHD.FileHeader.NumberOfSections - 1].SizeOfRawData + (bClear.Length)) - fBytes.Length))); }
Array.Copy(bClear, 0, fBytes, (SHD[NHD.FileHeader.NumberOfSections - 1].PointerToRawData + SHD[NHD.FileHeader.NumberOfSections - 1].SizeOfRawData), bClear.Length);
try
{
BinaryWriter bWriter = new BinaryWriter(new FileStream(sFilePath, FileMode.Open));
bWriter.Write(fBytes);
bWriter.Flush();
bWriter.Close();
}
catch { return false; }
return true;
}
private byte[] getBytes_(object oObject)
{
int iSize = Marshal.SizeOf(oObject);
IntPtr ipBuffer = Marshal.AllocHGlobal(iSize);
Marshal.StructureToPtr(oObject, ipBuffer, false);
byte[] bData = new byte[iSize];
Marshal.Copy(ipBuffer, bData, 0, iSize);
Marshal.FreeHGlobal(ipBuffer);
return bData;
}
private long Align(long dwValue, long dwAlign)
{
if (dwAlign != 0)
{
if ((dwValue % dwAlign) != 0)
{
return (dwValue + dwAlign) - (dwValue % dwAlign);
}
else { return dwValue; }
}
else { return dwValue; }
}
private long getLastSectionRaw(IMAGE_SECTION_HEADER[] Sections)
{
long lRet = 0;
for (int i = 0; i <= Sections.Length - 1; i++)
{
if (Sections[i].SizeOfRawData + Sections[i].PointerToRawData > lRet)
{
lRet = Sections[i].SizeOfRawData + Sections[i].PointerToRawData;
}
}
return lRet;
}
private long getLastSectionVirtual(IMAGE_SECTION_HEADER[] Sections)
{
long lRet = 0;
for (int i = 0; i <= Sections.Length - 1; i++)
{
if (Sections[i].VirtualSize + Sections[i].VirtualAddress > lRet)
{
lRet = Sections[i].VirtualSize + Sections[i].VirtualAddress;
}
}
return lRet;
}
//Structures
[StructLayout(LayoutKind.Sequential)]
private struct IMAGE_DOS_HEADER
{
public UInt16 e_magic;
public UInt16 e_cblp;
public UInt16 e_cp;
public UInt16 e_crlc;
public UInt16 e_cparhdr;
public UInt16 e_minalloc;
public UInt16 e_maxalloc;
public UInt16 e_ss;
public UInt16 e_sp;
public UInt16 e_csum;
public UInt16 e_ip;
public UInt16 e_cs;
public UInt16 e_lfarlc;
public UInt16 e_ovno;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public UInt16[] e_res1;
public UInt16 e_oemid;
public UInt16 e_oeminfo;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)]
public UInt16[] e_res2;
public Int32 e_lfanew;
}
[StructLayout(LayoutKind.Sequential)]
private struct IMAGE_NT_HEADERS
{
public UInt32 Signature;
public IMAGE_FILE_HEADER FileHeader;
public IMAGE_OPTIONAL_HEADER32 OptionalHeader;
}
[StructLayout(LayoutKind.Sequential)]
private struct IMAGE_FILE_HEADER
{
public UInt16 Machine;
public UInt16 NumberOfSections;
public UInt32 TimeDateStamp;
public UInt32 PointerToSymbolTable;
public UInt32 NumberOfSymbols;
public UInt16 SizeOfOptionalHeader;
public UInt16 Characteristics;
}
[StructLayout(LayoutKind.Sequential)]
private struct IMAGE_OPTIONAL_HEADER32
{
public UInt16 Magic;
public Byte MajorLinkerVersion;
public Byte MinorLinkerVersion;
public UInt32 SizeOfCode;
public UInt32 SizeOfInitializedData;
public UInt32 SizeOfUninitializedData;
public UInt32 AddressOfEntryPoint;
public UInt32 BaseOfCode;
public UInt32 BaseOfData;
public UInt32 ImageBase;
public UInt32 SectionAlignment;
public UInt32 FileAlignment;
public UInt16 MajorOperatingSystemVersion;
public UInt16 MinorOperatingSystemVersion;
public UInt16 MajorImageVersion;
public UInt16 MinorImageVersion;
public UInt16 MajorSubsystemVersion;
public UInt16 MinorSubsystemVersion;
public UInt32 Win32VersionValue;
public UInt32 SizeOfImage;
public UInt32 SizeOfHeaders;
public UInt32 CheckSum;
public UInt16 Subsystem;
public UInt16 DllCharacteristics;
public UInt32 SizeOfStackReserve;
public UInt32 SizeOfStackCommit;
public UInt32 SizeOfHeapReserve;
public UInt32 SizeOfHeapCommit;
public UInt32 LoaderFlags;
public UInt32 NumberOfRvaAndSizes;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public IMAGE_DATA_DIRECTORY[] DataDirectory;
}
[StructLayout(LayoutKind.Sequential)]
private struct IMAGE_DATA_DIRECTORY
{
public UInt32 VirtualAddress;
public UInt32 Size;
}
[StructLayout(LayoutKind.Sequential)]
private struct IMAGE_SECTION_HEADER
{
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public byte[] Name;
public uint VirtualSize;
public uint VirtualAddress;
public uint SizeOfRawData;
public uint PointerToRawData;
public uint PointerToRelocations;
public uint PointerToLinenumbers;
public short NumberOfRelocations;
public short NumberOfLinenumbers;
public uint Characteristics;
}
}
}