Source Code Level Research Articles

A New Method to Analyze the Security of Protocol Implementations Based on Ideal Trace

The security analysis of protocols on theory level cannot guarantee the security of protocol implementations. To solve this problem, researchers have done a lot, and many achievements have been reached in this field, such as model extraction and code generation. However, the existing methods do not take the security of protocol implementations into account. In this paper, we have proposed to exploit the traces of function return values to analyze the security of protocol implementations at the source code level. Taking classic protocols into consideration, for example (like the Needham-Schroeder protocol and the Diffie-Hellman protocol, which cannot resist man-in-the-middle attacks), we have analyzed man-in-the-middle attacks during the protocol implementations and have carried out experiments. It has been shown in the experiments that our new method works well. Different from other methods of analyzing the security of protocol implementations in the literatures, our new method can avoid some flaws of program languages (like C language memory access, pointer analysis, etc.) and dynamically analyze the security of protocol implementations.

Mingling of Program Slicing to Designing Phase

Objectives: Program Slicing is proved in breaking down the large program into the small relevant parts that is needed as per the specified criteria. The Objective of this paper is the betterment of existing program slicing techniques. Method/Statistical Analysis: Methodology is proposed to start slicing the software from designing level and continue it with source code level. Mingling of the program slicing with UML model slicing is done by applying the program slicing technique to code related to the remaining relevant model that is extracted from the large software architecture model at design level. Flowchart is presented with the steps proposed in the methodology. Findings: Using a case study it is concluded that the complexity of the complete software cycle is reduced as compared to the complexity of program slicing if applied directly to the code. Application/Improvements: Fault localization is taken as a single application, other applications like improvement in the changeability and reusability of source codes can be added.

A static technique for detecting input validation vulnerabilities in Android apps

Input validation vulnerabilities are common in Android apps, especially in inter-component communications. Malicious attacks can exploit this kind of vulnerability to bypass Android security mechanism and compromise the integrity, confidentiality and availability of Android devices. However, so far there is not a sound approach at the source code level for app developers aiming to detect input validation vulnerabilities in Android apps. In this paper, we propose a novel approach for detecting input validation flaws in Android apps and we implement a prototype named EasyIVD, which provides practical static analysis of Java source code. EasyIVD leverages backward program slicing to extract transaction and constraint slices from Java source code. Then EasyIVD validates these slices with predefined security rules to detect vulnerabilities in a known pattern. To detect vulnerabilities in an unknown pattern, EasyIVD extracts implicit security specifications as frequent patterns from the duplicated slices and verifies them. Then EasyIVD semi-automatically confirms the suspicious rule violations and reports the confirmed ones as vulnerabilities. We evaluate EasyIVD on four versions of original Android apps spanning from version 2.2 to 5.0. It detects 58 vulnerabilities including confused deputy attacks and denial of service attacks. Our results prove that EasyIVD can provide a practical defensive solution for app developers.

Consistent regions

Guaranteed tuple processing has become critically important for many streaming applications. This paper describes how we enabled IBM Streams, an enterprise-grade stream processing system, to provide data processing guarantees. Our solution goes from language-level abstractions to a runtime protocol. As a result, with a couple of simple annotations at the source code level, IBM Streams developers can define consistent regions , allowing any subgraph of their streaming application to achieve guaranteed tuple processing. At runtime, a consistent region periodically executes a variation of the Chandy-Lamport snapshot algorithm to establish a consistent global state for that region. The coupling of consistent states with data replay enables guaranteed tuple processing.

UML4IoT—A UML-based approach to exploit IoT in cyber-physical manufacturing systems

Internet of Things (IoT) is changing the world. The manufacturing industry has already identified that the IoT brings great opportunities to retain its leading position in economy and society. However, the adoption of the IoT changes the development process of the manufacturing system and raises many challenges. In this paper, the modern manufacturing system is considered as a composition of cyber-physical, cyber and human components, and IoT is used as a glue for their integration as far as their cyber interfaces are concerned. An approach based on a UML profile for the IoT is presented to fully automate the generation process of the IoT-compliant layer that is required for the cyber-physical component to be effectively integrated into the modern IoT manufacturing environment. The approach can also be applied at the source code level specification of the component in case that a UML design specification is not available. A prototype implementation of the myLiqueur production laboratory system is used to demonstrate the applicability and effectiveness of the UML4IoT approach.

