Aliasing is endemic in object oriented programming.
Because an object can be modified via any alias, object
oriented programs are hard to understand, maintain, and
analyse. Flexalias is a conceptual model of
inter-object relationships which limits the visibility
of changes via aliases, allowing objects to be aliased
but mitigating the undesirable effects of aliasing.
Flexalias can be checked statically using programmer
supplied {\”}aliasing modes{\”} and imposes no run-time
overhead. Using flexalias, programs can incorporate
mutable objects, immutable values, and updatable
collections of shared objects, in a natural object
oriented programming style, while avoiding the problems
caused by aliasing.

The sharing and transfer of references in object-oriented languages is difficult to control.  Without any constraint, practical experience has shown that even carefully engineered object-oriented code can be brittle, and subtle security deficiencies can go unnoticed.  In this paper, we present inexpensive syntactic constraints that strengthen encapsulation by imposing static restrictions on the spread of references.  In particular, we introduce confined types to impose a static scoping discipline on dynamic references and anonymous methods to loosen confinement somewhat to allow code reuse.  We have implemented a verifier which performs a modular analysis of Java programs and provides a static guarantee that confinement is respected.

Mobile agents show promise as a new distributed programming paradigm in which locality plays a central role - programs that are able to move closer to their data can overcome limitations of connectivity, latency or bandwidth.  Mobility also enables distributed systems to evolve; for instance, the deployment of a new service over a network can be programmed as part of the service itself.  Of course, moving programs introduces new challenges.  One of these is related to program structure: How much of a computation should be moved?  Where are the boundaries between mobile and immobile entities drawn?  A second challenge is to provide security guarantees: How can the actions of mobile agent be controlled?  And what kinds of securty properties can we realistically expect to enforce?  We answer these questions within the framework of the JavaSeal mobile agent system kernel.  JavaSeal provides several abstractions for constructuring agent systems in Java.  Our basic building block is the seal which is a nested encapsulated computation fragment with sharply delineated boundaries.  Strands are sequential threads of computation bound to a seal.  Capules transfer passive seals and objects over communication channels; Traffic over channels is regulated by portals.  We argue that these abstractions are sufficient to program secure mobile agent systems.  An electronic commerce application built over our kernel is used as a demonstrator.

In this paper we discuss security in mobile object
systems. Mobile object systems embody a paradigm where
computation may move across the network and carry out
distributed activities. This parasigm has been
popularized by the JAVA programming language and the
work on mobile software agent. We study security
problems of interaction mobile object systems taking
Java as an example, identify weaknesses and propose
solutions.

The SEAL calculus is a calculus of mobile computations designed for programming secure distributed applications over large scale open networks. The calculus is a distributed variant of the pi-calculus
that incorporates agent mobility as well as strong
protection mechanisms. Linear, revocable, capabilities
control access to resources and ensure that agents may
only use resources that have been allocated to them.
Capabilities are also used to protect agents from the
hosts on which they execute. The syntax and semantics
of the SEAL calculus are presented and its expressive
power is demonstrated with an example secure mobile

Software systems are becoming heterogeneous: instead of a small number of large programs from well-established sources, a user’s desktop may now consist of many smaller components that interact in intricate ways.  Some components will be downloaded from the network from sources that are only partially trusted.  A user would like to know that a number of securiy properties hold, e.g. that personal data is not leaked to the net, but it is typically infeasible to verify that such components are well-behaved.  Instad, hey must be executed in a secure environment that provides fine-grain control of the allowable interactions between them, and between components and other resources. In this paper, we concider the problem of assembling concurrent software systems from untrusted or partially trusted off-the-shelf components, using wrapper programs to encapsulate components and enforce security policies.  We introduce a model programming language, the box-pie calculus, that supports composition of software components and the enforcement of information flow security policies.  Several example wrappers are expressed using the calculus; we explore the delicate security properties they guarantee.  We present a novel casual type system that statically captures the allowed flows between wrapped possibly-badly-typed components; we use it to prove that an example ordered pipeline wrapper enforces a casual flow property.

Under U.S. Government contract N00039-92-C-0015 for SPAWAR, SRI International is developing functional NIDES prototypes with improved detection capability and increased functinality.  SPAWAR is currently modifying that contract to fund SRI to provide maintenance and support of the NIDES Beta Software release expected in late April 1994.  This Engineering and Technical Services Plan identifies SRI will provide to NIDES Beta sites upon completion and dleivery of the NIDES Beta release.  These activities will take place during Year 3 of our contract, and will terminate on 1 March 1995.  This Plan represents deliverable B002 under our currnet contract.

SRI International has designed and developed a real-time intrusion -detection expert system (IDES). IDES is a stand alone system that observes user behavior on one or more monitored computer systems and flgs suspicious events. IDES monitors the activities of individual users, groups, remote hosts and entire systems, and detects suspected security violations, by both insiders and outsiders, as they occur. IDES adaptively learns users\’ behavior patterns over time and detects behavior that deviates from these patterns.  IDES also has a rule-based component that can be used to encode information about known system vulnerabilities and intrusion scenarios.  Inegrating the two approaches makes IDES a comprehensive system for detecting intrusions as well as misuse by authorized users. IDES has been enhanced to run under GLU, a platform supporting distributed, parallel computation; GLU enhances configuration flexibility and system fault tolerance. Thhis final reprt is deliverable item for work supported by the U.S. navy, SPAWAR, which funded SRI through U.S. Governement Contract No. N00039-89-C-0050.

We have completely factored the numberators N2k of the Bernoulli numbers for all 2k<=152 and the Euler numbers E2k for all 2k<=88, using the even index notation. We studied the results seeking new theorems about the prime factors of these numbers. We rediscovered two nearly-forgotten congruences for the Euler numbers.