1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:

LPE_STD_CODE EnlargeHeader(PE_INFO *pe)
{
    LPE_STD_CODE            ret = LPE_HANDLEDERROR;
    HWND                    hErrDlg = GetActiveWindow();
    DWORD                   dwHSize, dwBuff, i;
    IMAGE_SECTION_HEADER    *pS;
    HANDLE                  hFile;
    void                    *pMem;
    DWORD                   dwMemSize;

    // possible ?
//    if (pe->pNTh->OptionalHeader.SizeOfHeaders >= 0x1000)
    if ( GetRealSizeOfHeaders( pe->pMap ) >= 0x1000 )
    {
        ShowError(hErrDlg, "The maximum SizeOfHeaders (0x1000) is already reached !");
        goto Exit;
    }

    // move the sections 0x200 bytes back
    dwHSize = GetRealSizeOfHeaders(pe->pMap);
    dwMemSize = pe->dwFileSize - dwHSize;
    pMem = m(dwMemSize);
    if (!pMem)
    {
        ret = LPE_NOMEMORY;
        goto Exit;
    }
    memcpy(pMem, (void*)((DWORD)pe->pMap + dwHSize), dwMemSize);
    pe->pNTh->OptionalHeader.SizeOfHeaders = dwHSize + 0x200;
    pS = pe->pSech;
    for (i = 0; i < pe->pNTh->FileHeader.NumberOfSections; i++)
    {
        if (pS->PointerToRawData) // Watcom C/C++
            pS->PointerToRawData += 0x200;
        ++pS;
    }

    UnloadPEFile(pe); // unmapped !!!

    hFile = GetFileHandle(pe->cPath, GFH_OPENEXISTING_RW);
    SetFilePointer(hFile, dwHSize + 0x200, 0, FILE_BEGIN);
    WriteFile(
        hFile,
        pMem,
        dwMemSize,
        &dwBuff,
        NULL);
    CloseHandle(hFile);
    f(pMem);
    if (LoadPEFile(pe) != LPEF_SUCCESS)
    {
        HandleRemapError(hErrDlg);
        goto Exit;
    }

    // refresh PE info dlg
    ShowPEBaseInfo(hPEEditor);

    ret = LPE_OK;

Exit:
    return ret;
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:

const
  LPE_HANDLEDERROR = 0; // Keine Ahnung wie das deklariert wurde
  LPE_NOMEMORY     = 1; // Keine Ahnung wie das deklariert wurde
  LPE_OK           = 2; // Keine Ahnung wie das deklariert wurde

  LPEF_SUCCESS     = 0; // Keine Ahnung wie das deklariert wurde

  GFH_OPENEXISTING_RW = 0; // Keine Ahnung wie das deklariert wurde

var
  hPEEditor: HWND; // Globale Varible??? Welcher Typ?

type
  PIMAGE_SECTION_HEADER = ^IMAGE_SECTION_HEADER;
  LPE_STD_CODE = Cardinal; // Keine Ahnung wie das deklariert wurde
  // Keine Ahnung wie der Record aussieht, kann ich an dem Source code nicht erkennen
  PPE_INFO = ^TPE_INFO;
  TPE_INFO = record // keine Ahnung wie und in welcher Reihenfolge der Record deklariert wurde
    pNTh: ^IMAGE_NT_HEADERS;
    pMap: Pointer; // keine Ahnung welcher Typ deklariert wurde
    pSech: PIMAGE_SECTION_HEADER; // Ich hoffe das wurde so deklariert
    dwFileSize: DWORD; // keine Ahnung welcher Typ deklariert wurde
    cPath: String; // keine Ahnung welcher Typ deklariert wurde, vermutlich array[0..MAX_PATH] of Char;
  end;

function GetRealSizeOfHeaders(Map: Pointer): Cardinal;
// Keine Ahnung welcher Rueckgabetyp und welcher Parameter
begin
  // ???
end;

procedure ShowError(hWnd: HWND; const Msg: String);
// Ich nehme an, die Funktion wurde so deklariert
begin
  // ???
end;

procedure HandleRemapError(hWnd: HWND);
// Ich nehme an, die Funktion wurde so deklariert
begin
  // ???
end;

procedure UnloadPEFile(pe: PPE_INFO);
// Ich nehme an, die Funktion wurde so deklariert
begin
  // ???
end;

function LoadPEFile(pe: PPE_INFO): Cardinal;
// Ich nehme an, die Funktion wurde so deklariert
begin
  // ???
end;

function GetFileHandle(const Path: String; dwMode: DWORD): THandle;
// Keine Ahnung welcher Rueckgabetyp und welcher Parameter
begin
  // ???
end;

procedure ShowPEBaseInfo(hPEEditor: HWND);
// Keine Ahnung welcher Parameter
begin
  // ???
end;

function EnlargeHeader(pe: PPE_INFO): LPE_STD_CODE;
var
  hErrDlg: HWND;
  dwHSize, dwBuff, i: DWORD;
  pS: PIMAGE_SECTION_HEADER;
  hFile: THandle;
  pMem: Pointer;
  dwMemSize: DWORD;
begin
  Result := LPE_HANDLEDERROR;
  hErrDlg := GetActiveWindow;
  // possible ?
  //if pe^.pNTh^.OptionalHeader.SizeOfHeaders >= $1000) then
    if (GetRealSizeOfHeaders(pe^.pMap) >= $1000) then begin
      ShowError(hErrDlg, 'The maximum SizeOfHeaders (0x1000) is already reached !');
      Exit;
    end;

  // move the sections 0x200 bytes back
  dwHSize := GetRealSizeOfHeaders(pe^.pMap);
  dwMemSize := pe^.dwFileSize - dwHSize;
  GetMem(pMem, dwMemSize); // Ich hoffe, dass m(dwMemSize) speicher reserviert....
  if not Assigned(pMem) then begin
    Result := LPE_NOMEMORY;
    Exit;
  end;
  Move(Pointer(DWord(pe^.pMap) + dwHSize)^, pMem^, dwMemSize);
  pe^.pNTh^.OptionalHeader.SizeOfHeaders := dwHSize + $200;
  pS := pe^.pSech;
  for i := 0 to pe^.pNTh^.FileHeader.NumberOfSections - 1 do begin
    if pS^.PointerToRawData <> 0 then // Watcom C/C++
      Inc(pS^.PointerToRawData, $200);
    Inc(pS); // Ich hoffe das ist so richtig, ++pS; (wuerde ja vor der Anweisung inkrementieren)
  end;
  UnloadPEFile(pe); // unmapped !!!
  hFile := GetFileHandle(pe^.cPath, GFH_OPENEXISTING_RW);
  SetFilePointer(hFile, dwHSize + $200, nil, FILE_BEGIN);
  WriteFile(hFile, pMem^, dwMemSize, dwBuff, nil);
  CloseHandle(hFile);
  FreeMem(pMem); // Ich hoffe, dass f(pMem) speicher freigeben sein soll....
  if LoadPEFile(pe) <> LPEF_SUCCESS then begin
    HandleRemapError(hErrDlg);
    Exit;
  end;
  ShowPEBaseInfo(hPEEditor);
  Result := LPE_OK;
end;