Characterizing emerging heterogeneous memory

Heterogeneous memory (HM, also known as hybrid memory) has become popular in emerging parallel architectures due to its programming flexibility and energy efficiency. Unlike the traditional memory subsystem, HM consists of fast and slow components. Usually, the fast memory lacks hardware support, which puts extra burdens on programmers and compilers for explicit data placement. Thus, HM provides both opportunities and challenges with programming parallel codes. It is important to understand how to utilize HM and set expectations on the benefits of HM. Prior work principally uses simulators to study HM, which lacks the analysis on a real hardware. To address this issue, this paper experiments with a real system—the TI KeyStone II—to study HM. We make three contributions. First, we develop a set of parallel benchmarks to characterize the performance and power efficiency of HM. It is the first benchmark suite with OpenMP 4.0 features that is functional on real HM architectures. Second, we build a profiling tool to provide guidance for placing data in HM. Our tool analyzes memory access patterns and provides high-level feedback at the source-code level for optimization. Third, we apply the data placement optimization to our benchmarks and evaluate the effectiveness of HM in boosting performance and saving energy.

Deriving thresholds of software metrics to predict faults on open source software: Replicated case studies

Object-oriented metrics aim to exhibit the quality of source code and give insight to it quantitatively. Each metric assesses the code from a different aspect. There is a relationship between the quality level and the risk level of source code. The objective of this paper is to empirically examine whether or not there are effective threshold values for source code metrics. It is targeted to derive generalized thresholds that can be used in different software systems. The relationship between metric thresholds and fault-proneness was investigated empirically in this study by using ten open-source software systems. Three types of fault-proneness were defined for the software modules: non-fault-prone, more-than-one-fault-prone, and more-than-three-fault-prone. Two independent case studies were carried out to derive two different threshold values. A single set was created by merging ten datasets and was used as training data by the model. The learner model was created using logistic regression and the Bender method. Results revealed that some metrics have threshold effects. Seven metrics gave satisfactory results in the first case study. In the second case study, eleven metrics gave satisfactory results. This study makes contributions primarily for use by software developers and testers. Software developers can see classes or modules that require revising; this, consequently, contributes to an increment in quality for these modules and a decrement in their risk level. Testers can identify modules that need more testing effort and can prioritize modules according to their risk levels.

GestUI: A Model-driven Method and Tool for Including Gesture-based Interaction in User Interfaces

Among the technological advances in touch-based devices, gesture-based interaction have become a prevalent feature in many application domains. Information systems are starting to explore this type of interaction. As a result, gesture specifications are now being hard-coded by developers at the source code level that hinders their reusability and portability. Similarly, defining new gestures that reflect user requirements is a complex process. This paper describes a model-driven approach to include gesture-based interaction in desktop information systems. It incorporates a tool prototype that captures user-sketched multi-stroke gestures and transforms them into a model by automatically generating the gesture catalogue for gesture-based interaction technologies and gesture-based user interface source codes. We demonstrated our approach in several applications ranging from case tools to form-based information systems.

Flexible, open-source programmes and estimating projections of urban tree benefits: A case study in Amherst, MA

Inventories of urban tree populations and affiliated analysis software are valuable, contemporary tools in use by municipalities across the globe. While software that allows users to explore the values and benefits of discrete urban tree populations may be readily available, capacity to model and project tree growth is limited. Using existing urban street tree inventory data from Amherst, MA (USA), a generic platform for tree growth modelling was developed to be implemented by the user at the source code level, called “Xylem”. Agile programmes like this provide a fast-working, extensible platform to generate tree growth projection data that can be delivered efficiently to the end user. The Amherst case study offers an example of how programmes written in Python 2.7 have application and can be readily customisable, to add value to existing tree inventory data.

Accelerating Orthogonal Space Sampling with Replica Exchange with Solute Tempering (REST2) through a Generic Implementation in NAMD

