Analyzing Unsafe Rust Usage Across Domains

Abdulaziz Alotaibi

Project Overview

Problem: Rust’s unsafe mode allows developers to bypass its memory safety guarantees to achieve fine-grained control over hardware and performance optimizations. However, this introduces significant risks such as memory safety bugs (e.g., use-after-free errors, null pointer dereferences, and data races) that can compromise system reliability and security. Understanding how unsafe Rust is used across different domains and improving tools to detect vulnerabilities are essential for enabling developers to write safer and more efficient systems.

Approach: I analyzed unsafe Rust usage in 20 open-source projects across five domains: embedded systems, databases, distributed systems, general-purpose libraries, and Byzantine Fault Tolerance (BFT). I categorized unsafe Rust code into four key patterns: Memory Management, Foreign Function Interfaces (FFI), Unchecked Assumptions, and Performance Optimization. Using a custom Python tool, I detected and isolated unsafe Rust blocks, then tested a subset of 60 blocks with Rudra, a static analysis tool, to identify memory safety vulnerabilities.

Results: The analysis revealed that unsafe Rust is used primarily for Memory Management and Interfacing with Non-Rust Code (FFI), particularly in performance-critical domains like embedded systems and databases. Rudra did not identify any memory safety bugs in the analyzed blocks, suggesting cautious developer practices but also exposing limitations in Rudra's ability to detect nuanced vulnerabilities. Future work could focus on expanding the analysis to more unsafe patterns, automating the isolation process for scalability, and improving detection tools to address complex real-world scenarios.

Project Materials

• Final Presentation (PDF)
• Source Code

References/Research

The analysis in this study builds on previous work and tools that address memory safety and unsafe Rust usage:

• Rust’s Memory Safety Model: Rust’s ownership model provides strong guarantees against common memory safety issues. However, its unsafe mode allows bypassing these safeguards, introducing risks like use-after-free errors and data races.
• Rudra: A static analysis tool developed to detect memory safety vulnerabilities in Rust at the ecosystem scale. Rudra focuses on identifying improper use of raw pointers and manual memory management (Y. Bae et al., 2021).
• YOGA: Building on Rudra, YOGA expands its capabilities to detect lifetime annotation bugs, making it suitable for more diverse Rust codebases (V. Nitin et al., 2024).
• Unsafe Rust Patterns: Previous studies have classified unsafe Rust usage into common patterns, such as manual memory management, unchecked assumptions, and performance optimizations (V. Astrauskas et al., 2020).
• Rust Adoption in Domains: The use of unsafe Rust varies by domain, including embedded systems, databases, and distributed systems, where it is critical for tasks like hardware interfacing and performance optimizations (J. Blandy & J. Orendorff, 2017).

This project extends the application of Rudra to real-world developer projects and highlights limitations in existing tools, setting the stage for future improvements in static analysis and unsafe Rust detection.