This is a simulation of attack by the Wicked Panda group (APT-41) targeting U.S. state government networks the attack campaign was active between May 2021 and February 2022, in addition to attacks targeting Taiwanese media, the attack chain starts with the in-memory execution of MoonWalk backdoor. Once the MoonWalk backdoor is successfully loaded by DodgeBox, the malware decrypts and reflectively loads two embedded plugins (C2 and Utility). The C2 plugin uses a custom encrypted C2 protocol to communicate with the attacker-controlled Google Drive account. I relied on zscaler to figure out the details to make this simulation: part 1: https://www.zscaler.com/blogs/security-research/dodgebox-deep-dive-updated-arsenal-apt41-part-1

part 2: https://www.zscaler.com/blogs/security-research/moonwalk-deep-dive-updated-arsenal-apt41-part-2

This attack included several stages including DodgeBox, a reflective DLL loader written in C, showcases similarities to StealthVector in terms of concept but incorporates significant improvements in its implementation. It offers various capabilities, including decrypting and loading embedded DLLs, conducting environment checks and bindings, and executing cleanup procedures. What sets DodgeBox apart from other malware is its unique algorithms and techniques.

Employs DLL sideloading as a means of executing DodgeBox. employs DLL sideloading as a means of executing DodgeBox. They utilize a legitimate executable (taskhost.exe).
The malicious DLL, DodgeBox, serves as a loader and is responsible for decrypting a second stage payload from an encrypted DAT file (sbiedll.dat), The decrypted payload, MoonWalk functions as a backdoor.
Data exfiltration: over GoogleDrive API C2 Channe, This integrates GoogleDrive API functionality to facilitate communication between the compromised system and the attacker-controlled server thereby potentially hiding the traffic within legitimate GoogleDrive communication.

The first stage (DodgeBox DLL loader)

This payload detects sandbox environments by checking for the presence of the SbieDll module and halts execution if found. It dynamically resolves API functions using obfuscated hashes to evade detection. The code allocates memory in the process using NtAllocateVirtualMemory, potentially for injecting or executing malicious code. It employs FNV-1a hashing to obscure strings like DLL and function names. Additionally, it uses DLL sideloading to execute DodgeBox, leveraging a legitimate executable like taskhost.exe to bypass security mechanisms.

Sandbox Detection

The SbieDll_Hook function attempts to detect a sandbox environment (e.g., Sandboxie) by checking for the SbieDll module using GetModuleHandle(L"SbieDll").

If the module is detected, it triggers an infinite sleep (Sleep(INFINITE)) to prevent further execution, a common evasion tactic used by malware to avoid analysis in sandboxed environments.

Triggering Core Logic

If the sandbox module is not detected, it proceeds to execute the core malicious functionality in the MalwareMain function.

Dynamic API Resolution

The ResolveImport function dynamically resolves Windows API functions by loading the required DLLs and identifying functions by their hashed names. This is an obfuscation and anti-analysis technique to hide API calls. It is specifically designed to resolve APIs like NtAllocateVirtualMemory.

Memory Allocation

MalwareMain uses the resolved API NtAllocateVirtualMemory to allocate memory in the process space. This allocated memory could be used for malicious purposes such as: Injecting malicious code. Executing a payload from memory. The allocation is made with read-write permissions (PAGE_READWRITE).

Custom Hashing

The fnv1a_salted function calculates a hash value using the FNV-1a algorithm, which is commonly used in malware for: Obfuscating strings or API names. Making it harder for analysts to interpret the payload. The provided test values demonstrate hashing of DLL and function names (ntdll and LdrLoadDll) with a specific salt.

The Second stage (generate obfuscated hashes - fnv1a_salted)

The fnv1a_salted function can be used to generate obfuscated hashes for string identifiers (like DLL or function names) by combining them with a salt. These hashes can then be used in the code for API function resolution or obfuscation to avoid detection.

Use fnv1a_salted

Input Preparation: Prepare the data (e.g., ntdll or LdrLoadDll) as a byte string. Prepare the salt, which is also a byte string. Use the default or custom seed_value for the hash calculation.

Function Usage: Call fnv1a_salted(data, salt) to generate the obfuscated hash. The hash output is a 32-bit integer, which can be converted to hexadecimal for use in your program.

Practical Application: Use the calculated hash values as constants in your code for obfuscated API resolution, avoiding the use of plain strings (e.g., "ntdll").

Why the attackers Use Hashing?

1.Evasion: Prevents easy detection by antivirus or static analysis tools.

2.Obfuscation: Masks the real purpose of the payload by hiding sensitive strings.

3.Memory-Only Execution: Useful in memory-resident malware that avoids writing cleartext strings to disk.

The third stage (MoonWalk backdoor)

This payload is a malicious program that establishes a reverse shell to an attacker's machine, enabling them to remotely execute commands on the victim's system via cmd.exe. It communicates with the attacker's system using an unencrypted TCP connection. The shell receives commands, executes them, and sends the output back to the attacker. To ensure persistence, it modifies the Windows Registry under HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run, adding a key named MoonWalkBackdoor. This key points to a file path intended to make the payload launch automatically on user login. However, the path specified (C:\Windows\System32\payload.dll).

1.Reverse Shell Creation:

Purpose: Establishes a reverse shell connection to a remote attacker's machine (IP,port). Mechanism: Connects to the attacker's system. Opens a cmd.exe process on the victim's machine. Sends commands received from the attacker to the shell and returns the output to the attacker.

Persistence Mechanism:

Registry Manipulation: Adds an entry in the Windows Registry under HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run. This ensures the backdoor runs every time the user logs in. The value points to C:\Windows\System32\payload.dll (a likely misconfiguration, as the current code produces an executable, not a DLL).
Networking:

Uses Windows' Winsock API to set up the socket connection to the attacker.

The fourth stage (Data Exfiltration) over OneDrive API C2 Channe

I have previously performed Data Exfiltration during an APT28 attack via OneDrive. You can refer to this link: https://github.com/S3N4T0R-0X0/APT-Attack-Simulation/tree/main/Russian%20APT/APT28-Adversary-Simulation for detailed steps on how this can be accomplished. However, in this particular attack, a more advanced and non-open-source version of BEAR-C2 was utilized for Data Exfiltration.

The attackers used the OneDrive C2 (Command and Control) API as a means to establish a communication channel between their payload and the attacker's server, By using OneDrive as a C2 server, attackers can hide their malicious activities among the legitimate traffic to OneDrive, making it harder for security teams to detect the threat. First, we need to create a Microsoft Azure account and activate its permissions, as shown in the following figure.

We will use the Application (client) ID for the inputs needed by the C2 server

After that, we will go to the Certificates & secrets menu to generate the Secret ID for the Microsoft Azure account, and this is what we will use in OneDrive C2.

Final result: payload connect to OneDrive By using BEAR-C2

https://github.com/user-attachments/assets/15f4c8dc-e983-41c5-ba25-96d64e1b9a02