Search 250 million research papers

µJava Java Virtual Machine and Bytecode Verifier – Subroutines –

Gerwin Klein · 2002

Cited by 0

Krakatoa: Decompilation in Java (Does Bytecode Reveal Source?)

Todd A. Proebsting, Scott A. Watterson · 1997

This paper presents our technique for automatically decompiling Java bytecode into Java source. Our technique reconstructs source-level expressions from bytecode, and reconstructs readable, high-level control statements from primitive goto- like branches. Fewer than a dozen simple coderewriting rules reconstruct the high-level statements. 1 Introduction Decompilation transforms a low-level language into a high-level language. The Java Virtual Machine (JVM) specifies a low-level bytecode language for a stack-based machine [LY97]. This language defines 203 operators, with most of the control flow specified by simple explicit transfers and labels. Compiling a Java class yields a class file that contains type information and bytecode. The JVM requires a significant amount of type information from the class files for object linking. Furthermore, the bytecode must be verifiably well-behaved in order to ensure safe execution. Decompilation systems can exploit this type information and well...

Cited by 0

A Space-Aware Bytecode Verifier for Java Cards

Cinzia Bernardeschi, Giuseppe Lettieri, Luca Martini et al. · Electronic Notes in Theoretical Computer Science · 2005

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 are too high. In this paper we propose a verification algorithm that remarkably reduces the use of the memory by performing the verification during multiple specialized passes. The algorithm reduces the type encoding space by operating on different abstractions of the domain of types. The results of the experiments show that this bytecode verification can be performed directly on small memory systems.

Cited by 3Open access

