layout: publication

title: "Statistical Deobfuscation of Android Applications"

authors: B. Bichsel, V. Raychev, P. Tsankov, M. Vechev

conference: CCS

year: 2016

bibkey: bichsel2016statistical

This work presents a new approach for deobfuscating Android APKs based on probabilistic learning of large code bases (termed "Big Code"). The key idea is to learn a probabilistic model over thousands of non-obfuscated Android applications and to use this probabilistic model to deobfuscate new, unseen Android APKs. The concrete focus of the paper is on reversing layout obfuscation, a popular transformation which renames key program elements such as classes, packages, and methods, thus making it difficult to understand what the program does. Concretely, the paper: (i) phrases the layout deobfuscation problem of Android APKs as structured prediction in a probabilistic graphical model, (ii) instantiates this model with a rich set of features and constraints that capture the Android setting, ensuring both semantic equivalence and high prediction accuracy, and (iii) shows how to leverage powerful inference and learning algorithms to achieve overall precision and scalability of the probabilistic predictions.

We implemented our approach in a tool called DeGuard and used it to: (i) reverse the layout obfuscation performed by the popular ProGuard system on benign, open-source applications, (ii) predict third-party libraries imported by benign APKs (also obfuscated by ProGuard), and (iii) rename obfuscated program elements of Android malware. The experimental results indicate that DeGuard is practically effective: it recovers 79.1% of the program element names obfuscated with ProGuard, it predicts third-party libraries with accuracy of 91.3%, and it reveals string decoders and classes that handle sensitive data in Android malware.

layout: publication

title: "Automatically generating features for learning program analysis heuristics"

authors: K. Chae, H. Oh, K. Heo, H. Yang

conference: ArXiV 1612.09394

year: 2016

bibkey: chae2016automatically

We present a technique for automatically generating features for data-driven program analyses. Recently data-driven approaches for building a program analysis have been proposed, which mine existing codebases and automatically learn heuristics for finding a cost-effective abstraction for a given analysis task. Such approaches reduce the burden of the analysis designers, but they do not remove it completely; they still leave the highly nontrivial task of designing so called features to the hands of the designers. Our technique automates this feature design process. The idea is to use programs as features after reducing and abstracting them. Our technique goes through selected program-query pairs in codebases, and it reduces and abstracts the program in each pair to a few lines of code, while ensuring that the analysis behaves similarly for the original and the new programs with respect to the query. Each reduced program serves as a boolean feature for program-query pairs. This feature evaluates to true for a given program-query pair when (as a program) it is included in the program part of the pair. We have implemented our approach for three real-world program analyses. Our experimental evaluation shows that these analyses with automatically-generated features perform comparably to those with manually crafted features.

layout: publication

title: "A deep language model for software code"

authors: H. K. Dam, T. Tran, T. Pham

conference: ArXiV 1608.02715

year: 2016

bibkey: dam2016deep

Existing language models such as n-grams for software code often fail to capture a long context where dependent code elements scatter far apart. In this paper, we propose a novel approach to build a language model for software code to address this particular issue. Our language model, partly inspired by human memory, is built upon the powerful deep learning-based Long Short Term Memory architecture that is capable of learning long-term dependencies which occur frequently in software code. Results from our intrinsic evaluation on a corpus of Java projects have demonstrated the effectiveness of our language model. This work contributes to realizing our vision for DeepSoft, an end-to-end, generic deep learning-based framework for modeling software and its development process.

layout: publication

title: "Semantically enhanced software traceability using deep learning techniques"

authors: J. Guo, J. Cheng, J. Cleland-Huang

conference: ICSE

year: 2017

bibkey: guo2017semantically

In most safety-critical domains the need for traceability is prescribed by certifying bodies. Trace links are generally created among requirements, design, source code, test cases and other artifacts; however, creating such links manually is time consuming and error prone. Automated solutions use information retrieval and machine learning techniques to generate trace links; however, current techniques fail to understand semantics of the software artifacts or to integrate domain knowledge into the tracing process and therefore tend to deliver imprecise and inaccurate results. In this paper, we present a solution that uses deep learning to incorporate requirements artifact semantics and domain knowledge into the tracing solution. We propose a tracing network architecture that utilizes Word Embedding and Recurrent Neural Network (RNN) models to generate trace links. Word embedding learns word vectors that represent knowledge of the domain corpus and RNN uses these word vectors to learn the sentence semantics of requirements artifacts. We trained 360 different configurations of the tracing network using existing trace links in the Positive Train Control domain and identified the Bidirectional Gated Recurrent Unit (BI-GRU) as the best model for the tracing task. BI-GRU significantly out-performed state-of-the-art tracing methods including the Vector Space Model and Latent Semantic Indexing.

layout: publication

title: "DeepFix: Fixing Common C Language Errors by Deep Learning"

