Context-Sensitive Analysis of x86 Obfuscated Executables

104 f. :il., tab.Ofuscação de código tem por finalidade dificultar a detecção de propriedades intrínsecas de um algoritmo através de alterações em sua sintaxe, entretanto preservando sua semântica. Desenvolvedores de software usam ofuscação de código para defender seus programas contra ataques de propriedade intelectual e para aumentar a segurança do código. Por outro lado, programadores maliciosos geralmente ofuscam seus códigos para esconder comportamento malicioso e para evitar detecção pelos anti-vírus. Nesta tese, é introduzido um método para realizar an alise com sensitividade ao contexto em binários com ofuscamento de chamada e retorno de procedimento. Para obter semântica equivalente, estes binários utilizam operações diretamente na pilha ao invés de instruções convencionais de chamada e retorno de procedimento. No estado da arte atual, a definição de sensitividade ao contexto está associada com operações de chamada e retorno de procedimento, assim, análises interprocedurais clássicas não são confiáveis para analisar binários cujas operações não podem ser determinadas. Uma nova definição de sensitividade ao contexto é introduzida, baseada no estado da pilha em qualquer instrução. Enquanto mudanças em contextos á chamada de procedimento são intrinsicamente relacionadas com transferência de controle, assim, podendo ser obtidas em termos de caminhos em um grafo de controle de fluxo interprocedural, o mesmo não é aplicável para mudanças em contextos à pilha. Um framework baseado em interpretação abstrata é desenvolvido para avaliar contexto baseado no estado da pilha e para derivar métodos baseado em contextos à chamada de procedimento para uso com contextos baseado no estado da pilha. O método proposto não requer o uso explícito de instruções de chamada e retorno de procedimento, porém depende do conhecimento de como o ponteiro da pilha é representado e manipulado. O método apresentado é utilizado para criar uma versão com sensitividade ao contexto de um algoritmo para detecção de ofuscamento de chamadas de Venable et al.. Resultados experimentais mostram que a versão com sensitividade ao contexto do algoritmo gera resultados mais precisos, como também, é computacionalmente mais eficiente do que a versão sem sensitividade ao contexto. ____________________________________________________________________________________.ABSTRACT: A code obfuscation intends to confuse a program in order to make it more dificult to understand while preserving its functionality. Programs may be obfuscated to protect intellectual property and to increase security of code. Programs may also be obfuscated to hide malicious behavior and to evade detection by anti-virus scanners. We introduce a method for context-sensitive analysis of binaries that may have obfuscated procedure call and return operations. These binaries may use direct stack operators instead of the native call and ret instructions to achieve equivalent behavior. Since definition of context-sensitivity and algorithms for context-sensitive analysis has thus far been based on the specific semantics associated to procedure call and return operations, classic interprocedural analyses cannot be used reliably for analyzing programs in which these operations cannot be discerned. A new notion of context-sensitivity is introduced that is based on the state of the stack at any instruction. While changes in calling-context are associated with transfer of control, and hence can be reasoned in terms of paths in an interprocedural control ow graph (ICFG), the same is not true for changes in stackcontext. An abstract interpretation based framework is developed to reason about stackcontext and to derive analogues of call-strings based methods for the context-sensitive analysis using stack-context. This analysis requires the knowledge of how the stack, rather the stack pointer, is represented and on the knowledge of operators that manipulate the stack pointer. The method presented is used to create a context-sensitive version of Venable et al.'s algorithm for detecting obfuscated calls. Experimental results show that the contextsensitive version of the algorithm generates more precise results and is also computationally more eficient than its context-insensitive counterpart