A prototype for WPAN slicing and virtualization is showcased in this demo, where we form a contiguous wireless PAN "underlay" spanned over two neighboring IEEE 802.15.4 mote networks.

Buffer overflow is known to be a common memory vulnerability affecting software. It is exploited to gain various kinds of privilege escalation. C and C++ are very commonly used to develop applications; due to the efficient “unmanaged” executions these languages are not safe. These attacks are highly successful as every executing copy of a shipped binary is the same. This work presents two approaches to randomizing the memory layout which does not require modifications at the developer end. Both techniques are implemented at the user-end machines and have no requirement for source code. The feasibility of the two techniques is shown by randomizing complex applications and demonstrating that the run-time penalty for the randomization schemes is very less.

Peer-to-peer (P2P) networks are vulnerable to peers who cheat, propagate malicious code, leech on the network, or simply do not cooperate. The traditional security techniques developed for the centralized distributed systems like client-server networks are insufficient for P2P networks by the virtue of their centralized nature. The absence of a central authority in a P2P network poses unique challenges for reputation management in the network. These challenges include identity management of the peers, secure reputation data management, Sybil attacks, and above all, availability of reputation data. In this paper, we present a cryptographic protocol for ensuring secure and timely availability of the reputation data of a peer to other peers at extremely low costs. The past behavior of the peer is encapsulated in its digital reputation, and is subsequently used to predict its future actions. As a result, a peer's reputation motivates it to cooperate and desist from malicious activities. The cryptographic protocol is coupled with self-certification and cryptographic mechanisms for identity management and countering Sybil attack. We illustrate the security and the efficiency of the system analytically and by means of simulations in a completely decentralized Gnutella-like P2P network.

Nodes in mobile ad hoc networks have limited transmission ranges that necessitate multihop communication. Hence the nodes expect their neighbours to relay the packets meant for nodes out of the transmission range of the source. Ad hoc networks are based on the fundamental assumption that if a node promises to relay a packet, it will relay the packet and will not cheat. This assumption becomes invalid when the nodes in the network have contradictory goals. As a result, routing protocols for ad hoc networks become vulnerable to rogue nodes. The reputations of the intermediate nodes, based on their past history of relaying packets, can be used by their neighbours to ensure that the packet will be relayed by the intermediate nodes. This paper introduces a reputation scheme for ad hoc networks that can motivate the intermediate nodes to relay packets. The source performs a route discovery (using Ad hoc on Demand Distance Vector Routing Protocol (AODV)) and finds a set of routes to the destination. Instead of choosing the shortest route to the destination, the source node chooses a path whose next hop node has the highest reputation. This policy, when used recursively, in the presence of 40% rogue nodes, improves the throughput of the system to 65%, from the 22% throughput provided by AODV with same number of rogue nodes. This improvement is obtained at the cost of a higher number of route discoveries with a minimal increase in the average hop length.

Malware and rootkits are serious security threats. They can be designed to be resistant to anti-virus and security software and even remain totally undetectable. This paper describes a hierarchical trust management scheme, where the root of trust is

Peer reputations have been used as security tools not only to motivate peers against cheating but also to protect good peers from the chronic cheaters. Although the reputation management techniques are not confined to P2P networks, they present novel challenges that were absent in central server based distributed systems. We enumerate these challenges and survey the solutions proposed by the community to counter them. These challenges include, but are not limited to, peer-identification in decentralized environments, reputation metrics, storage and exchange of reputation data. Finally we survey the applications which use P2P network paradigm and therefore can benefit from the reputation systems.

Distributed denial of service attacks prevent legitimate users from accessing a target machine or the service a target machine provides. One common method of attack is overwhelming the target machine with a large volume of traffic. Thus, handling congestion indirectly leads to detection and recovery from distributed denial of service attacks. The Internet is an interconnected collection of autonomous systems. Every host on an autonomous system connects to the Internet through an access router. Monitoring the rate of packets to and from a host, at the access router, helps in identifying distributed denial of service attacks initiated at the host. Monitoring every access router leads to an effective distributed denial of service prevention, but is infeasible. An alternative is a combination of access router monitoring and intermediate router monitoring with a novel push-forward mechanism that provides good defense within manageable deployment requirements. Push-forward messages reduce the amount of traffic to monitor at the intermediate routers. Prototype testing and simulations of such a combination reveal good congestion detection and recovery time with very little performance overhead.

Network security is conventionally implemented at the edge of the network (such as SSL, SSh), or router-based filtering. They require the awareness from the users and the understanding of the complicated configuration. They do little to provide resilience to network attacks. In this paper, we discuss a different approach to enhance of network security. We use smarter routers to build security mechanisms (source authentication, flow control, encryption) into the fabric of the network. It allows for incremental upgrading as well as compatibility with all current protocols. Since the security mechanisms are at the router level, there is no impact on the end user. We also show some implementation and simulation results.