authors: R. Gupta, S. Pal, A. Kanade, S. Shevade

conference: AAAI

year: 2017

bibkey: gupta2017deepfix

The problem of automatically fixing programming errors is a

very active research topic in software engineering. This is a

challenging problem as fixing even a single error may require

analysis of the entire program. In practice, a number of errors

arise due to programmer’s inexperience with the programming language or lack of attention to detail. We call these

common programming errors. These are analogous to grammatical errors in natural languages. Compilers detect such errors, but their error messages are usually inaccurate. In this

work, we present an end-to-end solution, called DeepFix, that

can fix multiple such errors in a program without relying on

any external tool to locate or fix them. At the heart of DeepFix

is a multi-layered sequence-to-sequence neural network with

attention which is trained to predict erroneous program locations along with the required correct statements. On a set of

6971 erroneous C programs written by students for 93 programming tasks, DeepFix could fix 1881 (27%) programs

completely and 1338 (19%) programs partially.

layout: publication

title: "CodeSum: Translate Program Language to Natural Language"

authors: X. Hu, Y. Wei, G. Li, Z. Jin

conference: ArXiV 1708.01837

year: 2017

bibkey: hu2017codesum

During software maintenance, programmers spend a lot of time on code comprehension. Reading comments is an effective way for programmers to reduce the reading and navigating time when comprehending source code. Therefore, as a critical task in software engineering, code summarization aims to generate brief natural language descriptions for source code. In this paper, we propose a new code summarization model named CodeSum. CodeSum exploits the attention-based sequence-to-sequence (Seq2Seq) neural network with Structure-based Traversal (SBT) of Abstract Syntax Trees (AST). The AST sequences generated by SBT can better present the structure of ASTs and keep unambiguous. We conduct experiments on three large-scale corpora in different program languages, i.e., Java, C#, and SQL, in which Java corpus is our new proposed industry code extracted from Github. Experimental results show that our method CodeSum outperforms the state-of-the-art significantly.

layout: publication

title: "Summarizing Source Code using a Neural Attention Model"

authors: S. Iyer, I. Konstas, A. Cheung, L. Zettlemoyer

conference: ACL

year: 2016

bibkey: iyer2016summarizing

High quality source code is often paired

with high level summaries of the computation it performs, for example in code

documentation or in descriptions posted

in online forums. Such summaries are

extremely useful for applications such as

code search but are expensive to manually

author, hence only done for a small fraction of all code that is produced. In this

paper, we present the first completely data-driven approach for generating high level

summaries of source code. Our model,

CODE-NN , uses Long Short Term Memory (LSTM) networks with attention to

produce sentences that describe C# code

snippets and SQL queries. CODE-NN

is trained on a new corpus that is automatically collected from StackOverflow,

which we release. Experiments demonstrate strong performance on two tasks:

(1) code summarization, where we establish the first end-to-end learning results

and outperform strong baselines, and (2)

code retrieval, where our learned model

improves the state of the art on a recently

introduced C# benchmark by a large margin.

layout: publication

title: "Automatically Generating Commit Messages from Diffs using Neural Machine Translation"

authors: S. Jiang, A. Armaly, C. McMillan

conference: ArXiV 1708.09492

year: 2017

bibkey: jiang2017automatically

Commit messages are a valuable resource in comprehension of software evolution, since they provide a record of changes such as feature additions and bug repairs. Unfortunately, programmers often neglect to write good commit messages. Different techniques have been proposed to help programmers by automatically writing these messages. These techniques are effective at describing what changed, but are often verbose and lack context for understanding the rationale behind a change. In contrast, humans write messages that are short and summarize the high level rationale. In this paper, we adapt Neural Machine Translation (NMT) to automatically "translate" diffs into commit messages. We trained an NMT algorithm using a corpus of diffs and human-written commit messages from the top 1k Github projects. We designed a filter to help ensure that we only trained the algorithm on higher-quality commit messages. Our evaluation uncovered a pattern in which the messages we generate tend to be either very high or very low quality. Therefore, we created a quality-assurance filter to detect cases in which we are unable to produce good messages, and return a warning instead.

layout: publication

title: "A Factor Graph Model for Software Bug Finding"

authors: T. Kremenek, A.Y. Ng, D. Engler

conference: IJCAI

year: 2007

bibkey: kremenek2007factor

Automatic tools for finding software errors require

knowledge of the rules a program must obey, or

“specifications,” before they can identify bugs. We

present a method that combines factor graphs and

static program analysis to automatically infer specifications directly from programs. We illustrate the

approach on inferring functions in C programs that

allocate and release resources, and evaluate the approach on three codebases: SDL, OpenSSH, and

the OS kernel for Mac OS X (XNU). The inferred

specifications are highly accurate and with them we

have discovered numerous bugs.