New AspectJ Pointcuts for Integer Overflow and Underflow Detection

ABSTRACT

Aspect-oriented Programming (AOP) appears to be a promising paradigm for software security hardening. Using AOP, security experts can be responsible for coding security properties, and developers can concentrate on the basic functionality of the program. AspectJ extends the Java programming language to implement crosscutting concerns modularly in general. In this paper, we have extended AspectJ with new pointcuts in order to detect integer overflows and underflows in Java. Integer overflows and underflows in Java occur silently without throwing an exception. A malicious user can exploit them to produce a security breach. Hence, we implement new pointcuts: addition, multiplication, and subtraction that allow to write advices around integer arithmetic operations to detect integer overflow and underflow and consequently prevent considerable number of security breaches.     

Distribution and persistence as aspects

This paper reports our experience using AspectJ, a general‐purpose aspect‐oriented extension to Java, to implement distribution and persistence concerns in a Web‐based information system. This system was originally implemented in Java and restructured with AspectJ. Our main contribution is to show that AspectJ is useful for implementing several persistence and distribution concerns in the considered application, but also in similar applications. We have also identified interferences between the implemented aspects and a few drawbacks in the language, so we suggest some minor language modifications that could significantly improve similar implementations. Despite those problems, we argue that the AspectJ implementation is superior to the pure Java implementation. Some of the aspects implemented in our experiment are abstract and constitute a simple aspect framework. The other aspects are application specific but we suggest that different implementations might follow the same aspect patterns. The framework and the patterns allow us to propose architecture‐specific guidelines that provide practical advice for both restructuring and implementing certain kinds of persistent and distributed applications with AspectJ. Copyright © 2006 John Wiley & Sons, Ltd.     

Profiling with AspectJ

This paper investigates whether AspectJ can be used for efficient profiling of Java programs. Profiling differs from other applications of AOP (e.g. tracing), since it necessitates efficient and often complex interactions with the target program. As such, it was uncertain whether AspectJ could achieve this goal. Therefore, we investigate four common profiling problems (heap usage, object lifetime, wasted time and time‐spent) and report on how well AspectJ handles them. For each, we provide an efficient implementation, discuss any trade‐offs or limitations and present the results of an experimental evaluation into the costs of using it. Our conclusions are mixed. On the one hand, we find that AspectJ is sufficiently expressive to describe the four profiling problems and reasonably efficient in most cases. On the other hand, we find several limitations with the current AspectJ implementation that severely hamper its suitability for profiling. Copyright © 2006 John Wiley & Sons, Ltd.     

A constraint-weaving approach to points-to analysis for AspectJ

Points-to analysis is a static code analysis technique that establishes the relationships between variables of references and allocated objects. A number of points-to analysis algorithms have been proposed for procedural and object-oriented languages like C and Java, while few of them can be used for AspectJ as we know so far. One main reason is that AspectJ is an aspect-oriented language which implements the separation of crosscutting concerns by advices, pointcuts, and inter-type declarations, while a points-to analysis of AspectJ programs may be imprecise because any aspect woven into the base code may change the points-to relations in the program and thus a conservative analysis has to be taken in order to handle the aspects. In this paper, we propose a context-sensitive points-to analysis technique called AJPoints for AspectJ. Similar to the weaving mechanism for AspectJ, AJPoints obtains the constraints and templates on the points-to relations for the base code and the aspects, respectively, but weaves and solves them in an iterative manner in order to cross the boundary between the base code and the aspects. We have implemented AJPoints on abc AspectJ compiler and evaluated it by using twelve AspectJ benchmark programs. The experimental results show that our technique can achieve a high precision about points-to relations in AspectJ programs.     

面向方面编程技术研究

面向方面编程是一项允许编程人员模块化横切关注点的新的编程技术，它引入了“方面”这一概念，“方面”把影响多个模块的行为封装到一个单独的可重用模块中，利用Xerox PARC发行的AspeetJ，Java开发者可以很方便地进行面向方面编程。本文介绍了AOP、AspeetJ的基本概念并举例说明了AOP在仓储管理系统中的应用。     

AspectC#——在C#中应用AOP

当前,AspectJ是用得最普遍的AOP工具,它是基于Java平台的。着重讨论了一种基于.NET平台的AOP技术,AspectC#。用户可以通过AspectC#在C#中应用AOP。目前,AspectC#只支持C#语言,但是.NET平台的多语言性使得跨语言的AOP应用成为可能。     

OWL本体到软件代码模型映射的研究

OWL本体在知识工程中有着广泛应用,人们考虑用它来解决软件开发中的问题。该文分析OWL本体和Java面向对象模型问的差别,指出直接映射存在的问题,阐述OWL本体映射到面向方面模型的特点,并提出OWL本体向AspectJ面向方面模型映射的具体方法,较好实现OWL本体向软件代码模型的映射。     

面向方面编程研究

本文阐述了面向方面编程（Aspect-Oriented Programming，AOP）的引入、实现技术，并介绍了AOP在Java平台下的一个实现——AspeccJ的应用，最后分析了AOP的技术优势．     

对AspectJ中Call和Execution语义的研究

AOP(面向方面编程)提供了一种有效的方法封装软件中的横切行为,AspectJ是对Java的一个通用AOP扩展。本文首先分析call和execution这两种类型PCD的语义,然后指出这两个PCD基于的一个共同基础存在语义上的不一致,最后基于前面的讨论分析给出了使用这两类PCD的使用建议。