Process migration has been used to perform specialized tasks, such as load sharing and checkpoint/restarting long running applications. Implementation typically consists of modifications to existing applications and the creation of specialized support systems, which limit the applicability of the methodology. Off the shelf applications have not benefited from process migration technologies, mainly due to the lack of an effective generalized methodology and facility. The benefits of process migration include mobility, checkpointing, relocation, scheduling and on the fly maintenance. This paper shows how regular shrink-wrapped applications can be migrated. The approach to migration is to virtualize the application by injecting functionality into running applications and operating systems. Using this scheme, we separate the physical resource bindings of the application and replace it with virtual bindings. This technique is referred to as virtualization. We have developed a virtualizing operating system (vOS), residing on top of Windows 2000 that injects stock applications with the virtualizing software. It coordinates activities across multiple platforms providing new functionality to the existing applications. The vOS makes it possible to build communities of systems that cooperate to run applications and share resources non-intrusively while retaining application binary compatibility.

Despite increasingly distributed Internet information sources with diverse storage formats and access-control constraints, most of the end applications (e.g. filters and media players) that view and manipulate data from these sources operate against a traditional file-based interface. These legacy applications need to be rewritten to access remote sources, or need to rely upon ad-hoc intermediary applications that aggregate the data into a passive file before executing the legacy application. This paper presents a simple, elegant, programmable method for allowing natural integration of legacy applications into distributed system infrastructures, The approach, called "active files", enables multiple information sources to be encapsulated as a local file that serves as their logical proxy. This local file is accessed though a sentinel process, which automatically starts when the file is opened, aggregates data from multiple sources, and filters all access to and from the file. More importantly, the integration of active files into client applications is transparent: an active file is virtually indistinguishable from a regular file. Active files find a variety of applications in both distributed and non-distributed systems. We discuss active files, their semantics, their usage and their implementations in Windows NT.

The importance of adapting networks of workstations for use as parallel processing platforms is well established. However current solutions do not always address important issues that exist in real networks. External factors like the sharing of resources, unpredictable behavior of the network and failures, are present in multiuser networks and must be addressed. CALYPSO is a prototype software system for writing and executing parallel programs on non-dedicated platforms, based on COTS networked workstations operating systems, and compilers. Among notable properties of the system are: (1) simple programming paradigm incorporating shared memory constructs and separating the programming and the execution parallelism, (2) transparent utilization of unreliable shared resources by providing dynamic load balancing and fault tolerance, and (3) effective performance for large classes of coarse-grained computations. We present the system and report our initial experiments and performance results in settings that closely resemble the dynamic behavior of a "real" network. Under varying work-load conditions, resource availability and process failures, the efficiency of the test program we present ranged from 84% to 94% bench-marked against a sequential program.

One of the most sought after software innovation of this decade is the construction of systems using off-the-shelf-workstations that actually deliver and even surpass, the power and reliability of supercomputers. Using completely novel techniques: eager scheduling, evasive memory layouts and dispersed data management it is possible to build an execution environment for parallel programs on workstation networks. These techniques were originally developed in a theoretical framework for an abstract machine which models a shared memory asynchronous multiprocessor. The network of workstations platform presents an inherently asynchronous environment for the execution of our parallel program. This gives rise to substantial problems of correctness of the computation and of proper automatic load balancing of the work amongst the processors, so that a slow processor will not hold up the total computation. A limiting case of asynchrony is when a processor becomes infinitely slow, i.e. fails. Our methodology copes with all these problems, as well as with memory failures. An interesting feature of this system is that it is neither a fault-tolerant system extended for parallel processing nor is it parallel processing system extended for fault tolerance. The same novel mechanisms ensure both properties.

The advantages of object-oriented programming systems are well known. However, in general, they do not support long-lived objects, nor do they allow concurrent sharing or dynamic re-use of language defined objects. Persistent object systems address some of these shortfalls. In this paper we present a design and implementation of a persistent object system that uses memory-mapping to directly map objects from the persistent store into the address space of user programs. Memory mapping makes the management and manipulation of persistent objects simpler. In particular, complex object structures can be executed (shared) concurrently on behalf of separate applications. A simple language extension has been designed and added to C++ to make the programming of persistence, sharing, synchronization and consistency control expressible. With efficient run-time support for persistent pointer resolution and consistency maintenance, this approach can provide much finer-grain execution concurrentcy and sharing, easier object navigation, simpler programability and possibly better performance, than object-oriented database systems.>

Discusses the design and the operating system support necessary for providing asynchronous event handling in distributed, passive object-based programming environments, where objects are potentially shared by disparate applications. We discuss the necessity of thread-based as well as object-based event notification and how a variety of hard-to-solve distributed programming issues can be handled by using the approach outlined in the design. The usefulness of the design is considered by using some examples. The implementation strategy and related work in this area are discussed.>

