1,721,052 research outputs found
Design and implementation of query languages for program databases.
No full textQuerying and analyzing source code is an essential aspect of a variety of software engineering tasks such as program understanding, reverse engineering, and program analysis. Current source code query mechanisms seem unable to combine expressive power and query compactness within a single framework; either they are highly expressive and involve writing queries as procedural code, or they have easy user interfaces with restricted expressive power. This dissertation presents a highly expressive, applicative solution to the source code query problem by letting users express complex source code queries and views as algebraic expressions. This paradigm shift in source code query processing is achieved by the design and implementation of an algebraic source code query language (Source Code Algebra or SCA) that interfaces with an object-oriented database populated with program source code. The SCA algebraic approach offers many benefits. First, it equips its users with an expressive and compact formal query language that can handle a variety of structural and flow information in a seamless manner. Second, it offers powerful capabilities for software view generation. Third, it serves as a unifying framework for formally expressing source code queries that have traditionally been dealt in isolation by graphical, relational, or pattern-based query languages. Finally, its algebraic formalism offers opportunities for query optimization. SCA is an order-sorted algebra that has a computational power equivalent to that of relational algebra extended with generalized transitive closure and sequence operations. In addition to the algebraic query paradigm, the dissertation also explores a pattern-based query paradigm for source code using a tool called SCRUPLE. Prototype query processing systems based on SCA and SCRUPLE have been implemented and used to analyze C programs. Experimental results demonstrate that the algebraic approach to source code query and analysis combines the benefits of expressive power, compactness, and formalism within a single query language.PhDComputer Science and EngineeringUniversity of Michigan, Horace H. Rackham School of Graduate Studieshttp://deepblue.lib.umich.edu/bitstream/2027.42/104686/1/9542928.pdfDescription of 9542928.pdf : Restricted to UM users only
*Policy management in secure group communication.
No full textContemporary group communication systems address the security requirements envisioned by software developers. However, the ability of these systems to address unanticipated requirements arising from their introduction into new environments is limited. This thesis addresses these limitations through the realization of an infrastructure supporting policy determination and enforcement in multiparty communication. The traditional definition of policy is extended to encompass provisioning, authentication, and access control. Hence, all aspects of communication security are explicitly stated through policy. A policy instantiation is constructed at run-time through policy determination. The Ismene policy determination engine reconciles the conditional, abstract, and discretionary policies stated by communication participants to arrive at an instantiation. The resulting instantiation is a concrete specification of the mechanisms, configurations, and access control model to be implemented by the session. The algorithms used to derive policy are formally analyzed. An empirical investigation of Ismene shows that the cost of policy determination is nominal. The semantics of an instantiation are achieved through policy enforcement. The Antigone policy enforcement architecture implements session policies through the composition and configuration of security mechanisms. Each mechanism implements some service for the group. Policy is enforced through the observation of and reaction to relevant events. Antigone, however, is not a subscription-based event architecture. An event-bus is used to broadcast events to all mechanisms. Hence, overheads associated with subscription management and event routing are avoided. Experiments have shown that Antigone can achieve very high throughput and low latencies in a wide range of group environments. A key consideration of any policy infrastructure is its ability to represent the policies appropriate for the target user communities. Policies appropriate for the Antigone-based AMirD filesystems mirroring application in a wide range of application environments are considered and performance evaluated. These results show that Antigone can flexibly represent and efficiently enforce policies appropriate for many applications and environments.PhDApplied SciencesComputer scienceUniversity of Michigan, Horace H. Rackham School of Graduate Studieshttp://deepblue.lib.umich.edu/bitstream/2027.42/128200/2/3029392.pd
Improving the storage manageability, flexibility, and security in virtual machine systems.
No full textVirtual machine technology is being widely used for many applications such as server consolidation, software testing, and fault isolation. While it provides tremendous benefits to users, it also imposes higher requirements on VM storage manageability, flexibility, and security. Unfortunately, the main form of storage for conventional virtual machines, virtual disks, have serious limitations with respect to flexibility and security. This dissertation proposes a virtualization aware file system (VAFS) named Prism, which works as an alternative to virtual disks, but helps improve manageability, flexibility, and security of virtual machines. Prism extends a conventional distributed filesystem, NFSv3, with new features such as cloning, sharing, and isolation. It presents each VM with a dedicated filesystem that is semantically isolated from filesystems in other VMs. Guest applications can read and write files on the Prism filesystem without requiring any modification. As a central storage, Prism can map identical files in different VMs to one file on disk, substantially reducing storage and disk I/O overhead. If one attempts to write a shared file, Prism performs copy-on-write to preserve isolation between VMs. The thesis describes the Prism file mapping and copy-on-write mechanisms. Prism offers a cloning primitive that can selectively clone one or more VMs' filesystems to compose a new VM's filesystem. The Prism cloning primitive is semantically similar to a copy operation in a conventional filesystem, except much faster. From an end-user perspective, cloning is completed instantaneously, irrespective of the size of the cloned filesystem. The Prism cloning mechanism uses disk space very efficiently. The parent and cloned filesystem share data of unchanged files, which usually occupy a large portion of files. Prism only consumes additional space to store changes between the parent and its clone. In addition, this dissertation proposes two techniques, Virtual Remote Procedure Call (VRPC) and Inter-VM Metadata Sharing , to improve the Prism performance. The two techniques use shared memory to substantially reduce the overhead of Prism communication between VMs on a same physical computer. Experiments show that the two techniques can make Prism performance close to a local filesystem running on virtual disks for normal workloads.PhDApplied SciencesComputer scienceUniversity of Michigan, Horace H. Rackham School of Graduate Studieshttp://deepblue.lib.umich.edu/bitstream/2027.42/126987/2/3287672.pd
Content-based publish subscribe systems: Scalability and security.
No full textPublish subscribe provides a simple communication abstraction which enables development of large-scale distributed applications. Information consumers (subscribers) indicate their interest in some information via subscriptions. Information producers (publishers) publish their data as events, which in turn are matched to subscriptions and delivered to interested subscribers. An emerging paradigm of pub-sub are content-based systems. Content-based systems support a flexible and expressive subscription language which allows subscribers to specify exactly what information they are interested in. Research in content-based systems has touched on many issues such as event filtering/matching, as well as delivery semantics, event composition, and reliability. In this thesis, we are interested only in efficient event delivery, secure event delivery, and access control in content-based systems. Scalability of content-based systems was in question until the introduction of multiple event routing algorithms through networks of event brokers. We explore this issue further and examine the possibility of taking advantage of multicast techniques for event delivery. We explore and evaluate a number of algorithms for content-based event delivery using multicast. Security and access control have been largely ignored in content-based systems. In existing systems, the focus is on subscribers being able to control what information they receive by specifying subscription predicates. In contrast, our primary focus is on publishers (owners) being able to control who receives their data and under what terms. We present access control and security models for content-based systems. Our model supports a flexible policy language (based on the KeyNote assertion language) which allows users to write fine-grained access control rules. We also present efficient solutions to the problem of secure distribution of events where each event can potentially go to a different subset of subscribers. We validate our ideas through a prototype content-based system. Our prototype supports most of the features of our security and access control models. We implement a location tracking application on top of our content-based system and show that our security infrastructure can be used to implement many types of privacy and access control policies and thus potentially provide a foundation for enhancing privacy of users in sensor-based pervasive environments.PhDApplied SciencesComputer scienceUniversity of Michigan, Horace H. Rackham School of Graduate Studieshttp://deepblue.lib.umich.edu/bitstream/2027.42/124529/2/3150061.pd
A framework and protocols for reliable, timely, and ordered message delivery in distributed collaborating group applications.
No full textIn this thesis, we consider the problem of Reliable, Timely, and Ordered (RTO) delivery of messages in collaborating group applications. We develop a formal framework for defining the RTO constraints, with particular emphasis on capturing application semantics. We also develop protocols to meet the RTO constraints. Reliability and ordering constraints in the RTO framework are based on a novel object-centric formulation of the reliable group multicast problem, which we refer to as the Group State Synchronization Problem (GSSP). This formulation allows us to capture and represent reliability and ordering semantics at the object level. Reliability in the GSSP formulation is defined by relating message delivery to predicates defined on the state of the processes. This approach is closer to the application's semantics, and leads to protocols that are less costly. Further, ordering is an integral part of the GSSP formulation. The use of conflict sets allows specification of ordering constraints at finer levels of granularity, again allowing a better way to capture application semantics. The GSSP formulation also allows the use of application semantics for failure detection. By exploiting application semantics, we are able to reduce the occurrence of incorrect and costly failure detections. Process joins are also a lightweight operation in the GSSP formulation. We next develop a formal framework for the timeliness constraints. We consider two timeliness constraints: jitter and playback delay. We refer to the problem of defining and meeting these timeliness constraints as Playback Synchronization. The playback synchronization framework allows different messages to have different playback durations. The framework also allows situations where the playback duration of a message can be different (in particular, larger) than the inter-generation time for that message. The framework is designed such that the source and destination clocks can have non-zero clock skew without impacting the protocols. Finally, we discuss how the GSSP and Playback synchronization frameworks can be integrated with each other and describe the architecture of a java-based implementation of the framework.PhDApplied SciencesComputer scienceUniversity of Michigan, Horace H. Rackham School of Graduate Studieshttp://deepblue.lib.umich.edu/bitstream/2027.42/128166/2/3029389.pd
A flexible framework for Internet-based collaboration.
No full textAs computers become widely used and the network grows rapidly, there has been a growing interest in collaborative systems that allow people to interact and work together over the network. A key to success of a collaborative system is to enable people to collaborate in a manner best suited to their needs. However, there are two major obstacles in achieving this. One is new unexpected needs in a collaborative environment and the other is different group needs in a user community using a collaborative system. To address these, this thesis presents Collaboratory Builder's Environment (CBE), a software infrastructure for building flexible, Internet-based collaborative environments that can be tailored to meet a range of collaborative needs. CBE is based on the metaphor of a room representing a shared workspace, which contains users, group-aware applets and arbitrary data objects. The contributions of CBE are as follows. First, it provides extensible collaborative environment that allows newly-developed tools to be incorporated into the system. Second, it provides dynamic collaborative environment for users. A user can set up shared workspaces by creating new objects (e.g. URLs, group works, uploaded files) or by bring objects from other shared workspaces. A user is allowed to participate in multiple shared workspaces at the same time. Finally, a shared workspace can be customized to support different collaboration paradigms (e.g. rooms, call centers). The persistence of shared workspace state across synchronous sessions allows shared workspaces to be used for asynchronous collaboration as well as synchronous group tasks. CBE supports role-based access control that facilitates open access over the Web to a collaboratory. A prototype of the model has been implemented in Java and used extensively in several world-wide scientific campaigns by space scientists over the Internet. Through the analysis of traced usage data, we identify users' usage behavior in actual collaborations and discuss the effectiveness of our model.PhDApplied SciencesComputer scienceElectrical engineeringUniversity of Michigan, Horace H. Rackham School of Graduate Studieshttp://deepblue.lib.umich.edu/bitstream/2027.42/132406/2/9963834.pd
Flexible support for synchronous collaboration with selective window sharing and stateful group communication services.
No full textThe ability to share synchronized views of interactions with an application is critical to supporting synchronous collaboration. This thesis presents a flexible synchronous collaboration paradigm, called selective window sharing, in which the sharing of user/application interactions occurs at the window level within a multi-user, multi-window application. Selective window sharing facilitates on-demand sharing of application state and allows private workspace within a shared application. The paradigm is incorporated into a toolkit for building synchronous collaborative applications, called DistView. DistView defines an object-oriented application model that adapts the well-known Model-View-Controller (MVC) programming paradigm. In order to provide low response times for shared windows, DistView uses a selective, object-level replication scheme that allows the widgets and data objects associated with shared windows to be dynamically exported and imported. Providing low response times is critical in supporting the fluid interactions among participants in interactive collaborative environments, especially over a wide area network. Replicating shared windows also increases flexibility in screen real-estate management; for example, users can place, move, and/or iconize shared windows independently of their co-workers. The DistView toolkit works in conjunction with Corona, a communication subsystem that provides stateful group communication services for DistView-based applications. Corona's services are stateful in that Corona can manage shared application objects. Corona's shared object management is message-based and independent of application semantics. Corona also provides state synchronization and group membership notification services, to which clients can selectively subscribe. The initial versions of DistView and Corona are implemented in Java and have been successfully tested and used for supporting team science over a wide-area network in the Upper Atmospheric Research Collaboratory (UARC) project. This thesis provides a detailed discussion of the design of DistView and Corona and describes its usage in the UARC project.PhDApplied SciencesComputer scienceUniversity of Michigan, Horace H. Rackham School of Graduate Studieshttp://deepblue.lib.umich.edu/bitstream/2027.42/131787/2/9929952.pd
Flexible control of downloaded executable content.
No full textThe goal of this thesis is to develop security services to control the access rights of downloaded executable content. Downloaded executable content, such as active mail, mobile agents, applets, and command scripts, are programs that are retrieved from a remote source, often over untrusted networks, and executed upon receipt. Downloaded content can, in general, enable complex programs to be built that provide custom interfaces, perform file I/O, communicate with remote principals, and execute the commands available in traditional languages. From a security perspective, the important feature of downloaded executable content is that it enables remote principals, whom we call content providers, to execute programs in a process owned by the downloading principal. Unless controlled, malicious downloaded content could enable its provider to: (1) gain access to the downloading principal's private data; (2) masquerade as the downloading principal to others; and (3) read secret system data, such secret passwords, on the downloading principal's system. To protect systems from these and other attacks, current downloaded content systems strictly limit the access rights of the content. For example, some Java-enabled web browsers do not permit their applets to perform any file I/O on the downloading principal's system and permit them to communicate only with processes at the originating IP address of the content. However, many applications have greater I/O requirements than are permitted by these systems, whereas some have fewer I/O requirements. For example, a workflow system needs to read and modify forms available on the downloading principal's system. In addition, communication with principals other than the content provider may be necessary to complete a workflow activity. On the other hand, it should be possible to download an application and not grant it the permission to communicate with the application's content provider. In this thesis, we develop a downloaded content execution system to control the access rights of content for this variety of applications. Therefore, content from trusted principals may be granted substantial rights to the downloading principal's system while content from untrusted sources can be given few if any rights. Our contributions are the identification of three key problems that must be solved for content to be flexibly controlled and the development of downloaded content execution systems that solve these problems under varying environmental assumptions. The key problems in flexibly controlling content are: (1) authentication of content providers; (2) derivation of content access rights given the trust in those content providers and their purpose; and (3) enforcement of these rights throughout the execution of the content. We detail solutions to these problems in three downloaded content systems that control content in progressively less restricted environments. In the first system, principals interact over a trusted network using a shared file system. In the second system, principals interact over an untrusted network, but where the users are trusted to make access control decisions at runtime without being spoofed. In the third system, the network is assumed to be untrusted, and the access control decisions that users are trusted to make are limited. We evaluate the functionality offered by this third system and the effect of a prototype implementation on its performance.PhDApplied SciencesComputer scienceUniversity of Michigan, Horace H. Rackham School of Graduate Studieshttp://deepblue.lib.umich.edu/bitstream/2027.42/130267/2/9722006.pd
Providing flexibility in distributed applications using a mobile component framework.
No full textFuture distributed applications will need to support computing devices with a wide range of capabilities, varying network connectivity, increasing mobility of users, and a wide variation in load placed by clients on services. This dissertation addresses these challenges through the realization of a component-based framework, named DACIA, for building and executing adaptive distributed applications. Applications are viewed as graphs of connected components that typically implement data streaming, processing, and filtering functions. DACIA provides mechanisms for run-time reconfiguration of applications to allow them to adapt to the changing operating environments. Applications can dynamically load new components, change the way various components interact and exchange data, move components from one host to another, and replicate some components across multiple hosts. We identify the issues involved in runtime application reconfiguration. We propose an algorithm for performing dynamic reconfiguration while preserving the consistency and correctness of the application and minimizing the application disturbance. This algorithm executes in linear time with respect to the size of the application graph, and graciously handles failures that occur during the reconfiguration. Component mobility in DACIA provides support for mobile users and mobile applications. Logical connections between moving components are persistent. Messages are reliably and orderly delivered during and after component relocation. The execution of components connected to the moving component is not affected. Users do not see any interruptions in the services accessed, and they do not need to manually re-establish connections with the communication parties. We give several examples of applications implemented using DACIA, that demonstrate the benefits of using our framework, both from the performance and from the usability standpoint. DACIA is designed so that communication overheads are low, comparable to those of procedure calls when components are co-located and those of raw network communication when they are located on remote hosts. Moreover, the cost of moving components across hosts can be kept low. We show that by using simple adaptive heuristics to re-configure an application, the performance of the application can be significantly improved compared to the static case in which the application structure is fixed.PhDApplied SciencesComputer scienceUniversity of Michigan, Horace H. Rackham School of Graduate Studieshttp://deepblue.lib.umich.edu/bitstream/2027.42/128033/2/3029376.pd
- …
