tor-browser

TestPEExportSection.cpp (24771B)

---

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */

// This test makes sure mozilla::nt::PEExportSection can parse the export
// section of a local process, and a remote process even though it's
// modified by an external code.

#include "mozilla/CmdLineAndEnvUtils.h"
#include "mozilla/NativeNt.h"
#include "nsWindowsDllInterceptor.h"

#include <stdio.h>
#include <windows.h>

#define EXPORT_FUNCTION_EQ(name, func) \
 (GetProcAddress(imageBase, name) == reinterpret_cast<void*>(func))

#define VERIFY_EXPORT_FUNCTION(tables, name, expected, errorMessage)        \
 do {                                                                      \
   if (tables.GetProcAddress(name) != reinterpret_cast<void*>(expected)) { \
     printf("TEST-FAILED | TestPEExportSection | %s", errorMessage);       \
     return kTestFail;                                                     \
   }                                                                       \
 } while (0)

using namespace mozilla::nt;
using mozilla::interceptor::MMPolicyInProcess;
using mozilla::interceptor::MMPolicyOutOfProcess;
using LocalPEExportSection = PEExportSection<MMPolicyInProcess>;
using RemotePEExportSection = PEExportSection<MMPolicyOutOfProcess>;

constexpr DWORD kEventTimeoutinMs = 5000;
const wchar_t kProcessControlEventName[] =
   L"TestPEExportSection.Process.Control.Event";

enum TestResult : int {
 kTestSuccess = 0,
 kTestFail,
 kTestSkip,
};

// These strings start with the same keyword to make sure we don't do substring
// match.  Moreover, kSecretFunctionInvalid is purposely longer than the
// combination of the other two strings and located in between the other two
// strings to effectively test binary search.
const char kSecretFunction[] = "Secret";
const char kSecretFunctionInvalid[] = "Secret invalid long name";
const char kSecretFunctionWithSuffix[] = "Secret2";

const wchar_t* kNoModification = L"--NoModification";
const wchar_t* kNoExport = L"--NoExport";
const wchar_t* kModifyTableEntry = L"--ModifyTableEntry";
const wchar_t* kModifyTable = L"--ModifyTable";
const wchar_t* kModifyDirectoryEntry = L"--ModifyDirectoryEntry";
const wchar_t* kExportByOrdinal = L"--ExportByOrdinal";

// Use the global variable to pass the child process's error status to the
// parent process.  We don't use a process's exit code to keep the test simple.
int gChildProcessStatus = 0;

// These functions are exported by linker or export section tampering at
// runtime.  Each of function bodies needs to be different to avoid ICF.
extern "C" __declspec(dllexport) int Export1() { return 0; }
extern "C" __declspec(dllexport) int Export2() { return 1; }
int SecretFunction1() { return 100; }
int SecretFunction2() { return 101; }

// This class allocates a writable region downstream of the mapped image
// and prepares it as a valid export section.
class ExportDirectoryPatcher final {
 static constexpr int kRegionAllocationTryLimit = 100;
 static constexpr int kNumOfTableEntries = 2;
 // VirtualAlloc sometimes fails if a desired base address is too small.
 // Define a minimum desired base to reduce the number of allocation tries.
 static constexpr uintptr_t kMinimumAllocationPoint = 0x8000000;

 struct ExportDirectory {
   IMAGE_EXPORT_DIRECTORY mDirectoryHeader;
   DWORD mExportAddressTable[kNumOfTableEntries];
   DWORD mExportNameTable[kNumOfTableEntries];
   WORD mExportOrdinalTable[kNumOfTableEntries];
   char mNameBuffer1[sizeof(kSecretFunction)];
   char mNameBuffer2[sizeof(kSecretFunctionWithSuffix)];

   template <typename T>
   static DWORD PtrToRVA(T aPtr, uintptr_t aBase) {
     return reinterpret_cast<uintptr_t>(aPtr) - aBase;
   }

