794 research outputs found
Applying Formal Methods to Networking: Theory, Techniques and Applications
Despite its great importance, modern network infrastructure is remarkable for
the lack of rigor in its engineering. The Internet which began as a research
experiment was never designed to handle the users and applications it hosts
today. The lack of formalization of the Internet architecture meant limited
abstractions and modularity, especially for the control and management planes,
thus requiring for every new need a new protocol built from scratch. This led
to an unwieldy ossified Internet architecture resistant to any attempts at
formal verification, and an Internet culture where expediency and pragmatism
are favored over formal correctness. Fortunately, recent work in the space of
clean slate Internet design---especially, the software defined networking (SDN)
paradigm---offers the Internet community another chance to develop the right
kind of architecture and abstractions. This has also led to a great resurgence
in interest of applying formal methods to specification, verification, and
synthesis of networking protocols and applications. In this paper, we present a
self-contained tutorial of the formidable amount of work that has been done in
formal methods, and present a survey of its applications to networking.Comment: 30 pages, submitted to IEEE Communications Surveys and Tutorial
Model checking user interfaces
User interfaces are crucial for the success of most software projects. As software grows in complexity there is a similar growth in the user interface com- plexity which leads to bugs which may be difficult to find by means of testing. In this paper we use the method of automated model checking to verify user interfaces with respect to a formal specification. We present an algorithm for the automated abstraction of the user interface model of a given system, which uses asynchronous and interleaving composition of a number of programs. This technique was successful at verifying the user interface of case study and brings us one step forward towards push button verification.peer-reviewe
Exploring formal verification methodology for FPGA-based digital systems.
Abstract Not Provide
Quickstrom: property-based acceptance testing with LTL specifications
We present Quickstrom, a property-based testing system for acceptance testing
of interactive applications. Using Quickstrom, programmers can specify the
behaviour of web applications as properties in our testing-oriented dialect of
Linear Temporal Logic (LTL) called QuickLTL, and then automatically test their
application against the given specification with hundreds of automatically
generated interactions. QuickLTL extends existing finite variants of LTL for
the testing use-case, determining likely outcomes from partial traces whose
minimum length is itself determined by the LTL formula. This temporal logic is
embedded in our specification language, Specstrom, which is designed to be
approachable to web programmers, expressive for writing specifications, and
easy to analyse. Because Quickstrom tests only user-facing behaviour, it is
agnostic to the implementation language of the system under test. We therefore
formally specify and test many implementations of the popular TodoMVC
benchmark, used for evaluation and comparison across various web frontend
frameworks and languages. Our tests uncovered bugs in almost half of the
available implementations.Comment: 13 pages, this is a technical report of a paper to appear at
Programming Languages Design and Implementation (PLDI 2022
Liveness Checking of the HotStuff Protocol Family
Byzantine consensus protocols aim at maintaining safety guarantees under any
network synchrony model and at providing liveness in partially or fully
synchronous networks. However, several Byzantine consensus protocols have been
shown to violate liveness properties under certain scenarios. Existing testing
methods for checking the liveness of consensus protocols check for time-bounded
liveness violations, which generate a large number of false positives. In this
work, for the first time, we check the liveness of Byzantine consensus
protocols using the temperature and lasso detection methods, which require the
definition of ad-hoc system state abstractions. We focus on the HotStuff
protocol family that has been recently developed for blockchain consensus. In
this family, the HotStuff protocol is both safe and live under the partial
synchrony assumption, while the 2-Phase Hotstuff and Sync HotStuff protocols
are known to violate liveness in subtle fault scenarios. We implemented our
liveness checking methods on top of the Twins automated unit test generator to
test the HotStuff protocol family. Our results indicate that our methods
successfully detect all known liveness violations and produce fewer false
positives than the traditional time-bounded liveness checks.Comment: Preprint of a paper accepted at IEEE PRDC 202
- …