Ashish Kumar Dwivedi

Incorporating Security Features in Service-Oriented Architecture using Security Patterns

Service-Oriented Architecture is an architectural style where different heterogeneous components share information with each other by using special types of messages based on the protocol known as Simple Object Access Protocol. Various technologies, such as Common Object Request Broker Architecture, Java 2 Platform, Enterprise Edition, Java Message Service etc. are applied to realize Service-Oriented Architecture for different applications. Besides these approaches, two other techniques, REpresentational State Transfer, and web services are applied for the realization of Service-Oriented Architecture. Web services provide a platform independent communication scheme between applications. The security preservation among the composition of services is an important task for Service-Oriented Architecture. In this study, an attempt is made to incorporate security features in Service- Oriented Architecture with the help of software security patterns. This scheme is described by developing an architectural model integrated with security goals and security patterns. The structural and behavioral aspects of composition of web services incorporated with security features are presented using a Unified Modeling Language class diagram and a sequence diagram respectively. At the end of this study, an evaluation is performed between identified security patterns and critical security properties along with Service-Oriented Architecture design principles. A case study of an online banking system is considered to explain the use of security patterns.

Detection of design pattern using Graph Isomorphism and Normalized Cross Correlation

Present day software engineering concept gives emphasis on the use of design patterns for developing software which are recurring in nature. Detection of design pattern is one of the emerging field of Software Reverse Engineering. In this work, an attempt has been made to present an approach for design pattern detection with the help of Graph Isomorphism and Normalized Cross Correlation techniques. In this study, system and design pattern are presented in the form of graphs. The Graph Isomorphism technique finds the pattern subgraph in the system graph and Normalized Cross Correlation provides a way to formulate the percentage existence of the design pattern in the system. An Eclipse Plug-in i.e., ObjectAid is used to extract Unified Modeling Language (UML) class diagrams as well as eXtensible Markup Language (XML) files from the software system and design patterns. An algorithm is proposed to identify relevant information from the XML files. Then Graph Isomorphism and Normalized Cross Correlation techniques are used to find the pattern subgraph and its percentage existence in the system. This approach has been applied on four open source software tools for the evaluation of five design patterns, such as Composite, Facade, Flyweight, State, and Template Method.

Formalization of web security patterns

Security issues in software industries become more and more challenging due to malicious attacks and as a result, it leads to exploration of various security holes in software system. In order to secure the information assets associated with any software system, organizations plan to design the system based on a number of security patterns, useful to build and test new security mechanisms. These patterns are nothing but certain design guidelines. But they have certain limitations in terms of consistency and usability. Hence, these security patterns may sometimes act as insecure. In this study, an attempt has been made to compose security patterns for the web-based application. Subsequently, a formal modeling approach for the composition of security patterns is presented. In order to maximize comprehensibility, Unified Modeling Language (UML) notations are used to represent structural and behavioral aspects of a web-based system. A formal modeling language i.e., Alloy has been taken into consideration for analyzing web-based security pattens. For the demonstration of this approach, a case study i.e., an online banking system is considered. A qualitative evaluation is performed for the identified security patterns against the critical security properties. In this study a model-driven framework is presented, which helps to automate the process of analyzing web security patterns.

Selecting and formalizing an architectural style: A comparative study

An architectural style is characterized by their control-flow and data-flow patterns, appropriation of functionality across components, connectors, ports, and roles. Selecting an architectural style for an application is not an easy task. It is a decision-making task in which different objectives must be taken into consideration. In this study, different architectural styles are classified on the basis of many style-induced architectural properties. This classification provides additional guidance for people who lack expertise and experience to select an appropriate style for their software systems. Subsequently, an appropriate style is selected for the case study i.e., cargo router system. After selecting an appropriate style for cargo router system, it is formalized using formal modeling languages Alloy and Promela. For the model checking of these formal notations, automated verifiers such as Alloy Analyzer and SPIN are used. At the end of this study, comparison of performance between modeling languages Alloy and Promela as well as associated tools such as Alloy Analyzer and SPIN is performed.

Impact of Design Patterns on Quantitative Assessment of Quality Parameters

