Security services can keep a system from security breaches for a while, but they are ultimately compromised as the system is deployed and used. This paper describes the modeling of security fault-tolerant (SFT) requirements, which can tolerate the failures of security services for systems. SFT requirements are specified together with the security services requirements so that they tolerate breaches of the security services. This paper addresses an approach for specifying and analyzing SFT requirements using a meta-model. Threats to systems are identified in the requirements specification and analysis phases, and SFT measures against the threats are described with security services. An electronic commerce system is selected to illustrate the approach.

This paper describes an approach to analyzing security failure-tolerant (SFT) requirements that are specified by means of SFT use cases, along with security use cases and application use cases for application systems.The SFT requirements are analyzed with the analysis model that consists of the static model and dynamic model.A meta-modeling approach is taken to specify the static and dynamic models for analysis of SFT requirements.Threats are identified in the analysis of SFT requirements, and SFT countermeasures against the threats are specified in the analysis model.An online shopping system is used for illustrating our approach.

This paper describes security failure-tolerant requirements, which tolerate the failures of security services that protect applications from security attacks.A security service, such as authentication, confidentiality or integrity security service, can be always broken down as advanced attack skills are coined.There is no security service that is forever secure.This paper describes an approach to developing the security failure-tolerant use case that specifies the security requirements for tolerating the breaches of security services.A security failure-tolerant use case is modeled along with application use case and security use case, and specified with application use case description.Threats to applications are identified and modeled to develop security failure-tolerant requirements.Online shopping system is used for illustrating security failure-tolerant requirements.

This paper describes the design of secure connectors that are used in the design of secure software architectures for distributed business applications. Mixing security concerns with business concerns in software architectures makes applications more complex. With the goal of making secure software architectures more maintainable and evolvable, the secure connectors proposed in this paper are designed separately from business application components by considering different communication patterns between the components as well as security services required by application components. Each secure connector encapsulates security relevant objects to provide application components with security services. In this paper, secure connectors are applied to design the software architectures of electronic commerce and automated teller machine applications.

This paper describes an approach to the design of a wrapper for self-managing COTS (commercial off-the-shelf) components. Each wrapper for COTS components encapsulates the properties of self-management — detection, reconfiguration, and repair. A COTS component deals with the application perspectives, whereas the wrapper handles the self-management perspectives, separately from the application perspectives. Each wrapper for self-managing COTS components is structured into several objects in support of detection, reconfiguration, and repair of the anomalous COTS components. The approach suggested in this paper is applied to the distributed elevator system consisting of multiple COTS components.

This paper describes an approach to designing COTS (commercial off-the-shelf) components-based software system in which each COTS component is self-managed by a wrapper to improve dependability of systems. The wrapper for self-managing a COTS component detects the anomalies of the component; it reconfigures the anomalous component at run-time; and it repairs the anomalous component. The wrappers co-operate to each other to reconfigure COTS components, so that they make the system more reliable. The approach suggested in this paper is applied to the distributed elevator system with multiple elevators

This paper describes model transformation for analyzing dynamic behavior of large-scale systems. The Unified Modeling Language (UML) based system model is transformed into the Colored Petri Nets (CPN) model, which is used for analyzing the scenarios of the use cases of a system and checking freedom of system deadlock at an early stage of software development. The CPN model that is executable is hierarchically structured on the basis of the functional decomposition of a large-scale system. The UML-based system model consisting of the use case model, class model and collaboration model is not executable so that the dynamic behavior of the system cannot be analyzed until implementation of the system. However, the UML-based system model has no hierarchical structure to be transformed into the hierarchical CPN model as well. The discrepancies of dynamic and structural views in the two models are resolved by transformation of the UML model into the layered, executable CPN model with three layers — the use case layer, object layer and operation layer. The model transformation is carried out using relationships among the use case model, class model, and collaboration model of the UML. With the executable CPN model transformed, the dynamic properties of the system are analyzed using the simulation technique, occurrence graph, and state space report provided by the Design/CPN tool. The approach in this paper is validated through two case studies — the gas station system and the distributed factory automation system.

This paper describes how to model complex applications by modelling application requirements and designs separately from security requirements and designs using the UML notation. By careful separation of concerns, the security requirements are captured in security use cases and encapsulated in security objects separately from the application requirements and objects. The approach reduces system complexity caused by mixing security requirements with business application requirements with the goal of making complex systems more maintainable. Furthermore, the security use cases and objects can be reused by other software applications.

This paper describes a multiple-view meta-modeling approach for software product lines using the Unified Modeling Language notation (UML). A multiple-view model for a software product line is an object-oriented domain model which defines the different aspects of a software product line, namely the use case model, static model, collaboration model, statechart model, and feature model, including the commonality and variability. The meta-model depicts life cycle phases, views within each phase, and meta-classes within each view. The relationships between the different views are described. Consistency checking rules are defined based on the relationships among meta-classes in the meta-model. Finally, tool support for the approach is described.

An application domain is defined as a family of systems that have some features in common and others that differentiate them. A domain model is a multiple view object oriented analysis model for the application domain that reflects the common aspects and variations among the members of the family of systems that constitute the domain. The paper describes the integration of the domain modeling method for analyzing and modeling families of software systems with the SOFL formal specification language. Aggregation hierarchies and generalization/specialization hierarchies are depicted using the UML static modeling notation. Object communication diagrams are depicted using the SOFL condition data flow diagram notation. SOFL is used for the formal specification of the kernel, optional and variant classes.