Security is an important issue for the widespread deployment of applications based on software agent technology. It is generally agreed that without the proper countermeasures in place, use of agent-based applications will be severely impeded. However, not all applications require the same set of countermeasures, nor can they depend entirely on the agent system to provide them. Instead, countermeasures are applied commensurate with the anticipated threat profile and intended security objectives for the application. While countermeasures typically include any action, device, procedure, technique, or other measure that reduces the vulnerability of or threat to a system, our focus here is specifically on technical mechanisms, as opposed to procedural or non-technical measures. Such countermeasures can be integrated directly into an agent system, or incorporated into the design of an agent to supplement the capabilities of an underlying agent system. This paper gives an overview of the t...

Active networking offers a change in the usual network paradigm: from passive carrier of bits to a more general computation engine. The implementation of such a change is likely to enable radical new applications that cannot be foreseen today. Large-scale deployment, however, involves significant challenges in interoperability and security. Less clear, perhaps, are the "immediate" benefits of such a paradigm shift, and how they might be used to justify migration towards active networking. In this paper, we focus on the benefits of active networking with respect to a problem that is unlikely to disappear in the near future: network congestion. In particular, we consider application-specific processing of user data within the network at congested nodes. Given an architecture in which applications can specify intra-network processing, the bandwidth allocated to each application's packets can be reduced in a manner that is tailored to the application, rather than being applied generically....

When agents roam, who can you trust? Roaming agents threaten a server with theft of assets, system resources and reputation. Generally ignored is the reciprocal threat of server against agent. Not only might aserver steal the assets, resources, and reputation of an agent, but it might actually kill the agent. The central security concern for systems that allow agents to roam is how to establish trust, and how to limit risk for both the server and the agent. The travels of the agent are key to establishing trust, and trust determines the level of risk.

In this paper we discuss some of the problems of the current Web and show how the introduction of object-orientation provides flexible and extensible solutions. Web resources become encapsulated as objects, with well-defined interfaces through which all interactions occur. The interfaces and their implementations can be inherited by builders of objects, and methods (operations) can be redefined to better suit the object. New characteristics, such as concurrency control and persistence, can be obtained by inheriting from suitable base classes, without necessarily requiring any changes to users of these resources. We describe the W3Object model which we have developed based upon these ideas, and show, through a prototype implementation, how we have used the model to address the problems of referential integrity and transparent object (resource) migration. We also give indications of future work.

Many information-processing tasks can be part of multiple customer applications, as summarizing stock prices, integrating catolog information from several companies in the same line of business, predicting the weather, and checking on transportation resources. We assign such sharable services to an active middleware layer, interposed between clients and servers. We define domain-specific mediator modules to populate this layer. Such mediating services must be of value to the customers, so that it will benefit their client applications to access mediators rather than the server sources directly. Several categories of value can be considered: improvement in access and coverage, improvement of content, and delegation of maintenance. We will define criteria for mediating modules: ownership by party who assumes responsibility for the rseults of the services, domain-specificity to delimit the scope of such a responsibility, and, of course, conformance with interface standards that ...

In this paper we present practical experiences gathered from the employment of two popular Java-based mobile-agent platforms, IBM's Aglets and Mitsubishi's Concordia. We present some basic distributed computing models and describe their adaptation to the mobile-agent paradigm. Upon these models we develop a set of frameworks for distributed database access over the World-Wide Web, using IBM's Aglets and Mitsubishi's Concordia platforms. We compare the two platforms both quantitatively and qualitatively. For the quantitative comparison, we propose, employ, and validate an approach to evaluate and analyze mobile-agent framework performance. For the qualitative assessment, we present our observations about the programmability and robustness of, and mobility provided by, the two platforms.

Mobile agent systems have attracted a great deal of attention in recent years. Various agent systems have been proposed and implemented so far. But their systems are usually equipped with their own features that are hard to simulate by other systems even with respect to agent movement-mechanisms. Therefore, a generalized framework that can describe various mechanisms in a formal manner is strongly needed. This paper proposes a simple and flexible calculus dist, which provides a neat tool for describing movement mechanisms of code, data and execution states.

In recent years, there has been considerable interest in using Java in introductory computer science courses. The advantages of choosing Java, however, must be balanced against two significant drawbacks: the instability caused by the rapid evolution of the Java toolkits and the complexity of the graphics model for new students. This paper outlines a strategy for teaching Java that eliminates these problems. The first component of that strategy is a set of low-level classes, DBCanvas and XGraphics, which together offer a double-buffered graphics model that is well matched to student intuition. The second component is a set of higher-level classes, principally Collage and Widget, which make it easy to introduce object-oriented techniques at the beginning of CS1. The sources for these classes are available on the Web at the

. Wireless communication with Mobile Computing devices is known to be problematic. It is very different in character from conventional communication over wired networks. Since many distributed applications make assumptions about network characteristics, they may not be used in a hostile mobile environment. We are proposing a new kind of messaging system which incorporates adaptive behaviour into the messages themselves. We call these `Smart Messages', and implement them using Mobile Agents. The metaphor we use is of a message being delivered by a courier (Mobile Agent), on a potentially unresolved route. The `intelligence' is in the messages themselves rather than in the network. The approach taken expands on the self-routing capabilities of current Mobile Agent systems such as Aglets or Telescript. We aim to provide structured support for handling the particular problems associated with wireless communications. These include very limited, variable and asymmetric bandwidth, frequent an...

Active Networks allow users to \program " the network infrastructure, by injecting information that describes or controls a distributed algorithm to be executed for the user by the network infrastructure. The nature of the services that can be implemented with such a facility is determined by the programming interface to the active network, i.e. the set of abstractions it exposes to users. The complexity of this interface may range from a few simple parameters to a completely general programming language. We present a model that supports reasoning independently about the correctness of both the underlying active network platform and the algorithms injected into it, in a manner that admits the full range of possible programming interfaces. The model is described without relying on any particular formalism. The interaction between the underlying platform and the userinjected program is captured in a specialized form of program composition that allows properties of each to be preserved. The use of the model is illustrated via an example dealing with mobility. For the example, we use the UNITY formalism to be more precise about the programs and properties that are preserved. 1