Background

Embedded software keeps growing in size, and more and more of it runs many tasks concurrently. In such software, bugs that depend on timing appear only rarely and are hard to reproduce, which makes them difficult to find with conventional testing.

The challenge

Safety and security cannot be explained just by saying that testing found no problems. We need systematic ways to show on what grounds a system can be trusted.

There are therefore two problems: finding rarely occurring bugs efficiently, and showing with evidence that the system can then be trusted.

Finding bugs: fuzzing and formal methods

We apply fuzzing (feeding programs many automatically generated inputs to uncover bugs) to concurrent programs and middleware. By also exploring the order in which threads run, our fuzzers can efficiently find concurrency bugs that rarely show up in normal testing.

Together with programming-language researchers, we also study formal methods: translating concurrent programs that use semaphores into logically constrained term rewrite systems, a mathematical model on which their properties can be verified rigorously.

Analyzing and assuring: security analysis and assurance cases

We study systematic ways to find weaknesses in systems, such as intrusion detection for in-vehicle networks (CAN) and security analysis based on HAZOP.

We also work on assurance cases, which are structured arguments that show why a system is safe or secure, and on combining them with quantitative evaluation.

Achievements so far

In fuzzing, applying coverage-based greybox fuzzing to middleware (IPSJ Journal, 2021) was selected as a specially selected paper and received the Zengo Award. The line has since evolved into Schfuzz, which explores thread schedules with feedback guidance (ENASE 2023), and race-directed fuzzing for more effective concurrency testing (WSSE 2024).

In formal methods, together with programming-language researchers we established a transformation from concurrent programs with semaphores into logically constrained term rewrite systems (Journal of Logical and Algebraic Methods in Programming, 2025).

In automotive security, our work ranges from defenses such as the ID-hopping CAN mechanism IDH-CAN (IEEE Access, 2018) and the centralized authentication scheme CaCAN (2014) to graph-based intrusion detection for CAN networks (CCNC 2026). TZmCFI, an RTOS-aware control-flow integrity mechanism using TrustZone (International Journal of Parallel Programming, 2020), HAZOP-based security analysis (Springer, 2016), and a quantitative security assurance case for in-vehicle systems (2021) cover the range from analysis to assurance.

Why this matters

Better verification finds bugs that manual testing misses before shipping, which reduces accidents and recalls.

Assurance cases let developers explain, with evidence, why a system can be trusted. Users and society can then judge a system's trustworthiness from that evidence instead of relying on the developer's confidence.

Where we are heading

We want verification and assurance techniques to be used routinely in everyday development, just like builds and tests.

Concretely, we aim to develop the theory and tools for running fuzzing and formal verification continuously, collecting their results into assurance cases, and using those cases to explain a system's safety to developers, clients, and users.

Example thesis topics

The targets of verification are expanding from concurrent programs to distributed systems and systems that include machine learning. Students' thesis topics are usually chosen from within these directions, through discussion.

  • More effective search strategies for fuzzing concurrent and distributed systems
  • Fuzzing environments combined with embedded-system simulators, independent of physical hardware
  • Extending verification based on logically constrained term rewrite systems to a wider class of concurrent programs
  • Practical evaluation of intrusion detection for in-vehicle networks, including dataset development
  • Safety design and assurance cases for systems that include machine-learning components