We extend the applicability of Replica Exchange with Solute Tempering (REST2) to accelerate orthogonal space sampling of biomolecular recognition simulations through a robust and generic implementation in molecular dynamics software NAMD. The rescaling procedure of force field parameters controlling REST2 “hot region” is implemented into NAMD at the source code level. A user can conveniently select hot region through VMD and write the selection information into a PDB file. The rescaling keyword/parameter is written in NAMD Tcl script interface that enables an on-the-fly simulation parameter change. REST2 is implemented within communication-enabled Tcl script built on top of Charm++, thus communication overhead of an exchange attempt is vanishingly small. Such a generic implementation facilitates seamless cooperation between REST2 and other modules of NAMD. Three challenging applications including native REST2 simulation for folding-unfolding transition of solvated peptide (AAQAA)3 starting from an extended state, Free Energy Perturbation/REST2 calculation for absolute binding affinity of T4 Lysozyme-pxylene complex and Umbrella Sampling/REST2 Hamiltonian exchange for free energy landscape calculation of SH3 domain-p41 peptide binding complex were carried out on IBM Blue Gene/Q computer to demonstrate efficacy of REST2 based on the present implementation. For the (AAQAA)3 system, alpha-helix contents in agreement with experiment are observed within 200ns simulation; for the T4 Lysozyme-pxylene binding complex, accurate sampling of rotameric states orthogonal to the thermodynamic axis results in binding free energy in excellent agreement with experiment; for SH3 domain-p41 peptide binding complex, REST2 significantly accelerates the convergence of PMF by enhancing structural reorganization along the reaction path.

Born-Oppenheimer Ab Initio QM/MM Molecular Dynamics Simulations of Enzyme Reactions.

There are two key requirements for reliably simulating enzyme reactions: one is a reasonably accurate potential energy surface to describe the bond-forming/breaking process as well as to adequately model the heterogeneous enzyme environment; the other is to perform extensive sampling since an enzyme system consists of at least thousands of atoms and its energy landscape is very complex. One attractive approach to meet both daunting tasks is Born-Oppenheimer ab initio QM/MM molecular dynamics (aiQM/MM-MD) simulation with umbrella sampling. In this chapter, we describe our recently developed pseudobond Q-Chem-Amber interface, which employs a combined electrostatic-mechanical embedding scheme with periodic boundary condition and the particle mesh Ewald method for long-range electrostatics interactions. In our implementation, Q-Chem and the sander module of Amber are combined at the source code level without using system calls, and all necessary data communications between QM and MM calculations are achieved via computer memory. We demonstrate the applicability of this pseudobond Q-Chem-Amber interface by presenting two examples, one reaction in aqueous solution and one enzyme reaction. Finally, we describe our established aiQM/MM-MD enzyme simulation protocol, which has been successfully applied to study more than a dozen enzymes.

Dynamic Logging with Dylog in Networked Embedded Systems

Event logging is an important technique for networked embedded systems like wireless sensor networks. It can greatly help developers to understand complex system behaviors and diagnose program bugs. Existing logging facilities do not well satisfy three practical requirements: flexibility , efficiency , and high synchronization accuracy . To simultaneously satisfy these requirements, we present Dylog, a dynamic logging facility for networked embedded systems. Dylog employs several techniques. First, Dylog uses binary instrumentation for dynamically inserting or removing logging statements, enabling flexible and interactive debugging at runtime. Second, Dylog incorporates an efficient storage system and log collection protocol for recording and transferring the logging messages. Third, Dylog employs a lightweight data-driven approach for reconstructing the synchronized time of the logging messages. Dylog uses MAC-layer timestamping and drift compensation to achieve high synchronization accuracy . We implement Dylog on the TinyOS 2.1.1/TelosB platform. Results show the following: (1) Dylog incurs a small overhead. Indirections in Dylog incur an additional execution overhead of less than 1%. Dylog reduces the logging storage size by approximately 50% compared with the standard TinyOS radio printf library. Dylog reduces the patch size by more than 90%, compared with incremental reprogramming. (2) Dylog reduces the synchronization overhead by 78% in terms of transmission cost, compared with a traditional time synchronization protocol, FTSP, and it can achieve a high time synchronization accuracy of 5.4μs. (3) Dylog can help diagnose system problems effectively at the source-code level for three real-world scenarios.

