The Experts below are selected from a list of 9591 Experts worldwide ranked by ideXlab platform
Jakob Rehof - One of the best experts on this subject based on the ideXlab platform.
-
Type elaboration and subtype completion for Java Bytecode
ACM Transactions on Programming Languages and Systems, 2001Co-Authors: Todd B. Knoblock, Jakob RehofAbstract:Java source code is strongly typed, but the translation from Java source to Bytecode omits much of the type information originally contained within methods. Type elaboration is a technique for reconstructing strongly typed programs from incompletely typed Bytecode by inferring types for local variables. There are situations where, technically, there are not enough types in the original type hierarchy to type a Bytecode program. Subtype completion is a technique for adding necessary types to an arbitrary type hierarchy to make type elaboration possible for all verifiable Java Bytecode. Type elaboration with subtype completion has been implemented as part of the Marmot Java compiler.
-
POPL - Type elaboration and subtype completion for Java Bytecode
Proceedings of the 27th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL '00, 2000Co-Authors: Todd B. Knoblock, Jakob RehofAbstract:Java source code is strongly typed, but the translation from Java source to Bytecode omits much of the type information originally contained within methods. Type elaboration is a technique for reconstructing strongly typed programs from incompletely typed Bytecode by inferring types for local variables. There are situations where, technically, there are not enough types in the original type hierarchy to type a Bytecode program. Subtype completion is a technique for adding necessary types to an arbitrary type hierarchy to make type elaboration possible for all verifiable Java Bytecode. Type elaboration with subtype completion has been implemented as part of the Marmot Java compiler.
John C. Mitchell - One of the best experts on this subject based on the ideXlab platform.
-
a type system for the java Bytecode language and verifier
Journal of Automated Reasoning, 2003Co-Authors: Stephen N Freund, John C. MitchellAbstract:The Java Virtual Machine executes Bytecode programs that may have been sent from other, possibly untrusted, locations on the network. Since the transmitted code may be written by a malicious party or corrupted during network transmission, the Java Virtual Machine contains a Bytecode verifier to check the code for type errors before it is run. As illustrated by reported attacks on Java run-time systems, the verifier is essential for system security. However, no formal specification of the Bytecode verifier exists in the Java Virtual Machine Specification published by Sun. In this paper, we develop such a specification in the form of a type system for a subset of the Bytecode language. The subset includes classes, interfaces, constructors, methods, exceptions, and Bytecode subroutines. We also present a type checking algorithm and prototype Bytecode verifier implementation, and we conclude by discussing other applications of this work. For example, we show how to extend our formal system to check other program properties, such as the correct use of object locks.
-
a type system for object initialization in the java Bytecode language
ACM Transactions on Programming Languages and Systems, 1999Co-Authors: Stephen N Freund, John C. MitchellAbstract:In the standard Java implementation, a Java language program is compiled to Java Bytecode. This Bytecode may be sent across the network to another site, where it is then executed by the Java Virtual Machine. Since Bytecode may be written by hand, or corrupted during network transmission, the Java Virtual Machine contains a Bytecode verifier that performs a number of consistency checks before code is run. These checks include type correctness and, as illus-trated by previous attacks on the Java Virtual Machine, are critical for system security. In order to analyze existing Bytecode verifiers and to understand the properties that should be verified, we develop a precise specification of statically correct Java Bytecode, in the form of a type system. Our focus in this article is a subset of the Bytecode language dealing with object creation and initialization. For this subset, we prove, that, for every Java Bytecode program that satisfies our typing constraints, every object is initialized before it is used. The type system is easily combined with a previous system developed by Stata and Abadi for Bytecode subroutines. Our analysis of subroutines and object initialization reveals a previously unpub-lished bug in the Sun JDK Bytecode verifier.
-
A Formal Framework for the Java Bytecode Language and Verifier
Proceedings of the 14th ACM SIGPLAN Conference on Object-oriented Programming Systems Languages and Applications, 1999Co-Authors: Stephen N Freund, John C. MitchellAbstract:This paper presents a sound type system for a large subset of the Java Bytecode language including classes, interfaces, constructors, methods, exceptions, and Bytecode subroutines. This work serves as the foundation for developing a formal specification of the Bytecode language and the Java Virtual Machine's Bytecode verifier. We also describe a prototype implementation of a type checker for our system and discuss some of the other applications of this work. For example, we show how to extend our work to examine other program properties, such as the correct use of object locks.
-
OOPSLA - A formal framework for the Java Bytecode language and verifier
Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming systems languages and applications - OOPSLA '99, 1999Co-Authors: Stephen N Freund, John C. MitchellAbstract:This paper presents a sound type system for a large subset of the Java Bytecode language including classes, interfaces, constructors, methods, exceptions, and Bytecode subroutines. This work serves as the foundation for developing a formal specification of the Bytecode language and the Java Virtual Machine's Bytecode verifier. We also describe a prototype implementation of a type checker for our system and discuss some of the other applications of this work. For example, we show how to extend our work to examine other program properties, such as the correct use of object locks.
-
a type system for object initialization in the java Bytecode language
Conference on Object-Oriented Programming Systems Languages and Applications, 1998Co-Authors: Stephen N Freund, John C. MitchellAbstract:In the standard Java implementation, a Java language program is compiled to Java Bytecode. This Bytecode may be sent across the network to another site, where it is then interpreted by the Java Virtual Machine. Since Bytecode may be written by hand, or corrupted during network transmission, the Java Virtual Machine contains a Bytecode verifier that performs a number of consistency checks before code is interpreted. As illustrated by previous attacks on the Java Virtual Machine, these tests, which include type correctness, are critical for system security. In order to analyze existing Bytecode verifiers and to understand the properties that should be verified, we develop a precise specification of statically-correct Java Bytecode, in the form of a type system. Our focus in this paper is a subset of the Bytecode language dealing with object creation and initialization. For this subset, we prove that for every Java Bytecode program that satisfies our typing constraints, every object is initialized before it is used. The type system is easily combined with a previous system developed by Stata and Abadi for Bytecode subroutines. Our analysis of subroutines and object initialization reveals a previously unpublished bug in the Sun JDK Bytecode verifier.
Todd B. Knoblock - One of the best experts on this subject based on the ideXlab platform.
-
Type elaboration and subtype completion for Java Bytecode
ACM Transactions on Programming Languages and Systems, 2001Co-Authors: Todd B. Knoblock, Jakob RehofAbstract:Java source code is strongly typed, but the translation from Java source to Bytecode omits much of the type information originally contained within methods. Type elaboration is a technique for reconstructing strongly typed programs from incompletely typed Bytecode by inferring types for local variables. There are situations where, technically, there are not enough types in the original type hierarchy to type a Bytecode program. Subtype completion is a technique for adding necessary types to an arbitrary type hierarchy to make type elaboration possible for all verifiable Java Bytecode. Type elaboration with subtype completion has been implemented as part of the Marmot Java compiler.
-
POPL - Type elaboration and subtype completion for Java Bytecode
Proceedings of the 27th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL '00, 2000Co-Authors: Todd B. Knoblock, Jakob RehofAbstract:Java source code is strongly typed, but the translation from Java source to Bytecode omits much of the type information originally contained within methods. Type elaboration is a technique for reconstructing strongly typed programs from incompletely typed Bytecode by inferring types for local variables. There are situations where, technically, there are not enough types in the original type hierarchy to type a Bytecode program. Subtype completion is a technique for adding necessary types to an arbitrary type hierarchy to make type elaboration possible for all verifiable Java Bytecode. Type elaboration with subtype completion has been implemented as part of the Marmot Java compiler.
Moshe Sipper - One of the best experts on this subject based on the ideXlab platform.
-
genetic programming in the wild evolving unrestricted Bytecode
Genetic and Evolutionary Computation Conference, 2009Co-Authors: Michael Orlov, Moshe SipperAbstract:We describe a methodology for evolving Java Bytecode, enabling the evolution of extant, unrestricted Java programs, or programs in other languages that compile to Java Bytecode. Bytecode is evolved directly, without any intermediate genomic representation. Our approach is based upon the notion of compatible crossover, which produces correct programs by performing operand stack-, local variables-, and control flow-based compatibility checks on source and destination Bytecode sections. This is in contrast to existing work that uses restricted subsets of the Java Bytecode instruction set as a representation language for individuals in genetic programming. Given the huge universe of unrestricted Java Bytecode, as is programs, our work enables the applications of evolution within this realm. We experimentally validate our methodology by both extensively testing the correctness of compatible crossover on arbitrary Bytecode, and by running evolution on a program that exploits the richness of the Java virtual machine architecture and type system.
-
GECCO - Genetic programming in the wild: evolving unrestricted Bytecode
Proceedings of the 11th Annual conference on Genetic and evolutionary computation - GECCO '09, 2009Co-Authors: Michael Orlov, Moshe SipperAbstract:We describe a methodology for evolving Java Bytecode, enabling the evolution of extant, unrestricted Java programs, or programs in other languages that compile to Java Bytecode. Bytecode is evolved directly, without any intermediate genomic representation. Our approach is based upon the notion of compatible crossover, which produces correct programs by performing operand stack-, local variables-, and control flow-based compatibility checks on source and destination Bytecode sections. This is in contrast to existing work that uses restricted subsets of the Java Bytecode instruction set as a representation language for individuals in genetic programming. Given the huge universe of unrestricted Java Bytecode, as is programs, our work enables the applications of evolution within this realm. We experimentally validate our methodology by both extensively testing the correctness of compatible crossover on arbitrary Bytecode, and by running evolution on a program that exploits the richness of the Java virtual machine architecture and type system.
Martin Abadi - One of the best experts on this subject based on the ideXlab platform.
-
a type system for java Bytecode subroutines
Symposium on Principles of Programming Languages, 1998Co-Authors: Raymie Stata, Martin AbadiAbstract:Java is typically compiled into an intermediate language, JVML, that is interpreted by the Java Virtual Machine. Because mobile JVML code is not always trusted, a Bytecode verifier enforces static constraints that prevent various dynamic errors. Given the importance of the Bytecode verifier for security, its current descriptions are inadequate. This paper proposes using typing rules to describe the Bytecode verifier because they are more precise than prose, clearer than code, and easier to reason about than either.JVML has a subroutine construct used for the compilation of Java's try-finally statement. Subroutines are a major source of complexity for the Bytecode verifier because they are not obviously last-in/first-out and because they require a kind of polymorphism. Focusing on subroutines, we isolate an interesting, small subset of JVML. We give typing rules for this subset and prove their correctness. Our type system constitutes a sound basis for Bytecode verification and a rational reconstruction of a delicate part of Sun's Bytecode verifier.
-
POPL - A type system for Java Bytecode subroutines
Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL '98, 1998Co-Authors: Raymie Stata, Martin AbadiAbstract:Java is typically compiled into an intermediate language, JVML, that is interpreted by the Java Virtual Machine. Because mobile JVML code is not always trusted, a Bytecode verifier enforces static constraints that prevent various dynamic errors. Given the importance of the Bytecode verifier for security, its current descriptions are inadequate. This paper proposes using typing rules to describe the Bytecode verifier because they are more precise than prose, clearer than code, and easier to reason about than either.JVML has a subroutine construct used for the compilation of Java's try-finally statement. Subroutines are a major source of complexity for the Bytecode verifier because they are not obviously last-in/first-out and because they require a kind of polymorphism. Focusing on subroutines, we isolate an interesting, small subset of JVML. We give typing rules for this subset and prove their correctness. Our type system constitutes a sound basis for Bytecode verification and a rational reconstruction of a delicate part of Sun's Bytecode verifier.
