Design and implementation of the J-SEAL2 mobile agent kernel

@article{Binder2001DesignAI,
  title={Design and implementation of the J-SEAL2 mobile agent kernel},
  author={Walter Binder},
  journal={Proceedings 2001 Symposium on Applications and the Internet},
  year={2001},
  pages={35-42}
}
  • Walter Binder
  • Published 8 January 2001
  • Computer Science
  • Proceedings 2001 Symposium on Applications and the Internet
J-SEAL2 is a secure, portable, and efficient execution environment for mobile agents. The core of the system is a micro-kernel fulfilling the same functions as a traditional operating system kernel: protection, communication, domain termination and resource control. This paper describes the key concepts of the J-SEAL2 micro-kernel and how they are implemented in pure Java. 
Portable resource control in the J-SEAL2 mobile agent system
TLDR
An overview of a new portable resource control model for Java and its integration in the J-SEAL2 mobile agent system is given.
Designing and Implementing a Secure , Portable , and EÆcient Mobile Agent Kernel : The J-SEAL 2 Approach ausgef
  • Computer Science
  • 2001
TLDR
The key concepts of the JSEAL2 micro-kernel and how they are implemented in Java are explained, which provide good scalability and performance for large-scale applications.
J-SEAL2—A Secure High-Performance Mobile Agent System
TLDR
The design of the new communication model in J-SEAL2 is focused on, which allows convenient, efficient, and mediated communication in a hierarchy of strong protection domains, which meets the high security, portability, and performance requirements of large-scale electronic commerce applications.
Security Risks in Java-based Mobile Code Systems
TLDR
This article takes an in-depth look at Java as a foundation for secure mobile agent systems and concludes that at the time of writing, it has neither resource control nor proper application separation.
A portable CPU-management framework for Java
TLDR
This article focuses on the extensible runtime APIs, which are designed to let developers tailor management policies to their needs, and modifies applications, libraries, and the Java development kit itself to expose details regarding thread execution.
A Portable CPU-Management Framework for Java
TLDR
The Java Resource Accounting Framework, second edition (J-RAF2), is a portable CPU-management framework for Java environments that modifies applications, libraries, and the Java development kit itself to expose details regarding thread execution.
Secure and reliable Java-based middleware - challenges and solutions
  • Walter Binder
  • Computer Science
    First International Conference on Availability, Reliability and Security (ARES'06)
  • 2006
TLDR
This paper explains why current standard JVMs are not suited to build secure and reliable component execution platforms and identifies the lack of proper component isolation and the absence of resource management mechanisms.
Portable Resource Control in Java: Application to Mobile Agent Security
Secure mobile agent systems using Java: where are we heading?
TLDR
In this article, an in-depth look at Java as a foundation for secure mobile agent systems is taken.
Portable resource control in Java
TLDR
This paper describes the model and implementation mechanisms underlying the new resource-aware version of the J-SEAL2 mobile object kernel and its fundamental objective is to achieve complete portability, and the approach is therefore based on Java bytecode transformations.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 35 REFERENCES
J-Kernel: A Capability-Based Operating System for Java
TLDR
The J-Kernel is described, a portable Java-based protection system that addresses issues of rights revocation, thread protection, resource management, and support for domain termination in a safe language alone.
J-SEAL2—A Secure High-Performance Mobile Agent System
TLDR
The design of the new communication model in J-SEAL2 is focused on, which allows convenient, efficient, and mediated communication in a hierarchy of strong protection domains, which meets the high security, portability, and performance requirements of large-scale electronic commerce applications.
Seal: A Framework for Secure Mobile Computations
TLDR
The design choices of the Seal calculus are motivated, the syntax and reduction semantics of the calculus are presented, and its expressiveness is demonstrated by examples focused on security and management distributed systems.
Designing JAVASEAL or How to Make JAVA Safe for Agents
TLDR
The design and implementation of J AVA SEAL are presented and the engineering compromises involved in integrating the model of mobility and protection within J AAVA are discussed.
Implementing Multiple Protection Domains in Java
TLDR
The J-Kernel is described, a portable Java-based protection system that addresses issues of rights revocation, thread protection, resource management, and support for domain termination.
Nested Java processes: OS structure for mobile code
TLDR
Alta, a prototype Java-based system patterned on Fluke, a highly structured, hardware-based OS, is presented and its features appropriate to mobile code are reported on, including hierarchical resource management and flexible object sharing.
Drawing the red line in Java
TLDR
It is shown why a "red line" must be present in order for a Java virtual machine to be as effective and as reliable as an operating system.
Type System Support for Dynamic Revocation
TLDR
A type system extension to support the revocation of data structures, called permits, is described, which uses a combination of static and run- time checks to ensure the revocability of data shared between safe language tasks, with a minimum of run-time overhead.
A Case for Language-Based Protection
TLDR
This paper examines the advantages and disadvantages of languagebased protection over more traditional protection mechanisms, such as standard virtual memory protection hardware, software fault isolation, and capability systems.
JRes: a resource accounting interface for Java
TLDR
It is argued that, in order to realize its full potential in applications dealing with untrusted code, Java needs a flexible resource accounting interface, and the design and prototype implementation of such an interface --- JRes --- is presented.
...
1
2
3
4
...