test-pe-parser.cpp File Reference

Test cases for PE parser helpers. More...

#include "pch.h"

Functions
BOOLEAN	TestPeParser ()
	Runs all PE parser unit tests and reports pass/fail results.

Detailed Description

Test cases for PE parser helpers.

Author

jtaw5649

Version

0.19

Date

2026-06-01

Copyright

This project is released under the GNU Public License v3.

Function Documentation

TestPeParser()

BOOLEAN TestPeParser

(

)

Runs all PE parser unit tests and reports pass/fail results.

Each numbered test case exercises a distinct behaviour of the PE image reader:

1. A valid PE32+ image initialises successfully and reports 64-bit.
2. A valid PE32 image initialises successfully and reports 32-bit.
3. A corrupt DOS magic causes initialisation to fail.
4. An optional header that is one byte too small causes initialisation to fail.
5. An e_lfanew value that points past the buffer causes initialisation to fail.
6. A valid section RVA maps to the correct raw file offset.
7. Header-range RVA resolution is enforced at SizeOfHeaders boundaries.
8. An 8-byte section name is always returned null-terminated.
9. An RVA whose raw mapping extends outside the file is rejected.

Returns

BOOLEAN TRUE if all tests pass, FALSE if any test fails

{
    BOOLEAN OverallResult         = TRUE;
    INT32   TestNum               = 0;
    BYTE    Buffer[PeFixtureSize] = {0};
 
    BuildMinimalPe64(Buffer);
    TestNum++;
    {
        PE_IMAGE_READER Reader = {0};
 
        if (PeImageReaderInitialize(Buffer, sizeof(Buffer), &Reader) && !PeImageReaderIs32Bit(&Reader))
        {
            printf("[+] Test number %d Passed\n", TestNum);
        }
        else
        {
            printf("[-] Test number %d Failed\n", TestNum);
            printf("[x] valid PE64 did not initialize as PE32+\n");
            return FALSE;
        }
    }
 
    BuildMinimalPe32(Buffer);
    TestNum++;
    {
        PE_IMAGE_READER Reader = {0};
 
        if (PeImageReaderInitialize(Buffer, sizeof(Buffer), &Reader) && PeImageReaderIs32Bit(&Reader))
        {
            printf("[+] Test number %d Passed\n", TestNum);
        }
        else
        {
            printf("[-] Test number %d Failed\n", TestNum);
            printf("[x] valid PE32 did not initialize as PE32\n");
            return FALSE;
        }
    }
 
    BuildMinimalPe64(Buffer);
    WriteWord(Buffer, 0, 0);
    TestNum++;
    {
        PE_IMAGE_READER Reader = {0};
 
        if (!PeImageReaderInitialize(Buffer, sizeof(Buffer), &Reader))
        {
            printf("[+] Test number %d Passed\n", TestNum);
        }
        else
        {
            printf("[-] Test number %d Failed\n", TestNum);
            printf("[x] invalid DOS magic initialized successfully\n");
            return FALSE;
        }
    }
 
    BuildMinimalPe64(Buffer);
    WriteWord(Buffer,
              PeHeaderOffset + sizeof(DWORD) + offsetof(IMAGE_FILE_HEADER, SizeOfOptionalHeader),
              sizeof(IMAGE_OPTIONAL_HEADER64) - 1);
    TestNum++;
    {
        PE_IMAGE_READER Reader = {0};
 
        if (!PeImageReaderInitialize(Buffer, sizeof(Buffer), &Reader))
        {
            printf("[+] Test number %d Passed\n", TestNum);
        }
        else
        {
            printf("[-] Test number %d Failed\n", TestNum);
            printf("[x] truncated optional header initialized successfully\n");
            return FALSE;
        }
    }
 
    BuildMinimalPe64(Buffer);
    WriteDword(Buffer, offsetof(IMAGE_DOS_HEADER, e_lfanew), PeFixtureSize);
    TestNum++;
    {
        PE_IMAGE_READER Reader = {0};
 
        if (!PeImageReaderInitialize(Buffer, sizeof(Buffer), &Reader))
        {
            printf("[+] Test number %d Passed\n", TestNum);
        }
        else
        {
            printf("[-] Test number %d Failed\n", TestNum);
            printf("[x] invalid e_lfanew initialized successfully\n");
            return FALSE;
        }
    }
 
    BuildMinimalPe64(Buffer);
    SetPe64OptionalHeaderSizeOfHeaders(Buffer, 0x1c0);
    ConfigureTextSection(Buffer, sizeof(IMAGE_OPTIONAL_HEADER64), 0x1000, 0x50, 0x1c0, 0x40);
    TestNum++;
    {
        PE_IMAGE_READER Reader     = {0};
        SIZE_T          FileOffset = 0;
 
        if (PeImageReaderInitialize(Buffer, sizeof(Buffer), &Reader) &&
            PeImageReaderRvaToFileOffset(&Reader, 0x1010, 4, &FileOffset) && FileOffset == 0x1d0)
        {
            printf("[+] Test number %d Passed\n", TestNum);
        }
        else
        {
            printf("[-] Test number %d Failed\n", TestNum);
            printf("[x] valid section RVA did not map to raw file offset\n");
            return FALSE;
        }
    }
 
    BuildMinimalPe64(Buffer);
    SetPe64OptionalHeaderSizeOfHeaders(Buffer, 0x1c0);
    TestNum++;
    {
        PE_IMAGE_READER Reader     = {0};
        SIZE_T          FileOffset = 0;
 
        if (PeImageReaderInitialize(Buffer, sizeof(Buffer), &Reader) &&
            PeImageReaderRvaToFileOffset(&Reader, 0x20, 4, &FileOffset) && FileOffset == 0x20 &&
            !PeImageReaderRvaToFileOffset(&Reader, 0x1be, 4, &FileOffset))
        {
            printf("[+] Test number %d Passed\n", TestNum);
        }
        else
        {
            printf("[-] Test number %d Failed\n", TestNum);
            printf("[x] header RVA bounds were not enforced\n");
            return FALSE;
        }
    }
 
    TestNum++;
    {
        IMAGE_SECTION_HEADER SectionHeader = {0};
        CHAR                 Name[9];
 
        FillMemory(Name, sizeof(Name), 'X');
        CopyMemory(SectionHeader.Name, "ABCDEFGH", IMAGE_SIZEOF_SHORT_NAME);
        if (PeImageReaderGetSectionName(&SectionHeader, Name, sizeof(Name)) &&
            strcmp(Name, "ABCDEFGH") == 0 && Name[IMAGE_SIZEOF_SHORT_NAME] == '\0')
        {
            printf("[+] Test number %d Passed\n", TestNum);
        }
        else
        {
            printf("[-] Test number %d Failed\n", TestNum);
            printf("[x] 8-byte section name was not null-terminated\n");
            return FALSE;
        }
    }
 
    BuildMinimalPe64(Buffer);
    SetPe64OptionalHeaderSizeOfHeaders(Buffer, 0x1c0);
    ConfigureTextSection(Buffer, sizeof(IMAGE_OPTIONAL_HEADER64), 0x1000, 0x40, 0x300, 0x20);
    TestNum++;
    {
        PE_IMAGE_READER Reader     = {0};
        SIZE_T          FileOffset = 0;
 
        if (PeImageReaderInitialize(Buffer, sizeof(Buffer), &Reader) &&
            !PeImageReaderRvaToFileOffset(&Reader, 0x1000, 1, &FileOffset))
        {
            printf("[+] Test number %d Passed\n", TestNum);
        }
        else
        {
            printf("[-] Test number %d Failed\n", TestNum);
            printf("[x] RVA mapping accepted raw pointer outside file\n");
            OverallResult = FALSE;
        }
    }
 
    return OverallResult;
}