wasm-mutate 0.247.0

A WebAssembly test case mutator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Mutator that generates a random renaming of a preexisting export
use super::Mutator;
use crate::{Result, WasmMutate};
use rand::RngExt;
use wasm_encoder::{ExportKind, ExportSection, Module};
use wasmparser::ExportSectionReader;

/// Generates a random renaming of pre-existing exports.
///
/// The export entry is selected randomly and then a new `field` name is
/// generated.
#[derive(Clone, Copy)]
pub struct RenameExportMutator {
    /// The maximum length of the generated export entry
    pub max_name_size: usize,
}

impl RenameExportMutator {
    /// Copied and transformed from wasm-smith name generation
    fn limited_string(&self, config: &mut WasmMutate, original: &str) -> crate::Result<String> {
        loop {
            config.consume_fuel(1)?;
            let mut bytes = original.as_bytes().to_vec();
            config.raw_mutate(&mut bytes, self.max_name_size)?;

            match std::str::from_utf8(&bytes) {
                Ok(_) => {}
                Err(e) => {
                    let i = e.valid_up_to();
                    bytes.drain(i..);
                }
            };
            if bytes.len() > self.max_name_size {
                continue;
            }
            let ret = String::from_utf8(bytes).unwrap();
            if ret != original && config.info().export_names.contains(&ret) {
                continue;
            }
            return Ok(ret);
        }
    }
}

impl Mutator for RenameExportMutator {
    fn mutate<'a>(
        &self,
        config: &'a mut WasmMutate,
    ) -> Result<Box<dyn Iterator<Item = Result<Module>> + 'a>> {
        let mut exports = ExportSection::new();
        let exports_idx = config.info().exports.unwrap();
        let reader = config.info().get_binary_reader(exports_idx);
        let reader = ExportSectionReader::new(reader)?;
        let max_exports = u64::from(reader.count());
        let skip_at = config.rng().random_range(0..max_exports);

        for (i, export) in reader.into_iter().enumerate() {
            let export = export?;
            config.consume_fuel(1)?;

            let new_name = if skip_at != i as u64 {
                // otherwise bypass
                String::from(export.name)
            } else {
                let new_name = self.limited_string(config, export.name)?;
                log::debug!("Renaming export {export:?} by {new_name:?}");
                new_name
            };

            match export.kind {
                wasmparser::ExternalKind::Func => {
                    exports.export(new_name.as_str(), ExportKind::Func, export.index);
                }
                wasmparser::ExternalKind::Table => {
                    exports.export(new_name.as_str(), ExportKind::Table, export.index);
                }
                wasmparser::ExternalKind::Memory => {
                    exports.export(new_name.as_str(), ExportKind::Memory, export.index);
                }
                wasmparser::ExternalKind::Global => {
                    exports.export(new_name.as_str(), ExportKind::Global, export.index);
                }
                _ => {
                    panic!("Unknown export {export:?}")
                }
            }
        }
        Ok(Box::new(std::iter::once(Ok(config
            .info()
            .replace_section(
                config.info().exports.unwrap(),
                &exports,
            )))))
    }

    fn can_mutate<'a>(&self, config: &'a WasmMutate) -> bool {
        !config.preserve_semantics && config.info().has_exports() && config.info().exports_count > 0
    }
}

#[cfg(test)]
mod tests {
    use super::RenameExportMutator;
    use crate::WasmMutate;
    use std::sync::Arc;

    #[test]
    fn test_rename_export_mutator() {
        // From https://developer.mozilla.org/en-US/docs/WebAssembly/Text_format_to_wasm

        let mut config = WasmMutate::default();
        config.raw_mutate_func(Some(Arc::new(|data, _| {
            assert_eq!(data, b"exported_func");
            *data = Vec::new();
            Ok(())
        })));
        config.match_mutation(
            r#"
        (module
            (func (export "exported_func") (result i32)
                i32.const 42
            )
        )
        "#,
            RenameExportMutator { max_name_size: 2 }, // the string is empty,
            r#"(module
            (type (;0;) (func (result i32)))
            (func (;0;) (type 0) (result i32)
            i32.const 42)
        (export "" (func 0)))"#,
        );
    }
}