Using recurrent neural networks for decompilation

Code comparison methods and tools are widely spread. However, most of the approaches target either only source code or only binary code, and methods for matching binary to source code are less investigated. In this article, we introduce Bin2Source: a tool for matching binary to source code. It gets as input a binary code (without debug information) and source code with its compilation commands. As a result, the tool returns matched functions and instructions of binary and source code. The major advantage of Bin2Source compared with existing tools is the capacity to perform instruction-to-instruction matching. The tool can be used for copyright infringements detection, algorithm recovery from binaries, third-party software detection in binaries, bugs detection, etc. Additionally, we propose a testing system to evaluate our tool's results. According to the developed testing system, Bin2Source has 85.66% precision, 83.26% recall, and 84.35% F1 score on average.

Source code instrumentation is a widely used method to generate fast software simulation models by annotating timing information into application source code. Source-level simulation models can be easily integrated into SystemC based simulation environment for fast simulation of complex multiprocessor systems. The accurate back-annotation of the timing information relies on the mapping between source code and binary code. The compiler optimizations might make it hard to get accurate mapping information. This paper addresses the mapping problems caused by complex compiler optimizations, which are the main source of simulation errors. To obtain accurate mapping information, we propose a method called fine-grained flow mapping that establishes a mapping between sequences of control flow of source code and binary code. In case that the code structure of a program is heavily altered by compiler optimizations, we propose to replace the altered part of the source code with functionally-equivalent IR-level code which has an optimized structure, leading to Partly Optimized Source Code (POSC). Then the flow mapping can be established between the POSC and the binary code and the timing information is back-annotated to the POSC. Our experiments demonstrate the accuracy and speed of simulation models generated by our approach.

The invention of Fountain codes is a major advance in the field of error correcting codes. The goal of this work is to study and develop algorithms for source and channel coding using a family of Fountain codes known as Raptor codes. From an asymptotic point of view, the best currently known sum-product decoding algorithm for non binary alphabets has a high complexity that limits its use in practice. For binary channels, sum-product decoding algorithms have been extensively studied and are known to perform well. In the first part of this work, we develop a decoding algorithm for binary codes on non-binary channels based on a combination of sum-product and maximum-likelihood decoding. We apply this algorithm to Raptor codes on both symmetric and non-symmetric channels. Our algorithm shows the best performance in terms of complexity and error rate per symbol for blocks of finite length for symmetric channels. Then, we examine the performance of Raptor codes under sum-product decoding when the transmission is taking place on piecewise stationary memoryless channels and on channels with memory corrupted by noise. We develop algorithms for joint estimation and detection while simultaneously employing expectation maximization to estimate the noise, and sum-product algorithm to correct errors. We also develop a hard decision algorithm for Raptor codes on piecewise stationary memoryless channels. Finally, we generalize our joint LT estimation-decoding algorithms for Markov-modulated channels. In the third part of this work, we develop compression algorithms using Raptor codes. More specifically we introduce a lossless text compression algorithm, obtaining in this way competitive results compared to the existing classical approaches. Moreover, we propose distributed source coding algorithms based on the paradigm proposed by Slepian and Wolf.

Embedded Domain-Specific Languages (EDSLs) are an alternative to quickly implement specialized languages without the need to write compilers or interpreters from scratch. In this territory, Haskell is a prime choice as the host language. EDSLs in Haskell, however, are often incapable of reifying useful static information from the source code, namely variable binding names and source locations. Not having access to variable names directly affects EDSLs designed to generate low-level code, where the variables names in the generated code do not match those found in the source code—thus broadening the semantic gap among source and target code. Similarly, many existing EDSLs produce poor error messages due to the lack of knowledge of source locations where errors are generated.