Java Bytecode Verification is not possible (Extended Abstract

Robert F. Stärk, Joachim Schmid · 2001

During an attempt to prove that our Java compiler in [6] generates code that is accepted by the Java Bytecode Verifier we found examples of legal Java programs which are rejected by any Bytecode Verifier. The examples show that Java Bytecode Verification as it has been introduced by Sun is not possible. We propose therefore to restrict the so-called rules of definite assignment for the try-finally statement as well as for the labeled statement such that our example programs are no longer allowed. Then we can prove, using the framework of Abstract State Machines (see [3, 1]), that each program from the restricted Java language is accepted by the Java Bytecode Verifier. The programs Test1 and Test2 in Table 1 are legal Java programs. When they are compiled using a standard Java compiler like Sun’s JDK 1.2 or 1.3 compiler, then the generated bytecode is rejected by any bytecode verifier we tried including JDK 1.2, JDK 1.3, Netscape 4.73–4.76, Microsoft VM for Java 5.0 and 5.5 and the Kimera Verifier [5]. The problem is that in the eyes of the verifier the variable i is unusable at the end of the method at the return i instruction, whereas according to the JLS [2, §16.2.14] the variable i is definitely assigned after the try-finally statement. The two programs Test1 and Test2 cannot be verified, because the class of valid Java programs is too large for verifiers. Our solution to the problem is to restrict the so-called “rules of definite assignment” for the try-finally and the labeled statement [2, §16.2.14 and §16.2.5]. The two restrictions of the rules of definite assignment are sufficient to prove the following theorem: Theorem 1 If a Java compiler satisfies the constraints of Part II in [6], then the bytecode it generates from valid Java programs of the restricted Java language will be accepted by a correct bytecode verifier. A compiler satisfying the constraints of Part II in [6] must compile boolean test expressions in a special way taking care of the boolean literals true and false. It must compile try-finally statements as it is described in [4, §7.13]. class Test1 { int m1(boolean b) { int i; try { if (b) return 1; i = 2;} finally { if (b) i = 3; return i;

Cited by 0

Memory and Time Consumption of Java Bytecode Programs

Laurent Hubert · 2006

Mobile code is spreading in our daily life and an important part of this code is in Java bytecode. This is the main language for applications for mobile phones, PDAs (Personal Digital Assistant) and smartphones. For the consumer, i.e the mobile device user, to trust the software he wants to

Cited by 0

Checking security of Java bytecode by abstract interpretation

Roberto Barbuti, Cinzia Bernardeschi, Nicoletta De Francesco · 2002

We present a method to certify a subset of the Java bytecode, with respect to security. The method is based on abstract interpretation of the operational semantics of the language. We define a concrete small-step enhanced semantics of the language, able to keep information on the flow of data and control during execution. A main point of this semantics is the handling of the influence of the information flow on the operand stack. We then define an abstract semantics, keeping only the security information and forgetting the actual values. This semantics can be used as a static analysis tool to check security of programs. The use of abstract interpretation allows, on one side, being semantics based, to accept as secure a wide class of programs, and, on the other side, being rule based, to be fully automated.

Cited by 25

Trace-based Debloat for Java Bytecode, experiment results

César Soto-Valero, Thomas Durieux, Nicolas Harrand et al. · Zenodo (CERN European Organization for Nuclear Research) · 2020

This entry contains the experiment results of the paper <em>Trace-based Debloat for Java Bytecode. </em>It contains executions logs, coverage reports, test results reports, jars.

Cited by 0Open access

µJava Java Virtual Machine and Bytecode Verifier – Arrays –

Gerwin Klein · 2002

Cited by 0

A Specification of Java Loading and Bytecode Verification

Allen Goldberg Kestrel, Allen Goldberg · 1998

This paper gives a mathematical specification the Java Virtual Machine (JVM) bytecode verifier. The specification is an axiomatic description of the verifier that makes precise subtle aspects of the JVM semantics and the verifier. We focus on the use of data flow analysis to verify type-correctness and the use of typing contexts to insure global type consistency in the context of an arbitrary strategy for dynamic class loading. The specification types interfaces with sufficient accuracy to eliminate run-time type checks. Our approach is to specify a generic dataflow architecture and formalize the JVM verifier as an instance of this architecture. The emphasis in this paper is on readability of the specification and mathematical clarity. The specification given is consistent with the descriptions in the Lindholm&amp;apos;s and Yellin&amp;apos;s The Java^TM Virtual Machine Specification. It less committed to certain implementation choices than Sun&amp;apos;s version 1.1 implementation. In particular, the specification does not commit an implementation to any loading strategy, and detects all type errors as early as possible.

Cited by 0

Bytecode Similarity Detection for Obfuscated Java Android Applications

Munkhjargal, Misheelt · Spectrum Research Repository (Concordia University) · 2024

Code similarity detection has many practical applications, such as intellectual property protection, vulnerability search, and malware detection. However, existing approaches typically focus on the source code, while many third-party libraries are released in bytecode format. Hence, developers may unknowingly use third-party libraries without knowing possible license violations or vulnerabilities. In this thesis, we introduce a deep learning approach, ByClone, to detect source code clones based on Java bytecode. We collect source-code level clone data for bytecode in 140 Android applications to conduct the experiments. We find that ByClone is effective in detecting code clones based on bytecode, with a precision and recall of 78.37 and 75.24. After obfuscating the bytecode, ByClone still has a precision and recall of 82.55 and 70.95, highlighting the potential of ByClone. Finally, we find that ByClone is not sensitive to different obfuscation options. Our study highlights the potential of clone detection based on bytecode. We also release the data for future research in this direction.

Cited by 0Open access

Mobile Code Security by Java Bytecode Instrumentation\\Lambda

2008

Cited by 0

Trace-based Debloat for Java Bytecode, experiment results

César Soto-Valero, Thomas Durieux, Nicolas Harrand et al. · Zenodo (CERN European Organization for Nuclear Research) · 2020

This entry contains the experiment results of the paper <em>Trace-based Debloat for Java Bytecode. </em>It contains executions logs, coverage reports, test results reports, jars.

Cited by 0Open access

Bytecode 2007 Preliminar Version An Efficient, Parametric Fixpoint Algorithm for Analysis of Java Bytecode Abstract

Mario Méndez, Jorge Navas, Manuel V. Hermenegildo · 2008

Abstract interpretation has been widely used for the analysis of object-oriented languages and, in particular, Java source and bytecode. However, while most existing work deals with the problem of finding expressive abstract domains that track accurately the characteristics of a particular concrete property, the underlying fixpoint algorithms have received comparatively less attention. In fact, many existing (abstract interpretation based–) fixpoint algorithms rely on relatively inefficient techniques for solving inter-procedural call graphs or are specific and tied to particular analyses. We also argue that the design of an efficient fixpoint algorithm is pivotal to supporting the analysis of large programs. In this paper we introduce a novel algorithm for analysis of Java bytecode which includes a number of optimizations in order to reduce the number of iterations. The algorithm is parametric-in the sense that it is independent of the abstract domain used and it can be applied to different domains as “plug-ins”-, multivariant, and flow-sensitive. Also, is based on a program transformation, prior to the analysis, that results in a highly uniform representation of all the features in the language and therefore simplifies analysis. Detailed descriptions of decompilation solutions are given and discussed with an example. We also provide some performance data from a preliminary implementation of the analysis. 1 The authors would like to thank Samir Genaim for useful discussions on the topic of the paper, as well

Cited by 0

Design and implementation of bytecode-based Java slicing system

F. Umemori, K. Konda, Reishi Yokomori et al. · 2004

A program slice is a set of statements that affect the value of a variable v in a statement s. In order to calculate a program slice, we must know the dependence relations between statements in the program. Program slicing techniques are roughly divided into two categories, static slicing and dynamic slicing, and we have proposed DC slicing technique which uses both static and dynamic information. We propose a method of constructing a DC slicing system for Java programs. Java programs have many elements which are dynamically determined at the time of execution, so the DC slicing technique is effective in the analysis of Java programs. To construct the system, we have extended a Java virtual machine for extraction of dynamic information. We have applied the system to several sample programs to evaluate our approach.

Cited by 28

Evaluation Results for: DALEQ - Explainable Equivalence for Java Bytecode

Dietrich, Jens, Hassanshahi, Behnaz · Zenodo (CERN European Organization for Nuclear Research) · 2025

This is the dataset created by running the evaluation experiments for the paper DALEQ - Explainable Equivalence for Java Bytecode. It uses this dataset as input: https://zenodo.org/records/14915249 .

Cited by 0Open access

Abstract Bytecode 2005 Preliminary Version Towards Verification of Well-Formed Transactions in Java Card Bytecode

René Rydhof Hansen, Mathematical Modelling, Igor A. Siveroni · 2008

Using transactions in Java Card bytecode programs can be rather tricky and requires special attention from the programmer in order to work around some of the limitations imposed and to avoid introducing serious run-time errors due to inappropriate use of transactions. In this paper we present a novel analysis that combines control and data flow analysis with an analysis that tracks active transactions in a Java Card bytecode program. We formally prove the correctness of the analysis and show how it can be used to solve the above problem of guaranteeing that transactions in a Java Card bytecode program are well-formed and thus do not give rise to run-time errors.

Cited by 0

Decompilation of Java Bytecode to Prolog by Partial Evaluation

Elvira Albert · 2009

The interpretative approach to compilation allows compiling programs by partially evaluating an interpreter w.r.t. a source program. This approach, though very attractive in principle, has not been widely applied in practice mainly because of the difficulty in finding a partial evaluation strategy which always obtain “quality ” compiled programs. In spite of this, in recent work we have performed a proof of concept of that, at least for some examples, this approach can be applied to decompile Java bytecode into Prolog. This allows applying existing advanced tools for analysis of logic programs in order to verify Java bytecode. However, successful partial evaluation of an interpreter for (a realistic subset of) Java bytecode is a rather challenging problem. The aim of this work is to improve the performance of the decompilation process above in two respects. First, we would like to obtain quality decompiled programs, i.e., simple and small. We refer to this as the effectiveness of the decompilation. Second, we would like the decompilation process to be as efficient as possible, both in terms of time and memory usage, in order to scale up in practice. We refer to this as the efficiency of the decompilation. With this aim, we propose several techniques for improving the partial evaluation strategy. We argue that our experimental results show that we are able to improve significantly the efficiency and effectiveness of the decompilation process. 1

Cited by 0

\tAUTOMATED TERMINATION ANALYSIS OF JAVA BYTECODE BY TERM REWRITING

Carsten Otto, Marc Brockschmidt, Christian Von Essen et al. · 2010

We present an automated approach to prove termination of Java Bytecode (JBC) programs by automatically transforming them to term rewrite systems (TRSs). In this way, the numerous techniques and tools developed for TRS termination can now be used for imperative object-oriented languages like Java, which can be compiled into JBC.

Cited by 0

An Evaluation of Static Java Bytecode Watermarking [Draft Version]

James Hamilton, Sebastian Danicic · 2011

Abstract—The rise in the use of the Internet and bytecode languages such as Java bytecode and Microsoft’s Common Intermediate Language have made copying, decompiling and disassembling software easier. The global revenue loss due to software piracy was estimated to be more than $50 billion in 2008. Watermarking is a technique which attempts to protect software by inserting copyright notices or unique indentifiers into software to prove ownership. We evaluate the existing static watermarking systems and algorithms by using them to watermark bytecode files and then applying distortive attacks to each watermarked program by obfuscating and optimising. Our study revealed that a high proportion of watermarks were removed as a result of these transformations both in the commercial and academic watermarking systems that we tested. This is further evidence that static watermarking techniques on their own do not give sufficient protection against software piracy. Keywords-java; bytecode; watermarking; obfuscation; program transformation; I.

Cited by 0

Intra-procedural Inference of Static Types for Java Bytecode

Etienne Gagnon and Laurie Hendren, Etienne Gagnon, Laurie Hendren · 1998

In this paper, we present practical algorithms for inferring static types for local variables and stack locations of Java bytecode. By decoupling the type inference problem from the low level bytecode representation, and abstracting it into a constraint system, we are able to construct a sound and efficient algorithm for inferring the type of most bytecode found in practice. Using this same constraint system, we then prove that this type inference problem is NP-complete in general. However, our experimental results show that all of the 16,500 methods used in our tests were successfully typed by the efficient polynomial algorithm. 1 Introduction While Java bytecode [7] retains type information for method calls and field accesses, it operates on untyped local variables and stack locations. In order to decompile bytecode back to Java source code [5], or to improve subsequent analyzes on Java bytecode, it is important to find a static type for these locations. In this paper, we address th...

Cited by 0