Hunting CUDA Bugs at Scale with cuFuzz

• URL: http://arxiv.org/abs/2603.12485v1
• Date: Thu, 12 Mar 2026 22:06:11 GMT
• Title: Hunting CUDA Bugs at Scale with cuFuzz
• Abstract summary: GPU programs are prone to memory-safety and bugs that evade static analysis.<n>While fuzz-testing, combined with dynamic error checking tools, offers a plausible solution, it remains underutilized for GPUs.<n>We present cuFuzz, the first instrument and first NV-oriented fuzzer that makes fuzzing practical.
• Score: 2.0745580313629097
• License: http://creativecommons.org/licenses/by/4.0/
• Abstract: GPUs play an increasingly important role in modern software. However, the heterogeneous host-device execution model and expanding software stacks make GPU programs prone to memory-safety and concurrency bugs that evade static analysis. While fuzz-testing, combined with dynamic error checking tools, offers a plausible solution, it remains underutilized for GPUs. In this work, we identify three main obstacles limiting prior GPU fuzzing efforts: (1) kernel-level fuzzing leading to false positives, (2) lack of device-side coverage-guided feedback, and (3) incompatibility between coverage and sanitization tools. We present cuFuzz, the first CUDA-oriented fuzzer that makes GPU fuzzing practical by addressing these obstacles. cuFuzz uses whole program fuzzing to avoid false positives from independently fuzzing device-side kernels. It leverages NVBit to instrument device-side instructions and merges the resultant coverage with compiler-based host coverage. Finally, cuFuzz decouples sanitization from coverage collection by executing host- and device-side sanitizers in separate processes. cuFuzz uncovers 43 previously unknown bugs (19 in commercial libraries) across 14 CUDA programs, including illegal memory accesses, uninitialized reads, and data races. cuFuzz achieves significantly more discovered edges and unique inputs compared to baseline approaches, especially on closed-source targets. Moreover, we quantify the execution time overheads of the different cuFuzz components and add persistent-mode support to improve the overall fuzzing throughput. Our results demonstrate that cuFuzz is an effective and deployable addition to the GPU testing toolbox. cuFuzz is publicly available at https://github.com/NVlabs/cuFuzz/.

Related papers

• CUADebug: Diagnosing and Repairing Computer-Use Agent Failures [65.56066380320107]
  Computer-use agents (CUAs) operate real desktop and web interfaces through screenshots, mouse and keyboard actions, and stateful UI feedback.<n>Unlike text-only agents, CUA failures arise from coupled visual perception, grounding, low-level interaction, task reasoning, and environment dynamics.<n>We introduce CUA Debug, a framework for diagnosing and repairing CUA failures.
  arXiv  Detail & Related papers  (2026-07-31T13:59:45Z)
• AgentDebugX: An Open-Source Toolkit for Failure Observability, Attribution, and Recovery in LLM Agents [83.37969790806069]
  LLM agent failures are difficult to debug because the step where an error surfaces is often not the one that caused it.<n>We present Agent DebuggerX, an open-source framework that organizes debug as a closed loop of Detect, Attribute, Recover, and Rerun.<n>At its core, Deep Debugger performs multi-turn root-cause diagnosis through global trajectory understanding.
  arXiv  Detail & Related papers  (2026-07-21T06:21:13Z)
• CUDABeaver: Benchmarking LLM-Based Automated CUDA Debugging [18.460942231908376]
  We introduceBEAVER, a benchmark for evaluating programs produced during real failing workspaces.<n>Each task provides the broken candidate, native build/test commands, raw error evidence, and a single file.<n>We show that protocol-aware evaluation gives a more faithful view of performance-loss tolerance.
  arXiv  Detail & Related papers  (2026-05-08T20:24:32Z)
• GPU-Fuzz: Finding Memory Errors in Deep Learning Frameworks [16.88852734850369]
  GPU memory errors are a critical threat to deep learning (DL) frameworks, leading to crashes or even security issues.<n>We introduce GPU-Fuzz, a fuzzer locating these issues efficiently by modeling operator parameters as formal constraints.
  arXiv  Detail & Related papers  (2026-02-11T03:32:43Z)
• Outrunning LLM Cutoffs: A Live Kernel Crash Resolution Benchmark for All [57.23434868678603]
  Live-kBench is an evaluation framework for self-evolving benchmarks that scrapes and evaluates agents on freshly discovered kernel bugs.<n> kEnv is an agent-agnostic crash-resolution environment for kernel compilation, execution, and feedback.<n>Using kEnv, we benchmark three state-of-the-art agents, showing that they resolve 74% of crashes on the first attempt.
  arXiv  Detail & Related papers  (2026-02-02T19:06:15Z)
• Rust and Go directed fuzzing with LibAFL-DiFuzz [0.0]
  We present a novel approach to directed fuzzing tailored specifically for Rust and Go applications.<n>Our implemented fuzzing tools, based on LibAFL-DiFuzz backend, demonstrate competitive advantages.
  arXiv  Detail & Related papers  (2026-01-30T09:52:50Z)
• Chasing Elusive Memory Bugs in GPU Programs [2.7752002595974172]
  Memory safety bugs, such as out-of-bound accesses (OOB) in GPU programs, can compromise the security and reliability of GPU-accelerated software.<n>We build SCuBA, a first-of-its-kind compile-time technique that analyzes CPU and GPU code to capture semantic relations (if present)<n>Compared to NVIDIA's Compute Sanitizer that misses 45 elusive memory bugs across 20 programs, SCuBA misses none with no false alarms.
  arXiv  Detail & Related papers  (2026-01-29T11:13:36Z)
• CuFuzz: Hardening CUDA Programs through Transformation and Fuzzing [12.40365281970697]
  CuFuzz is a novel compiler-runtime co-design solution to extend state-of-the-art CPU fuzzing tools.<n>CuFuzz transforms GPU programs into CPU programs using compiler IR-level transformations.<n>CuFuzz uncovered 122 security vulnerabilities in widely used benchmarks.
  arXiv  Detail & Related papers  (2026-01-03T03:02:47Z)
• CrashFixer: A crash resolution agent for the Linux kernel [58.152358195983155]
  This work builds upon kGym, which shares a benchmark for system-level Linux kernel bugs and a platform to run experiments on the Linux kernel.<n>This paper introduces CrashFixer, the first LLM-based software repair agent that is applicable to Linux kernel bugs.
  arXiv  Detail & Related papers  (2025-04-29T04:18:51Z)
• G-Fuzz: A Directed Fuzzing Framework for gVisor [48.85077340822625]
  G-Fuzz is a directed fuzzing framework for gVisor. G-Fuzz has been deployed in industry and has detected multiple serious vulnerabilities.
  arXiv  Detail & Related papers  (2024-09-20T01:00:22Z)
• KGym: A Platform and Dataset to Benchmark Large Language Models on Linux Kernel Crash Resolution [59.20933707301566]
  Large Language Models (LLMs) are consistently improving at increasingly realistic software engineering (SE) tasks. In real-world software stacks, significant SE effort is spent developing foundational system software like the Linux kernel. To evaluate if ML models are useful while developing such large-scale systems-level software, we introduce kGym and kBench.
  arXiv  Detail & Related papers  (2024-07-02T21:44:22Z)

This list is automatically generated from the titles and abstracts of the papers in this site.

This site does not guarantee the quality of this site (including all information) and is not responsible for any consequences.