Against the “Networked Information Economy”: Rethinking Decentralization, Community, and Free Software Development Ben Roberts (bio) The free, libre, and open source software (FLOSS) movement is often cited as an example of fundamental changes in production associated with the rise of information networks. Don Tapscott and Anthony D. Williams see it as an example of wikinomics, a powerful new form of economic production based on sharing and self-organization.1 Yochai Benkler argues that the form of social or peer production evident in FLOSS can compete with or even displace traditional forms of capitalist organization and sees it as a symptom of the “networked information economy,” replacing the “industrial information economy,” which has been in force since the late-nineteenth century.2 The main feature of this networked information economy is the much greater role within it for decentralized individual action.3 This essay contests this broadly liberal take on the significance of the free software movement. It argues that Benkler is typical of an approach that tends to view the Internet as the primary enabler of decentralization (for example, in the form of decentralized software development). Of course, it would be foolish to discount the role that networks have played in the success of FLOSS. But, as I will argue, an examination of its history suggests that its origins can’t be entirely accounted for in purely technological and economic grounds. The proponents of such an approach often resist the claim that their focus on networks is technologically determinist,4 arguing that the network itself is shaped by social and cultural factors. However, this makes the explanatory power of networks rather circular: the existence of networks explains social and cultural behavior at the same time as being explained by it. The explanation of free software in terms of the economic properties of networks is simply too static and asocial; it serves to explain how a particular mode of production can functionally compete with the market without really being able to account for how this change has come about. In particular, as I will show, the marginalization [End Page 385] of the question of labor in theories of peer production disconnects the analysis from wider changes in the nature of economic production. Moreover, the emphasis on the empowerment of individuals ignores the possibility that decentralization consists in radical new forms of sociality and collectivity, something that can perhaps be seen in the communities built around particular free software projects. As I will argue, Gilbert Simondon’s concept of individuation may help inform a better understanding of the emergence of such free software communities. From the perspective of a nonprogrammer, it is easiest to understand the concept of FLOSS by explaining how proprietary software such as Microsoft Windows is distributed. The operating system and applications that users run on their personal computers (PCs) are most often compiled software. The creators of the application have written the code in any one of a number of different human-readable programming languages; this program is known as the source code. The source code is then converted by another program known as a compiler into object or binary code, which is a machine-readable version of the program executed when the application is run on a PC. Binary, or object, code is the form in which software is most often distributed to users, either on installation media such as compact discs (CDs), installed on a computing device before sale or, increasingly, downloaded over the Net. The end user of proprietary software created and distributed in this fashion has no access to the original source code and is therefore unable to alter, change, or fix the software running on their machine: in the words of Bob Young, the former chief executive officer (CEO) of open source software company Red Hat, purchasing proprietary software is like buying a “car with the hood welded shut.”5 In addition to the absence of source code, proprietary software is usually distributed under the terms of a highly restrictive software license. In effect, the applications run by a user remain the property of the software maker and may be used only under the terms of this contract. Typically, the license prevents sharing...

Deep learning to binary coding improves multivariate time series retrieval performance by end-to-end representation learning and binary codes from training data. However, it is fair to say that exist deep learning retrieval methods, e.g., Encoder-Decoder based on recurrent or Convolutional neural network, failed to capture the latent dependencies between pairs of variables in multivariate time series, which results in substantial loss of retrieval quality. Furthermore, supervised deep learning to binary coding failed to meet the requirements in practice, due to the lack of labeled multivariate time series datasets. To address the above issues, this paper presents Unsupervised Transformer-based Binary Coding Networks (UTBCNs), a novel architecture for deep learning to binary coding, which consists of four key components, Transformer-based encoder (T-encoder), Transformer-based decoder (T-decoder), an adversarial loss, and a hashing loss. We employ the Transformer encoder-decoder to encode temporal dependencies, and inter-sensor correlations within multivariate time series by attention mechanisms solely. Meanwhile, to enhance the generalization capability of deep network, we add an adversarial loss based upon improved Wasserstein GAN (WGAN-GP) for real multivariate time series segments. To further improve of quality of binary code, a hashing loss based upon Convolutional encoder (C-encoder) is designed for the output of T-encoder. Extensive empirical experiments demonstrate that the proposed UTBCNs can generate high-quality binary codes and outperform state-of-the-art binary coding retrieval models on Twitter dataset, Air quality dataset, and Quick Access Recorder (QAR) dataset.

