Source Code Verification Research Articles

Predicate Abstraction Refinement in Thread-Modular Analysis

Thread-modular approach over predicate abstraction is an efficient technique for software verification of complicated real-world source code. One of the main problems in the technique is a predicate abstraction refinement in a multithreaded case. A default predicate refiner considers only a path related to one thread, and does not refine the thread-modular environment. For instance, if we have applied an effect from the second thread to the current one, then the path in the second thread to the applied effect is not refined. Our goal was to develop a more precise refinement procedure, reusing a default predicate refiner to refine both: a path in a current thread and a path to an effect in the environment. The idea is to construct a joined boolean formula from these two paths. Since some variables may be common, a key challenge is to correctly rename and equate variables in two parts of the formula to accurately represent the way threads interact. It is essential to get reliable predicates that can potentially prove spuriousness of the path. The proposed approach is implemented on top of CPAchecker framework. It is evaluated on standard SV-COMP benchmark set, and the results show some benefit. Evaluation on the real-world software does not demonstrate significant accuracy increase, as the described flaw of predicate refinement is not the only reason of false positive results. While the proposed approach can successfully prove some specific paths to be spurious, it is not enough to fully prove correctness of some programs. However, the approach has further potential for improvements.

Development a mathematical model for the software security testing first stage

This paper reports an analysis of the software (SW) safety testing techniques, as well as the models and methods for identifying vulnerabilities. An issue has been revealed related to the reasoned selection of modeling approaches at different stages of the software safety testing process and the identification of its vulnerabilities, which reduces the accuracy of the modeling results obtained. Two steps in the process of identifying software vulnerabilities have been identified. A mathematical model has been built for the process of preparing security testing, which differs from the known ones by a theoretically sound choice of the moment-generating functions when describing transitions from state to state. In addition, the mathematical model takes into consideration the capabilities and risks of the source code verification phase for cryptographic and other ways to protect data. These features generally improve the accuracy of modeling results and reduce input uncertainty in the second phase of software safety testing. An advanced security compliance algorithm has been developed, with a distinctive feature of the selection of laws and distribution parameters that describe individual state-to-state transitions for individual branches of Graphical Evaluation and Review Technique networks (GERT-networks). A GERT-network has been developed to prepare for security testing. A GERT-network for the process of checking the source code for cryptographic and other data protection methods has been developed. A graphic-analytical GERT model for the first phase of software safety testing has been developed. The expressions reported in this paper could be used to devise preliminary recommendations and possible ways to improve the effectiveness of software safety testing algorithms

Abstraction and subsumption in modular verification of C programs

The type-theoretic notions of existential abstraction, subtyping, subsumption, and intersection have useful analogues in separation-logic proofs of imperative programs. We have implemented these as an enhancement of the verified software toolchain (VST). VST is an impredicative concurrent separation logic for the C language, implemented in the Coq proof assistant, and proved sound in Coq. For machine-checked functional-correctness verification of software at scale, VST embeds its expressive program logic in dependently typed higher-order logic (CiC). Specifications and proofs in the program logic can leverage the expressiveness of CiC—so users can overcome the abstraction gaps that stand in the way of top-to-bottom verification: gaps between source code verification, compilation, and domain-specific reasoning, and between different analysis techniques or formalisms. Until now, VST has supported the specification of a program as a flat collection of function specifications (in higher-order separation logic)—one proves that each function correctly implements its specification, assuming the specifications of the functions it calls. But what if a function has more than one specification? In this work, we exploit type-theoretic concepts to structure specification interfaces for C code. This brings modularity principles of modern software engineering to concrete program verification. Previous work used representation predicates to enable data abstraction in separation logic. We go further, introducing function-specification subsumption and intersection specifications to organize the multiple specifications that a function is typically associated with. As in type theory, if $$\phi $$ is a of $$\psi $$ , that is $$\phi <:\psi $$ , then $$x:\phi $$ implies $$x:\psi $$ , meaning that any function satisfying specification $$\phi $$ can be used wherever a function satisfying $$\psi $$ is demanded. Subsumption incorporates separation-logic framing and parameter adaptation, as well as step-indexing and specifications constructed via mixed-variance functors (needed for C’s function pointers).

Integrating Formative Feedback in Introductory Programming Modules

