Model Checking Python Programs with MSVL

This paper presents an approach to performing artificial intelligence planning through temporal logic programming with Search Control Knowledge (SCK). First, the planning problem described with Planning Domain Description Language is modeled as a program m in Modeling, Simulation and Verification Language (MSVL). Second, the SCK is also specified with an MSVL program $$m'$$ . Third, using the basic operation “and” in MSVL, a new MSVL program “ $$m~and~m'$$ ” is obtained. Forth, with the compiler MC of MSVL, an executable binary code of program “ $$m~and~m'$$ ” is obtained. Finally, planning result can be obtained via executing the executable code. Experimental results on selected benchmark planning domains from the International Planning Competition 2014 show that our approach is more effective in practice. Furthermore, the obtained plans are verified with the toolkit MSV so that a plan can be confirmed whether it is a reliable one.

This paper presents an approach to simulate and verify the CTCS-3 (Chinese Train Control System 3) protocol with a Modeling, Simulation and Verification Language (MSVL) which is an executable subset of Projection Temporal Logic (PTL). First, the syntax and semantics of PTL and MSVL are briefly introduced. Then, CTCS-3 protocol is briefly presented and a simplified CTCS-3 protocol described by an MSVL program is given, and the property to be verified is specified by a Propositional Projection Temporal Logic (PPTL) formula. Finally, the simulation is conducted by means of the interpreter of MSVL. A dynamic graph showing behavior of train is depicted. Based on the graph, we can verify whether or not the protocol satisfies the property.

