Attilio Picoco · 2012
Student: Attilio Picoco Title: Modular Extraction of Control-Flow Graphs from Java Bytecode Abstract: In the current project we present a strategy to perform the extraction of Control-Flow Graphs (CFG) from Java Bytecode in a modular fashion. A modular approach allows to analyze incomplete systems, that is, software systems whose some of its components are not available. Our solution is based on the notion of interfaces. This technique requires the user to make some assumptions on the missing components. This information is necessary to resolve any of the inter-dependencies present in the system that involve the missing parts. We base our strategy on two previous results. First, we extend a formal definition of the Java Virtual Machine framework to represent incomplete Bytecode programs. This allows us to manage the presence of different configurations of a program whenever any component is either newly provided or modified or added. We define a refinement relation. We check if such a relation exists between two versions of the program, according to some formal rules. Next, we generalize a previous algorithm that performs the extraction of CFGs for closed programs only. We adapt it to cope with those methods not provided. The algorithm uses the information provided for the missing methods by the user to resolve any inter-dependence between an available method and a missing one. Inter-dependencies exist in terms of method invocations. In fact, there may be a call which can go either to missing method, or to a concrete one. Whenever there is a method invocation, we soundly over-approximate the possible receivers to the call, and the set of exceptions potentially propagated by them. We implemented the modular extraction framework in the ConFlEx tool. The tool checks if a given method is missing. If it is, the tool perform the over-approximations mentioned. Moreover, ConFlEx compares two versions of a program and checks if one refines the other, following the refinement rules we have defined. If it does, the tool performs the extraction of CFGs incrementally. Finally, the tool can also store and load partially the results obtained so that they can be reused in a later execution. Our technique over-approximate a lot to achieve soundness. Despite this, our test cases show that ConFlEx is efficient. Moreover, the extraction of the CFGs gets considerable speed-up by reusing results from previous analyses, whenever the task is performed after providing those components not available originally.
Cited by 1
Dongjin Yu, Jiazha Yang, Xin Chen et al. · IEEE Access · 2019
When the source code is copied and pasted or modified, there will be a lot of identical or similar code snippets in the software system, which are called code clones. Because code clones are believed to result in undesirable maintainability of software, numerous approaches and techniques have been proposed for code clone detection. However, most of them are based on the source code, while only a few employ the bytecode to detect code clones. In this paper, we introduce an approach based on Java bytecode, which mainly contains the steps of bytecode sequence alignment and similarity score comparison. In particular, we apply the Smith-Waterman algorithm to align bytecode sequences for precise matching. Moreover, we separately consider the similarities between instruction sequences and method call sequences, thus improving its effectiveness in detecting code clones. We conducted an extensive experiment on five open-source software to evaluate the proposed approach. The results show that our approach outperforms other state-of-the-art techniques.
Cited by 25Open access
Tsakani Joseph Mbhambhu · SUNScholar (Stellenbosch University) · 2002
Cited by 0Open access
Wang Tong-yang, Pengfei Yu, Wu Jun-jun et al. · Journal of Computers · 2009
The bytecode verification is a key point of the security chain of the Java Platform. This feature is optional in many embedded devices since the memory requirements of the verification process and the process capability of hardware are too high. In this paper we propose a verifier that utilizes the logical flow graph based cache policy and an improved non stressing type coding method, for the bytecode verification on the Java card, which remarkably reduces the use of the memory by the scheduling algorithm of the bytecode verifier. Off-card pre-processing is unnecessary for the bytecode, hence it is possible to be implemented on card and to prevent any bytecode, which is correct yet not pre-processed, from being refused by the oncard verifier. This algorithm also features strong transportability and feasibility with a perfect verification process based on traditional bytecode verification. The results of the experiments show that this bytecode verification can be performed directly on small memory systems.
Cited by 1
Pawel Swierszcz · 2008
Abstract. Java’s features such as system platform independence, dynamic and network oriented architecture, robustness as well as growing number of common standards make it a language of choice for many projects. However an increasing complexity of created software and requirement for high stability and high quality of applications make it desirable for a developer to inspect, monitor, debug or in any way alter Java programs behaviour on-the-fly. The main goal of this paper is to present the design of a system for instrumenting Java classes at runtime. This system is to aid developer in modifying program by adding fragments of code at specific locations that implement some new functionality. This allows programmer to enhance classes with logging, monitoring, caching or any other capabilities that are required at run-time. Keywords: Java, instrumentation, bytecode, J-OMIS, J-OCM 1
Cited by 0
Gerwin Klein · 2002
Cited by 0
Alam, Muhammed Jawaherul, Goodrich, Michael T., Johnson, Timothy · Graph Drawing E-print Archive (Die Universität zu Köln) · 2016
Cited by 0
Soomro, Safeeullah, Belgaum, Mohammad Riyaz, Alansari, Zainab et al. · arXiv (Cornell University) · 2019
In the domain of Software Engineering, program analysis and understanding has been considered to be a very challenging task since decade, as it demands dedicated time and efforts. The analysis of source code may occasionally be comparatively easier due to its static nature, however, the back end code (Bytecode), especially in terms of Java programming, is complicated to be analysed. In this paper, we present a methodological approach towards understanding the Bytecode of Java programs. We put forward a framework for the debugging process of Java Bytecode. Furthermore, we discuss the debugging process of Bytecode understanding from simple to multiple statements with regards to data flow analysis. Finally, we present a comparative analysis of Bytecode along with the simulation of the proposed framework for the debugging process
Cited by 0Open access
Walter Binder, Jarle Hulaas, Philippe Moret · 2007
Java bytecode instrumentation is a widely used technique, especially for profiling purposes. In order to ensure the instrumentation of all classes in the system, including dynamically generated or downloaded code, instrumentation has to be performed at runtime. The standard JDK offers some mechanisms for dynamic instrumentation, which however either require the use of native code or impose severe restrictions on the instrumentation of certain core classes of the JDK. These limitations prevent several instrumentation techniques that are important for efficient, calling context-sensitive profiling. In this paper we present a generic bytecode instrumentation framework that goes beyond these restrictions and enables the customized, dynamic instrumentation of all classes in pure Java. Our framework addresses important issues, such as bootstrapping an instrumented JDK, as well as avoiding measurement perturbations due to dynamic instrumentation or execution of instrumentation code. We validated and evaluated our framework using an instrumentation for exact profiling which generates complete calling context trees of various platform-independent dynamic metrics.
Cited by 0
Étienne Payet, Fausto Spoto · Lecture notes in computer science · 2007
Cited by 13
Andreas Gal, Christian W. Probst, Michael Franz · 2008
Existing Java verifiers perform an iterative data-flow analysis to discover the unambiguous interpretation to obtain definition/use information for each register and stack location in the program, which in turn is used to transform the program into Static Single Assignment form. In SSA, verification is reduced to simple type compatibility checking between the definition type of each SSA variable and the type of each of its uses. Inter-adjacent transitions of a value through stack and registers are no longer verified explicitly. This integrated approach is more efficient than traditional bytecode verification but still as safe as strict verification, as overall program correctness can be induced once the data flow from each definition to all associated uses is known to be type-safe. Key words: abstract interpretation, verification, optimization 1
Cited by 0
2008
Abstract interpretation [10] has served as a primary framework for the formalderivation of static analyses from the property of interest. It features the ability
Cited by 0
E. Albert, P. Arenas, S. Genaim et al. · 2008
Cited by 0
Verifier Andreas Gal, Andreas Gal, Christian W. Probst et al. · 2003
Java Bytecode Verification was so far mostly approached from a correctness perspective. Security vulnerabilities have been found repeatedly and were corrected shortly thereafter. However, correctness is not the only potential point of failure in the verifier idea. In this paper we construct Java code, which is correct, but requires an excessive amount of time to prove safety. In contrast to previous flaws in the bytecode verifier, the enabling property for this exploit lies in the verification algorithm itself and not in the implementation and is thus not easily fixable. We explain how this architectural weakness could be exploited for denial-of-service attacks on JVM-based services and devices.
Cited by 0
Robert O'Callahan · 2007
A type system with proven soundness is a prerequisite for the safe and efficient execution of Java bytecode programs. So far, eftbrts to construct such a type system have followed a "forward dataflow" approach, in the spirit of the original Java Virtual Machine bytecode verifier. We present an alternative type system, based on conventional ideas of type constraints, polymorphic recursion and continuations. We compare it to Stata and Abadi's JVML-0 type system for bytecode subroutines, and demonstrate that our system is simpler and able to type strictly more programs, including code that could be produced by Java compilers and cannot be typed in JVML-0. Examination of real Java programs shows that such code is rare but does occur. We explain some of the apparently arbitrary constraints imposed by previous approaches by showing that they are consequences of our simpler type rules, or actually unnecessary.
Cited by 0
Fausto Spoto, Lunjin Lu, Fred Mesnard · Electronic Notes in Theoretical Computer Science · 2009
Cited by 5Open access
Diana Vanessa Ramírez Deantes · Dialnet (Universidad de la Rioja) · 2011
Static program analysis of object-oriented languages poses some
challenges for termination analyzers. One of these challenges is that
termination analysis traditionally requires the use of global analysis
techniques to prove that the execution of an entry method terminates
for any input value. In order to solve this problem, it is necessary
to prove termination for all methods invoked from the entry method
during its execution. Scalability is an important disadvantage of
global analysis, especially in memory consumption, because it needs to
analyze over and over again the whole code even if there is a small
part modified. It also requires to have the code available, of all
methods reachable from the method being analyzed.
Some techniques developed to provide a modular termination analysis of
a Java program, are presented in an approach that allows a high level of
scalability, granularity and reusability to perform termination
analysis of incomplete code. This approach is able to
decompose large programs into small parts and can reuse previous
analysis results. Also it allows reusability and scalability through
the use of assertions, to store the analysis results obtained by analyzing a
method at a time. Then the assertions generated are applied to the
analysis of subsequent methods.
Most static analyzers do not keep track of object fields, because they
are field-insensitive. This type of analysis produces too imprecise
results whereas applying only field-sensitive analysis is
computationally intractable. There has been significant interest in
developing techniques that result in a good balance between the
accuracy of analysis and its associated computational cost. To solve
this challenge, an implementation of field-sensitive analysis
performed on object fields is presented. This transformation is based
on a context-sensitive analysis that splits a program into fragments,
to provide a safe way to replace an object field by a local variable
in each fragment. Also using a polyvariant transformation achieves, a
very good balance between accuracy and efficiency.
The modular and field-sensitive termination analyses were developed,
implemented and tested in a COSt and Termination Analyzer of java
bytecode(COSTA). An analyzer that receives as entry a method
signature and infers termination for all possible input values of its
code and related methods.
In order to test the applicability of the modular termination
framework it has been applied to phoneME core libraries. Based on the
implementation of Java Micro Edition (JavaME), that corresponds to
the libraries used for developing mobile applications or MIDlets. Also
these libraries have been used for estimating execution time of a
mobile application, before running it in a specific mobile device.
Finally, another contribution of this thesis is the availability of
the COSTA system through a web interface, to allow users try out the
system on a set of representative examples, and also to upload their
own bytecode programs.
Cited by 0
S Parthasarathy, Michał Cierniak, Li, Wei · 1996
In this paper we present a system for network based visualization of profile information generated by Java applets/bytecode. The system, called NetProf, is composed of several components each of which is interesting in their own right. The components are a bytecode to Java source code translator, a profiler that includes a static pass to insert profiler code, a dynamic runtime library that records relevant events and finally a visualization mechanism which highlights the profile information in an easy to use manner. All of this can be done over the Internet using a client-server approach and is independent of the underlying architecture/machine and human intervention. Keywords: Java, Bytecode, Profiling, Visualization, Client-Server, World Wide Web, Internet. The University of Rochester Computer Science Department supported this work. This work was supported in part by an NSF Research Initiation Award (CCR-9409120) and ARPA contract F19628-94-C-0057. 1 Introduction The past few...
Cited by 3
Gaowei Bian, Ken Nakayama, Yoshitake Kobayashi et al. · 2005
Java programs can be transmitted and executed on another host in bytecode format, thus the sensitive information of the host may be leaked via these assembly-like programs. Information flow policy can ensure data confidentiality, however, conventional information flow analysis mainly focused on the programs written in high-level programming languages and is generally performed by type checking approach, which assigns security classes to the variables then verifies information flow policy in program executing order. These approaches are inadequate to address the information flow in bytecode and the type systems verification method is imprecise. This paper presents a method to disclose java bytecode information flow by dependence analysis, in which the information flow analysis is separated to two phases to improve precision. First is determining information dependence relationship among the variables in the bytecode then is verifying the security based on security class. A prototype tool has been developed, by which the bytecode information flow of object or class files can be analyzed.
Cited by 0
Giacomo Cabri, Luca Ferrari, Letizia Leonardi · IBM Systems Journal · 2005
Agents are problem-solving entities that can be used to develop complex and distributed systems because they are autonomous, mobile, reactive, social, and proactive. Today's trends in agent technology include the development of applications as multi-agent systems, where several agents interact within the same application. In these systems, the interactions among agents must be carefully considered. Roles constitute a powerful paradigm for modeling interactions, allowing algorithmic issues and interaction-dependent issues to be handled independently. In this paper, we present the RoleX interaction infrastructure, which enables Java™ agents to dynamically assume and use roles at runtime. Our approach is based on using bytecode manipulation to add (or remove) Java members from agents, changing their capabilities. We detail the main component of RoleX, the Role Loader, which performs the bytecode manipulation that allows agents to dynamically assume and release roles.
Cited by 25Open access