Introductory programming modules are challenging for both the lecturers and students. In previous works, the authors have introduced educational innovations to mitigate these challenges and facilitate learning. This paper presents a further step forward, proposing a learning process enriched with formative feedback. To this end, visual programming environments and educational robots are combined and complemented with automatic source code verification and validation feedback. The feedback integration proposal is presented along with the lessons learned from previously carried out experiments that established the basis of this paper. The proposal has been implemented and tested in the object oriented programming module in the bachelor’s in computer management and information systems engineering at the Faculty of Engineering of Vitoria-Gasteiz, UPV/EHU University. The results of the evaluation have been positive and are also presented here.

THE CAPABILITIES OF OPEN SOURCE CFD CODE FOR MODELING THE STAND TANK FILLING PROCESS WITH LIQUID HYDROGEN

The paper analyzes the functioning and launching of the cryogenic propulsion upper stages and the stages of rocket-space systems, which are largely determined by heat and mass exchange processes in the elements of supply systems. This is due to the fact that in ground conditions, there are no possibilities of flight conditions simulation during cooling of feed lines and starting the engine. Therefore, the simulation of the flow of cryogenic components with respect to heat and mass exchange processes in supply systems of the units and the test stand is important. The paper gives data that booster pump aggregates of oxidant and fuel, as a rule, are located in the corresponding fuel tanks. This makes it possible to significantly reduce the costs of the component for carrying out the operations of cooling and filling fuel lines and the tank, and to optimize the process of starting the engine when it is switched on repeatedly. It is also noted that in complex ground tests of upper stages there are usually no possibilities to simulate flight conditions during launching operations in complex ground tests of upper stages, therefore the use of physical and mathematical models for the calculation of nonstationary multiphase processes with intensive phase transformations makes it possible to determine the characteristics and to forecast the parameters of supply systems. The following tasks have been accomplished: the development of open source code based on CFD program OpenFoam for simulation of cryogenic flows in conjunction with heat exchange processes with the wall of the tank; the verification of open source code on a simple two-dimensional model of the tank for determination the main mechanisms that arise in the process of cooling and filling the stand tank; the implementation of open source code for simulation the initial stage of the refilling of the stand fuel tank taking into account the evaporation of the cryogenic liquid and heat exchange with the walls. The paper shows that the processes of flow and evaporation can be modeled in the framework of models with a free surface flow. The results of calculations of basic parameters of two-phase flows in the process of cooling the liquid hydrogen fuel tank are presented. The results of the study are expected to be used in the methodology for estimating the parameters of two-phase flows during testing of the advanced space rocket systems.

Source Code Verification on Embedded Control Devices

A control system device is a hardware system with special processor and interface modules that have their own function and software under an operating system. In developing a new device, a designer searches for a new interface modules-supported driver algorithm for reducing developing time. In this case, the program code interfaced with this module used to be the same one as other products. It would then be difficult to verify which code is the original source program in keeping the copyright. Regarding property right verification, it is difficult to compare this with each program code to find a difference. In the case of an open source code, a developer program could be the same to most code lines, which is released by an interface module vendor. In this paper, we show a way to keep the property rights of the owner as for the module interface and communication interface, while the peripheral interface is under an open source operating system.

열차제어시스템 소프트웨어 정적 테스팅 적용시험 결과 분석

Many function of railway signalling system which is in charge of most core function in a railway system are being operated by the software according to the development of computer technology. Accordingly, the source code testing to verify the safety of the railway signalling system software becomes to be more important, and related international standards highly recommend verifications on the source code also. For this reason, several related studies on vital source code verification were executed from several years ago in Korea. This paper performed tests through the application to railway signalling system being applied to the existing actual domestic railway sites through automated testing tools for coding rules of signalling system software and another signaling system software under development in Korea recently, and analyzed their results.

Experimental evaluation of a tool for the verification and transformation of source code in event-driven systems