To implement a program functionality, developers can reuse previously written code snippets by searching through a large-scale codebase. Over the years, many code search tools have been proposed to help developers. The existing approaches often treat source code as textual documents and utilize information retrieval models to retrieve relevant code snippets that match a given query. These approaches mainly rely on the textual similarity between source code and natural language query. They lack a deep understanding of the semantics of queries and source code. In this paper, we propose a novel deep neural network named CODEnn (Code-Description Embedding Neural Network). Instead of matching text similarity, CODEnn jointly embeds code snippets and natural language descriptions into a high-dimensional vector space, in such a way that code snippet and its corresponding description have similar vectors. Using the unified vector representation, code snippets related to a natural language query can be retrieved according to their vectors. Semantically related words can also be recognized and irrelevant/noisy keywords in queries can be handled. As a proof-of-concept application, we implement a code search tool named DeepCS using the proposed CODEnn model. We empirically evaluate DeepCS on a large scale codebase collected from GitHub. The experimental results show that our approach can effectively retrieve relevant code snippets and outperforms previous techniques.

Many safety-critical real-time embedded systems need to meet stringent timing constraints such as preserving delay bounds between input and output events. In model-based development, a system is often implemented by using a code generator to automatically generate source code from system models, and integrating the generated source code with a platform. It is challenging to guarantee that the implemented systems preserve required timing constraints, because the timed behavior of the source code and the platform is closely intertwined. In this paper, we address this challenge by proposing a model transformation approach for the code generation. Our approach compensates the platform-processing delays by adjusting the timing parameters in system models, based on an Integer Linear Programming problem formulation. We demonstrate the usefulness of our approach via a case study of infusion pump systems. Experimental results show that the code generated using our approach can better preserve the timing constraints.

Internet code search is quite popular research area. StackOverflow allows developers to ask and answer questions about code. Previous approach to search code on StackOverflow uses tf-idf method that based on number of occurrences of words to recommend source code. This method has the disadvantage that variable or method identifiers are considered as normal words, even though identifiers are often a combination of two or more words. For example, there is an identifier named “randomString”. In that case, if we search using a keyword “random” the system probably will not recommend “randomString” because both words are different. Concept location can tackle this problem. Concept location has been used widely to obtain the correlation between code with a specific concepts or features. Previous research of concept location only focused on source code's comments, and relation among the objects within the source code. This research proposes a mechanism for finding code on StackOverflow uses Latent Dirichlet Allocation (LDA) using concept location in the preprocessing stage. Questions, answers, and code snippets about Java programming are downloaded from StackOverflow to a local repository. Corpuses are generated by extracting questions, answers and code snippets. Inferencing concept location from source code is created using LDA algorithm. Developers query concepts and then system will recommend source code based on the relevant concepts. The result of the experiment shows that the system is able to recommend source code with 48% average of precision and 58% average of recall.

Vulnerability detection across source and binary code is an important yet challenging task in software security research. Existing deep learning methods are mostly limited to a single modality and fail to effectively leverage complementary feature information between source and binary codes, thereby limiting detection capabilities and application scenarios. In this paper, we propose a cross-modal vulnerability detection framework based on modal adapters and memory alignment, <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$\text{MA}^{2}$</tex>-VD. Specifically, we first address heterogeneity differences across modalities using modality-specific adapters. Then, we construct a cross-modal feature memory bank based on FAISS, which implicitly aligns features by dynamically retrieving matching cross-modal features during inference to achieve memory alignment. We evaluated <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$\text{MA}^{2}$</tex>-VD on the dual-modal NVD dataset that contains both source and binary code samples. The results show that <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$\text{MA}^{2}$</tex>-VD outperforms the existing baseline methods by <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$5.21 \%, 1.23 \%, 9.86 \%$</tex>, and 5.71 % in terms of <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$F 1$</tex>-score, precision, recall, and accuracy, respectively. Ablation studies and incremental experiments further demonstrate the effectiveness of <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$\text{MA}^{2}$</tex>-VD in cross-modal vulnerability detection.