Software engineering concept emphasizes on the use of design patterns for developing software which are recurring in nature. The aim of this work is to provide a methodology to compare the quality attributes of a system having design pattern solution with a system without usages of design pattern solution, both the system intending to provide same functionalities. Further, QMOOD (Quality Model for Object-Oriented Design) approach is adopted to assess the effects of design patterns in an object-oriented system environment. Using this approach, object-oriented metrics are calculated in terms of the number of classes and their relationships in a UML (Unified Modeling Language) class diagram. The cut-off points are calculated in order to provide the exact size of the system in terms of the number of classes, for which the solution adopted using design pattern provides more quality parameters. For the demonstration of this approach, different design patterns, such as Visitor, Bridge, and Abstract Factory design patterns have been taken into consideration.

Software design pattern mining using classification-based techniques

Design patterns are often used in the development of object-oriented software. It offers reusable abstract information that is helpful in solving recurring design problems. Detecting design patterns is beneficial to the comprehension and maintenance of object-oriented software systems. Several pattern detection techniques based on static analysis often encounter problems when detecting design patterns for identical structures of patterns. In this study, we attempt to detect software design patterns by using software metrics and classification-based techniques. Our study is conducted in two phases: creation of metrics-oriented dataset and detection of software design patterns. The datasets are prepared by using software metrics for the learning of classifiers. Then, pattern detection is performed by using classification-based techniques. To evaluate the proposed method, experiments are conducted using three open source software programs, JHotDraw, QuickUML, and JUnit, and the results are analyzed.

Transformation of Alloy Notation into a Semantic Notation

Transformation of a model based on first-order logic to a model that provides semantic notations is helpful necessary during the analysis phase of any proposed software. The semantic notations often guide the designer to develop pseudocode correctly. This study focuses on facilitation of transformation of one formal model, i.e., Alloy into another, i.e., OWL. The proposed approach extends the concept of existing techniques i.e., UML2Alloy and TwoUse to transform Alloy model into OWL. UML2Alloy transforms UML model into Alloy model, whereas TwoUse approach bridges the gap between UML model and OWL model. Alloy2OWL is based on metamodel-based transformation techniques, which help to map source model, i.e., Alloy into target model, i.e., OWL. For the proper explanation of this study, a model transformation framework is presented, which can be applied to other transformation languages. The proposed approach utilizes the Model-Driven Development techniques to deal with the analysis of Alloy model and determines design problems within a specification. In this paper, various challenges are also presented which occur during the transformation of Alloy to OWL.

Formalization of e-commerce patterns using state-based and event-based approaches

Due to complex and heterogeneous nature of a software being used in present-day scenario, the need for developing solution to the design related problems, where solutions were made earlier can be reused in a recurring manner. For solving various design problems, it is observed that design pattern helps to find a better solution to many of the recurring design problems. Generally, design patterns are specified using semi-formal notation, such as UML (Unified Modeling Language). But these types of semi-formal notations sometimes lead to ambiguities and inconsistencies. In this study, an attempt has been made to present design patterns for a case study on e-Commerce system and formalize the notations of patterns using a state-based approach i.e., Alloy as well as an event-based approach i.e., Colored Petri Nets (CPNs). The structural aspect of patterns is specified by using UML (Unified Modeling Language) class diagram. At the end of this study, a comparative analysis has been made between performance of models such as Alloy and CPNs for the modeling of design patterns.

Applying software metrics for the mining of design pattern

Development of desired software in the present day scenario is becoming too much complex as the user requirements becoming complex day-by-day. Hence there is a need for developing the right methodology for solving complex problem. To solve various problems in design phase, a number of tools and techniques are available and one of them is known as the use of design pattern, which helps to find a better solution for the problems, which are recurring in nature. It is often desired to detect design patterns from the source code of similar category of software, as it improves maintainability of source code of a software. In this study, mining of design pattern technique has been presented, which is based on supervised learning techniques as well as software metrics. During the pattern mining process, metrics-based dataset is developed. Subsequently, machine learning techniques such as Layer Recurrent Neural Network and Random Forest are applied for the pattern mining process. For the critical examination of the proposed study, data from an open source software e.g., JUnit is considered for the mining of software patterns.

Software design pattern recognition using machine learning techniques

Design patterns helpful for software development are the reusable abstract documents which provide acceptable solutions for the recurring design problems. But in the process of reverse engineering, it is often desired to identify as well as recognize design pattern from source code, as it improves maintainability and documentation of the source code. In this study, the process of software design pattern recognition is presented which is based on machine learning techniques. Firstly, a training dataset is developed which is based on software metrics. Subsequently, machine learning algorithms such as Layer Recurrent Neural Network and Decision Tree are applied for patterns detection process. In order to evaluate the proposed study, an open source software i.e., JHotDraw 7.0.6 has been used for the recognition of design patterns.