Aspect] is a simple and practical aspect-oriented extension to Java With just a few new constructs, AspectJ provides support for modular implementation of a range of crosscutting concerns. In AspectJ's dynamic join point model, join points are well-defined points in the execution of the program; pointcuts are collections of join points; advice are special method-like constructs that can be attached to pointcuts; and aspects are modular units of crosscutting implementation, comprising pointcuts, advice, and ordinary Java member declarations. AspectJ code is compiled into standard Java bytecode. Simple extensions to existing Java development environments make it possible to browse the crosscutting structure of aspects in the same kind of way as one browses the inheritance structure of classes. Several examples show that AspectJ is powerful, and that programs written using it are easy to understand.

An overview of AspectJ

The present disclosure provides a system that includes a server hosting an application under test (AUT), an observer configured to monitor instructions executed by the AUT, and a computing device communicatively coupled to the AUT and the observer through a common communication channel. The computing device may be configured to send an application request to the AUT, wherein the application request is configured to expose a potential vulnerability of the AUT. The computing device may receive an application response from the AUT in accordance with the AUT's programming. The computing device may send a service request to the observer, and receive a service response from the observer that contains information corresponding to the instructions executed by the AUT due to the application request, information about the AUT, or information about a server hosting the AUT.

Application security testing

Context: Dynamic languages have turned out to be suitable for developing specific applications where runtime adaptability is an important issue. Although .Net and Java platforms have gradually incorporated features to improve their support of dynamic languages, they do not provide intercession for every object or class. This limitation is mainly caused by the rigid class-based object model these platforms implement, in contrast to the flexible prototype-based model used by most dynamic languages. Objective: Our approach is to provide intercession for any object or class by defining a hybrid class- and prototype-based object model that efficiently incorporates structural intercession into the object model implemented by the widespread .Net and Java platforms. Method: In a previous work, we developed and evaluated an extension of a shared-source implementation of the .Net platform. In this work, we define the formal semantics of the proposed reflective model, and modify the existing implementation to include the hybrid model. Finally, we assess its runtime performance and memory consumption, comparing it to existing approaches. Results: Our platform shows a competitive runtime performance compared to 9 widespread systems. On average, it performs 73% and 61% better than the second fastest system for short- and long-running applications, respectively. Besides, it is the JIT-compiler approach that consumes less average memory. The proposed approach of including a hybrid object-model into the virtual machine involves a 444% performance improvement (and 65% less memory consumption) compared to the existing alternative of creating an extra software layer (the DLR). When none of the new features are used, our platform requires 12% more execution time and 13% more memory than the original .Net implementation. Conclusion: Our proposed hybrid class- and prototype-based object model supports structural intercession for any object or class. It can be included in existing JIT-compiler class-based platforms to support common dynamic languages, providing competitive runtime performance and low memory consumption.

A hybrid class- and prototype-based object model to support language-neutral structural intercession

Distributed systems are commonly required to be flexible and scalable, as the number and arrangement of their (potentially mobile) devices may easily change. Security in distributed systems is a complex issue which can produce several problems such as eavesdropping, phishing or denial of service. To overcome these problems, there are various security measures that can be applied. This study proposes the use of dynamic aspect-oriented software development (AOSD) to implement security mechanisms in distributed systems. By applying dynamic separation of concerns using AOSD, it becomes possible to adapt the security measures of distributed systems, even when their sizes and arrangements change, without compromising global security. These changes can be applied when a distributed system is running, without requiring its execution to be stopped or interrupted. Using the dynamic and static aspect weaving AOSD platform, the authors have implemented solutions for two common security problems in distributed systems: (i) access control and data flow and (ii) encryption of transmissions. Moreover, the proposed approach has been tested in a real client-server FTP scenario. Qualitative and quantitative evaluations of both implementations are presented to estimate the pros and cons of using dynamic AOSD in the development of security measures of distributed systems.

Applying dynamic separation of aspects to distributed systems security: A case study

