A Novel Approach for Computing Dynamic Slices of Web Based Applications

The main issues of current web application is easily hacking the user information by unauthorized person. The development of entire web application depends on scripting languages that easily displays the user authentication code to the web browser. All code must be transferred through query string parameter (URL) of the web application. This kind of application security fails when verifying it by penetration testing which is based on XSS languages. This study overcomes the security issues by developing a web application based on cross site scripting technique which the user codes are encrypted using RSA algorithm and cookies, cross domain verification based on encrypted use code. XSS vulnerabilities come in different forms and may be categorized into two varieties: reflected and stored. Reflected is on type of attack which can be performed against applications that employ a dynamic page error message to users. Stored XSS vulnerability appears when data submitted by one user is store in the application or in the back-end database. The user cookies of the web browser store only the encrypted key values. These techniques applied in Enterprise web application it support multiple organization for processing product purchase order, sales order and invoice details.

Scripting languages have become a very popular choice for implementing server-side programs in Web applications. Scripting languages are thought to provide quick start up and enhance programmer productivity. We present two case studies in which scripting languages were used. In both studies, the projects struggled with implementation; however, project factors such as the strength of management and the training of the development team are thought to out weigh the choice of programming language in terms of impact on project success. The choice to implement a Web application with a scripting language can lead to undisciplined behavior on the part of management and the development team, so caution must be exercised when implementing complex applications. Testers of scripted implementations should adjust their risk profile to match the error-prone aspects of the language. Dynamically type checked scripting languages are likely to be susceptible to type errors. Scripting languages are powerful enough to successfully implement complex e-commerce applications as long as management and software engineering practice are strong.

This paper presents a context-sensitive dynamic slicing technique for concurrent AOPs having multiple threads. To effectively represent the concurrent AOP, we propose an intermediate graph called Multithreaded Aspect-Oriented Dependence Graph (MAODG). Based on this intermediate representation, we design a precise and accurate dynamic slicing algorithm for concurrent AOPs. This algorithm takes the MAODG of the concurrent AOP and a slicing criterion as input and computes the dynamic slice for the given concurrent AOP.

A System of Systems (SoS), composed of independent constituent systems, can create synergy among its systems to achieve a common goal. Many studies have used statistical model checking techniques to verify how well an SoS can achieve its goals. SoS models are usually complex and probabilistic, which makes statistical verification computationally expensive. To reduce this cost, dynamic slicing techniques can be applied to SoS models since both dynamic slicing and statistical verification focus on the models' execution samples. However, existing dynamic slicing techniques cannot guarantee executable accurate slices of SoS models when the models contain uncertainty. Therefore, we propose a hybrid slicing approach that combines dynamic backward slicing and modified observation-based slicing to produce accurate executable slices. Experimentation on the proposed technique found that the verification time was significantly reduced (47--56%), depending on the property, while preserving the verification results.

Aspect-oriented Programming (AOP) is a recent programming paradigm that focuses on modular implementations of various crosscutting concerns. The typical features of AOP such as join-point, advice, introduction, aspects etc. make it difficult for applying slicing. Program slicing is a method to extort statements that are relevant to a particular variable. Program slicing, as initially defined by Weiser is based on static dataflow examination on the flow graph of the program. Program slicing has been applied in parallel processing, program debugging, program integration,program understanding , software testing and maintenance etc.In this paper, we proposed a technique for dynamic slicing of aspectoriented software based on the UML 2.0 Communication diagram. Here, we can use slicing at the architectural level to find the slicing of communication diagram at an earlier stage of software development. To represent the various unique features of AOP in UML diagrams is very difficult and complex in nature. For this purpose, we first draw the communication diagram for aspect-oriented program considering the classes, pointcuts, advices and aspects. Next, we have generated an intermediate representation from the communication diagram. Then, we proposed an edge marking dynamic slicing algorithm that traverses the intermediate representation and finds the slices for the communication diagram of the given problem scenario. The novelty in our approach is that we present the communication diagram for the aspect-oriented software. Also, we proposed an algorithm to find the slice from it. The advantage of using communication diagram is that it mainly focuses on the interaction between the objects involved in the problem scenario.

This paper proposes a novel dynamic slicing technique for object oriented concurrent programs. We introduce the notion of object oriented concurrent program dependence graph (OOCPDG). Our dynamic slicing technique uses OOCPDG as the intermediate representation and is based on marking and unmarking the dependence edges as and when the dependences arise and cease at runtime. Our approach eliminates the use of trace files and is more efficient than existing algorithms. Besides, it encompasses different aspects of object oriented programming paradigm viz. inheritance, polymorphism from the slicing arena. It can handle dynamically created object based processes. It can also handle process interactions through shared memory and message passing. The updating to the intermediate representation is truly concurrent. Multiple processors execute different object based processes concurrently and require special handling. We also report a dynamic slicing tool called CDSOOCP (concurrent dynamic sheer for object oriented concurrent programs) which implements our dynamic slicing technique.

A relevant consequence of the expansion of the web and e-commerce is the growth of the demand of new web sites and web applications. As a result, web sites and applications are usually developed without a formalized process, and web pages are directly coded in an incremental way, where new pages are obtained by duplicating existing ones. Duplicated web pages, having the same structure and just differing for the data they include, can be considered as clones. The identification of clones may reduce the effort devoted to test, maintain and evolve web sites and applications. Moreover, clone detection among different web sites aims to detect cases of possible plagiarism. In this paper we propose an approach. based on similarity metrics, to detect duplicated pages in web sites and applications, implemented with HTML language and ASP technology. The proposed approach has been assessed by analyzing several web sites and Web applications. The obtained results are reported in the paper with respect to some case studies.

