strawberry/fuzz/fuzz_rule_partition.cpp
trvon 169a05cd2a
fuzz: target the YARA rule partitioner
rule_partition.cpp parses rule sources (splitting rules, extracting top-level
condition identifiers and facts), but had no fuzz target, contradicting the
repository rule that every parser of attacker-influenced input gets one.
fuzz_rule_partition asserts the splitter is a total, exact partition of its
input, that rule/condition slicing stays within the rule, and that partition
selection agrees with magic bytes and the size bucket boundaries.

It is registered in fuzz/meson.build (with rule_partition.cpp), swept by
scripts/run_fuzzers.sh, and documented next to the other targets. Seeds cover
comments, strings, regexes, hex blocks, an include and a truncated source.
2026-11-17 13:45:12 -07:00

101 lines
4.5 KiB
C++

// YARA rule partitioning: the splitter, the condition facts and the file classification all read
// rule text and file bytes the host did not write (feeds fetched by strawberry-update, operator
// rules, scanned files), so the invariants the partitioning relies on must hold for arbitrary bytes.
#include "strawberry/rule_partition.hpp"
#include <cctype>
#include <cstdint>
#include <cstdlib>
#include <string>
#include <string_view>
namespace {
using namespace strawberry::rules;
bool is_identifier(const std::string& s) {
if (s.empty()) return false;
for (std::size_t i = 0; i < s.size(); ++i) {
const unsigned char c = static_cast<unsigned char>(s[i]);
const bool ok = i == 0 ? (std::isalpha(c) != 0 || c == '_') : (std::isalnum(c) != 0 || c == '_');
if (!ok) return false;
}
return true;
}
// A successful split is a partition of the source into an ordered, non-overlapping list of rules:
// nothing dropped, nothing counted twice, each rule ending at its closing brace and its condition
// being the tail of its own text.
void check_split(std::string_view source) {
const auto r = split_rules(source);
if (r.ok && !r.error.empty()) std::abort();
if (!r.ok && r.error.empty()) std::abort();
std::size_t covered = r.preamble.size();
std::size_t previous_end = 0;
for (const auto& rule : r.rules) {
if (rule.begin >= rule.end || rule.end > source.size() || rule.begin < previous_end) std::abort();
if (source[rule.end - 1] != '}') std::abort();
previous_end = rule.end;
if (!is_identifier(rule.name)) std::abort();
const std::string_view text = source.substr(rule.begin, rule.end - rule.begin);
if (text.size() < rule.condition.size() + 1) std::abort();
if (text.compare(text.size() - rule.condition.size() - 1, rule.condition.size() + 1, rule.condition + "}")
!= 0) {
std::abort();
}
covered += rule.end - rule.begin;
}
if (r.ok && covered != source.size()) std::abort();
}
// Condition facts may only narrow: a class requirement excludes exactly the other class group and a
// filesize bound excludes every bucket whose low end is at or above it. Anything else keeps the rule.
void check_condition(std::string_view condition) {
for (const auto& id : condition_identifiers(condition)) {
if (!is_identifier(id)) std::abort();
}
const auto facts = condition_facts(condition);
for (std::size_t i = 0; i < kPartitions; ++i) {
const auto key = PartitionKey::from_index(i);
if (key.index() != i) std::abort();
const bool excluded_here = excluded(facts, key);
if (facts.required_class) {
const bool needs_pe = *facts.required_class == FileClass::pe;
const bool other_group = (key.cls == ClassGroup::pe) != needs_pe;
if (other_group && !excluded_here) std::abort();
}
if (facts.filesize_lt && *facts.filesize_lt <= kBucketLow[key.bucket] && !excluded_here) std::abort();
}
}
// The file's partition must agree with its magic and with its size: the bucket low end never exceeds
// the file size and the next bucket's low end is never reached.
void check_partition(const uint8_t* data, std::size_t size) {
const std::size_t head_len = size < 8 ? size : 8;
const auto cls = file_class(data, head_len);
if (size >= 2 && data[0] == 'M' && data[1] == 'Z' && cls != FileClass::pe) std::abort();
if (size >= 4 && data[0] == 0x7f && data[1] == 'E' && data[2] == 'L' && data[3] == 'F'
&& cls != FileClass::elf) {
std::abort();
}
uint64_t file_size = size;
for (std::size_t i = 0; i < head_len; ++i) file_size = (file_size << 8) | data[i];
const auto key = partition_for(data, head_len, file_size);
if (key.index() >= kPartitions) std::abort();
if ((cls == FileClass::pe) != (key.cls == ClassGroup::pe)) std::abort();
if (kBucketLow[key.bucket] > file_size) std::abort();
if (key.bucket + 1 < kSizeBuckets && file_size >= kBucketLow[key.bucket + 1]) std::abort();
}
} // namespace
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
if (data == nullptr || size == 0) return 0;
const std::string_view source(reinterpret_cast<const char*>(data), size);
check_split(source);
// A truncated download looks like a suffix of a good file: a rule cut mid-body must fail cleanly.
if (size > 2) check_split(source.substr(size / 2));
check_condition(source);
check_partition(data, size);
return 0;
}