Loop squashing transformations for amorphous slicing

Program slicing is a source code extraction technique that can be used to support reverse engineering by automatically extracting executable subprograms that preserve some aspect of the original program's semantics. Although minimal slices are not generally computable, safe approximate algorithms can be used to good effect. However, the precision of such slicing algorithms is a major factor in determining the value of slicing for reverse engineering. Amorphous slicing has been proposed as a way of reducing the size of a slice. Amorphous slices preserve the aspect of semantic interest, but not the syntax that denotes it, making them generally smaller than their syntactically restricted counterparts. Amorphous slicing is suitable for many reverse engineering applications, since reverse engineering typically abandons the existing syntax to facilitate structural improvements. Previous work on amorphous slicing has not attempted to exploit its potential to apply loop-squashing transformations. This paper presents an algorithm for amorphous slicing of loops, which identifies induction variables, transformation rule templates and iteration-determining compile-time expressions. The algorithm uses these to squash certain loops into conditional assignments. The paper also presents an inductive proof of the rule templates and illustrates the application of the algorithm with a detailed example of loop squashing

Static Slicing of Interprocedural Programs

Program slicing has many applications in a software development environment such as debugging, testing, anomaly detection, program understanding and many more. The concept being introduced by Weiser and it was started with static slicing calculation. Talking about static slicing, it is a subset of statements of a program which directly or indirectly affect the values of the variables computed providing a slicing criterion. In this project, we have developed an approach for creating an intermediate representation of a program in the form of System Dependence Graph (SDG) which is to be, again taken as input for computing the slicing of a program with respect to slicing criterion. The slicing approach computes the slices with respect to a given slicing criterion. For generating the graph, we have analysed the input program, identified the tokens and finally generated the relation between tokens as data dependent or control dependent. For calculating the slice, we have used two-phase graph reachability algorithm developed by Horwitz, Reps and Binkley, which creates a graph consisting of only those nodes that are dependent on slicing criterion. Finally we have plotted a graph between time taken to create graph versus number of functions used in program. Our approach of calculating slices has been limited only to C programs

Forward Static Program Slicing

Program slicing is a practical disintegration methodology that omits program modules that are irrelevant to a particular computation process based on a criterion known as the slicing criterion. The original program’s semantics is projected through the computation of an executable program formed by the left over modules called a slice. Using this methodology we can automatically determine the relevance of a module in a particular computation. Once such modules are ascertained amongst the program, the testing process takes considerably less effort and time because testing phase generally accounts for more than one third of time during the software development cycle. Slicing applications spread out through debugging methodologies to authentication of properties done through finite state models are appraised. Program slicing methodology reduces the effort of a software designer/coder and enthusiasts as well to directly get to the core of the problem. Forward slices contain all parts of the program that might be influenced by the variable. Static slicing may be used to identify these parts of the program that potentially contribute to the computation of the selected function for all possible programs inputs. Static slicing is helpful to gain a general understanding of these parts of the program that contribute to the computation to the selected function. In this project work, we have developed a forward static slicing algorithm. We have used file tracing to compute the forward static slices of a simple program. We have implemented our algorithm by using Java in net beans IDE on windows platform. The experimental results show that as the number of statements increase the slice computation time also increases raciprocally

An Overview of Recent Trends in Software Testing

In the field of search based software testing, genetic algorithm based testing has received a major share of attention among researchers during the last few years. Though there are advantages for this type of testing, there also exist some practical difficulties which can make this technique less attractive for software testing industry. The potential of program slicing in testing has not been fully exploited till now and the works that have explicitly demonstrated the application of slicing in testing field are rare. Our paper aims to analyze existing techniques for software testing and to introduce an approach for software testing using program slicing technique. A systematic review of genetic algorithm based works reveals that, fitness function design, population initialization and parameter settings impact the quality of solution obtained in software testing using genetic algorithm. Based on the conclusions from the existing literature, we have probed deeper about the issues in these areas. Making an unbiased review like this may help to solve these unresolved issues in genetic algorithm based software testing. In this work, we have emphasized and has given clear directions on how slicing can be used as a potential tool for practical software testing. In addition, a set of research questions have been framed, which may be answered by reviewing the study made in this work. This may help future research in this area, leading to major breakthrough in software testing field

Evaluating Lexical Approximation of Program Dependence

Complex dependence analysis typically provides an underpinning approximation of true program dependence. We investigate the effectiveness of using lexical information to approximate such dependence, introducing two new deletion operators to Observation-Based Slicing (ORBS). ORBS provides direct observation of program dependence, computing a slice using iterative, speculative deletion of program parts. Deletions become permanent if they do not affect the slicing criterion. The original ORBS uses a bounded deletion window operator that attempts to delete consecutive lines together. Our new deletion operators attempt to delete multiple, non-contiguous lines that are lexically similar to each other. We evaluate the lexical dependence approximation by exploring the trade-off between the precision and the speed of dependence analysis performed with new deletion operators. The deletion operators are evaluated independently, as well as collectively via a novel generalization of ORBS that exploits multiple deletion operators: Multi-operator Observation-Based Slicing (MOBS). An empirical evaluation using three Java projects, six C projects, and one multi-lingual project written in Python and C finds that the lexical information provides a useful approximation to the underlying dependence. On average, MOBS can delete 69% of lines deleted by the original ORBS, while taking only 36% of the wall clock time required by ORBS

A method for re-modularising legacy code