This paper proposes an approach to verifying programs against context free properties. To this end, the system to be verified is modeled by a program m in Modeling, Simulation and Verification Language (MSVL), and the desired property is also specified by an MSVL program \(m'\). Then program m and formula \(\lnot m'\) are interpreted by means of executing programs m and \(m'\). If an acceptable execution path is generated, a counterexample is found, otherwise the property is valid. To show how the proposed approach works, an example is given.

Model checking Petri nets with MSVL

To solve the problem that UML (Unified Modeling Language) design model cannot be model-checked for its rough semantics, an extension of UML, called xUML4MC, is defined by extending the activity diagram with accurate syntax and semantics to model the activities of an object. Besides, the technique for automatical transformation of xUML4MC model into MSVL (Modeling, Simulation and Verification Language) model is also presented, which in turn can be verified with model checking tool MSV. The formalism arms the classical visual specification language UML with the power of model checking, and helps to promote the quality of software system.

A novel approach to verifying context free properties of programs

Concurrent programs are commonly used in real-time system software. Verifying the correctness of concurrent programs is an important job to ensure the reliability of real-time system software. The causes of concurrency in a real-time system program include task scheduling and interrupt mechanism, where multi-interruption is an effective means of real-time response to asynchronous events. This paper studies the modeling approach for multi-interruption concurrent programs based on TMSVL (Timed Modeling, Simulation and Verification Language), so as to verify temporal properties of multi-interruption concurrent programs, such as safety and liveness properties. The formal syntax and semantics of multi-interruption concurrent programs is established based on TMSVL, and the correctness and practicability of our approach is demonstrated with a case study.

In this paper, we propose a DSE based model checking approach (DSE-MC) for verifying programs written in Modelling, Simulation and Verification Language (MSVL) [1, 3]. For doing so, we adopt a DSE method to execute an MSVL program to generate a symbolic execution tree (SEtree) which is used as the abstract model of the program. Further, a property to be verified is specified by a Propositional Projection Temporal Logic (PPTL) formula [8, 13]. To check whether or not the program satisfies the property, first the SEtree and the negation of the property are both described in Labelled Normal Form Graphs (LNFGs) [21], then the product of two LNFGs is produced. As a result, a counter example is encountered if the product is not empty. Otherwise, we cannot determine if the program satisfies the property. In this case, the verification process could be restarted with new inputs. In this way, a software system written in C can also be verified since the C program can be transformed to an MSVL program automatically by using toolkit MSV [19] developed by us.KeywordsDSEConstraintsTemporal logicMSVLModel checking

Model checking is a technique for finding bugs in systems by systematically exploring their state spaces. We wish to extract sound models from concurrent programs automatically and check the behaviors of these models systematically. The zing project is an effort to build a flexible infrastructure to represent and model check abstractions of large concurrent software.To support automatic extraction of models from programs written in common programming languages, zing’s modeling language supports three facilities present in modern programming languages: (1) procedure calls with a call-stack, (2) objects with dynamic allocation, and (3) processes with dynamic creation, using both shared memory and message passing for communication. We believe that these three facilities capture the essence of model checking modern concurrent software.Building a scalable model-checker for such an expressive modeling language is a huge challenge. zing’s modular architecture provides a clear separation between the expressive semantics of the modeling language, and a simple view of zing programs as labeled transition systems. This separation has allowed us to decouple the design of efficient model checking algorithms from the complexity of supporting rich constructs in the modeling language. zing’s model checking algorithms have been designed to exploit existing structural abstractions in concurrent programs such as processes and procedure calls. We present two such novel techniques in the paper: (1) compositional checking of zing models for message-passing programs using a conformance theory inspired by work in the process algebra community, and (2) a new summarization algorithm, which enables zing to reuse work at procedure boundaries by extending interprocedural data-flow analysis algorithms from the compiler community to analyze concurrent programs.KeywordsModel CheckModeling LanguageProcedure CallLabel Transition SystemConcurrent ProgramThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The intimate relationship between model checking and abstract interpretation has been shown in a large number of relevant papers in literature. Maybe the use of abstract interpretation to reduce the well-known state space explosion problem in model checking was the first and most successful combination of these two techniques. However, this is not the only possible way both methods can collaborate to improve the software reliability. Along these last 20 years, our contributions in this area have been focussed on the practical application of abstract interpretation in the context of model checking tools. From our point of view, model checking tools such as spin can be hardly improved in terms of efficiency. Thus, we have concentrated on applying abstraction to completely reuse the underlying model checkers. We have applied our ideas to different modelling and programming languages, tools and real applications. In this paper, we summarize some of these contributions.

In temporal-logic model checking, we verify the correctness of a program with respect to a desired behavior by checking whether a structure that models the program satisfies a temporal-logic formula that specifies the behavior. The model-checking problem for the branching-time temporal logic CTL can be solved in linear running time, and model-checking tools for CTL are used successfully in industrial applications. The development of programs that must meet rigid real-time constraints has brought with it a need for real-time temporal logics that enable quantitative reference to time. Early research on real-time temporal logics uses the discrete domain of the integers to model time. Present research on real-time temporal logics focuses on continuous time and uses the dense domain of the reals to model time. There, model checking becomes significantly more complicated. For example, the model-checking problem for TCTL, a continuous-time extension of the logic CTL, is PSPACE-complete.In this paper we suggest a reduction from TCTL model checking to CTL model checking. The contribution of such a reduction is twofold. Theoretically, while it has long been known that model-checking methods for untimed temporal logics can be extended quite easily to handle discrete time, it was not clear whether and how untimed methods can handle the reset quantifier of TCTL, which resets a realvalued clock. Practically, our reduction enables anyone who has a tool for CTL model checking to use it for TCTL model checking. The TCTL model-checking algorithm that follows from our reduction is in PSPACE, matching the known bound for this problem. In addition, it enjoys the wide distribution of CTL model-checking tools and the extensive and fruitful research efforts and heuristics that have been put into these tools.KeywordsModel CheckTemporal LogicAtomic PropositionKripke StructureTemporal ReasoningThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Graph transformation has recently become more and more popular as a general, rule-based visual specification paradigm to formally capture (a) requirements or behavior of user models (on the model-level), and (b) the operational semantics of modeling languages (on the meta-level) as demonstrated by benchmark applications around the Unified Modeling Language (UML). The current paper focuses on the model checking-based automated formal verification of graph transformation systems used either on the model-level or meta-level. We present a general translation that inputs (i) a metamodel of an arbitrary visual modeling language, (ii) a set of graph transformation rules that defines a formal operational semantics for the language, and (iii) an arbitrary well-formed model instance of the language and generates a transitions system (TS) that serve as the underlying mathematical specification formalism of various model checker tools. The main theoretical benefit of our approach is an optimization technique that projects only the dynamic parts of the graph transformation system into the target transition system, which results in a drastical reduction in the state space. The main practical benefit is the use of existing back-end model checker tools, which directly provides formal verification facilities (without additional efforts required to implement an analysis tool) for many practical applications captured in a very high-level visual notation. The practical feasibility of the approach is demonstrated by modeling and analyzing the well-known verification benchmark of dining philosophers both on the model and meta-level.

Because of the language’s simplicity, flexibility and massive libraries supporting artificial intelligence, web development and data science python has become one of the widely used programming language. But this speedy growth has led to software security and vulnerability concerns. This paper examines the security provisions available in python programming and their role in developing secure applications. Herein the analysis is done based on security mechanisms such as validation of inputs, authentication and authorization, libraries available for cryptography, management of dependency tools, static code analysis tools and secure web frameworks. The paper highlights the common security challenges faced in python programming and emphasis on the importance of secure coding practices and comparison of vulnerability detection tools implemented in the past research works. The finding proclaims that python provides several built-in tools and mechanisms which when properly implemented can notably improve reliability and security of software systems. Keywords: Python Security, Secure Coding Practices, Vulnerability Detection, Machine Learning Based Security Analysis, Static Code Analysis, Cryptography in Python, Software Security

Security protocols ensure secure communication between and within systems such as internet services, factories, and smartphones. As evidenced by numerous successful attacks against popular protocols such as TLS, designing protocols securely is a tedious and error-prone task. Model checkers greatly aid protocol verification, yet any single model checker is oftentimes insufficient to check a protocol's security in full. Instead, engineers are forced to maintain multiple overlapping and hopefully non-contradicting and non-diverging specifications, one per model-checking tool---an error-prone task.To address this problem, this paper presents VICE, a scenario-based approach to security-protocol verification. It provides a visual modeling language based for specifying security protocols independent of the model checker. It then automatically transforms the relevant fragments of these models into equivalent inputs to multiple model checkers. In result, VICE completely relieves the security engineer from choosing and specifying queries via a fully automatic generation of all necessary queries.Through a case study involving real-world specifications of eight security protocols, we show that VICE is applicable in practice.

An Integrated Intelligent Modeling and Simulation Language for Model-based Systems Engineering