use arbitrary::{Result, Unstructured};

use wasmparser::{Parser, Validator, WasmFeatures};

pub fn run(u: &mut Unstructured<'_>) -> Result<()> {

// Either use `wasm-smith` to generate a module with possibly invalid

// functions or try validating raw bytes from the input itself.

if u.arbitrary()? {

validate_maybe_invalid_module(u)?;

} else {

validate_raw_bytes(u)?;

}

Ok(())

}

pub fn validate_maybe_invalid_module(u: &mut Unstructured<'_>) -> Result<()> {

// Generate a "valid" module but specifically allow invalid functions which

// means that some functions may be defined from the input bytes raw. This

// means that most of the module is valid but only some functions may be

// invalid which can help stress various bits and pieces of validation.

let (wasm, config) = crate::generate_valid_module(u, |config, _| {

config.allow_invalid_funcs = true;

Ok(())

})?;

validate_all(u, crate::validator_for_config(&config), &wasm)

}

pub fn validate_raw_bytes(u: &mut Unstructured<'_>) -> Result<()> {

// Enable arbitrary combinations of features to validate the input bytes.

let validator = Validator::new_with_features(WasmFeatures::from_bits_truncate(u.arbitrary()?));

let wasm = u.bytes(u.len())?;

crate::log_wasm(wasm, "");

validate_all(u, validator, wasm)

}

fn validate_all(u: &mut Unstructured<'_>, mut validator: Validator, wasm: &[u8]) -> Result<()> {

// First try printing this module. Generate a random configuration for

// printing and then see what happens. Mostly making sure nothing panics

// here.

let mut cfg = wasmprinter::Config::new();

cfg.fold_instructions(u.arbitrary()?);

cfg.print_skeleton(u.arbitrary()?);

cfg.print_offsets(u.arbitrary()?);

cfg.name_unnamed(u.arbitrary()?);

log::debug!("print config {cfg:?}");

let mut wat = String::new();

let _ = cfg.print(wasm, &mut wasmprinter::PrintFmtWrite(&mut wat));

// After printing then try to parse and validate the module. See how far we

// get as invalid modules are explicitly allowed here. Generally looking for

// panics and excessive resource usage here.

for payload in Parser::new(0).parse_all(wasm) {

let payload = match payload {

Ok(p) => p,

Err(_) => return Ok(()),

};

if validator.payload(&payload).is_err() {

return Ok(());

}

// Check that the payload's range is in bounds, since the payload is

// supposedly valid.

use wasmparser::Payload::*;

match payload {

Version { range, .. } => assert!(wasm.get(range).is_some()),

TypeSection(s) => assert!(wasm.get(s.range()).is_some()),

ImportSection(s) => assert!(wasm.get(s.range()).is_some()),

FunctionSection(s) => assert!(wasm.get(s.range()).is_some()),

TableSection(s) => assert!(wasm.get(s.range()).is_some()),

MemorySection(s) => assert!(wasm.get(s.range()).is_some()),

TagSection(s) => assert!(wasm.get(s.range()).is_some()),

GlobalSection(s) => assert!(wasm.get(s.range()).is_some()),

ExportSection(s) => assert!(wasm.get(s.range()).is_some()),

StartSection { range, .. } => assert!(wasm.get(range).is_some()),

ElementSection(s) => assert!(wasm.get(s.range()).is_some()),

DataCountSection { range, .. } => assert!(wasm.get(range).is_some()),

DataSection(s) => assert!(wasm.get(s.range()).is_some()),

CodeSectionStart { range, .. } => assert!(wasm.get(range).is_some()),

CodeSectionEntry(body) => assert!(wasm.get(body.range()).is_some()),

InstanceSection(s) => assert!(wasm.get(s.range()).is_some()),

CoreTypeSection(s) => assert!(wasm.get(s.range()).is_some()),

ComponentInstanceSection(s) => assert!(wasm.get(s.range()).is_some()),

ComponentAliasSection(s) => assert!(wasm.get(s.range()).is_some()),

ComponentTypeSection(s) => assert!(wasm.get(s.range()).is_some()),

ComponentCanonicalSection(s) => assert!(wasm.get(s.range()).is_some()),

ComponentStartSection { range, .. } => assert!(wasm.get(range).is_some()),

ComponentImportSection(s) => assert!(wasm.get(s.range()).is_some()),

ComponentExportSection(s) => assert!(wasm.get(s.range()).is_some()),

CustomSection(s) => assert!(wasm.get(s.range()).is_some()),

UnknownSection { range, .. } => assert!(wasm.get(range).is_some()),

// In order to support streaming parsing and validation, these

// sections' ranges are not checked during validation, since they

// contain nested sections and we don't want to require all nested

// sections are present before we can parse/validate any of them.

ComponentSection {

unchecked_range: _, ..

}

| ModuleSection {

unchecked_range: _, ..

} => {}

// No associated range.

End(_) => {}

_ => {}

}

}

Ok(())

}

#[test]

fn smoke() {

super::test::test_n_times(100, run);

}