It’s been a busy month for me and I was not able to save time to write the final part of the series on Malware Development. But I am receiving too many DMs on Twitter accounts lately to publish the final part. So here we are.
If you are reading this blog, I am basically assuming that you know C/C++ and Windows API by now. If you don’t, then you should go back and read my other blogs on Static AV Evasion and Malware Development using WINAPI (basics).
In this post, we will be using multiple ways to evade endpoint detection mechanisms and sandboxes. Machine Learning is applied at two major levels in most of the organizations. One is at the network level where it tries to identify anomalies based on the behaviour of network connections, proxy logs and pattern of connections over time. Most Network ML Solutions tend to analyze beacons of malware and DPI (deep packet inspection) to identify the malware. This is something that Microsoft ATA (Advanced Threat Analytics), or FireEye sandboxes do. On the other hand, we have Endpoint agents like Symantec EP, Crowdstrike, Endgame, Microsoft Cloud Defender and similar monitoring tools which perform behavioural analysis of the code along with signature detection to detect malicious processes.
I will be focusing only on multiple ways where we can make our malware behave like a legitimate executable or try to confuse the Endpoint agent to evade detection. I’ve used the methods mentioned in this blog to successfully evade Crowdstrike Agent, Symantec EP and Microsoft Windows Cloud Defender, the videos of the latter which I have already posted in my previous blogs. However, you might need to modify or add new techniques as this might become detectable over time. One of the best ways to avoid AV is to disable the Process creation altogether and just use WINAPI. But that would mean carefully crafting your payloads and it would be difficult to port them for shellcoding. That’s the main reason malware authors write their malware in C, and only selected payloads in shellcode. A combination of these two makes malware unbeatable on all fronts.
Each of the techniques mentioned below creates a unique signature which most AVs won’t have. It’s more of a trial and error to check which AVs detect which techniques. Also, remember that we can use stubs and packers for encryption, but that’s for a different blog post that I will do later.
P.S.: This blog is exclusive of shellcodes, reason being I will be writing a separate blog series on windows Shellcoding later. I will be using encrypted functions during the shellcoding part and not in this post. This post is specifically how Malware authors use C to perform evasions. You can also use the same APIs and code snippets mentioned below to craft a custom malware for Red Teaming.
So, before we start let’s try to get a based understanding of how Machine learning works. Machine learning is purely focused on the behaviour of the user (in the case of endpoints). In short, if we sign our malware and try to make it act like a legitimate executable, it becomes really easy to evade ML. I’ve seen people using PowerShell to write reverse shells, but they get easy detectable due to Microsoft’s AMSI (Anti-Malware Scan Interface) which consistently keeps on checking (including and mainly PowerShell) to detect malicious process executions and connections. For those of you who don’t know, Microsoft uses DMTK(Microsoft Distributed Machine Learning Toolkit) framework which is basically a decision tree based algorithm which specifies whether a file is malicious or not. PowerShell is very tightly controlled by Microsoft and it gets harder over time to evade ML when using PowerShell.
This is the reason I decided to switch to C and C++ to get reverse shells over the network so that I could have flexibility at a lower level to do whatever I want. We will be using a lot of windows APIs, encrypted variables and a lot of decision tree of our own to evade ML. This it supposed to work till Microsoft doesn’t start using CNTK framework which is a much better framework than DMTK, but harder to apply at the same time.
Encrypted Host & Process Names
So, the first thing to do is to encrypt our hostname. We can possibly use something as simple as XOR, or any custom complicated mathematical equation to decrypt our encrypted variable to get the hostname. I created a python script which takes a hostname and a character and returns a Xor’d Array:
As you can see, it gives the Key value in an integer of the Xor Key, the length of the encrypted array and the whole Encrypted array which we can simply use in a C integer or char array.
The next step is to decrypt this array at runtime and we need to hardcode the key inside the executable. This is the only key that we would be hardcoding into the code. Also, to make it complicated for the reverse engineer, we will write a C function to automatically detect that the last integer is the key and use that to loop through the array to decrypt the encrypted string. Below is how it would look like
So, we are creating a char buffer of the size of EncryptedHost on a heap. We are then passing the host, length and decrypted host variable to the Decrypter function. Below is how the Decrypter function looks:
To explain in short, it creates an Encrypted Integer array of our char array and xors them back again using the key to convert the encrypted value to the original value and stores them in the decrypted data array we created previously. With the help of this, if someone runs strings, they wouldn’t be able to see any host in the executable. They would need to understand the math and set a proper breakpoint in Debugger to fetch the C2 host. You can create more complicated mathematical equations to decrypt host if required. We can now use this decrypted data array within our sockets to connect to the remote host.
P.S.: Reverse Engineers & Sandboxes can fetch the C2 names with the help of packet captures and DNS Name Resolutions. It is better to send raw packets to multiple hosts to confuse which one is the real C2 server. But at the same time, this can lead to easy detection of the malware. Check my Legitimate Domain Routing technique below which is much better than using this.
If you’ve read my previous post, then you know that I created a cmd.exe process using the CreateProcessW winAPI. We can do what we did above for Creating Processes as well. But instead of hard coding the Encrypted array for the Process to be executed, we will send the process name as an array over the network once the executable connects to the C2 Server along with the host. We can also use authentication on the C2 server, and only allow it to connect if it sends a proper key. Below is the Code for Creating Processes using Encrypted Char array over sockets
In this way, when a system sandboxes our executable, it won’t know that what process are we executing beforehand inside a sandbox. Below is a much clearer description of what we are doing:
- Decrypt C2 host at runtime and connect to host
- Receive password and verify if it is right
- If the key is right, wait for 5 seconds to receive encrypted array(process name) over the socket
- Decrypt the received Process and run it using CreateProcessW API
With the help of the above technique, if our C2 is down, then the sandbox/analyst will not be able to find what we are executing since we have not hardcoded any processes to execute.
Code Signing with Spoofed Certs
I wrote a Script in python which can fetch and create duplicate certificates from any website which we can use for code signing. One thing I noticed is that Antiviruses don’t check and verify the whole chain of the certificate. They don’t even verify the authenticity. The main reason being not every antivirus can connect to the internet in every organization to fetch and verify the certificates for every third-party application installed. You can find the Certificate spoofing python script on my GitHub profile here.
And this is the scan results of Windows ML Defender after Signing:
Next thing is we will try to add a few features to our malware to detect if we are running in a sandbox or inside a virtual machine. We will try to evade Sandboxes as much as possible and kill our executable as soon as we find anything suspicious. We need to make sure that our malware doesn’t even look suspicious. Because if it does, then the sandbox will quarantine it and send an alert that there is a suspicious process running. This is worse than detection because this is where most SOC detects the malware and the Red Teaming gets detected.
Legitimate Domain Routing (Evade Proxy Categorization Detection and Endpoint Detection)
This is one of the best techniques I’ve found out till date which almost works every time. Let’s say I buy a C2 domain named abc.com. I will modify the A records so that it points to Microsoft.com or some similar legitimate site for a month or so. When the malware executes on the victim’s system, it will connect to this domain which will send a normal HTTP reply from Microsoft and the malware will go to sleep for a few hours and then loop into doing the same thing. Now whenever I want to get a reverse shell of my malware, I will simply change the A records of abc.com to my C2 hosting server and it will send a key in HTTP to the malware which will trigger it to fetch shellcode or send a shell back to my C2. This way, our abc.com will also get categorized as a legitimate domain instead of malicious or phishing site. And even the Endpoint systems will not block it since it is contacting a legitimate domain. Over time I’ve also used Symantec’s website to connect as a temporary domain, later changing it to my malicious C2 server.
Check System Uptime & Idletime (Evades Virtual Machine Sandboxes)
If our executable is running in a virtual machine, the uptime will be pretty short since it will boot up, perform analysis on our binary and then shut down. So, we can check the uptime of the machine and sleep till it reaches 20-30 minutes and then runs it. Make sure to use NTP to check the time with an external domain, else Sandboxes can fast-forward system time for process executions. Checking via NTP will make sure that correct time is checked. Below is the code to check uptime of a system and also an idletime in case required.
Check Mac Address of Virtual Machine (Known OUIs)
Vmware, Virtual box, MS Hyper-v and a lot of virtual machine providers use a fixed MAC Unique identifier which can be used to run in a loop to check if current mac address matches to any of those mentioned in the list. If it is, then it is highly possible that the malware is running in a virtual environment, mostly for the purpose of sandboxing and reverse engineering. Below are the OUIs that I know for the moment. If there are more, do let me know in the comments.
|Company and Products||MAC unique identifier (s)|
|VMware ESX 3, Server, Workstation, Player||00-50-56, 00-0C-29, 00-05-69|
|Microsoft Hyper-V, Virtual Server, Virtual PC||00-03-FF|
|Parallels Desktop, Workstation, Server, Virtuozzo||00-1C-42|
|Virtual Iron 4||00-0F-4B|
|Red Hat Xen||00-16-3E|
|Sun xVM VirtualBox||08-00-27|
Below is the C code to detect mac address of a Windows machine:
Execute shellcode when a specific key is pressed. (Sleep & hook method)
Here, we are only executing our shellcode/malicious process when the user presses a specific key. For this, we can hook the keyboard and create a list of multiple keys that specify what kind of shellcode needs to be executed. This is basically polymorphism. Every time a different shellcode depending on the key will confuse the Antivirus, and secondly in a sandbox, no one presses any key. So, our malware won’t execute in a sandbox. Below is the Code to hook the keyboard and check the key pressed.
P.S.: Below code can also be used for Keylogging 😉
Check number of files in Temp and Recent Files
Whenever a malware is running in a sandbox, the sandbox will have the minimum number of recent files in the virtual machine reason being sandboxes are not used for usual work. So, we can run a loop to check the number of recent files and also files in temp directory to check if we are running in a virtual machine. If the number of recent files is less than 10-15, just sleep or suspend itself. Below is a code I wrote which loops to check all files and folders in a directory:
Now I can keep on going like this, but the blog will just get lengthier with this. Besides, below are a few things you can code to check if we are running in a sandbox:
- Check if the hard disk size is greater than 60 GB (Default Virtual Machine Sandbox Size is <100GB)
- Check if Packet Capture Driver is installed in the registry (To check if Wireshark or similar is running for packet analysis)
- Check if Virtual Box additions/extension pack is installed
- WannaCry DNS Sinkhole Method
This is another method which WannaCry used. So basically, the malware will try to connect to a domain that doesn’t exist. If it does, it means the malware is running in a sandbox, since Sandboxes will reply to an NX Domain too to check if that’s a C2 Server. If we get an NX domain in reply, then we can directly connect to the C2 host. BEWARE, that DNS Sinkholes can prevent your malware from executing at all. Instead, you can buy a certain domain and check for a customized response to check if you are running in a sandbox environment.
Now, there are much more different ways to evade ML and AV detection and they aren’t really that hard. Evading ML-based AVs are not rocket science as people say. It’s just that it requires more free time to sit and understand how the underlying architecture works and find flaws to evade it.
It’s much better to invest in a highly technical Threat Hunter for detecting suspicious behaviours in your environment’s and logs rather than buying a high-end Sandbox or Antivirus Solution, though the latter is also useful in its own sense too.