We propose a dynamic program slicing technique for object-oriented programs. We introduce the notion of compact dynamic dependence graph (CDDG) which is used as the intermediate program representation. Our dynamic slicing algorithm is based on the CDDG. We show that our algorithm is more time and space efficient than the existing ones. The worst case space complexity of our algorithm is O(n), where n is the number of statements of the program.

Security-by-construction in web applications development via database annotations

The goal of this paper is to give a general overview of e-management and its sub-areas, the advantages and disadvantages of these tools, and their impact nowadays. Web application technologies are taking over physically installed software in the daily routine. The necessity to have unlimited access to an application regardless of user location and without any time restriction. gave a huge advantage to online web applications since it made many companies, operating in different areas, turn their focus on them to perform their management tasks. Location and time are not the only limits device-based software has. Many of them require high-performance machines to be executed properly, and cloud-based web applications offer a very good solution in this case by not forcing these companies to buy expensive computers just to use software but instead offering them the same services online. The most popular e-management tools are listed in this paper. A focus is given to e-management in education and more precisely in academic networks. Web applications used in different areas and programming or scripting languages they use are compared based on a set of features.

Program slicing is a well-established technique for identifying a reduced subset of a program based on pre-defined criteria, leading to complexity reduction in subsequent activities. Despite extensive study over the past 40 years, slicing techniques for software product lines (SPLs) remain notably scarce. The absence of dedicated SPL slicing approaches hinders their efficient analysis and maintenance, limiting the ability to focus only on relevant parts of the SPL. One reason for this deficiency is the complex nature of a common variability implementation: the use of C preprocessor #ifdef-annotations within C code. A slicing approach for C-based SPLs must address the intricate interplay between the C code and the functionality introduced by the C preprocessor. Effectively handling these intricacies will unleash the full potential of SPL analysis. In this paper, we present a novel syntax-preserving program slicing approach for C-based SPLs. Unlike existing methods, our approach enables the computation of program slices through an integrated analysis of both C and CPP code, while preserving the original program syntax (no element of its syntax is disregarded or changed). This preservation ensures that the resulting program slices remain authentic subsets of the SPL, making them suitable inputs for variability-aware analyses. Additionally, we demonstrate the practical applicability of these slices in the context of software transplantation, showcasing their potential for facilitating functionality transfer between different program versions. In contrast to existing transplantation approaches, our solution works without test cases, removing the need for product configuration and execution. Consequently, the variability implementation (along with all other contained preprocessor code) is preserved during the transplantation. We empirically evaluate our approach on four distinct open-source SPLs, showcasing its effectiveness in generating diverse program slices tailored to different slicing criteria. We asses the accuracy of our code representation, the time required for slicing and transplantation, the size reduction achieved through the slices, and the functionality of our variability-aware transplantation approach.

Dependent types provide a strong foundation for specifying and verifying rich properties of programs through type-checking. The earliest implementations combined dependency, which allows types to mention program variables; with type-level computation, which facilitates expressive specifications that compute with recursive functions over types. While many recent applications of dependent types omit the latter facility, we argue in this paper that it deserves more attention, even when implemented without dependency.In particular, the ability to use functional programs as specifications enables statically-typed metaprogramming: programs write programs, and static type-checking guarantees that the generating process never produces invalid code. Since our focus is on generic validity properties rather than full correctness verification, it is possible to engineer type inference systems that are very effective in narrow domains. As a demonstration, we present Ur, a programming language designed to facilitate metaprogramming with first-class records and names. On top of Ur, we implement Ur/Web, a special standard library that enables the development of modern Web applications. Ad-hoc code generation is already in wide use in the popular Web application frameworks, and we show how that generation may be tamed using types, without forcing metaprogram authors to write proofs or forcing metaprogram users to write any fancy types.

Program slicing is a well-known program analysis technique that extracts the elements of a program related to a particular computation. Based on modular monadic semantics of a programming language, this paper presents a new formal method for slicing, called modular monadic slicing, by abstracting the computation of slicing as a slice monad transformer. With the use of slice transformer, the feature of program slicing can be combined in a modular way into semantic descriptions of the program analyzed. According to these, this paper gives both monadic dynamic and static slicing algorithms. They compute program slices directly on abstract syntax, without the needs to explicitly construct intermediate structures such as dependence graphs, or to record an execution history in dynamic slicing algorithm.

Program slicing techniques are widely used in the field of program debugging and testing, It is divided into static slicing and dynamic slicing. Existing dynamic slicing methods are inadequate, To solve these problems, A new dynamic slicing algorithm is designed, This algorithm based on coverage testing, The core idea is to establish a dynamic dependence graph, And the construction of this dependence graph is based on the coverage testing. This algorithm not only uses the static information, but also uses the dynamic execution information, The advantage of this algorithm is that it does not recalculate when the standard of slice changes.

Web applications are not protected by today's network level firewalls, because they allow access to TCP port 80 without restrictions. However, many successful attacks today are not on the network level, but on application level. For protecting against application level attacks, a firewall must understand the application protocols, that are used on its open ports. This happens in application level firewalls and for Web application in Web application firewalls. The underlying concepts of Web application firewalls differ much from the concepts of traditional network level firewalls. This book explains the underlying concepts of Web application firewalls. Afterwards, they are applied to a collection of security requirements, that application developers should respect today for developing a secure Web application. A Web application firewall is capable of automatically implementing many of these requirements. As a result, Web application developers can ignore these requirements, because the Web applications firewall already ensures their implementation and therefore the security of the Web application. This book is intended for anyone, who is interested in securing his Web application.