As a standard of operating system in automotive industry, OSEK/VDX is applied on dozens of mature industrial operating systems and widely installed on the products of major automotive manufacturers. In this empirical report, we introduce our experience on verifying OSEK/VDX real-time operating system. From both source code and binary code level, the OSEK/VDX operating system is verified based on approaches comprising Hoare Logic, Communicating Sequential Processes, Binary Code Analysis and Discrete-Time Markov Chains model checking. Based on our approach, a commercial OSEK/VDX standard automotive operating system is verified and it is proved to be of great help to the development of software.

This paper presents a semi-automatic methodology to create abstract driver models to be used as formal reference when developing the firmware for embedded device drivers. Our methodology extracts the behavior of driver software automatically as an abstract finite state machine. This replaces manually crafting these models from informal specifications, which is error-prone, laborious, and does not account for undocumented behavior. Our approach specifically targets untrusted driver software that is only available as binary code, for example as third-party IP, and for which the source code is unknown. Our extracted model is formally sound with respect to the implementation, while still being understandable by a human developer. Our experiments for industry-size driver software demonstrate that human-readable, sound, abstract driver models can be extracted from binary code in affordable run times and with small manual effort.

While finding clones in source code has drawn considerable attention, there has been only very little work in finding similar fragments in binary code and intermediate languages, such as Java bytecode. Some recent studies showed that it is possible to find distinct sets of clone pairs in bytecode representation of source code, which are not always detectable at source code-level. In this paper, we present a bytecode clone detection approach, called SeByte, which exploits the benefits of compilers (the bytecode representation) for detecting a specific type of semantic clones in Java bytecode. SeByte is a hybrid metric-based approach that takes advantage of both, Semantic Web technologies and Set theory. We use a two-step analysis process: (1) Pattern matching via Semantic Web querying and reasoning, and (2) Content matching, using Jaccard coefficient for set similarity measurement. Semantic Web-based pattern matching helps us to find method blocks which share similar patterns even in case of extreme dissimilarity (e.g., numerous repetitions or large gaps). Although it leads to high recall, it gives high false positive rate. We thus use the content matching (via Jaccard) to reduce false positive rate by focusing on content semantic resemblance. Our evaluation of four Java systems and five other tools shows that SeByte can detect a large number of semantic clones that are either not detected or supported by source code based clone detectors.

Third-party libraries (TPLs) are reused frequently in software applications for reducing development cost. However, they could introduce security risks as well. Many TPL detection methods have been proposed to detect TPL reuse in Android bytecode or in source code. This paper focuses on detecting TPL reuse in binary code, which is a more challenging task. For a detection target in binary form, libraries may be compiled and linked to separate dynamic-link files or built into a fused binary that contains multiple libraries and project-specific code. This could result in fewer available code features and lower the effectiveness of feature engineering. In this paper, we propose a binary TPL reuse detection framework, LibDB, which can effectively and efficiently detect imported TPLs even in stripped and fused binaries. In addition to the basic and coarse-grained features (string literals and exported function names), LibDB utilizes function contents as a new type of feature. It embeds all functions in a binary file to low-dimensional representations with a trained neural network. It further adopts a function call graph-based comparison method to improve the accuracy of the detection. LibDB is able to support version identification of TPLs contained in the detection target, which is not considered by existing detection methods. To evaluate the performance of LibDB, we construct three datasets for binary-based TPL reuse detection. Our experimental results show that LibDB is more accurate and efficient than state-of-the-art tools on the binary TPL detection task and the version identification task. Our datasets and source code used in this work are anonymously available at https://github.com/DeepSoftwareAnalytics/LibDB.

We propose a new approach to an automatic source code generator for the AUTOSAR-based vehicular software. The growing number of electrics/electronics software in vehicle systems makes more and more necessary the increasing demands. For example, it needs the essential requirements such as ensuring reliability, low production cost, coping with limited resources, and so on. Recently, there have been relative studies that point to this issue. An AUTOSAR development partnership is such a case. AUTOSAR is a standardized automotive software architecture which is an alliance of OEM and supplier. Now, the focus is mainly directed at a source code generator that deals with the AUTOSAR standard concept. In this paper, we present a novel source code generator which is based on the AUTOSAR software platform. The experimental process is presented to functionally verify the module, and structurally verify the generated source code.