Protecting network-accessible resources from unauthorized use requires understanding of network vulnerability. Building attack models as chains of vulnerability exploits by an attacker can help locate flaws to prevent attacks. This paper presents an approach to automatically analyzing security attack models called exploit-based analysis. By using knowledge about exploitability of network vulnerabilities combined with a Markov computational process commonly used in link analysis, exploit based analysis ranks nodes in the attack model in order of their likelihoods of being compromised. The paper discusses the details of the approach, illustrates its use, and compares results with an existing technique.

An attack graph increasingly plays an important role in network security. It shows possible paths of actions consisting of the network vulnerability exploits that can lead to security breaches. Because most attack graphs are very large and complex, much research has focused on how these graphs can be automatically and efficiently generated. However, little has been done on attack graph analysis, namely how we can use attack graphs to better protect the network. This paper addresses the latter issue. We present a suit of systematic approaches to statically analyzing attack graphs by means of reasoning mechanisms based on logical expressions and conditional preference networks. The proposed approaches are general and theoretically grounded. The paper describes the approaches in details. We show how the resulting analysis can help derive many useful decisions. For example, it can assist a security administrator in selecting most cost-effective countermeasures, based on his preference criteria, to improve the security flaws found in the attack graph. For understandability, we illustrate our approach by presenting a study of a simple and small but realistic case scenario.

This paper addresses a fundamental issue of Web service composition. We present a simple but powerful conceptual model that leads to a scalable approach to automatically constructing a composite Web service to meet its requirements by using as few services as possible. Our approach is based on a state space model that has a monotone property to allow efficient search along with efficient algorithms for pruning and simple parallelization. We provide both empirical and theoretical analyses of the proposed approach and show that it has time complexity of O(n2), for a repository with n services. However, the approach takes linear time for sequential compositions when service applicability is performed by service discovery and thus, it is shown to give asymptotically optimal performance. Although optimality in the number of services deployed is not guaranteed, our experiments on public benchmark data sets show correct optimized solutions 100% of the time, with a reduction in the average running time, compared to a well-performed planning-based system, of better than 35% over 207 composition problems.

The order in which software components are tested can have a significant impact on the number of stubs required during component integration testing. This paper presents an efficient approach that applies heuristics based on a given software component test dependency graph to automatically generate a test order that requires a (near) minimal number of test stubs. Thus, the approach reduces testing effort and cost. The paper describes the proposed approach, analyses its complexity and illustrates its use. Comparison with three well known graph-based approaches, for a real-world software application, shows that only the classic Le Traon et al.'s approach and ours give an optimal number of stubs. However, experiments on randomly simulated dependency models with 100 to 10,000 components show that our approach has a significant performance advantage with a reduction in the average running time of 96.01%.

Advances in Internet and software technology play increasing roles in creating work environments and online services that impact our everyday living. Web service computing paradigm has revolutionized how these software applications can be developed rapidly and reliably by employing available services available in standard forms across the web. Automatic composition of Web services is necessary and challenging when there are a huge growing number of available Web services but no single service offers the desired function. This paper presents an approach to automatically combining published Web services to meet the application requirements using as few services as possible. Our approach is based on heuristic algorithms that incorporate semantics of services from their ontology into identifying valid executable services in the composition structure. The paper describes the approach and evaluates its performance on public service repositories. Our experimental results show correct optimized solutions 100% of the time, with a reduction in the average running time, compared to champion of Web service chal-lenge'06 competition, of 60.2% over 31 composition problems.

Role-based access control (RBAC) is the most predominant access control model in today's security management due to its ability to simplify authorization, and flexibility to specify and enforce protection policies. In RBAC, Separation of Duty (SoD) constrains user role authorization to protect sensitive information from frauds due to conflicts of interests. SoD constraints are commonly defined by mutually exclusive roles (MER) (e.g., bank teller and auditor). This paper proposes practical computational techniques for analyzing SoD by integrating workflows of the enterprise processes into the RBAC framework. Specifically, we present 1) an algorithm for generating MER to enforce SoD, and 2) a verification algorithm to check if a given RBAC state (role authorization and user-role assignments) satisfies a given type of SoD constraint or not. The paper discusses the details of the approach and illustrates its use in a loan application domain.

Research has successfully applied model checking, a formal verification technique, to automatically generate chains of vulnerability exploits that an attacker can use to reach his goal. Due to the combinatorial explosion of the chain generation problem space, model checkers do not scale well to networks containing a large number of hosts. This paper proposes a methodology that uses a host-centric modeling approach together with a monotonicity assumption to alleviate the scalability problem of model checkers. We describe the proposed approach, its limitations, and show how it can reduce the time complexity of chain generation to a quadratic polynomial of the number of hosts, both theoretically and empirically. We also compare its advantages over similar customized graph-based approaches.

Managing access authorities is critical to the security of information systems. To prevent fraud or abuse due to conflict of interests, a well-known authorization constraint called separation of duty (SoD) is commonly applied. SoD ensures that no single user receives too many authorities. Enforcement of authorization constraints such as SoD in large organizations can be difficult due to the large number of information system users, the variety of assets involved, and tasks that require roles that may be shared or delegated at multiple levels. Most existing work in this area focuses on specifications of SoD constraints and assumes that constraints can be enforced by logical inference mechanisms at run-time. A drawback of this approach is that when violations occur, finding alternative role activations at run-time may not be feasible. This can result in delays or even failure for critical service transactions. Moreover, logic-based systems are difficult to understand and do not scale easily. This paper presents an algorithmic set-based approach that automatically checks for SoD compliance prior to run-time by searching for a set of valid role activations. The paper discusses details of this approach and illustrates its use in managing access authorizations in a health insurance claim processing system.