   explicit ExportDirectory(uintptr_t aImageBase) : mDirectoryHeader{} {
     mDirectoryHeader.Base = 1;
     mExportAddressTable[0] = PtrToRVA(SecretFunction1, aImageBase);
     mExportAddressTable[1] = PtrToRVA(SecretFunction2, aImageBase);
     mExportNameTable[0] = PtrToRVA(mNameBuffer1, aImageBase);
     mExportNameTable[1] = PtrToRVA(mNameBuffer2, aImageBase);
     mExportOrdinalTable[0] = 0;
     mExportOrdinalTable[1] = 1;
     strcpy(mNameBuffer1, kSecretFunction);
     strcpy(mNameBuffer2, kSecretFunctionWithSuffix);
   }
 };

 uintptr_t mImageBase;
 ExportDirectory* mNewExportDirectory;

 DWORD PtrToRVA(const void* aPtr) const {
   return reinterpret_cast<uintptr_t>(aPtr) - mImageBase;
 }

public:
 explicit ExportDirectoryPatcher(HMODULE aModule)
     : mImageBase(PEHeaders::HModuleToBaseAddr<uintptr_t>(aModule)),
       mNewExportDirectory(nullptr) {
   SYSTEM_INFO si = {};
   ::GetSystemInfo(&si);

   int numPagesRequired = ((sizeof(ExportDirectory) - 1) / si.dwPageSize) + 1;

   uintptr_t desiredBase = mImageBase + si.dwAllocationGranularity;
   desiredBase = std::max(desiredBase, kMinimumAllocationPoint);

   for (int i = 0; i < kRegionAllocationTryLimit; ++i) {
     void* allocated =
         ::VirtualAlloc(reinterpret_cast<void*>(desiredBase),
                        numPagesRequired * si.dwPageSize,
                        MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
     if (allocated) {
       // Use the end of a allocated page as ExportDirectory in order to test
       // the boundary between a commit page and a non-commited page.
       allocated = reinterpret_cast<uint8_t*>(allocated) +
                   (numPagesRequired * si.dwPageSize) -
                   sizeof(ExportDirectory);
       mNewExportDirectory = new (allocated) ExportDirectory(mImageBase);
       return;
     }

     desiredBase += si.dwAllocationGranularity;
   }

   gChildProcessStatus = kTestSkip;
   printf(
       "TEST-SKIP | TestPEExportSection | "
       "Giving up finding an allocatable space following the mapped image.\n");
 }

 ~ExportDirectoryPatcher() {
   // Intentionally leave mNewExportDirectory leaked to keep a patched data
   // available until the process is terminated.
 }

 explicit operator bool() const { return !!mNewExportDirectory; }

 void PopulateDirectory(IMAGE_EXPORT_DIRECTORY& aOutput) const {
   aOutput.NumberOfFunctions = aOutput.NumberOfNames = kNumOfTableEntries;
   aOutput.AddressOfFunctions =
       PtrToRVA(mNewExportDirectory->mExportAddressTable);
   aOutput.AddressOfNames = PtrToRVA(mNewExportDirectory->mExportNameTable);
   aOutput.AddressOfNameOrdinals =
       PtrToRVA(mNewExportDirectory->mExportOrdinalTable);
 }

 void PopulateDirectoryEntry(IMAGE_DATA_DIRECTORY& aOutput) const {
   PopulateDirectory(mNewExportDirectory->mDirectoryHeader);
   aOutput.VirtualAddress = PtrToRVA(&mNewExportDirectory->mDirectoryHeader);
   aOutput.Size = sizeof(ExportDirectory);
 }
};

// This exports SecretFunction1 as "Export1" by replacing an entry of the
// export address table.
void ModifyExportAddressTableEntry() {
 MMPolicyInProcess policy;
 HMODULE imageBase = ::GetModuleHandleW(nullptr);
 auto ourExe = LocalPEExportSection::Get(imageBase, policy);

 auto addressTableEntry =
     const_cast<DWORD*>(ourExe.FindExportAddressTableEntry("Export1"));
 if (!addressTableEntry) {
   gChildProcessStatus = kTestFail;
   return;
 }

 mozilla::AutoVirtualProtect protection(
     addressTableEntry, sizeof(*addressTableEntry), PAGE_READWRITE);
 if (!protection) {
   gChildProcessStatus = kTestFail;
   return;
 }

 *addressTableEntry = reinterpret_cast<uintptr_t>(SecretFunction1) -
                      PEHeaders::HModuleToBaseAddr<uintptr_t>(imageBase);

 if (!EXPORT_FUNCTION_EQ("Export1", SecretFunction1) ||
     !EXPORT_FUNCTION_EQ("Export2", Export2)) {
   gChildProcessStatus = kTestFail;
 }
}

// This switches the entire address table into one exporting SecretFunction1
// and SecretFunction2.
void ModifyExportAddressTable() {
 MMPolicyInProcess policy;
 HMODULE imageBase = ::GetModuleHandleW(nullptr);
 auto ourExe = LocalPEExportSection::Get(imageBase, policy);

 auto exportDirectory = ourExe.GetExportDirectory();
 if (!exportDirectory) {
   gChildProcessStatus = kTestFail;
   return;
 }

 mozilla::AutoVirtualProtect protection(
     exportDirectory, sizeof(*exportDirectory), PAGE_READWRITE);
 if (!protection) {
   gChildProcessStatus = kTestFail;
   return;
 }

 ExportDirectoryPatcher patcher(imageBase);
 if (!patcher) {
   return;
 }

 patcher.PopulateDirectory(*exportDirectory);

 if (GetProcAddress(imageBase, "Export1") ||
     GetProcAddress(imageBase, "Export2") ||
     !EXPORT_FUNCTION_EQ(kSecretFunction, SecretFunction1) ||
     !EXPORT_FUNCTION_EQ(kSecretFunctionWithSuffix, SecretFunction2)) {
   gChildProcessStatus = kTestFail;
 }
}

// This hides all export functions by setting the table size to 0.
void HideExportSection() {
 HMODULE imageBase = ::GetModuleHandleW(nullptr);
 PEHeaders ourExe(imageBase);

 auto sectionTable =
     ourExe.GetImageDirectoryEntryPtr(IMAGE_DIRECTORY_ENTRY_EXPORT);

 mozilla::AutoVirtualProtect protection(sectionTable, sizeof(*sectionTable),
                                        PAGE_READWRITE);
 if (!protection) {
   gChildProcessStatus = kTestFail;
   return;
 }

 sectionTable->VirtualAddress = sectionTable->Size = 0;

 if (GetProcAddress(imageBase, "Export1") ||
     GetProcAddress(imageBase, "Export2")) {
   gChildProcessStatus = kTestFail;
 }
}

// This makes the export directory entry point to a new export section
// which exports SecretFunction1 and SecretFunction2.
void ModifyExportDirectoryEntry() {
 HMODULE imageBase = ::GetModuleHandleW(nullptr);
 PEHeaders ourExe(imageBase);

 auto sectionTable =
     ourExe.GetImageDirectoryEntryPtr(IMAGE_DIRECTORY_ENTRY_EXPORT);

 mozilla::AutoVirtualProtect protection(sectionTable, sizeof(*sectionTable),
                                        PAGE_READWRITE);
 if (!protection) {
   gChildProcessStatus = kTestFail;
   return;
 }

 ExportDirectoryPatcher patcher(imageBase);
 if (!patcher) {
   return;
 }

 patcher.PopulateDirectoryEntry(*sectionTable);

 if (GetProcAddress(imageBase, "Export1") ||
     GetProcAddress(imageBase, "Export2") ||
     !EXPORT_FUNCTION_EQ(kSecretFunction, SecretFunction1) ||
     !EXPORT_FUNCTION_EQ(kSecretFunctionWithSuffix, SecretFunction2)) {
   gChildProcessStatus = kTestFail;
 }
}

// This exports functions only by Ordinal by hiding the export name table.
void ExportByOrdinal() {
 ModifyExportDirectoryEntry();
 if (gChildProcessStatus != kTestSuccess) {
   return;
 }

 MMPolicyInProcess policy;
 HMODULE imageBase = ::GetModuleHandleW(nullptr);
 auto ourExe = LocalPEExportSection::Get(imageBase, policy);

 auto exportDirectory = ourExe.GetExportDirectory();
 if (!exportDirectory) {
   gChildProcessStatus = kTestFail;
   return;
 }

 exportDirectory->NumberOfNames = 0;

 if (GetProcAddress(imageBase, "Export1") ||
     GetProcAddress(imageBase, "Export2") ||
     GetProcAddress(imageBase, kSecretFunction) ||
     GetProcAddress(imageBase, kSecretFunctionWithSuffix) ||
     !EXPORT_FUNCTION_EQ(MAKEINTRESOURCE(1), SecretFunction1) ||
     !EXPORT_FUNCTION_EQ(MAKEINTRESOURCE(2), SecretFunction2)) {
   gChildProcessStatus = kTestFail;
 }
}

class ChildProcess final {
 nsAutoHandle mChildProcess;
 nsAutoHandle mChildMainThread;

public:
 static int Main(const nsAutoHandle& aEvent, const wchar_t* aOption) {
   if (wcscmp(aOption, kNoModification) == 0) {
     ;
   } else if (wcscmp(aOption, kNoExport) == 0) {
     HideExportSection();
   } else if (wcscmp(aOption, kModifyTableEntry) == 0) {
     ModifyExportAddressTableEntry();
   } else if (wcscmp(aOption, kModifyTable) == 0) {
     ModifyExportAddressTable();
   } else if (wcscmp(aOption, kModifyDirectoryEntry) == 0) {
     ModifyExportDirectoryEntry();
   } else if (wcscmp(aOption, kExportByOrdinal) == 0) {
     ExportByOrdinal();
   }

   // Letting the parent process know the child process is ready.
   ::SetEvent(aEvent);

   // The child process does not exit itself.  It's force terminated by
   // the parent process when all tests are done.
   for (;;) {
     ::Sleep(100);
   }
 }