This thesis proposes a method for the re-modularisation of legacy COBOL. Legacy code often performs a number of functions that if split, would improve software maintainability. For instance, program comprehension would benefit from a reduction in the size of the code modules. The method aims to identify potential reuse candidates from the functions re-modularised, and to ensure clear interfaces are present between the new modules. Furthermore, functionality is often replicated across applications and so the re-modularisation process can also seek to reduce commonality and hence the overall amount of a company's code requiring maintenance. A 10 step method is devised which assembles a number of new and existing techniques into an approach suitable for use by staff not having significant reengineering experience. Three main approaches are used throughout the method; that is the analysis of the PERFORM structure, the analysis of the data, and the use of graphical representations. Both top-down and bottom-up strategies to program comprehension are incorporated within the method as are automatable, and user controlled processes to reuse candidate selection. Three industrial case studies are used to demonstrate and evaluate the method. The case studies range in size to gain an indication of the scalability of the method. The case studies are used to evaluate the method on a step by step basis; both strong points and deficiencies are identified, as well as potential solutions to the deficiencies. A review is also presented to assesses the three main approaches of the methods; the analysis of the PERFORM and data structures, and the use of graphical representations. The review uses the process of software evolution for its evaluation using successive versions of COBOL software. The method is retrospectively applied to the earliest version and the known changes identified from the following versions are used to evaluate the re-modularisations. Within the evaluation chapters a new link within the dominance tree is proposed as is an approach for dealing with multiple dominance trees. The results show that «ach approach provides an important contribution to the method as well as giving a useful insight (in the form of graphical representations) of the process of software evolution

Protecting mobile agents against malicious hosts.

by Sau-Koon Ng.Thesis (M.Phil.)--Chinese University of Hong Kong, 2000.Includes bibliographical references (leaves 100-112).Abstracts in English and Chinese.Chapter 1 --- Introduction --- p.1Chapter 1.1 --- Evolution of the mobile agent paradigm --- p.1Chapter 1.2 --- Terminology --- p.5Chapter 1.3 --- Beneficial aspects --- p.7Chapter 1.3.1 --- Autonomy --- p.7Chapter 1.3.2 --- Client customization --- p.8Chapter 1.3.3 --- Attendant and real time interactions --- p.8Chapter 1.4 --- Fundamental deployment bottleneck: security concern --- p.9Chapter 1.4.1 --- Risking the mobile agent hosts --- p.10Chapter 1.4.2 --- Risking the mobile agents --- p.11Chapter 1.4.3 --- The difficult problem --- p.12Chapter 1.5 --- Contribution of this thesis --- p.13Chapter 1.6 --- Structure of the thesis --- p.14Chapter 2 --- Understanding attacks and defense --- p.15Chapter 2.1 --- Introduction --- p.15Chapter 2.2 --- Understanding attacks --- p.16Chapter 2.2.1 --- The meaning of an attack --- p.16Chapter 2.2.2 --- An abstract model of attacks --- p.17Chapter 2.2.3 --- A survey of various attacks --- p.21Chapter 2.3 --- Understanding defense --- p.25Chapter 2.3.1 --- The meaning of defense --- p.25Chapter 2.3.2 --- Security requirements of defense --- p.26Chapter 2.3.3 --- A survey of protection schemes --- p.28Chapter 2.4 --- Concluding remarks --- p.40Chapter 3 --- Confidentiality in mobile agent systems --- p.42Chapter 3.1 --- Introduction --- p.42Chapter 3.2 --- Motivations --- p.43Chapter 3.2.1 --- Program comprehension --- p.44Chapter 3.2.2 --- Black-box testing --- p.45Chapter 3.3 --- Theory --- p.46Chapter 3.3.1 --- Assumptions --- p.46Chapter 3.3.2 --- Entropy of mobile agents --- p.46Chapter 3.3.3 --- Intention spreading by insertion --- p.49Chapter 3.3.4 --- Intention shrinking by splitting --- p.52Chapter 3.3.5 --- Nested spreading and shrinking --- p.55Chapter 3.4 --- Implementation possibilities --- p.55Chapter 3.4.1 --- Addition of irrelevant variables and conditional statements --- p.55Chapter 3.4.2 --- Splitting the cost function --- p.60Chapter 3.5 --- Security analysis --- p.63Chapter 3.5.1 --- Human inspection --- p.63Chapter 3.5.2 --- Automatic program comprehension --- p.64Chapter 3.6 --- Related work --- p.66Chapter 3.6.1 --- Time limited blackbox security --- p.66Chapter 3.6.2 --- Computing with encrypted function --- p.66Chapter 3.7 --- Applicability --- p.67Chapter 3.8 --- Further considerations --- p.68Chapter 3.8.1 --- Weaknesses --- p.68Chapter 3.8.2 --- Relationship with other approaches --- p.69Chapter 3.8.3 --- Further development --- p.71Chapter 3.9 --- Concluding remarks --- p.71Chapter 4 --- Anonymity in mobile agent systems --- p.73Chapter 4.1 --- Introduction --- p.73Chapter 4.2 --- Solutions to anonymity --- p.74Chapter 4.2.1 --- Mixing --- p.75Chapter 4.2.2 --- Group signatures --- p.76Chapter 4.3 --- Anonymous agents --- p.78Chapter 4.3.1 --- Anonymous connection --- p.78Chapter 4.3.2 --- Anonymous communication --- p.79Chapter 4.4 --- Concluding remarks --- p.84Chapter 5 --- Open issues --- p.86Chapter 5.1 --- Introduction --- p.86Chapter 5.2 --- Security issues --- p.86Chapter 5.2.1 --- Reachable problems --- p.87Chapter 5.2.2 --- Difficult problems --- p.88Chapter 5.3 --- Performance issues --- p.88Chapter 5.3.1 --- Complexity and strength --- p.89Chapter 5.3.2 --- An optimizing protocol --- p.90Chapter 5.4 --- Concluding remarks --- p.94Chapter 6 --- Conclusions --- p.9