// I/O-failure fuzzing (built with STRAWBERRY_FAULT_INJECTION=1). // // The input is both a fault schedule and file contents: the fuzzer decides, per // I/O call, whether it fails (and with which errno) or returns short, and what // the /proc-like files and the executable image contain. Any exception that // escapes is a crash (the class of bug behind the 2026-10-25 freeze). #include "strawberry/hash_utils.hpp" #include "strawberry/proc_read.hpp" #include "strawberry/resource_governor.hpp" #include "strawberry/sys_io.hpp" #include "../src/image_file.hpp" #include #include #include #include #include #include #include #include #include namespace fs = std::filesystem; namespace { class ScheduleFaults final : public strawberry::io::FaultInjector { public: ScheduleFaults(const uint8_t* data, size_t size) : data_(data), size_(size) {} strawberry::io::FaultDecision decide(strawberry::io::Op) noexcept override { strawberry::io::FaultDecision d; if (size_ == 0) { return d; } const uint8_t b = data_[pos_++ % size_]; static constexpr std::array errors{ESRCH, EIO, ENOENT, EINTR, EAGAIN, ENOSPC}; if ((b & 0xC0) == 0xC0) { d.error = errors[b % errors.size()]; } else if ((b & 0xC0) == 0x80) { d.short_bytes = b & 0x3F; } return d; } private: const uint8_t* data_; size_t size_; size_t pos_ = 0; }; void write_raw(const fs::path& path, const std::string& content) { fs::create_directories(path.parent_path()); if (FILE* f = std::fopen(path.c_str(), "wb")) { std::fwrite(content.data(), 1, content.size(), f); std::fclose(f); } } } // namespace extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { if (size < 4) { return 0; } // First quarter: fault schedule. Rest: file contents split by 0xFF bytes. const size_t schedule_len = size / 4; const std::string body(reinterpret_cast(data) + schedule_len, size - schedule_len); std::vector parts{""}; for (char c : body) { if (static_cast(c) == 0xFF && parts.size() < 9) { parts.emplace_back(); } else { parts.back().push_back(c); } } parts.resize(9); static const fs::path root = fs::temp_directory_path() / ("sb-fuzz-io-" + std::to_string(::getpid())); write_raw(root / "proc" / "stat", parts[0]); write_raw(root / "proc" / "self" / "stat", parts[1]); write_raw(root / "proc" / "self" / "status", parts[2]); write_raw(root / "proc" / "self" / "cgroup", parts[3]); write_raw(root / "proc" / "pressure" / "cpu", parts[4]); write_raw(root / "proc" / "meminfo", parts[5]); write_raw(root / "proc" / "loadavg", parts[6]); write_raw(root / "image", parts[7]); write_raw(root / "cg" / "memory.max", parts[8]); ScheduleFaults faults(data, schedule_len); strawberry::io::ScopedInjector scope(&faults); try { (void) strawberry::read_small_file((root / "proc" / "self" / "stat").string(), 4096); strawberry::SystemSampler sampler((root / "proc").string(), (root / "cg").string()); (void) sampler.sample(); (void) sampler.sample(); const int fd = ::open((root / "image").c_str(), O_RDONLY | O_CLOEXEC); if (fd >= 0) { std::vector bytes; std::string error; const bool ok = strawberry::detail::read_fd_bounded(fd, 1u << 20, bytes, error); if (ok && bytes.size() != parts[7].size()) { __builtin_trap(); // success must mean the exact file } (void) strawberry::HashUtils::sha256_fd(fd); ::close(fd); } (void) strawberry::HashUtils::sha256_file((root / "image").string()); (void) strawberry::HashUtils::md5_file((root / "image").string()); } catch (...) { __builtin_trap(); // nothing may escape under I/O failure } return 0; }