 ChildProcess(const wchar_t* aExecutable, const wchar_t* aOption,
              const nsAutoHandle& aEvent, const nsAutoHandle& aJob) {
   const wchar_t* childArgv[] = {aExecutable, aOption};
   auto cmdLine(mozilla::MakeCommandLine(std::size(childArgv), childArgv));

   STARTUPINFOW si = {sizeof(si)};
   PROCESS_INFORMATION pi;
   BOOL ok = ::CreateProcessW(aExecutable, cmdLine.get(), nullptr, nullptr,
                              FALSE, 0, nullptr, nullptr, &si, &pi);
   if (!ok) {
     printf(
         "TEST-FAILED | TestPEExportSection | "
         "CreateProcessW falied - %08lx.\n",
         GetLastError());
     return;
   }

   if (aJob && !::AssignProcessToJobObject(aJob, pi.hProcess)) {
     printf(
         "TEST-FAILED | TestPEExportSection | "
         "AssignProcessToJobObject falied - %08lx.\n",
         GetLastError());
     ::TerminateProcess(pi.hProcess, 1);
     return;
   }

   // Wait until requested modification is done in the child process.
   if (::WaitForSingleObject(aEvent, kEventTimeoutinMs) != WAIT_OBJECT_0) {
     printf(
         "TEST-FAILED | TestPEExportSection | "
         "Child process was not ready in time.\n");
     return;
   }

   mChildProcess.own(pi.hProcess);
   mChildMainThread.own(pi.hThread);
 }

