Tesis:
Lineage Inference of Packed Malware using Binary Code Similarity
- Autor: UL HAQ, Irfan
- Título: Lineage Inference of Packed Malware using Binary Code Similarity
- Fecha: 2019
- Materia: Sin materia definida
- Escuela: E.T.S DE INGENIEROS INFORMÁTICOS
- Departamentos: LENGUAJES Y SISTEMAS INFORMATICOS E INGENIERIA DE SOFTWARE
- Acceso electrónico: http://oa.upm.es/57490/
- Director/a 1º: CABALLERO BAYERRI, Juan
- Resumen: El software evoluciona para adaptarse a los requisitos cambiantes al agregar nuevas funcionalidades y mejorar la estabilidad a través de la corrección de errores. El linaje de software estudia las relaciones evolutivas entre software. En particular, el linaje del programa estudia la evolución de un programa a lo largo del tiempo en sus diferentes versiones. El código fuente de un programa manifiesta su evolución. Desafortunadamente, muchos programas de software se distribuyen como ejecutables sin código fuente, por ejemplo, malware y programas comerciales estándar (COTS). Sin embargo, el código binario de un programa también refleja su evolución a través de versiones, por ejemplo, código binario agregado, eliminado y actualizado. Por lo tanto, para calcular el linaje, podemos aprovechar la similitud del código binario mediante la comparación de dos o más piezas de código binario y capturar sus diferencias. Al igual que los programas benignos, las familias de malware también evolucionan con el tiempo. No obstante, la inferencia de linaje de malware tiene tres desafíos adicionales que los enfoques de linaje existentes no abordan. Primero, el desarrollo de malware generalmente comprende un paso adicional que no está presente en el desarrollo de software benigno. Una vez que una nueva versión de una familia de malware está lista, los autores del malware empaquetan el ejecutable resultante para ocultar su código binario original. El único código binario directamente visible en una muestra de malware empaquetada es el código para desempaquetar el código binario original. En segundo lugar, el proceso de empaquetado generalmente se aplica muchas veces al mismo ejecutable de entrada, creando variantes polimórficas de exactamente la misma versión de malware, que parece diferente según los detectores de malware, pero tiene la misma funcionalidad. En consecuencia, muchas muestras de malware empaquetadas pueden corresponder a la misma versión. Por lo tanto, la identificación de la versión de malware es un desafío fundamental para inferir el linaje de malware recolectado en un entorno real. En tercer lugar, se desconoce el modelo de desarrollo, por ejemplo, línea recta o ramificación y fusión. Una familia de malware puede usar un modelo de desarrollo. Por lo tanto, necesitamos un algoritmo de inferencia de linaje que funcione independientemente del modelo de desarrollo utilizado por la familia de malware. En esta tesis, desarrollamos un enfoque para inferir el linaje del malware empaquetado utilizando similitud de código binario. En particular, esta tesis proporciona cuatro contribuciones. Primero, realizamos un estudio sistemático para analizar la investigación existente sobre código binario semejante. Sistematizamos cuatro aspectos de la investigación de similitud de código binario: aplicaciones permitidas, enfoques empleados, cómo se han implementado los enfoques, y puntos de referencia y metodologías de evaluación. Segundo, proponemos el primer enfoque para identificar versiones de malware de una familia. Nuestro enfoque utiliza análisis estático y dinámico para recuperar el código binario original de un malware empaquetado y desmontar el código binario recuperado. Luego, realiza similitudes de código binario utilizando los hashes semánticos del código desmontado para identificar las versiones de la familia de malware. Tercero, desarrollamos un algoritmo de inferencia de linaje de malware para malware empaquetado que funciona independientemente del modelo de desarrollo de la familia de malware. Produce un gráfico de linaje donde los nodos son versiones de la familia y los bordes describen las relaciones entre versiones. Finalmente, contribuimos con dos métricas para evaluar los enfoques de desempaque todo y desensamblado de malware, y los usamos para evaluar nuestro enfoque. ----------ABSTRACT---------- Software evolves to adapt to changing requirements by adding new functionality and improving stability through bug fixing. Software lineage studies the evolutionary relationships among software. In particular, program lineage studies the evolution of a program over time across its different versions. The source code of a program manifests its evolution. Unfortunately, many software programs are distributed as executables without source code, e.g., malware and commercial off-the-shelf (COTS) programs. Fortunately, the binary code of a program also reflects its evolution across versions, e.g., added, removed, and updated binary code. Thus, to infer lineage we can leverage binary code similarity approaches that compare two, or more, pieces of binary code and capture their differences. Similar to benign programs, malware families also evolve over time. But, malware lineage inference has three additional challenges not addressed by existing lineage approaches. First, malware development typically comprises of an extra step not present in benign software development. Once a new version of a malware family is ready, the malware authors pack the resulting executable to hide its original binary code. The only directly visible binary code in a packed malware sample is the code for unpacking the original binary code. Second, the packing process is typically applied many times to the same input executable, creating polymorphic variants of exactly the same malware version. These variants look different to malware detectors, but have the same functionality. Consequently, many packed malware samples may correspond to the same version. Thus, version identification is a fundamental challenge to infer lineage of malware collected in the wild. Third, the development model used by the malware, e.g., straight-line or branching and merging, is unknown. Thus, we need a lineage inference algorithm that works independently of the development model used by the malware family. In this thesis, we develop an approach for inferring the lineage of packed malware using binary code similarity. In particular, this thesis provides four contributions. First, we perform a systematic study to analyze existing research on binary code similarity. We systematize four aspects of binary code similarity research: the applications enabled, the approaches employed, how the approaches have been implemented, and the benchmarks and evaluation methodologies. Second, we propose the first approach to identify malware versions of a malware family. Our approach uses static and dynamic analysis to recover the original binary code of a packed malware and disassemble the recovered binary code. Then, it performs binary code similarity using the semantic hashes of the disassembled code to identify the versions of the malware family. Third, we develop a malware lineage inference algorithm for packed malware that works independently of the development model of the malware family. It produces a lineage graph where nodes are versions of the family and edges describe the relationships between versions. Finally, we contribute two metrics to evaluate malware unpacking and disassembly approaches, and use them to evaluate our approach.