Aspect-Oriented Software Development (AOSD) provides systematic means to modularize crosscutting concerns in software development. Common AOSD benefits are a higher level of abstraction, concern reuse, better legibility, and software maintainability improvement. In AOSD, static weaving implementations commonly obtain better runtime performance, whereas dynamic weaving provides runtime application adaptiveness and a valuable aid in software development. Since both approaches provide benefits, we have developed a Dynamic and Static Aspect Weaving (DSAW) platform that supports both kinds of weavers: a full dynamic one to offer high dynamic adaptiveness and a static one to obtain better runtime performance when the application is deployed. Furthermore, both weaving techniques can even be used simultaneously in the same application. Depending on the adaptiveness requirements and the life cycle stage, the programmer could change from one type of weaving to the other without performing any modification in the source code of either components or aspects. Therefore, DSAW provides the separation of the dynamism (weaving-time) concern in the aspect-oriented software development process. Moreover, our platform also supports a wide set of join-points and is language and platform neutral. A detailed assessment has revealed that the DSAW platform provides a competitive alternative to develop aspect oriented software.

/pdf/the-dsaw-aspect-oriented-software-development-platform-3279fsxchm.pdf

The dsaw aspect-oriented software development platform

Although dynamic languages are becoming widely used due to the flexibility needs of specific software products, their major drawback is their runtime performance. Compiling the source program to an abstract machine’s intermediate language is the current technique used to obtain the best performance results. This intermediate code is then executed by a virtual machine developed as an interpreter. Although JIT adaptive optimizing compilation is currently used to speed up Java and .net intermediate code execution, this practice has not been employed successfully in the implementation of dynamically adaptive platforms yet. We present an approach to improve the runtime performance of a specific set of structural reflective primitives, extensively used in adaptive software development. Looking for a better performance, as well as interaction with other languages, we have employed the Microsoft Shared Source CLI platform, making use of its JIT compiler. The SSCLI computational model has been enhanced with semantics of the prototype-based object-oriented computational model. This model is much more suitable for reflective environments. The initial assessment of performance results reveals that augmenting the semantics of the SSCLI model, together with JIT generation of native code, produces better runtime performance than the existing implementations.

/pdf/adding-structural-reflection-to-the-sscli-34iwijj4mt.pdf

Adding Structural Reflection to the SSCLI

Aspect Oriented Software Development is an effective realization of the Separation of Concerns principle. A key issue of this paradigm is the moment when components and aspects are weaved together, composing the final application. Static weaving tools perform application composition prior to its execution. This approach reduces dynamic aspectation of running applications. In response to this limitation, dynamic weaving aspect tools perform application composition at runtime. The main benefit of dynamic weaving is runtime adaptability; its main drawback is runtime performance. Existing research has identified the suitability of hybrid approaches, obtaining the benefits of both methods in the same platform. Applying static weaving where possible and dynamic weaving when needed provides a balance between runtime performance and dynamic adaptability. This paper presents DSAW, an aspectoriented system that supports both dynamic and static weaving homogeneously over the .Net platform. An aspect can be used to adapt an application both statically and dynamically, without needing to modify its source code. Moreover, DSAW is language and platform neutral, and source code of neither components nor aspects is required.

DSAW - A Dynamic and Static Aspect Weaving Platform

Since Aspect Oriented Software Development (AOSD) has appeared, a set of tools have been developed that enable its use at software development. On many occasions, applications must be capable of adapting to runtime emerging requirements. This is possible through the use of dynamic weaving tools. However, these tools are subject to limitations such as language dependency or a limited set of join points, which limit their utility. This paper shows the research we are carrying out in the dynamic weaving field. We apply computational reflection at the virtual machine computational level in order to achieve dynamic weaving regardless of the language. We have selected the .NET system as the platform to develop our dynamic weaver, making possible the dynamic adaptation of platform-independent applications.

A Dynamic Aspect Weaver over the.NET Platform

Since Aspect Oriented Software Development (AOSD) has appeared, a set of tools have been developed that enable its use at software development. On many occasions, applications must be capable of adapting to runtime emerging requirements. This is possible through the use of dynamic weaving tools. However, these tools are subject to limitations such as language dependency or a limited set of join points, which limit their utility.

Luis Vinuesa

Papers

The dsaw aspect-oriented software development platform

Adding Structural Reflection to the SSCLI

DSAW - A Dynamic and Static Aspect Weaving Platform

A Dynamic Aspect Weaver over the.NET Platform

A Dynamic Aspect Weaver over the .NET Platform