 ~ChildProcess() { ::TerminateProcess(mChildProcess, 0); }

 operator HANDLE() const { return mChildProcess; }

 TestResult GetStatus() const {
   TestResult status = kTestSuccess;
   if (!::ReadProcessMemory(mChildProcess, &gChildProcessStatus, &status,
                            sizeof(status), nullptr)) {
     status = kTestFail;
     printf(
         "TEST-FAILED | TestPEExportSection | "
         "ReadProcessMemory failed - %08lx\n",
         GetLastError());
   }
   return status;
 }
};

template <typename MMPolicy>
TestResult BasicTest(const MMPolicy& aMMPolicy) {
 const bool isAppHelpLoaded = ::GetModuleHandleW(L"apphelp.dll");

 // Use ntdll.dll because it does not have any forwarder RVA.
 HMODULE ntdllImageBase = ::GetModuleHandleW(L"ntdll.dll");
 auto ntdllExports = PEExportSection<MMPolicy>::Get(ntdllImageBase, aMMPolicy);

 auto exportDir = ntdllExports.GetExportDirectory();
 auto tableOfNames =
     ntdllExports.template RVAToPtr<const PDWORD>(exportDir->AddressOfNames);
 for (DWORD i = 0; i < exportDir->NumberOfNames; ++i) {
   const auto name =
       ntdllExports.template RVAToPtr<const char*>(tableOfNames[i]);

   if (isAppHelpLoaded && strcmp(name, "NtdllDefWindowProc_W") == 0) {
     // In this case, GetProcAddress will return
     // apphelp!DWM8AND16BitHook_DefWindowProcW.
     continue;
   }

   auto funcEntry = ntdllExports.FindExportAddressTableEntry(name);
   if (ntdllExports.template RVAToPtr<const void*>(*funcEntry) !=
       ::GetProcAddress(ntdllImageBase, name)) {
     printf(
         "TEST-FAILED | TestPEExportSection | "
         "FindExportAddressTableEntry did not resolve ntdll!%s.\n",
         name);
     return kTestFail;
   }
 }

 for (DWORD i = 0; i < 0x10000; i += 0x10) {
   if (ntdllExports.GetProcAddress(MAKEINTRESOURCE(i)) !=
       ::GetProcAddress(ntdllImageBase, MAKEINTRESOURCE(i))) {
     printf(
         "TEST-FAILED | TestPEExportSection | "
         "GetProcAddress did not resolve ntdll!Ordinal#%lu.\n",
         i);
     return kTestFail;
   }
 }

 // Test a known forwarder RVA.
 auto k32Exports = PEExportSection<MMPolicy>::Get(
     ::GetModuleHandleW(L"kernel32.dll"), aMMPolicy);
 if (k32Exports.FindExportAddressTableEntry("HeapAlloc")) {
   printf(
       "TEST-FAILED | TestPEExportSection | "
       "kernel32!HeapAlloc should be forwarded to ntdll!RtlAllocateHeap.\n");
   return kTestFail;
 }

 // Test invalid names.
 if (k32Exports.FindExportAddressTableEntry("Invalid name") ||
     k32Exports.FindExportAddressTableEntry("")) {
   printf(
       "TEST-FAILED | TestPEExportSection | "
       "FindExportAddressTableEntry should return "
       "nullptr for a non-existent name.\n");
   return kTestFail;
 }

 return kTestSuccess;
}

TestResult RunChildProcessTest(
   const wchar_t* aExecutable, const wchar_t* aOption,
   const nsAutoHandle& aEvent, const nsAutoHandle& aJob,
   TestResult (*aTestCallback)(const RemotePEExportSection&)) {
 ChildProcess childProcess(aExecutable, aOption, aEvent, aJob);
 if (!childProcess) {
   return kTestFail;
 }

 auto result = childProcess.GetStatus();
 if (result != kTestSuccess) {
   return result;
 }

 MMPolicyOutOfProcess policy(childProcess);

 // One time is enough to run BasicTest in the child process.
 static TestResult oneTimeResult = BasicTest<MMPolicyOutOfProcess>(policy);
 if (oneTimeResult != kTestSuccess) {
   return oneTimeResult;
 }

 auto exportTableChild =
     RemotePEExportSection::Get(::GetModuleHandleW(nullptr), policy);
 return aTestCallback(exportTableChild);
}

mozilla::LauncherResult<nsReturnRef<HANDLE>> CreateJobToLimitProcessLifetime() {
 uint64_t version;
 PEHeaders ntdllHeaders(::GetModuleHandleW(L"ntdll.dll"));
 if (!ntdllHeaders.GetVersionInfo(version)) {
   printf(
       "TEST-FAILED | TestPEExportSection | "
       "Unable to obtain version information from ntdll.dll\n");
   return LAUNCHER_ERROR_FROM_LAST();
 }

 constexpr uint64_t kWin8 = 0x60002ull << 32;
 nsAutoHandle job;

 if (version < kWin8) {
   // Since a process can be associated only with a single job in Win7 or
   // older and this test program is already assigned with a job by
   // infrastructure, we cannot use a job.
   return job.out();
 }

 job.own(::CreateJobObject(nullptr, nullptr));
 if (!job) {
   printf(
       "TEST-FAILED | TestPEExportSection | "
       "CreateJobObject falied - %08lx.\n",
       GetLastError());
   return LAUNCHER_ERROR_FROM_LAST();
 }

 JOBOBJECT_EXTENDED_LIMIT_INFORMATION jobInfo = {};
 jobInfo.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;

 if (!::SetInformationJobObject(job, JobObjectExtendedLimitInformation,
                                &jobInfo, sizeof(jobInfo))) {
   printf(
       "TEST-FAILED | TestPEExportSection | "
       "SetInformationJobObject falied - %08lx.\n",
       GetLastError());
   return LAUNCHER_ERROR_FROM_LAST();
 }

 return job.out();
}

extern "C" int wmain(int argc, wchar_t* argv[]) {
 nsAutoHandle controlEvent(
     ::CreateEventW(nullptr, FALSE, FALSE, kProcessControlEventName));

 if (argc == 2) {
   return ChildProcess::Main(controlEvent, argv[1]);
 }

 if (argc != 1) {
   printf(
       "TEST-FAILED | TestPEExportSection | "
       "Invalid arguments.\n");
   return kTestFail;
 }

 MMPolicyInProcess policy;
 if (BasicTest<MMPolicyInProcess>(policy)) {
   return kTestFail;
 }

 auto exportTableSelf =
     LocalPEExportSection::Get(::GetModuleHandleW(nullptr), policy);
 if (!exportTableSelf) {
   printf(
       "TEST-FAILED | TestPEExportSection | "
       "LocalPEExportSection::Get failed.\n");
   return kTestFail;
 }

 VERIFY_EXPORT_FUNCTION(exportTableSelf, "Export1", Export1,
                        "Local | Export1 was not exported.\n");
 VERIFY_EXPORT_FUNCTION(exportTableSelf, "Export2", Export2,
                        "Local | Export2 was not exported.\n");
 VERIFY_EXPORT_FUNCTION(
     exportTableSelf, "Invalid name", 0,
     "Local | GetProcAddress should return nullptr for an invalid name.\n");

 // We'll add the child process to a job so that, in the event of a failure in
 // this parent process, the child process will be automatically terminated.
 auto probablyJob = CreateJobToLimitProcessLifetime();
 if (probablyJob.isErr()) {
   return kTestFail;
 }

 nsAutoHandle job(probablyJob.unwrap());

 auto result = RunChildProcessTest(
     argv[0], kNoModification, controlEvent, job,
     [](const RemotePEExportSection& aTables) {
       VERIFY_EXPORT_FUNCTION(aTables, "Export1", Export1,
                              "NoModification | Export1 was not exported.\n");
       VERIFY_EXPORT_FUNCTION(aTables, "Export2", Export2,
                              "NoModification | Export2 was not exported.\n");
       return kTestSuccess;
     });
 if (result == kTestFail) {
   return result;
 }

 result = RunChildProcessTest(
     argv[0], kNoExport, controlEvent, job,
     [](const RemotePEExportSection& aTables) {
       VERIFY_EXPORT_FUNCTION(aTables, "Export1", 0,
                              "NoExport | Export1 was exported.\n");
       VERIFY_EXPORT_FUNCTION(aTables, "Export2", 0,
                              "NoExport | Export2 was exported.\n");
       return kTestSuccess;
     });
 if (result == kTestFail) {
   return result;
 }

 result = RunChildProcessTest(
     argv[0], kModifyTableEntry, controlEvent, job,
     [](const RemotePEExportSection& aTables) {
       VERIFY_EXPORT_FUNCTION(
           aTables, "Export1", SecretFunction1,
           "ModifyTableEntry | SecretFunction1 was not exported.\n");
       VERIFY_EXPORT_FUNCTION(
           aTables, "Export2", Export2,
           "ModifyTableEntry | Export2 was not exported.\n");
       return kTestSuccess;
     });
 if (result == kTestFail) {
   return result;
 }

 result = RunChildProcessTest(
     argv[0], kModifyTable, controlEvent, job,
     [](const RemotePEExportSection& aTables) {
       VERIFY_EXPORT_FUNCTION(aTables, "Export1", 0,
                              "ModifyTable | Export1 was exported.\n");
       VERIFY_EXPORT_FUNCTION(aTables, "Export2", 0,
                              "ModifyTable | Export2 was exported.\n");
       VERIFY_EXPORT_FUNCTION(
           aTables, kSecretFunction, SecretFunction1,
           "ModifyTable | SecretFunction1 was not exported.\n");
       VERIFY_EXPORT_FUNCTION(
           aTables, kSecretFunctionWithSuffix, SecretFunction2,
           "ModifyTable | SecretFunction2 was not exported.\n");
       VERIFY_EXPORT_FUNCTION(
           aTables, kSecretFunctionInvalid, 0,
           "ModifyTable | kSecretFunctionInvalid was exported.\n");
       return kTestSuccess;
     });
 if (result == kTestFail) {
   return result;
 }

 result = RunChildProcessTest(
     argv[0], kModifyDirectoryEntry, controlEvent, job,
     [](const RemotePEExportSection& aTables) {
       VERIFY_EXPORT_FUNCTION(
           aTables, "Export1", 0,
           "ModifyDirectoryEntry | Export1 was exported.\n");
       VERIFY_EXPORT_FUNCTION(
           aTables, "Export2", 0,
           "ModifyDirectoryEntry | Export2 was exported.\n");
       VERIFY_EXPORT_FUNCTION(
           aTables, kSecretFunction, SecretFunction1,
           "ModifyDirectoryEntry | SecretFunction1 was not exported.\n");
       VERIFY_EXPORT_FUNCTION(
           aTables, kSecretFunctionWithSuffix, SecretFunction2,
           "ModifyDirectoryEntry | SecretFunction2 was not exported.\n");
       VERIFY_EXPORT_FUNCTION(
           aTables, kSecretFunctionInvalid, 0,
           "ModifyDirectoryEntry | kSecretFunctionInvalid was exported.\n");
       return kTestSuccess;
     });
 if (result == kTestFail) {
   return result;
 }

 result = RunChildProcessTest(
     argv[0], kExportByOrdinal, controlEvent, job,
     [](const RemotePEExportSection& aTables) {
       VERIFY_EXPORT_FUNCTION(aTables, "Export1", 0,
                              "ExportByOrdinal | Export1 was exported.\n");
       VERIFY_EXPORT_FUNCTION(aTables, "Export2", 0,
                              "ExportByOrdinal | Export2 was exported.\n");
       VERIFY_EXPORT_FUNCTION(
           aTables, kSecretFunction, 0,
           "ModifyDirectoryEntry | kSecretFunction was exported by name.\n");
       VERIFY_EXPORT_FUNCTION(
           aTables, kSecretFunctionWithSuffix, 0,
           "ModifyDirectoryEntry | "
           "kSecretFunctionWithSuffix was exported by name.\n");
       VERIFY_EXPORT_FUNCTION(
           aTables, MAKEINTRESOURCE(1), SecretFunction1,
           "ModifyDirectoryEntry | "
           "kSecretFunction was not exported by ordinal.\n");
       VERIFY_EXPORT_FUNCTION(
           aTables, MAKEINTRESOURCE(2), SecretFunction2,
           "ModifyDirectoryEntry | "
           "kSecretFunctionWithSuffix was not exported by ordinal.\n");
       return kTestSuccess;
     });
 if (result == kTestFail) {
   return result;
 }

 return kTestSuccess;
}