Research Interests

My main field of interest is software security, including secure software design, memory safety, static program analysis and program instrumentation. These interests manifest mainly in work with the LLVM compiler framework and the Rust programming language‘s compiler. I’m driven to create methods to enabele a secure step-by-step transition from unsafe languages like C/C++ to memory-safe languages, primarily Rust.

Since the beginning of my PhD, I have been very attracted to Rust because of its type system, especially with the Ownership & Borrowing concepts. It allows writing memory-safe programs—even for low-level high-performance targets since it works without garbage collection. By implementing this linear (or more precisely affine) type system, Rust also restricts pointer aliasing, enabling precise AND scalable alias analyses. This makes Rust programs a prime case for static analyses, e.g., for Information Flow Control (IFC). 1

What motivates me to implement security features inside of compilers is that it helps the adoption of software security because, for software developers, it can be as easy as activating a compiler flag. Security has always been seen as an additional burden to software developers. That is why security mechanisms must be designed to lower the entry barrier for software developers who just want to focus on implementing their product.

Other topics I am interested in:

  • Application of advanced program analysis techniques and formal methods, e.g., model checking, abstract interpretation, symbolic execution
  • Memory Safety & Control Flow Integrity (CFI)
  • Secure software and systems architecture
  • Secure microkernels and operating systems
  • Programming language design & domain-specific languages

Research Projects

↬ Memory-Safety for Mixed-Language Binaries (Rust & C/C++)

↬ Specification, Design, Implementing, and Model Checking of the IDS Communication Protocol

Supervised Thesis Projects

Detecting Numeric Operations Threatening Memory Safety in Rust
Combining symbolic execution and static dataflow analysis on LLVM IR to find integer overflows and similar arithmetic errors in Rust programs whose results can cause memory-safety violations.

Minimal Runtime in Rust for seL4-based Confidential Computing VMs
Runtime environment for trusted services written in Rust on top of the seL4 kernel, based on Google’s CantripOS. During provision, the trusted service binary is encrypted. Upon VM startup, the runtime environment dynamically decrypts the trusted service after successful remote attestation and executes it as an seL4 task.

Automatic Compartmentalization of Rust Programs to Simplify Software Development with AMD SEV
Semi-automatic splitting of Rust programs into security-critical and non-critical binaries with function calls between the compartments automatically replaced by RPC calls.

A Dataflow Engine for Rust: Analyzing Security Critical Programs
Static whole-program dataflow analysis implemented on the Rust compiler’s middle intermediate representation (MIR).

A Systematic Approach to Gradually Integrate Rust into Existing Codebases
Guidelines to systematically replace parts of C/C++ code by Rust code in existing software projects.

Attack Path Tracing with Dynamic Dataflow Analysis
Combining Control Flow Integrity with Dynamic Taint Tracking to trace back the origin of the attack, e.g., to network packets or commandline input.

Teaching Seminars at LMU University of Munich and TU Munich

  • Software Hardening (2024)
  • Software Security Analysis (2020-2022)
  • Security Concepts of Selected OS-Kernels (2020)
  • Linux Security – Kernel Features and Attack Vectors (2018)

  1. Balasubramanian, A., Baranowski, M. S., Burtsev, A., Panda, A., Rakamarić, Z., & Ryzhyk, L. (2017). System programming in rust: Beyond safety. In Proceedings of the 16th workshop on hot topics in operating systems (pp. 156-161). https://doi.org/10.1145/3102980.3103006. ↩︎