Do #ifdef-based Variation Points Realize Feature Model Constraints?

Two mechanisms widely used in the Software Product Lines (SPL) Engineering are the feature model and the conditional compilation. The former models the variability in the problem space and the latter realizes it in the solution space. Even though the research community know that the feature model imposes a number of constraints to the product line implementation, there is a lack of support to co-evolve problem space and solution space. In this paper, we present an exploratory study whether problem space constraints are considered at source code level of #ifdef-based SPL implementations. In order to accomplish our goal, we developed a preliminary approach to check problem and solution spaces in a prototype tool (fclcheck). The results show a lack of realization of feature model constraints while implementing variation points with that mechanism. We also evaluated the scalability of the approach and the recoverability of the tool.

A generic implementation of replica exchange with solute tempering (REST2) algorithm in NAMD for complex biophysical simulations

Replica Exchange with Solute Tempering (REST2) is a powerful sampling enhancement algorithm of molecular dynamics (MD) in that it needs significantly smaller number of replicas but achieves higher sampling efficiency relative to standard temperature exchange algorithm. In this paper, we extend the applicability of REST2 for quantitative biophysical simulations through a robust and generic implementation in greatly scalable MD software NAMD. The rescaling procedure of force field parameters controlling REST2 “hot region” is implemented into NAMD at the source code level. A user can conveniently select hot region through VMD and write the selection information into a PDB file. The rescaling keyword/parameter is written in NAMD Tcl script interface that enables an on-the-fly simulation parameter change. Our implementation of REST2 is within communication-enabled Tcl script built on top of Charm++, thus communication overhead of an exchange attempt is vanishingly small. Such a generic implementation facilitates seamless cooperation between REST2 and other modules of NAMD to provide enhanced sampling for complex biomolecular simulations. Three challenging applications including native REST2 simulation for peptide folding–unfolding transition, free energy perturbation/REST2 for absolute binding affinity of protein–ligand complex and umbrella sampling/REST2 Hamiltonian exchange for free energy landscape calculation were carried out on IBM Blue Gene/Q supercomputer to demonstrate efficacy of REST2 based on the present implementation. Program summaryProgram title: REST2-NAMDCatalogue identifier: AEXX_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEXX_v1_0.htmlProgram obtainable from: CPC Program Library, Queen’s University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 240886No. of bytes in distributed program, including test data, etc.: 8474342Distribution format: tar.gzProgramming language: C/C++, Tcl8.5.Computer: Not computer specific.Operating system: Any.Has the code been vectorized or parallelized?: Yes, MPI and/or PAMI parallelized depending on machine system software; ≥ 8192 cores used on IBM Blue Gene/QClassification: 3.External routines: NAMD 2.10 (http://www.ks.uiuc.edu/Research/namd/)Nature of problem: A generic implementation providing user-friendly API including input file preparation and performing replica exchange, and high frequency exchange attempt frequency with minimal communication overhead.Solution method: The rescaling procedure of force field parameters controlling REST2 is implemented into NAMD at the source code level. A user can conveniently select hot region through VMD and write the selection information into a PDB file. The rescaling keyword/parameter is written in NAMD Tcl script interface that enables an on-the-fly simulation parameter change. The implementation of REST2 is within communication-enabled Tcl script built on top of Charm++, thus communication overhead of an exchange attempt is vanishingly small.Running time: 30 min–60 min

Change Impact Identification in Object-Oriented System: Dependence Graph Approach

The development of software products consumes a lot of time and resources. On the other hand, these development costs are lower than maintenance costs, which represent a major concern, specially, for systems designed with recent technologies. Systems modification should be taken rigorously, and change effects must be considered. The need to offer tools allowing on the one hand, to explain the mechanisms of changes at the source code level, and on the other hand, to reduce the effort as well as the cost of maintenance, is affirmed more and more. We propose in this article an approach based on dependence graph to identify change impact of objectoriented systems. The analysis of change ripple effect is made on the dependence graph representing the considered system. The identification at graph level of maximum range of change ripple effect will enable us to know consequences change at code source of system. This knowledge will enable us to estimate the change cost and to make a compromise between the various suggested changes. Finally, to concretize this study we produced a tool and tested our approach on certain systems.

Assessing vulnerability exploitability risk using software properties

Attacks on computer systems are now attracting increased attention. While the current trends in software vulnerability discovery indicate that the number of newly discovered vulnerabilities continues to be significant, the time between the public disclosure of vulnerabilities and the release of an automated exploit is shrinking. Thus, assessing the vulnerability exploitability risk is critical because this allows decision-makers to prioritize among vulnerabilities, allocate resources to patch and protect systems from these vulnerabilities, and choose between alternatives. Common vulnerability scoring system (CVSS) metrics have become the de facto standard for assessing the severity of vulnerabilities. However, the CVSS exploitability measures assign subjective values based on the views of experts. Two of the factors in CVSS, Access Vector and Authentication, are the same for almost all vulnerabilities. CVSS does not specify how the third factor, Access Complexity, is measured, and hence it is unknown whether it considers software properties as a factor. In this work, we introduce a novel measure, Structural Severity, which is based on software properties, namely attack entry points, vulnerability location, the presence of the dangerous system calls, and reachability analysis. These properties represent metrics that can be objectively derived from attack surface analysis, vulnerability analysis, and exploitation analysis. To illustrate the proposed approach, 25 reported vulnerabilities of Apache HTTP server and 86 reported vulnerabilities of Linux Kernel have been examined at the source code level. The results show that the proposed approach, which uses more detailed information, can objectively measure the risk of vulnerability exploitability and results can be different from the CVSS base scores.

Bridging the gap between test cases and requirements by abstract testing

In this article we propose a technique, called abstract testing, which replaces traditional test cases by abstract test cases. By doing so, fewer test cases are needed, and they are linked more closely to the requirements. Abstract tests can be considered as verification scenarios on the source code level which are derived from the requirements. Checking verification scenarios against the source code is done automatically using a software model checker. We also suggest a migration path from traditional tests to abstract test cases, which provides a smooth transition towards this new technique. Finally, we demonstrate feasibility of abstract testing by a case study from the automotive systems domain.

Coalitional Games for Determining Rate Region of Multiple Description Coding

To combat erasure channels, multiple description coding (MDC) introduces diversity at source coding level. Each description provides a coarse reconstruction of source information at destination. As the number of received description increases, the reconstruction quality would be improved. Rate region of MDC is the set of achievable rates for a given set of expected distortions. In this paper, coalitional game theory is proposed as a nontrivial approach for determining rate region of MDC. To this end, elaborate game theoretic analysis is provided. Moreover, Shapley value is utilized to determine each description's rate. As a result, a fair rate adjustment is obtained that comprises entropy and mutual information of original and reconstructed descriptions.

The Numerical Multi-Physics project (NUMPS) at VTT Technical Research Centre of Finland

The four-year Numerical Multi-Physics (NUMPS) project funded by the Academy of Finland was initiated at VTT Technical Research Centre of Finland in September 2012, for the purpose of studying and developing high-fidelity computational methods for nuclear reactor analysis. The project is built around calculation codes developed at VTT, and it aims at the coupled three-dimensional modeling of neutronics, thermal hydraulics and fuel behavior of nuclear reactors. The work involves the continuous-energy Monte Carlo code Serpent and CFD code PORFLO, together with two light-weight solvers, COSY and FINIX, coupled to Serpent at source code level. This paper is a review on the current status and development activities, reflecting the status of the NUMPS project at the beginning of its second complete year.

A New Method for Code Optimization

In this paper, we propose a new method for code optimization. This new method is based on backward data flow analysis, and the optimization is done on the source code level. First we design a tiny language to experiment with. Then, using data flow analysis, we set up some simultaneous equations and collect the liveness information for all program points. This is the basis for the optimization. Using this technique, some code can be safely eliminated without affecting the semantics of the code segment.