In event-driven systems, separating the reactive part of software (i.e., event-driven control) from the non-reactive part is a common design practice. The reactive part is typically structured according to the states and transitions of a system, whereas the non-reactive part is typically structured according to the concepts of the application domain (e.g., the services provided by the system). In such systems, the non-reactive part of software stimulates the reactive part with event calls. Whenever the non-reactive part is modified (e.g., during evolution), the existing event calls may become invalid, new event calls may become necessary, and the two parts of software may become incompatible. Manually finding and repairing these types of defects is a time-consuming and error-prone maintenance task. In this article, we present a solution that combines source code model checking and aspect-oriented programming techniques, to reduce the time spent by developers and to automatically find defects, while performing the maintenance task mentioned above. In addition, we present controlled experiments showing that the solution can reduce the time by 75%, and enable the prevention of one defect per 140 lines of source code.

Formal verification of software source code through semi-automatic modeling

We describe the experience of modeling and formally verifying a software cache algorithm using the model checker RuleBase. Contrary to prevailing wisdom, we used a highly detailed model created directly from the C code itself, rather than a high-level abstract model.

Runtime Verification of Concurrent Haskell Programs

In this article we use model checking techniques to debug Concurrent Haskell programs. LTL formulas specifying assertions or other properties are verified at runtime. If a run which falsifies a formula is detected, the debugger emits a warning and records the path leading to the violation. It is possible to dynamically add formulas at runtime, giving a degree of flexibility which is not available in static verification of source code. We give a comprehensive example of using the new techniques to detect lock-reversal in Concurrent Haskell programs and introduce a template mechanism to define LTL formulas ranging over an arbitrary set of threads or communication abstractions.

Source code verification of a secure payment applet

This paper discusses a case study in formal verification and development of secure smart card applications. An elementary Java Card electronic purse applet is presented whose specification can be simply formulated as “in normal operation, the applet’s balance field can only be decreased, never increased”. The applet features a challenge-response mechanism which allows legitimate terminals to increase the balance by putting the applet into a special operation mode. A systematic approach is used to guarantee a secure flow of control within the applet: appropriate transition properties are first formalized as a finite state machine, then incorporated in the specification, and finally formally verified using the Loop translation tool and the PVS theorem prover.

The Use of Cyclic Redundancy Check (CRC-32) and Adler-32 Checksums for Source Code Verification

The need for electronic files, specifically computer programs or source code, to be traceable is widely recognized. Certain types of checksums, a form of digital signature, provide a practical and efficient method of accomplishing that. This paper will show the rationale for using the Cyclic Redundancy Check (CRC-32) and Adler-32 checksums and present a practical approach to help manage source code.

A microprogramming design laboratory

Sophisticated design aids are available to help automate microprogram development both for large, complex computers and for microprocessor-based systems. These aids include procedures for source code verification, object code generation, microprogram simulation, and interactive debugging. For various reasons, such aids are generally not well-developed for microprogrammable minicomputers. This paper describes a microprogramming laboratory developed for the Interdata 85 minicomputer which uses both the minicomputer itself as well as the time-sharing and batch facilities of a large computer center. Experience with the laboratory has shown that the facility for interacting with a microprogram is as important as the availability of complete diagnostic information. The argument is made that design automation aids for microprogramming minicomputers could be produced efficiently from standardized assembly and simulation programs.

A microprogramming design laboratory

Sophisticated design aids are available to help automate microprogram development both for large, complex computers and for microprocessor-based systems. These aids include procedures for source code verification, object code generation, micro-program simulation, and interactive debugging. For various reasons, such aids are generally not well-developed for micro-programmable minicomputers. This paper describes a microprogramming laboratory developed for the Interdata 85 minicomputer which uses both the minicomputer itself as well as the time-sharing and batch facilities of a large computer center. Experience with the laboratory has shown that the facility for interacting with a microprogram is as important as the availability of complete diagnostic information. The argument is made that design automation aids for microprogramming minicomputers could be produced most efficiently from standardized assembly and simulation programs.

A microprogramming design laboratory

Sophisticated design aids are available to help automate microprogram development both for large, complex computers and for micro-processor-based systems. These aids include procedures for source code verification, object code generation, microprogram simulation, and interactive debugging. For various reasons, such aids are generally not well-developed for microprogrammable minicomputers. This paper describes a microprogramming laboratory developed for the Interdata 85 minicomputer which uses both the minicomputer itself as well as the time-sharing and batch facilities of a large computer center. Experience with the laboratory has shown that the facility for interacting with a microprogram is as important as the availability of complete diagnostic information. The argument is made that design automation aids for microprogramming minicomputers could be produced efficiently from standardized assembly and simulation programs.