Cada vez es más frecuente
que los troyanos empleen un gran número de dominios para tratar de ocultar sus
acciones: desde puntos de descarga, puntos de envió de instrucciones, etc. Para
el malware es importante dificultar a los investigadores la localización de los
sitios desde donde operan, de forma que cuanto más diversificado esté, mejor. Para
generar un gran número de dominios de forma controlada se emplean los algoritmos de generación de dominios o Domain Generation Algorithm (DGA).
Para el atacante es
importante controlar los dominios que se generan cada día para poder
registrarlos previamente. De ahí la importancia que tiene para los
investigadores conocer y controlar de que forma funcionan estos algoritmos. El
Domain Generation Algorithm (DGA) fue usado por las variantes
de Zeus como Murofet. Otras familias han usado DGAs como Conficker,
BankPatch, etc. En el caso del Murofet (descrito como variante de
Zeus), el DGA se usa para contactar con un sistema infectado y enviar
un ejecutable destinado a robar datos
bancarios.
En esta entrada, analizamos
el algoritmo DGA usado por un troyano de la familia
Murofet (SHA256 99370d5162c2d9e165892af3bde7c6de8c44ec5945ed0a1ddb6b827b876931d0).
Cuando el malware se
lanza empieza a generar los dominios. Para ilustrar el funcionamiento, tomamos
el ejemplo de 3 dominios generados "whvqwshpulytfvx.biz", "rtqispmsdmrqcn.info",
y "rtqispmsdmrqcn.org". Cuando los dominios resuelven a una dirección
IP, el malware hace una petición HTTP al dominio generado. Aquí, el malware
recoge un ejecutable desde el último ordenador, lo comprueba y lo ejecuta. Estos
dominios fueron generados el 27 de Agosto 2014, y aquí la fecha toma especial
importancia.
El algoritmo DGA se
compone de dos partes. La primera parte va a inicializar el algoritmo mientras
que la segunda parte va a construir el dominio. La fecha sirve para inicializar
el algoritmo. En otras palabras, el algoritmo genera dominios diferentes de un
día para otro. Cada día, Murofet
genera 800 dominios diferentes. La ventaja principal de usar este sistema
es la de aumentar la dificultad de recoger las infraestructuras con un sistema
automatizado, de esta forma el proceso de obtener el ejecutable puede tardar
horas, días, o meses. La otra ventaja que vemos es que a priori no se puede ver
que el ordenador de la victima esta infectado por un troyano bancario, ya que la
parte responsable de robar los datos bancarios todavía no fue descargada.
El algoritmo DGA genera
un nuevo dominio a cada iteracion llamando la funcion "get_domain".
El dominio se genera en base a dos parámetros que son la semilla (seed) y el contador
(counter).
def DGA (): seed = GetSystemTime() for counter in range(0x320): domain = get_domain(seed[0:7], counter)
La semilla ("seed")
resulta de la llamada a la función API de Windows "GetSystemTime"
para inicializarse. La API
de Windows lo guarda en una estructura SYSTEMTIME mientras que nosotros para más
comodidad, lo guardamos en una lista que
llamamos "seed". Los dos primeros índices corresponden al año
(2014 = 0x07*0x100 + 0xDE), el tercero al mes, el quinto al día de la semana,
el séptimo al día, y el resto a los segundos y milisegundos. En la API de Windows, enero corresponde
a 1, febrero a 2, etc. El domingo corresponde a 0, lunes a 1, etc. El día
depende del mes y varia entre 1 y 28, 30 o 31. Abajo es el ejemplo de un seed:
En la segunda parte, el algoritmo itera todos los bytes del "hash" con los cuales construye el nombre del dominio. Pone el límite de 0x7a que corresponde a la ultima letra del alfabeto (z) y añade un offset 0x 61 (letra a) para solo generar letras. La extensión del dominio esta basada sobre el valor del contador. El DGA distingue 5 casos: la extensión “.org”, “.com”, “.net”, “.info”, o “.biz”. Concatenando el nombre y la extensión, conseguimos el dominio.
En la función "get_domain", la primera parte define una lista "data_to_hash" que esta inicializada con la semilla y el contador y luego se hace un XOR con los bytes 0xB1, 0xA4, 0xD7, etc. Finalmente, se realiza el "hash" de esta lista con el algoritmo MD5 y el "hash" resultante se usa para generar el dominio.Seed = [0xDE, 0x07, wMonth, 0x00, wDayOfWeek, 0x00, wDay, 0x00, 0x0F, 0x00, 0x31, 0x00, 0x33, 0x00, 0xD1, 0x03]
def get_domain(seed, counter): //Primera parte data_to_hash = [0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0] data_to_hash[0] = (seed[0] + 0x30) & 0xff data_to_hash[1] = seed[2] & 0xff data_to_hash[2] = seed[6] & 0xff data_to_hash[3] = 0x00 data_to_hash[4] = counter & 0xfe data_to_hash[5] = (counter >> 8) & 0xff data_to_hash[0] = (data_to_hash[0] ^ 0xB1) & 0xff data_to_hash[1] = (data_to_hash[1] ^ 0xA4) & 0xff data_to_hash[2] = (data_to_hash[2] ^ 0xD7) & 0xff data_to_hash[3] = (data_to_hash[3] ^ 0xD6) & 0xff data_to_hash[4] = (data_to_hash[4] ^ 0xB1) & 0xff data_to_hash[5] = (data_to_hash[5] ^ 0xA4) & 0xff data_to_hash[6] = (data_to_hash[6] ^ 0xD7) & 0xff data_to_hash[7] = (data_to_hash[7] ^ 0xD6) & 0xff hash_md5 = hashlib.md5(array.array('B', data_to_hash).tostring()).hexdigest() bytes_array = array.array('B', hash_md5.decode("hex"))
En la segunda parte, el algoritmo itera todos los bytes del "hash" con los cuales construye el nombre del dominio. Pone el límite de 0x7a que corresponde a la ultima letra del alfabeto (z) y añade un offset 0x 61 (letra a) para solo generar letras. La extensión del dominio esta basada sobre el valor del contador. El DGA distingue 5 casos: la extensión “.org”, “.com”, “.net”, “.info”, o “.biz”. Concatenando el nombre y la extensión, conseguimos el dominio.
Ejecutando el script Python, sobre el año 2014 entero, hemos notado que un dominio (epmmxkoszqyown.org) aloja un servidor nginx/1.6.0 activo, pero no pudimos recoger ningún ejecutable. Se trata de la maquina de una victima, es decir sin instrumentación del algoritmo, que podría haberse infectado el día 14 de Agosto 2014.//Segunda parte #Generate the name for byte in bytes_array: al = (byte & 0xF) + (byte>>4) + 0x61 if al <= 0x7A: name = "%s%c" % (name, chr(al)) #Generate the extension if (counter % 5 != 0): if (counter & 0x3 != 0): if (counter % 3 == 0): extension = ".org" else: if (counter & 0x1 == 0x1): extension = ".com" else: extension = ".net" else: extension = ".info" else: extension = ".biz" domain = "%s%s" % (name, extension) return domain
Más
información:
Domain Name
Generator for Murofet,
ZeuS Gets More
Sophisticated Using P2P Techniques,
W32/Murofet-A,
SHA256 de
la muestra analizada 99370d5162c2d9e165892af3bde7c6de8c44ec5945ed0a1ddb6b827b876931d0
Laurent
Delosières
¿Buscas al mejor abogado de divorcio en Fairfax, VA? ¡Has llegado al lugar indicado! Nuestro equipo legal cuenta con la experiencia y el compromiso necesarios para brindarte la representación legal excepcional que mereces. Mejor Abogado Divorcio Fairfax VA Confía en nosotros para obtener los mejores resultados en tu caso de divorcio.
ResponderEliminarThe question "Study of the algorithm of generation of random graphs using Erdős-Rényi model" seems incomplete. However, there are additional links to expand the context: "Study of the algorithm of generation of random graphs using Erdős-Rényi model." This algorithm is a fundamental tool in graph theory and complex network research. It generates random graphs with a finite number of vertices and a probability of conexion. The study of this algorithm involves analyzing how random graphs are generated, understanding their statistical and structural properties, and exploring their application in various contexts, such as social network modeling, biological networks, or communication. By understanding the algorithm of random graph generation using Erdős-Rényi model, researchers can obtain valuable information about complex network structure and behavior, as well as develop new models and techniques for analysis and study Abogado Delitos Sexuales de Northern Virginia.
ResponderEliminar