The authors present the design and implementation of a persistent store called SPOMS. SPOMS is a runtime system that provides a store for persistent objects and is language independent. The objects are created via calls to SPOMS, and, when used, SPOMS directly maps them into the spaces of all requesting processes. The objects are stored in native format and are concurrently sharable. The store can handle distributed applications. The system uses the concept of a compiled class to manage persistent objects. The compiled class is a template that is used to create and store objects in a language independent manner and so that object reuse can occur without recompilation or relinking of an application that uses it. A prototype of SPOMS has been built on top of the Mach operating system. The motivations, the design, and implementation details are presented. Related and future work are discussed.>

The implementation details of a Lisp environment built on top of a distributed operating system are presented. The system provides transparent distribution, protected large-grain persistent heaps, concurrency within each environment and seamless sharing of Lisp data structures between separate environments.>

Implementation of a kernel-level consistency control mechanism called invocation-based consistency control (IBCC) is presented. IBCC supports general-purpose persistent object-based distributed computing. It provides mechanisms that support a range of powerful, well-defined consistency semantics. IBCC mechanisms can also be used to implement custom recovery and synchronization. An operating-system-level implementation of IBCC as part of the Clouds distributed operating system that uses memory faulting to initiate locking and intermediate version creation is also given. Performance aspects are discussed, as well as the overhead incurred by supporting IBCC in terms of additional data structures needed in the operating system, and the additional amount of required code.>

Clouds LISP distributed environments (CLIDE) is a distributed, persistent object-based symbolic programming system being implemented on the Clouds distributed operating system. LISP environment instances are stored as large-grained persistent objects, enabling users on many machines to share the contents of these environments through interenvironment evaluations. CLIDE provides a comprehensive research environment for distributed symbolic language, invocation and consistency semantics, and an implementation vehicle for the construction of the symbolic processing portions of complex megaprogrammed systems.>

Concurrency control protocols based on two-phase locking are a popular family of locking protocols that preserve serializability in general (unstructured) database systems. A concurrency control algorithm (for databases with no inherent structure) is presented that is practical, non two-phase, and allows varieties of serializable logs not possible with any commonly known locking schemes. All transactions are required to predeclare the data they intend to read or write. Using this information, the protocol anticipates the existence (or absence) of possible conflicts and hence can allow non-two-phase locking. It is well known that serializability is characterized by acyclicity of the conflict graph representation of interleaved executions. The two-phase locking protocols allow only forward growth of the paths in the graph. The Five Color protocol allows the conflict graph to grow in any direction (avoiding two-phase constraints) and prevents cycles in the graph by maintaining transaction access information in the form of data-item markers. The read and write set information can also be used to provide relative immunity from deadlocks.

An object/thread based paradigm is presented that links data consistency with object/thread semantics. The paradigm can be used to achieve a wide range of consistency semantics from strict atomic transactions to standard process semantics. The paradigm supports three types of data consistency. Object programmers indicate the type of consistency desired on a per-operation basis, and the system performs automatic concurrency control and recovery management to ensure that those consistency requirements are met. This allows programmers to customize consistency and recovery on a per-application basis without having to supply complicated, custom recovery management schemes. The paradigm allows robust and nonrobust computation to operate concurrently on the same data in a well-defined manner. The operating system need support only one vehicle of computation-the thread.>

A description is given of Clouds, an operating system designed to run on a set of general-purpose computers that are connected via a medium-to-high-speed local area network. The structure of Clouds promotes transparency, support for advanced programming paradigms, and integration of resource management, as well as a fair degree of autonomy at each site. The system structuring paradigm chosen for Clouds is an object/thread model. All instances of services, programs, and data in Clouds are encapsulated in objects. The concept of persistent objects does away with the need for file systems, replacing it with a more powerful concept, namely, the object system. The facilities in Clouds include integration of resources by location transparency; support for various types of atomic operations, including conventional transactions; advanced support for achieving fault tolerance; and provisions for dynamic reconfiguration.>

Clouds is a distributed object-based operating system designed to support fault tolerance, location independence, and an action/object programming environment. Some of the key issues in supporting Clouds are the availability of object memory, object location, and object recovery. Object memory provides a set of global, persistent, named address spaces for sorting objects. The address spaces resemble conventional segmentation schemes, but are persistent and thus replace both the computational and storage systems used in conventional schemes by a more powerful paradigm. The object location system provides transparent object operation invocation mechanisms throughout the distributed environment. The object recovery system supports recoverable objects through shadowing and two-phase commit techniques to allow atomicity of actions. The key issues in the design and implementation of the object memory and storage management system are briefly described.>

article Free Access Share on A probe-based monitoring scheme for an object-oriented distributed operating system Author: Partha Dasgupta Georgia Tech Georgia TechView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 21Issue 11Nov. 1986 pp 57–66https://doi.org/10.1145/960112.28704Online:01 June 1986Publication History 13citation436DownloadsMetricsTotal Citations13Total Downloads436Last 12 Months9Last 6 weeks3 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF