├── .gitignore ├── Corpus ├── README.md ├── corpus │ ├── Cargo.toml │ ├── README.md │ ├── corpus │ │ ├── invalid_1.txt │ │ ├── invalid_2.txt │ │ ├── valid_1.txt │ │ └── valid_2.txt │ └── src │ │ └── main.rs ├── disk_based_corpus │ ├── Cargo.toml │ ├── README.md │ ├── corpus │ │ ├── 1024554299.bin │ │ ├── 1025764880.bin │ │ ├── 1041517598.bin │ │ ├── 1042559712.bin │ │ ├── 1064605865.bin │ │ ├── 1084175018.bin │ │ ├── 1102201561.bin │ │ ├── 113714739.bin │ │ ├── 1178839413.bin │ │ ├── 1203968583.bin │ │ ├── 1253796503.bin │ │ ├── 126408189.bin │ │ ├── 1277085810.bin │ │ ├── 1286432834.bin │ │ ├── 1321184108.bin │ │ ├── 1363426704.bin │ │ ├── 1412733058.bin │ │ ├── 1430240426.bin │ │ ├── 1434194677.bin │ │ ├── 1436251403.bin │ │ ├── 1457390316.bin │ │ ├── 1496034452.bin │ │ ├── 1531066090.bin │ │ ├── 1531428112.bin │ │ ├── 1543877857.bin │ │ ├── 1598839442.bin │ │ ├── 1691632384.bin │ │ ├── 1757131800.bin │ │ ├── 1786426492.bin │ │ ├── 1796175900.bin │ │ ├── 1840653031.bin │ │ ├── 1877285214.bin │ │ ├── 1985160825.bin │ │ ├── 2010499191.bin │ │ ├── 2018958260.bin │ │ ├── 2024872185.bin │ │ ├── 2161256327.bin │ │ ├── 2164765522.bin │ │ ├── 2174343166.bin │ │ ├── 219461705.bin │ │ ├── 2247380198.bin │ │ ├── 2254461020.bin │ │ ├── 2355532087.bin │ │ ├── 2442221914.bin │ │ ├── 2465477071.bin │ │ ├── 2487946642.bin │ │ ├── 252215271.bin │ │ ├── 253977615.bin │ │ ├── 2584379440.bin │ │ ├── 2599139795.bin │ │ ├── 2609123055.bin │ │ ├── 2651931244.bin │ │ ├── 2658877291.bin │ │ ├── 2664934266.bin │ │ ├── 2708075248.bin │ │ ├── 2920573194.bin │ │ ├── 2932114721.bin │ │ ├── 2950638823.bin │ │ ├── 2981467136.bin │ │ ├── 3022920988.bin │ │ ├── 3024329518.bin │ │ ├── 3036060798.bin │ │ ├── 3123588621.bin │ │ ├── 3129842195.bin │ │ ├── 3175126494.bin │ │ ├── 3249868486.bin │ │ ├── 3362873881.bin │ │ ├── 3465361584.bin │ │ ├── 3530403716.bin │ │ ├── 3639849080.bin │ │ ├── 3665280871.bin │ │ ├── 3672699799.bin │ │ ├── 3814970799.bin │ │ ├── 3850397225.bin │ │ ├── 3863844622.bin │ │ ├── 3914216688.bin │ │ ├── 3931067433.bin │ │ ├── 4008785515.bin │ │ ├── 4014036935.bin │ │ ├── 4036155543.bin │ │ ├── 4092713653.bin │ │ ├── 4204124392.bin │ │ ├── 4215993880.bin │ │ ├── 4231403985.bin │ │ ├── 4246929270.bin │ │ ├── 4277156466.bin │ │ ├── 477951739.bin │ │ ├── 493390179.bin │ │ ├── 497348646.bin │ │ ├── 498853085.bin │ │ ├── 564408748.bin │ │ ├── 570319017.bin │ │ ├── 578845221.bin │ │ ├── 647289954.bin │ │ ├── 662318707.bin │ │ ├── 815348036.bin │ │ ├── 863074020.bin │ │ ├── 887780958.bin │ │ ├── 926468965.bin │ │ ├── 936719502.bin │ │ └── 972025495.bin │ └── src │ │ └── main.rs ├── general_corpus │ ├── Cargo.toml │ ├── README.md │ ├── corpus │ │ ├── 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 │ └── src │ │ └── main.rs ├── generative_corpus │ ├── Cargo.toml │ ├── README.md │ ├── fuzz_corpus │ │ ├── sample_000 │ │ ├── sample_001 │ │ ├── sample_002 │ │ ├── sample_003 │ │ ├── sample_004 │ │ ├── sample_005 │ │ ├── sample_006 │ │ ├── sample_007 │ │ ├── sample_008 │ │ ├── sample_009 │ │ ├── sample_010 │ │ ├── sample_011 │ │ ├── sample_012 │ │ ├── sample_013 │ │ ├── sample_014 │ │ ├── sample_015 │ │ ├── sample_016 │ │ ├── sample_017 │ │ ├── sample_018 │ │ ├── sample_019 │ │ ├── sample_020 │ │ ├── sample_021 │ │ ├── sample_022 │ │ ├── sample_023 │ │ ├── sample_024 │ │ ├── sample_025 │ │ ├── sample_026 │ │ ├── sample_027 │ │ ├── sample_028 │ │ ├── sample_029 │ │ ├── sample_030 │ │ ├── sample_031 │ │ ├── sample_032 │ │ ├── sample_033 │ │ ├── sample_034 │ │ ├── sample_035 │ │ ├── sample_036 │ │ ├── sample_037 │ │ ├── sample_038 │ │ ├── sample_039 │ │ ├── sample_040 │ │ ├── sample_041 │ │ ├── sample_042 │ │ ├── sample_043 │ │ ├── sample_044 │ │ ├── sample_045 │ │ ├── sample_046 │ │ ├── sample_047 │ │ ├── sample_048 │ │ ├── sample_049 │ │ ├── sample_050 │ │ ├── sample_051 │ │ ├── sample_052 │ │ ├── sample_053 │ │ ├── sample_054 │ │ ├── sample_055 │ │ ├── sample_056 │ │ ├── sample_057 │ │ ├── sample_058 │ │ ├── sample_059 │ │ ├── sample_060 │ │ ├── sample_061 │ │ ├── sample_062 │ │ ├── sample_063 │ │ ├── sample_064 │ │ ├── sample_065 │ │ ├── sample_066 │ │ ├── sample_067 │ │ ├── sample_068 │ │ ├── sample_069 │ │ ├── sample_070 │ │ ├── sample_071 │ │ ├── sample_072 │ │ ├── sample_073 │ │ ├── sample_074 │ │ ├── sample_075 │ │ ├── sample_076 │ │ ├── sample_077 │ │ ├── sample_078 │ │ ├── sample_079 │ │ ├── sample_080 │ │ ├── sample_081 │ │ ├── sample_082 │ │ ├── sample_083 │ │ ├── sample_084 │ │ ├── sample_085 │ │ ├── sample_086 │ │ ├── sample_087 │ │ ├── sample_088 │ │ ├── sample_089 │ │ ├── sample_090 │ │ ├── sample_091 │ │ ├── sample_092 │ │ ├── sample_093 │ │ ├── sample_094 │ │ ├── sample_095 │ │ ├── sample_096 │ │ ├── sample_097 │ │ ├── sample_098 │ │ └── sample_099 │ └── src │ │ └── main.rs ├── hybrid_corpus │ ├── Cargo.toml │ ├── README.md │ ├── hybrid_corpus │ │ ├── invalid.png │ │ ├── truncated.jpg │ │ ├── valid.jpg │ │ └── valid.png │ └── src │ │ ├── main.rs │ │ ├── valid.jpg │ │ └── valid.png ├── in_memory_corpus │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── seed_corpus │ ├── Cargo.toml │ ├── README.md │ ├── seed_corpus │ │ ├── seed1.txt │ │ ├── seed2.txt │ │ └── seed3.txt │ └── src │ │ └── main.rs └── targeted_corpus │ ├── Cargo.toml │ ├── README.md │ ├── image_corpus │ ├── invalid.png │ └── valid.png │ └── src │ └── main.rs ├── Coverage ├── README.md ├── basic_feedback_driven │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── block_coverage │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── branch_coverage │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── feedback_driven_fuzzing │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── function_coverage │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── loop_coverage │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── path_coverage │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── predicate_coverage │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs └── statement_coverage │ ├── Cargo.toml │ ├── README.md │ └── src │ └── main.rs ├── Executor ├── README.md ├── fork-based_fuzzer │ ├── Cargo.toml │ ├── README.md │ ├── src │ │ └── main.rs │ ├── target.c │ └── target1 ├── process_level_parallelism │ ├── .gitignore │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── target_input │ ├── Cargo.toml │ ├── README.md │ ├── program.c │ ├── src │ │ └── main.rs │ └── target_program ├── thread_level_parallelism │ ├── .gitignore │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs └── wget_fuzzer │ ├── Cargo.toml │ ├── README.md │ └── src │ └── main.rs ├── Monitor ├── README.md ├── log_fuzzing_events │ ├── Cargo.toml │ ├── README.md │ ├── fuzz.log │ └── src │ │ └── main.rs ├── log_test_cases │ ├── Cargo.toml │ ├── README.md │ ├── crash-cases.txt │ └── src │ │ └── main.rs ├── panic_crash │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── sanity_checks │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── sysinfo_test │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── track_statistics │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs └── use_profiling │ ├── Cargo.toml │ ├── README.md │ └── src │ └── main.rs ├── Mutation ├── README.md ├── arithmetic_mutate │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── bitmask_mutation │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── gen_rand_mutation │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── gen_rand_mutation_byte │ ├── Cargo.toml │ ├── README.md │ └── src │ │ └── main.rs ├── mutated_seed_files │ ├── Cargo.toml │ ├── README.md │ ├── original_seed.txt │ └── src │ │ └── main.rs └── token_mutation │ ├── Cargo.toml │ ├── README.md │ └── src │ └── main.rs └── README.md /Corpus/README.md: -------------------------------------------------------------------------------- 1 | # Corpus 2 | 3 | * _Corpus fuzzing is a software testing technique that uses a large corpus of valid input data to automatically generate semi-valid test cases for fuzz testing_ -------------------------------------------------------------------------------- /Corpus/corpus/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "corpus" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /Corpus/corpus/README.md: -------------------------------------------------------------------------------- 1 | # Corpus 2 | 3 | * _Corpus fuzzing is a software testing technique that uses a large corpus of valid input data to automatically generate semi-valid test cases for fuzz testing_ 4 | 5 | 6 | # Build 7 | 8 | ```bash 9 | $ cargo run 10 | ``` 11 | # Output 12 | ```bash 13 | # cargo run 14 | Finished dev [unoptimized + debuginfo] target(s) in 0.00s 15 | Running `target/debug/corpus` 16 | # exa 17 | invalid_1.txt invalid_2.txt valid_1.txt valid_2.txt 18 | ``` -------------------------------------------------------------------------------- /Corpus/corpus/corpus/invalid_1.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/corpus/corpus/invalid_1.txt -------------------------------------------------------------------------------- /Corpus/corpus/corpus/invalid_2.txt: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /Corpus/corpus/corpus/valid_1.txt: -------------------------------------------------------------------------------- 1 | This is a valid input -------------------------------------------------------------------------------- /Corpus/corpus/corpus/valid_2.txt: -------------------------------------------------------------------------------- 1 | Another valid sample -------------------------------------------------------------------------------- /Corpus/corpus/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::fs; 2 | use std::io::Write; 3 | 4 | fn generate_corpus() { 5 | 6 | // Create a new directory for the corpus 7 | fs::create_dir("corpus").unwrap(); 8 | 9 | // Generate some valid samples 10 | let mut f = fs::File::create("corpus/valid_1.txt").unwrap(); 11 | f.write_all(b"This is a valid input").unwrap(); 12 | 13 | let mut f = fs::File::create("corpus/valid_2.txt").unwrap(); 14 | f.write_all(b"Another valid sample").unwrap(); 15 | 16 | // Generate some invalid/malformed samples 17 | let mut f = fs::File::create("corpus/invalid_1.txt").unwrap(); 18 | f.write_all(b"Invalid\xFF").unwrap(); 19 | 20 | let mut f = fs::File::create("corpus/invalid_2.txt").unwrap(); 21 | f.write_all(b"\x00\x00\x00").unwrap(); 22 | } 23 | 24 | fn main() { 25 | generate_corpus(); 26 | } -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "disk_based_corpus" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/README.md: -------------------------------------------------------------------------------- 1 | # Disk-Based-Corpus 2 | 3 | * _Disk-based corpus refers to a corpus (collection of texts or speech data) that is too large to fit into the main memory of a computer and needs to be stored on disk_ 4 | 5 | 6 | # Build 7 | ```bash 8 | $ cargo run 9 | ``` 10 | # Output 11 | ```bash 12 | # cargo run 13 | Compiling disk_based_corpus v0.1.0 (/home/raminfp/IdeaProjects/Corpus/disk_based_corpus) 14 | Finished dev [unoptimized + debuginfo] target(s) in 0.34s 15 | Running `target/debug/disk_based_corpus` 16 | Fuzzed input: [72, 101, 108, 186, 111] 17 | Fuzzed input: [72, 101, 108, 186, 39] 18 | Fuzzed input: [72, 101, 108, 186, 77] 19 | Fuzzed input: [72, 101, 211, 186, 77] 20 | Fuzzed input: [72, 101, 211, 186, 180] 21 | Fuzzed input: [72, 101, 75, 186, 180] 22 | Fuzzed input: [72, 183, 75, 186, 180] 23 | Fuzzed input: [72, 183, 75, 44, 180] 24 | Fuzzed input: [18, 183, 75, 44, 180] 25 | Fuzzed input: [18, 239, 75, 44, 180] 26 | Fuzzed input: [18, 239, 75, 111, 180] 27 | Fuzzed input: [26, 239, 75, 111, 180] 28 | Fuzzed input: [26, 239, 24, 111, 180] 29 | Fuzzed input: [26, 239, 24, 92, 180] 30 | Fuzzed input: [26, 239, 24, 92, 185] 31 | Fuzzed input: [26, 239, 24, 92, 207] 32 | Fuzzed input: [26, 239, 24, 71, 207] 33 | Fuzzed input: [26, 239, 24, 113, 207] 34 | Fuzzed input: [26, 183, 24, 113, 207] 35 | Fuzzed input: [26, 183, 24, 63, 207] 36 | Fuzzed input: [26, 183, 24, 211, 207] 37 | Fuzzed input: [26, 183, 11, 211, 207] 38 | Fuzzed input: [26, 183, 45, 211, 207] 39 | Fuzzed input: [26, 183, 45, 211, 221] 40 | 41 | ``` -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1024554299.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1024554299.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1025764880.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1025764880.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1041517598.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1041517598.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1042559712.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1042559712.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1064605865.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1064605865.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1084175018.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1084175018.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1102201561.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1102201561.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/113714739.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/113714739.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1178839413.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1178839413.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1203968583.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1203968583.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1253796503.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1253796503.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/126408189.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/126408189.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1277085810.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1277085810.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1286432834.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1286432834.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1321184108.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1321184108.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1363426704.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1363426704.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1412733058.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1412733058.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1430240426.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1430240426.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1434194677.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1434194677.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1436251403.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1436251403.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1457390316.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1457390316.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1496034452.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1496034452.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1531066090.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1531066090.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1531428112.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1531428112.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1543877857.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1543877857.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1598839442.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1598839442.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1691632384.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1691632384.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1757131800.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1757131800.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1786426492.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1786426492.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1796175900.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1796175900.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1840653031.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1840653031.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1877285214.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1877285214.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/1985160825.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/1985160825.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2010499191.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2010499191.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2018958260.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2018958260.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2024872185.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2024872185.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2161256327.bin: -------------------------------------------------------------------------------- 1 | Hello -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2164765522.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2164765522.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2174343166.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2174343166.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/219461705.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/219461705.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2247380198.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2247380198.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2254461020.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2254461020.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2355532087.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2355532087.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2442221914.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2442221914.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2465477071.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2465477071.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2487946642.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2487946642.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/252215271.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/252215271.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/253977615.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/253977615.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2584379440.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2584379440.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2599139795.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2599139795.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2609123055.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2609123055.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2651931244.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2651931244.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2658877291.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2658877291.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2664934266.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2664934266.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2708075248.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2708075248.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2920573194.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2920573194.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2932114721.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2932114721.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2950638823.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2950638823.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/2981467136.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/2981467136.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3022920988.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3022920988.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3024329518.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3024329518.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3036060798.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3036060798.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3123588621.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3123588621.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3129842195.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3129842195.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3175126494.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3175126494.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3249868486.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3249868486.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3362873881.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3362873881.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3465361584.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3465361584.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3530403716.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3530403716.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3639849080.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3639849080.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3665280871.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3665280871.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3672699799.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3672699799.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3814970799.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3814970799.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3850397225.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3850397225.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3863844622.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3863844622.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3914216688.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3914216688.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/3931067433.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/3931067433.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/4008785515.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/4008785515.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/4014036935.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/4014036935.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/4036155543.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/4036155543.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/4092713653.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/4092713653.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/4204124392.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/4204124392.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/4215993880.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/4215993880.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/4231403985.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/4231403985.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/4246929270.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/4246929270.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/4277156466.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/4277156466.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/477951739.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/477951739.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/493390179.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/493390179.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/497348646.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/497348646.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/498853085.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/498853085.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/564408748.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/564408748.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/570319017.bin: -------------------------------------------------------------------------------- 1 | JHENP -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/578845221.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/578845221.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/647289954.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/647289954.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/662318707.bin: -------------------------------------------------------------------------------- 1 | HeӺM -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/815348036.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/815348036.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/863074020.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/863074020.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/887780958.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/887780958.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/926468965.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/926468965.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/936719502.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/936719502.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/corpus/972025495.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/disk_based_corpus/corpus/972025495.bin -------------------------------------------------------------------------------- /Corpus/disk_based_corpus/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | use std::{ 3 | fs::{self, File}, 4 | io::{Write, Read}, 5 | path::{Path, PathBuf}, 6 | }; 7 | 8 | struct Fuzzer { 9 | corpus: Vec, 10 | } 11 | 12 | impl Fuzzer { 13 | fn new(input_dir: &str) -> Fuzzer { 14 | let mut fuzzer = Fuzzer { 15 | corpus: Vec::new(), 16 | }; 17 | fuzzer.populate_corpus(input_dir); 18 | fuzzer 19 | } 20 | 21 | fn populate_corpus(&mut self, input_dir: &str) { 22 | // Walk directory to add seed files 23 | let paths = fs::read_dir(input_dir).unwrap(); 24 | for path in paths { 25 | self.corpus.push(path.unwrap().path()); 26 | } 27 | } 28 | 29 | fn fuzz(&mut self) -> Vec { 30 | let seed = self.pick_seed(); 31 | let mut buffer = self.mutate_seed(&seed); 32 | 33 | let new_file = self.write_seed(&buffer); 34 | self.corpus.push(new_file); 35 | 36 | buffer 37 | } 38 | 39 | fn mutate_seed(&self, seed: &Path) -> Vec { 40 | let mut buffer = self.read_seed(seed); 41 | self.mutate(&mut buffer); 42 | buffer 43 | } 44 | 45 | fn pick_seed(&mut self) -> PathBuf { 46 | let index = rand::thread_rng().gen_range(0..self.corpus.len()); 47 | self.corpus.swap_remove(index) 48 | } 49 | fn read_seed(&self, path: &Path) -> Vec { 50 | let mut file = File::open(path).unwrap(); 51 | let mut buffer = Vec::new(); 52 | file.read_to_end(&mut buffer).unwrap(); 53 | buffer 54 | } 55 | 56 | fn mutate(&self, buffer: &mut Vec) { 57 | let offset = rand::thread_rng().gen_range(0..buffer.len()); 58 | let val = rand::thread_rng().gen::(); 59 | buffer[offset] = val; 60 | } 61 | 62 | fn write_seed(&self, buffer: &[u8]) -> PathBuf { 63 | let mut path = PathBuf::new(); 64 | path.push("corpus"); 65 | path.push(format!("{}.bin", rand::random::())); 66 | let mut file = File::create(&path).unwrap(); 67 | file.write_all(buffer).unwrap(); 68 | path 69 | } 70 | } 71 | 72 | fn main() { 73 | let mut fuzzer = Fuzzer::new("seeds"); 74 | 75 | // Add initial seed 76 | let seed = b"Hello"; 77 | let path = fuzzer.write_seed(seed); 78 | fuzzer.corpus.push(path); 79 | 80 | // Fuzz 81 | for _ in 0..100 { 82 | let input = fuzzer.fuzz(); 83 | // Test input... 84 | 85 | println!("Fuzzed input: {:?}", input); 86 | } 87 | } 88 | -------------------------------------------------------------------------------- /Corpus/general_corpus/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "general_corpus" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Corpus/general_corpus/README.md: -------------------------------------------------------------------------------- 1 | # General Corpus 2 | 3 | * _A general corpus contains a wide variety of valid and invalid sample inputs for the target application. This allows the fuzzer to generate a diverse set of test cases._ 4 | 5 | # Build 6 | ```bash 7 | $ cargo run . 8 | ``` 9 | # Output 10 | ```bash 11 | # cargo run 12 | Finished dev [unoptimized + debuginfo] target(s) in 0.04s 13 | Running `target/debug/general_corpus` 14 | Generated corpus files in corpus 15 | [13:00] raminfp@zenbook:general_corpus (main *%) # exa corpus/ 16 | 1 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61 65 69 73 77 81 85 89 93 97 17 | 2 6 10 14 18 22 26 30 34 38 42 46 50 54 58 62 66 70 74 78 82 86 90 94 98 18 | 3 7 11 15 19 23 27 31 35 39 43 47 51 55 59 63 67 71 75 79 83 87 91 95 99 19 | 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96 20 | 21 | ``` -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/1: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/1 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/10: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/10 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/11: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/11 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/12: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/12 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/13: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/13 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/14: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/14 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/15: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/15 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/16: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/16 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/17: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/17 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/18: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/18 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/19: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/19 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/2 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/20: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/20 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/21: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/21 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/22: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/22 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/23: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/23 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/24: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/24 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/25: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/25 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/26: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/26 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/27: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/27 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/28: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/28 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/29: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/29 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/3: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/3 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/30: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/30 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/31: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/31 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/32: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/32 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/33: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/33 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/34: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/34 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/35: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/35 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/36: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/36 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/37: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/37 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/38: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/38 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/39: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/39 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/4: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/4 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/40: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/40 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/41: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/41 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/42: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/42 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/43: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/43 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/44: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/44 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/45: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/45 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/46: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/46 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/47: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/47 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/48: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/48 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/49: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/49 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/5: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/5 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/50: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/50 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/51: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/51 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/52: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/52 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/53: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/53 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/54: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/54 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/55: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/55 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/56: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/56 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/57: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/57 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/58: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/58 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/59: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/59 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/6: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/6 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/60: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/60 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/61: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/61 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/62: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/62 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/63: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/63 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/64 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/65: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/65 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/66: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/66 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/67: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/67 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/68: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/68 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/69: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/69 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/7: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/7 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/70: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/70 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/71: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/71 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/72: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/72 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/73: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/73 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/74: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/74 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/75: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/75 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/76: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/76 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/77: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/77 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/78: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/78 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/79: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/79 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/8: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/8 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/80: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/80 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/81: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/81 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/82: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/82 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/83: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/83 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/84: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/84 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/85: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/85 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/86: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/86 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/87: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/87 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/88: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/88 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/89: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/89 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/9: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/9 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/90: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/90 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/91: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/91 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/92: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/92 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/93: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/93 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/94: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/94 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/95: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/95 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/96: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/96 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/97: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/97 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/98: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/98 -------------------------------------------------------------------------------- /Corpus/general_corpus/corpus/99: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/general_corpus/corpus/99 -------------------------------------------------------------------------------- /Corpus/general_corpus/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | use std::fs; 3 | use std::io::Write; 4 | 5 | 6 | fn main() { 7 | let mut rng = rand::thread_rng(); 8 | let corpus_dir = "corpus"; 9 | fs::create_dir_all(corpus_dir).unwrap(); 10 | 11 | for i in 1..100 { 12 | let mut content = Vec::new(); 13 | // Generate random length content 14 | let length = rng.gen_range(0..1000); 15 | for _ in 0..length { 16 | content.push(rng.gen::()); 17 | } 18 | // Write content to a file 19 | let filename = format!("{}/{}", corpus_dir, i); 20 | let mut file = fs::File::create(&filename).unwrap(); 21 | file.write_all(&content).unwrap(); 22 | } 23 | println!("Generated corpus files in {}", corpus_dir); 24 | } 25 | -------------------------------------------------------------------------------- /Corpus/generative_corpus/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "generative_corpus" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Corpus/generative_corpus/README.md: -------------------------------------------------------------------------------- 1 | # Generative corpus 2 | 3 | * _A generative corpus uses grammars, models or generators to automatically create a diverse corpus for the fuzzer._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | ```bash 13 | [13:07] raminfp@zenbook:generative_corpus (main) # cargo run . 14 | Compiling generative_corpus v0.1.0 (/home/raminfp/IdeaProjects/Corpus/generative_corpus) 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.36s 16 | Running `target/debug/generative_corpus .` 17 | Stored 100 samples in fuzz_corpus 18 | [13:08] raminfp@zenbook:generative_corpus (main %) # exa fuzz_corpus/ 19 | sample_000 sample_012 sample_024 sample_036 sample_048 sample_060 sample_072 sample_084 sample_096 20 | sample_001 sample_013 sample_025 sample_037 sample_049 sample_061 sample_073 sample_085 sample_097 21 | sample_002 sample_014 sample_026 sample_038 sample_050 sample_062 sample_074 sample_086 sample_098 22 | sample_003 sample_015 sample_027 sample_039 sample_051 sample_063 sample_075 sample_087 sample_099 23 | sample_004 sample_016 sample_028 sample_040 sample_052 sample_064 sample_076 sample_088 24 | sample_005 sample_017 sample_029 sample_041 sample_053 sample_065 sample_077 sample_089 25 | sample_006 sample_018 sample_030 sample_042 sample_054 sample_066 sample_078 sample_090 26 | sample_007 sample_019 sample_031 sample_043 sample_055 sample_067 sample_079 sample_091 27 | sample_008 sample_020 sample_032 sample_044 sample_056 sample_068 sample_080 sample_092 28 | sample_009 sample_021 sample_033 sample_045 sample_057 sample_069 sample_081 sample_093 29 | sample_010 sample_022 sample_034 sample_046 sample_058 sample_070 sample_082 sample_094 30 | sample_011 sample_023 sample_035 sample_047 sample_059 sample_071 sample_083 sample_095 31 | 32 | ``` -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_000: -------------------------------------------------------------------------------- 1 | {solmbtiqknugmok:truekeniblpysffgl:true}[true,"string",true] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_001: -------------------------------------------------------------------------------- 1 | {oyphvkpntoqpsoklg:"string",}["string""string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_002: -------------------------------------------------------------------------------- 1 | {qyisphciyxap:123,}{ubyhjloxunksxcfio:"string",iqjqqhwj:"string",mphksiipfnowxh:"string"hbfuih:123,}["string",true,truetrue,] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_003: -------------------------------------------------------------------------------- 1 | {ldgduuirp:123nrlgfuufhsni:"string",}{kpdagqxykxpal:"string"}{ptseoovmxucexllan:123,}{mfndtt:"string",oyjiohvxivfvghyjsr:123kiewqhojqw:"string"yopyawoxpu:123,}{gsqoiiusegvatojtqj:123ukcelbmsohtrvqsbpgj:"string",pnexubvnntin:"string"pcjxxavwoqgtqqvmxd:"string"}{kejfdvwfuxloith:"string"awkysnhthxe:true,}{puqkp:"string",hccuchtuicgpmcltx:trueavmxqsiywwshaj:"string"}{mmcjhobljy:"string",roqktcood:"string",}{yadjcssagrcaky:"string"rtcfwdhwrktrhpavwt:trueoxihhiqaujgpgjdiw:"string"}[true"string",true"string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_004: -------------------------------------------------------------------------------- 1 | {ydkgtpbkuaybxpc:true,pculxxumiuiviqgxvba:123,gauknvbxaldvcd:"string",qxsupincdxooum:true,}{vlvajgvyfxeaokrjt:"string",}{oauyoim:"string",uyrqw:true}{sfcehvnrq:truecdgnjwjkxbtwqbmjmap:123,wdhkmivkls:123}{qfjtejupf:"string"}{thocrqwmawiljwjkn:"string"ejqbbxqhiyvsqhx:"string",wrvboideaxfk:123,biitgdluqlcvghb:"string",}{muhbuqbbqecuwydnr:trueretcj:true}{jqnxcscj:"string",stvfbpwm:"string"kupcphpcswrjfd:true,ayxrtdoeqbyx:"string",}{gjpjcrbmmuy:123,}[true,true,] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_005: -------------------------------------------------------------------------------- 1 | {auhypvdysqkebdsh:123}{sfsiklvmlxfggbg:"string"lmvqavlwcdstnal:true,}{mcgkmcvibcxv:truerdvefpyttlvhir:"string",}{imfdtfvtdc:123gjtyksraryvhgvecrm:true}{ixqolixvlctgxkhp:123vbuefyml:"string",kqdubsjlckvhu:123}{tuabswxuxqxbsdv:"string",}{vpydeif:"string"iabnjcicuvcdvim:123,kobfpkxvmhsjcwauw:"string",}[truetrue123,] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_006: -------------------------------------------------------------------------------- 1 | {dvtcgyefbfqwe:"string",}{byxcriseikfrhcwixx:"string"}{wryphonilirhv:123,gohgubhovhiygywxpf:true,}{jmpeipsp:true,apeysljwanoye:"string"frtww:123}{frubuhqqjacp:true,}{hsumb:"string"rsqkoh:"string"uhmrjnkglnbckpjfl:"string",}{qgjsmhllvqk:true,kecbuno:123} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_007: -------------------------------------------------------------------------------- 1 | {kuvjkp:"string"ukwikphhx:123fcgwejnampepwu:123,}{pujxcqicuvgr:"string",bbkwghprosmpsekeq:123}{jckcicxeievss:123ahesjyqbjpeuupyhov:"string",idcwbgojqyutmigowrw:123,wmfqhfphqwwtwp:"string"}{dxxch:"string",spmqwvmolnvmed:123}{ngnugfjyyshfli:123}{nwohhgolygqtoqdptgn:"string",ngxvimbdq:"string",kckhijbfivlsajqv:123}["string","string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_008: -------------------------------------------------------------------------------- 1 | {pvpgiprctt:123,}{oeemeukjuwqa:"string"stykwkmxcysv:"string"}{imcypdotnapeidhax:123}{ygdxbgolpnq:"string"waxwibficku:"string",btkstaovpdkwqep:trueuccqhlua:"string",}{wwvyfy:true}{udgolc:"string",carhyoxa:123wpmpplkhrqxjhupfod:"string"}{ulvsc:truewptsjoysporbuky:"string"}["string",true123] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_009: -------------------------------------------------------------------------------- 1 | {rebwiuhgvcuej:true,rrneptllhwiwofmslny:"string",hapwnhvwtbrgnwk:123,vhvdumdmd:true}{rwveopnokoja:"string",bkbdwi:"string"}["string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_010: -------------------------------------------------------------------------------- 1 | {albiercbvbfu:123}{ceidfgrhtagwxarjdnu:"string"drkblg:123}["string","string","string""string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_011: -------------------------------------------------------------------------------- 1 | {myngniingnkfhntrl:123,whbwtakigyikkglo:"string",}{epryjh:true,adlfgngjbenhyiwj:"string",} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_012: -------------------------------------------------------------------------------- 1 | {ioxoakbcrmhdd:"string",qbyxjpfrynjhjjifi:123}{kkkucjtvxry:"string"lgmatmvmfjhgkj:true,ebxqopgvdsxg:123,mdxti:true}{rrqyaqvomoohqv:true}{awacfifhyjuorn:"string",ewotecip:"string"oiduweeveqvuejaytl:"string"lpmweugx:true,}{ikjlcbren:"string",urupocxcgukjrykxrm:"string"rbrjnchgtcrfvcwurjf:"string"}{wmrdhevypemvcvwkn:"string"yhebvh:"string",nuuywvjckrwblrb:123pqypdvwijklaiiamp:123,}{sjwwsaikkbxfty:truearodkq:123,wloahgdngf:"string",}{wtdsq:truefweciv:trueownlh:truefqqli:true}{uaqydruwffm:"string"ihliikehojn:true,hmevnmxwjq:"string"bwoxhjmw:true,} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_013: -------------------------------------------------------------------------------- 1 | {ttdhmuancfwkputyiu:123,}{ohyeoktjvixdtqn:"string",uojptwsusimgsg:"string",lrcjrngtmcwrxks:trueuljlykqgkjyjre:"string"}{csejinwwtfelpeyb:true,}{ttaclpotunvl:"string",gsukrrdac:true,bjjcasoatxqgqbwrp:"string",soqdhdrynxvkkoatl:"string"}{jujnxys:"string"hjegpwlxpfc:true,}{ssxujost:"string"nxatwb:"string",mvgykdiixygra:123,eftohtqbbe:"string"}{ogxlgfsfu:123,}{mokqdsfnvwv:"string"kwqhkixqfnhujbmjnu:"string",}["string""string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_014: -------------------------------------------------------------------------------- 1 | {gycio:123,utdejaqwro:trueacpdlcqetwafxg:"string"}{kovkt:"string"exhewtbhv:123,ghijksajamdwlsj:123mxndvvtxqsltregepg:true}["string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_015: -------------------------------------------------------------------------------- 1 | {upitaunsullvtcqeic:123,}{aebrmp:"string",}{fofosjxbig:123uwbnhp:"string"whpridjatn:truecgipedtpjo:"string",}{uckks:123}{vdsbmqfogjhycrslt:true}{rpfca:"string"uwoyackxdhjj:123,}{cndws:true} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_016: -------------------------------------------------------------------------------- 1 | {kmgarebti:"string",} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_017: -------------------------------------------------------------------------------- 1 | {wnpugftiafq:123,qfiwaoeaf:"string"nrpryisuicbirxlur:"string",twjkprnsnqm:123,}{euscoclcnuok:"string"}{ktpvspxhelvlkip:true} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_018: -------------------------------------------------------------------------------- 1 | {yypgqyiilvkpul:"string",pjvefudkjn:true,iyfusodtifyn:"string"hmqmrqbyx:"string",}{vqejgspnpfqhnoai:"string",esraxpclrdmtcapgb:"string",vcmhrtxscg:"string",}{xmkddunadyfvcad:true,}{stnwyirvprjfqplt:"string",cajbfgdmqkwlebu:truevgkepwaghdwhwfvokb:123,}{ouardcvpvlvn:"string"uvdpmuoqpfmhvpoofvn:true,}{yxlita:"string"vijmoob:123} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_019: -------------------------------------------------------------------------------- 1 | {rbnhtaldhcnnobnyu:"string",jyagojt:true,diqssgiddrbppjn:truenfmhj:"string"}{oosdasy:123,}{bkxtyydawcojiayg:true,}{nrubiqakdvv:"string",uxiagdcscwxaquuujs:"string",makcr:"string"doddgbinrbg:"string"}{trcoyykbnaq:trueoxkprdhkhyyr:true,rppngba:"string"}["string""string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_020: -------------------------------------------------------------------------------- 1 | {wthlkmegl:"string"uflseajpnjydrsmtnv:"string",dexoocusqkyvimmuwfd:"string",txtuwsvri:"string",}{whswtjygk:123xcyotqqit:123,}{lcgjrcgjmifgdc:"string"soffgqqfhtqtewfvei:"string"eicajkn:true} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_021: -------------------------------------------------------------------------------- 1 | {taawaiqqmkjcxfo:"string"}{bqmfalowqq:"string",meguyvhtljrhjupjb:"string",rfutqtrrvm:"string"rbfbfinbg:"string",}{usexnduldddsqs:"string",vordwysn:123,wtvxlpedorrmws:true,}{wyxftpt:"string"mshlivsp:"string"}{extaffnbysxr:"string"}{cepateius:123qgeflvedqmdisf:"string",plfbog:123}{ggiopcbtgntodbbauf:123honjrvgeticsiym:123fjtekcvdkuxvrwto:"string"}{okatwaqbwmlemavfy:"string",yovrsmyidnmipduiijc:"string"vfpdvauktdpecioc:trueuoiqhhqauteiipa:123,}{vnsrkijfmg:"string"vynhy:"string"trbisqb:true}[123,] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_022: -------------------------------------------------------------------------------- 1 | {pxqdjobexdgc:"string",}{jofuhsxbah:true,cotjqjetbokw:123,}{asyucjgjtsjroen:"string",ohpmxibxmultrvaoklj:123xiiewxqr:123,nmpwousikvkiokcbghk:123}{tcajsevmffyxoepw:truebxfrvelwvbo:true}{kuuojjddtvoxs:true,}{pdhnyevtoosyt:trueylhhwgy:"string",}{qiclvdkuoknkuyquum:123,vyitjyktip:true,}{sqnxbrdtgygi:"string",ertgu:"string"axlshuixgmcygqaes:true} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_023: -------------------------------------------------------------------------------- 1 | {hurnlql:true,siponleakyf:"string"}{qjqnxheuxmwqwro:123,juksjtwexgjuxaqxk:true,uydjearnxi:"string",kxoft:true}{iuqqpyyijkqamrrtna:truelnfelek:123fcmjnxvih:"string",twcrptcprpxsadmi:"string",}{yrxyuqulujqfqxyiu:"string",}{jxsdcgeodbswq:truefwjbjdb:123,gkfxo:"string"}{dopyphdjbvpb:"string"}{vyndsdfwxkojta:123hcoxvtxuy:"string"evbrvlmdvdlxmcirax:123,}{jjteawlwbjogwill:"string",}{xvuwevkrdct:"string"uolhunplal:true}[true"string""string"123] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_024: -------------------------------------------------------------------------------- 1 | {woprfvndiswuka:"string"}{wnyoxpr:"string",rbgpockofhbyvjiek:"string"}{ygsxcpewaqkkxgd:"string"mgrnaomvb:123,ktwpmiwse:123vlahtiovxkmuwr:true}{ukcsiuyqaqcku:123aaxdbdb:"string"neuqbgnutikjyurtrrq:"string"}{manmjsfkw:"string",jibfobaxfekbgvjleuw:"string"ecuvdg:"string",jpnmoyosvvlajdvpthh:"string"}{djtajblucrvbgcfnij:"string"epgeeyrhc:123}{fygcglbhclxmd:"string"}{kpcfvxfyeackrgdg:"string"}[true,] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_025: -------------------------------------------------------------------------------- 1 | {mewvrtrqocpmrxipnsl:true,ixgdmkibnwoxdvpywen:"string",ypxin:true,}{lwhiky:"string",}{cegclhcautxme:"string",}{ataajomqot:trueefshgdqyq:123hhnti:"string",}{getlplu:123,} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_026: -------------------------------------------------------------------------------- 1 | {bhcuriceimtkjqc:123,}{qkushs:"string",vgqiruxrsqscv:"string"disvwchran:123llviffm:"string"}{oisqyaskxmpe:true,padyfpyvqdheg:"string",rxnbpdtfmfaycf:true,uskdyjbecqcqmvdvy:true}{quhwjexiwesbdwo:"string",ksebmbstecdely:true}{pxmclusqmhm:123,usrmg:"string"uaimu:"string"}{elkxlhhefikg:"string",}{yubulrroofcgcalcmm:true,wljjejlbmhwqgvx:true,oqsgvvtbjqcpmvdxs:true,efrtabmfhc:123}{lrgrrpfdjjtsm:123,}{iiqhhppmfgkyem:123}["string",123,"string",true] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_027: -------------------------------------------------------------------------------- 1 | {lhsienkpobdpwugklge:true}{ftcwpbitnj:"string"}{qjoignyemgcy:123dfluds:true}{hcpncfaecwte:123vwqvhogtvcfmfa:123,}{xjuwmxavledwgvlqni:true,riuqhvqwkweff:123dydtupbdugmripnpmqt:truejkvksurxddindehjbv:"string",}{agmeasxcjafxcvpwlku:"string"}[123"string","string",true,] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_028: -------------------------------------------------------------------------------- 1 | {cbuwbqllsykj:"string"bcgynwvhxchgvmk:"string"isuxwmtueuugae:"string",}{mtvsrx:"string",wsldxdrn:123,}{gbpjwppjxacswcspfpd:123xfednmosiqelcwc:"string",dxmcxnyidrn:"string"agxcxoj:true}{qjksjy:true,nuogusvildhum:123lwytruqnhbo:123}{ykmxyjsqiwsunal:trueylews:"string",}{uyljwvbmluwbuttp:123,icywpxypfcxfc:123yiauatrmdvqhmaffnoi:true}{nmhxynjwjvpfhkgcqfe:true,kypxyolrytfeciw:"string"ahojvaqqlucgl:"string",}{inbsng:true,}{tklwajobuturlf:"string"saggsllr:123iigxwmnogavwahi:123bsobtwqqeeskdouauo:"string"}[123"string"true] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_029: -------------------------------------------------------------------------------- 1 | {djhjyqgljxyg:true}{vyvnd:"string",njrtshqixprmmjon:123rgiymiyfcaghoj:"string"}{ydugfwypa:123,gpxscvafhgeorcuglv:"string",apanahemtibunjv:123,quiwqvvno:true}["string","string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_030: -------------------------------------------------------------------------------- 1 | {irhouxpblxohyeva:"string"lpcxos:true,aqfogkvpe:"string"jkunsewjoeuropotl:"string"}{lysbpuxqrcaxjm:123,sqrfrkajtelphdvxgvl:true,sfudvlplxkx:"string"} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_031: -------------------------------------------------------------------------------- 1 | {aaegpular:"string"vcjndwaxashmw:"string"lrrbghokiwv:"string"}{vsxxprfotdj:"string"ilqcxvk:123,lmkeqdqciesbkfv:123,nthoyp:"string",}{axkanodnhd:"string"lnuedrdxvwg:"string"cktcwvbse:"string",}{vaflqpyuhwjs:"string"wclcfdmgkjlivhvvi:"string",agyrxcxn:"string",tryjhlfcaa:"string",}{roegv:"string"emutowvjthjdyuntea:"string",yexfv:true,}{cngtbqpnbcq:"string",ayvahvsjejgrfp:123ojoau:"string"ipxevdj:"string",}[true] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_032: -------------------------------------------------------------------------------- 1 | {vkjbuhodhseeaxabva:"string"rlofsrghtmbchqjh:true,ydluajpnvxbh:123}{lnemnuer:trueykqhivwxqxur:true,vyiufkmslejfrdts:"string",}{bnsucrfxrxxquavaki:123,klqqphtrqxsxjmdu:"string"}{lacvbls:"string",wkakmcospnbvdvacgim:123,cdxiahthtq:true,ahxstrcgebsssml:true,}{kunaufraqiydkvpynif:123jdkskjpijtth:true,bxxmjq:true,}{evldatlvvnnryi:"string"} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_033: -------------------------------------------------------------------------------- 1 | {coaurbfqpsvxwxi:"string"}{mhokcvu:trueihtguvedlgpifkdh:"string",iaciarbrosbbgpqao:123aqcaahr:"string",}{invigojkswtilnafjc:true}{dryvgmcn:truelvtrlosyn:true,sbbobuadgsxslwjdyhq:123}{mxnjjenh:"string",ibnkiqqkdi:"string",byvmtxafrjcgjuguj:"string"xuiqkaabvt:123}{kohvrfslaqe:truehnwycorvlfeol:"string",}{uvcxwh:123xtmhamyhusjnxthxg:true,}["string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_034: -------------------------------------------------------------------------------- 1 | {dnbrwjxebwbmsvc:"string"wtnkepwhttmf:123embssmidufmkdltmwe:"string",}{bateqnwqg:"string",rkjvgu:123,ecyvbnxkva:"string"tjjdxjekunv:true,}{cxowyc:123,yueqrmxuyb:"string",kymaucbigprkqn:123}["string"123,"string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_035: -------------------------------------------------------------------------------- 1 | {cxavmxppkfwapfc:123hdvxbhx:"string"skixksfjq:"string"}{gbqdhqwjgshfekl:"string"cfuexdsstmw:truemunvonuevygdfkii:"string"xkhqcga:"string"}{wvarh:123,shifyoixlukhmcl:"string"}{pigbysnbi:true}{xxgkseyxyhwo:truebjdbbcsrwelsh:trueysjsjfqkx:123ihscxqchvxgyjcb:"string"}{hsjhiioevem:true,}{pnndb:true,wcpig:true,}{pkpydidb:123,vyaaxslbnqbiytmxk:true} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_036: -------------------------------------------------------------------------------- 1 | {rbuvrdmyp:"string"tcibpwpq:trueyolpkqupos:"string"}{xsppovohstroirywnw:"string"arkvvfnvrpkcycjo:truendiqicgaohho:"string",uvviepwxbovyemc:"string",}{bvvqjm:true,vgvsvvgclctietdfnap:"string"wupwnqxoijd:123}{xfckuyf:"string",osnbdqxfylq:"string",}{kxmmwcajw:"string"oiahpflnevshj:true,}{jbnaupcjeega:"string"djiwffv:123mcjdlkxoctfhwnmau:"string",} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_037: -------------------------------------------------------------------------------- 1 | {cxlklblhjue:trueawkkau:"string",}{ierrfck:"string"rxmmblyxeimw:123,}[true,"string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_038: -------------------------------------------------------------------------------- 1 | {lrbtddjhxb:truefuoteyqrlmbsqevl:"string"dlhyiiisbqudiimtgn:trueoqktwwsobpxqworbhgj:true}{hckvbbjh:true,ilxjyqvkjjyfa:true,}{ruwauatp:truewxctvimrwrg:123,}{lruvwrmahxxvjycn:"string",aryrarsk:"string"}{hktytcm:123,}[true,] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_039: -------------------------------------------------------------------------------- 1 | {rwiitltvvwujgvku:"string",fdmqnlncidyirgght:truejvbnhepnew:"string",suipniefoeyutcj:"string",}{kfmolfv:true,mqpvjpddogwetnblegn:123qsanwbtakxiic:"string"}{fuggadbjdhneihuqnc:"string",}["string"true"string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_040: -------------------------------------------------------------------------------- 1 | {bxxjdkevspg:"string"ubxyobpngoboyawo:true,dxgbmgmsyejpe:123,ysdqqgxrmpajh:"string"} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_041: -------------------------------------------------------------------------------- 1 | {knnsamcmh:true,}{jtsrllxcsdxirjldv:true}{vwmsulshn:"string"pyfbdbuoyos:"string",}{wsfvdflkrevjvhuyt:"string",cqprqptfboquvwiq:"string",pknuylbutnkukxqig:"string",avyfnjqkmpcrvsctoor:"string"}{pownrnviuvkqkjbxsfe:"string",pgfvq:true}{nnficup:"string"}{xriacvpesmxtnk:truerppvmjucwmppdndw:"string"gdidqxcg:123,}[true,"string""string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_042: -------------------------------------------------------------------------------- 1 | {ckmqbl:"string",jfsahfmmwkesp:123taqihrnngjwuvp:123vprygeq:"string"} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_043: -------------------------------------------------------------------------------- 1 | {rwgfgioaahmvcdo:"string"xynljxnpupfdaemp:truecdkhljhm:123,}{eyterppcipteibgb:"string",}{mvyfnih:123,}{pmhxwsce:"string",jbpybvio:"string"cpydmufq:"string",ckqlddkwmoxraeda:true,}{umqxtddscltsxi:123,iwcgyhwgdbycrqtm:123,pxsgncn:123,}{mtqnupue:"string"pxmit:123} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_044: -------------------------------------------------------------------------------- 1 | {weuslqxnwraxbtt:"string"}{qbaqygf:"string",wpdctwodsrrjgxix:"string",osstbxo:"string",}{ilxrvayjc:true,}{hwiotplephqdct:123mvpmjnlcjqyccoacr:"string"}{fhqhrd:"string"}{xwroltimonywbc:"string"aqrgxqspmnep:true,}{dldrxjrgnworg:"string"xuvbamvmuoymywx:"string"nvwpbnwojnasgonvnbe:trueeacrpxqeaorubrly:true}{btvxdwkhqa:"string",lehxw:123}{kuaiwmtcwxvtr:123} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_045: -------------------------------------------------------------------------------- 1 | {hmevpkdamecpsjsvfd:"string"gljdplplfssb:123qoscsctvrjqh:"string"gyuouiouemknrueer:true}{hjrumehjhdn:"string"riejetuvqcdpndqccpp:"string",tsowebkhoq:"string"}{rvuqfjwexipyclpnbm:true,dbhvvlmputhjbvof:"string"rdjqmxonevbonouro:true} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_046: -------------------------------------------------------------------------------- 1 | {nxdxojpf:true,anusudkjxjoqtwieds:123dnjrtakojiiyon:123,pvooml:"string"}{cvbejbgbqepylxhcsn:true,rknjatxubkvmoyxm:true,fiescqkofvddhdgo:123} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_047: -------------------------------------------------------------------------------- 1 | {bkbrdtphviecnf:123}{bhjdlqdvqtrmlrrwxhe:"string",rdlcmlc:"string"}{asefajnpgpojptxtre:123,klpblpgsx:"string"jbnvtydadguokqpltk:true,ngrjkjeehlqmrs:"string",}["string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_048: -------------------------------------------------------------------------------- 1 | {vfocaiixiiyc:"string",jngffbty:"string",tdyvfpbi:"string"}{ghjwkxkpwofqqyedwdr:trueffisjrqfkklynloo:"string",hlfbscdvqyvghgoqm:123}{iigdemxetccr:"string",ybofathcwtcpd:"string",}{bamiahswulety:"string"}{kxyctqfukkvplniylw:true,}{vwaosas:"string",fqdhboqufuiob:"string"}{mptrfxkrretqr:123,otanpeisjbotqvedwhk:123}{bkmqcqtlsvynm:trueovdgnikg:"string"} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_049: -------------------------------------------------------------------------------- 1 | {rvcdhd:"string"rmxdjftubwfvnj:"string",}{kpnpwa:"string"qotwctwpdotmfl:truegmvcpnfru:123wgfbqscmco:123,}{mxoecyrw:123,xepnta:truedsnjpiohfjjeprrup:truewikuohwfasopeeqvv:"string"}{fweaicbytcu:123aeegifqbhcer:true,ihcliakhilp:123,}{rbvgj:truelyddkbsbbjlrrme:trueiojxrthyx:123,}{bwyxjoy:"string"}{kyjeboobcpq:"string",qlgtmkuhqtxijtcgk:"string",sikuifbgsynoh:"string",}{epghgffgkpkxmfgfx:"string",}{ejgvuevqresgns:true,ypabtqviwfkip:true,}["string""string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_050: -------------------------------------------------------------------------------- 1 | {hkdfoemovbc:trueckrffnwwsmltxcxp:"string",}{crppqnontgsioe:"string"uhckq:123,gbwwgrtxrbticaxf:123,}{wrpgamvnlvwpfqjl:"string",}{naebjhfyr:123,gsqyfcdacyuxnpq:123wntvjgewavsc:"string",slaqxud:123,}{qrteahtvoaxuwjg:"string"oovbchsofckfg:123,}{puubgpd:trueuulmyxwdqwirrfufvpl:"string"}{eadgy:"string"}{khxjhdhnbqqklvdn:true,kjthfavatva:"string"brpyxsaac:"string"vwsrcsyrweb:"string",}{pbttm:truevyhjklrvnomqsrbwwmx:"string",} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_051: -------------------------------------------------------------------------------- 1 | {fnwxtmkwqcoi:"string",}{lqrqtpllouilmjy:123bdwkawsfgnjxtw:123,}{mxicbkghkgqefvwu:"string"ffgytaeppvtp:true,ipbwetrbobaa:123}{rnjpxyodqrxc:truesmldjtmwvy:"string",}{pyoxlcmjuwv:"string",bfofqbiw:"string"damac:"string"fgjgnqgv:"string"}{srabgkel:true}{iwlbfjakfckamdhpmni:"string",}{mxsbcqnyvhurnsd:"string"grklm:true,uhbbascspgc:truewcsffbwlqumyyq:123,}{pupkxn:"string",fpfprbsmwqmfjayu:123,} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_052: -------------------------------------------------------------------------------- 1 | {vxbeqgq:"string"odedlhpejdsop:"string",} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_053: -------------------------------------------------------------------------------- 1 | {crksdmefqhnqrutgkg:123avvgdefx:true}{tncxweehp:123,ifkqxbhyypavc:"string"jvdylqupfiuj:truethsnvmghc:true,}[true"string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_054: -------------------------------------------------------------------------------- 1 | {cencva:123,pkosowganhvjnw:"string",}{yohfadmglaxsoffyo:"string",ffkpkdtyfietkommv:true,mgkppqehlvqxixv:123nqtfmpfwxu:true}{klapqij:123ktoyjristtlifnrbmg:"string",huknk:truefwkrflhqrnjwvk:true} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_055: -------------------------------------------------------------------------------- 1 | {grfsorhps:true,tvgtushlkkvguepqteu:truewwovh:"string",}{sefeo:"string"qxkauywtmxiyxkk:"string"hfdmhpfwpgpky:true,}{kcurdaegyjwcrppwq:"string"ayhacmxj:"string"tdhgjv:"string"vahhaycjdikbidig:"string"}{sdreibas:truehovhxims:"string"ikyudalejhynq:true,qycjkse:"string"}{laxmytwfkb:"string"junqeqm:"string",uyutynu:"string",ommxbi:"string"} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_056: -------------------------------------------------------------------------------- 1 | {qfrtyjqxckh:123,dbejnvvnfaprg:"string"}{ugcdt:"string",bthcbeabpfycegb:truejnkwiivmke:true}["string"true] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_057: -------------------------------------------------------------------------------- 1 | {asllwvwx:"string",sykslvxhbece:"string",jclkmgvckuwjuhbch:"string",lavgcmeifabolg:"string",}[123,"string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_058: -------------------------------------------------------------------------------- 1 | {yuqstcsrgvsgkyudyy:123hlfhfkmrtnnvieihj:"string",}{cvirmgxv:"string",}{wxpebdkrwxkpmc:truependjxjthnykdqwwf:"string",}[true,123] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_059: -------------------------------------------------------------------------------- 1 | {sqwmwsebwfqyvlpnf:"string"jaymeg:123urisodxhipiye:123harbyixrfplibpwkd:true}{djyyapnbyfadya:true}{axaipavcbummwsf:"string",qphbsdka:true,ytsolpmexlefw:true,}{afpcyfmo:"string"erdtgyknneyii:true,}{igohvkmxtqkmwghisud:"string"dfjjgvqcsxv:"string",}{rpjhmvhtgpghhw:truevcatbmx:"string",byktsqiecbhcyaax:true,bucyankgeexlc:"string"}{kudrytir:"string"}{jdtjnogobx:"string"}["string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_060: -------------------------------------------------------------------------------- 1 | {mddyqsqofuhjitj:"string"mxwwsyqwyhabxyaox:"string"}{dudtaeyugbrat:"string",jwvsfcardkfpulpow:true}{cutfwmefaodyhunjvhq:123rptheykm:"string",}{vcklhjkbgghbw:123,}{rilhqrkylf:123xufjtismtt:123jdxov:123}{lvvbggce:"string",}{fbbii:"string"xqgwlpbonbxuyqgam:123,icoxevurckkrds:true,etjccrxtkk:true,}{tebndtpauogfqhs:"string"pwbcvtx:"string",}[123,"string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_061: -------------------------------------------------------------------------------- 1 | {jgdbgxdsq:"string",gxvyfc:"string"}{sdcicv:"string"}{xnvebjksoc:"string"} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_062: -------------------------------------------------------------------------------- 1 | {sdsxyybgjcjaydvuu:"string",kneirjckyvknr:"string"}{blfxlxxp:"string"bwqsc:"string",rhmcpxwm:true,bwsua:"string",}{toupriphafdhq:true,qkohr:"string"rjcurfsrrwsyly:123,agheblwycbdmaas:"string",}{twqfpp:true}{lrhifpglublku:true,hllevfs:123}{icqvew:true,deamvnrcwmjugdyu:123}{onngdwvqgmnbtbyqnow:trueognihghofgsbve:true,cndxqxci:true}{ulvbe:"string"kuqgarto:"string",pelwcvqxbgje:123bubqfud:"string"} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_063: -------------------------------------------------------------------------------- 1 | {tuwpskcbujlmvccpth:"string",}{exqsopdnqgwhuawxx:123,qaupmqhnlyy:"string"vvirkjfkiokhpecvo:true}{dapeakcnpoekdd:true,}{kexxvbnqtmmimrolnvk:"string"kolbxlujppjkjwom:"string"wifdvwvs:"string"aaverajisbg:"string",}{qhaig:123,gqmeqemcwixwr:"string"tuanr:123,}{pilsmc:123,cnvqmhwlsh:"string"dxgmacarquiw:"string",fvqfsnbjbokmlhmad:"string"}{uulmdafjfabigtobvn:123,dxyrt:"string"}{octmigdboy:true,saodfhlpigwlaj:"string"}["string""string",123] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_064: -------------------------------------------------------------------------------- 1 | {bndwestwxuypj:123,}{ybhymmlamxmsajppy:"string",xbgdeisweoq:truebmddpixboavncgnqpab:true}{tuoyjdrfvurxn:"string"yjuqvbupsa:true}{mqwkmbugsy:"string",rrjshrlbjixk:123jnowdlyjrqlafty:"string",vjnht:true}{upfjcoo:"string"tgrojawdicwxne:123llvsooamtfesqsc:123}{bnbufvixtuh:"string"sohnxywvhfrdbhw:123jvvxrjrpjrjdja:true,qtjcmeoftdlmxjwgoto:"string"}{vgkdvydwbmiydvbbmuj:"string"}["string",123,"string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_065: -------------------------------------------------------------------------------- 1 | {uoikpssjnxy:true}{jrdffgx:"string"}{siroxhbqseflyvw:"string"tnebfxvwreuoqhmceqa:123kjsflxn:123}{onwvbdrtly:"string"elgtjcnbeucv:"string"}{cssvxwnrlvctleabj:123tiixsgvylwpevlneewj:"string",ikifuoe:123}{dcklopinkify:true}{uvjdapulxwfidf:"string",qiyapovphlmtuhnqqo:"string"lgqqgoqsdi:true,dtvcbpeqhklpc:123}{eitefaojwfwsyup:true} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_066: -------------------------------------------------------------------------------- 1 | {puskwvlojquurprueqo:"string",}{bbtkplwjwdvfbk:"string"}{forag:"string",bmwkfxcnbmhpcdhrda:true}{ymfrngbidfgvmysxlh:"string"}{cwduobfmdelijah:"string",kbnie:trueygfcnupgfqrum:123,}[123,"string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_067: -------------------------------------------------------------------------------- 1 | {aymjgyiabaxelntksc:"string",sjtwiixstc:"string",yodaohamt:123,alyym:true}{xtsosjtuhpxqrho:123}{tjhvjqtqvqmlfrn:"string",}{pqbjytu:"string"adkqyahwgnxnlounxw:true,djsjgwdd:123,ujhwbmryve:"string",}{kgwagjsggp:"string"}{hiphjesvscpafpb:true,rbgidvxbj:"string"}{ylskhm:123,hvjexlsrpseod:"string",kdhvknc:"string"}{brqtnpgcvc:"string",bwdgv:truecvcjhlkwgcgk:123,}{asaeuktwagpeeeobt:"string"sgechieml:"string",}["string""string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_068: -------------------------------------------------------------------------------- 1 | {soielfqidsejjlkpg:"string",}{atqcdlhdplcn:"string",wverotpotsabgwjqmpq:truerweqbefb:"string",agsroc:123}{dnnrsfqpxuksonxrks:"string",ofpfrdsqhyjxjqqjeno:true,lqjggtgt:"string"}{rukbgqgxdgmlljbim:123nykpgchboenp:"string"rjamyixehhcej:true,bcsawsafwwkxiiili:true}{txycvgqcedt:"string"visqyl:"string"}[123"string"true,123,] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_069: -------------------------------------------------------------------------------- 1 | {cstoxyvwwerrbcly:true,mrkfyyxq:"string"blxcoammbfmugnnhf:123}{oudktrnm:123,gwqthkootbms:true,lvdymglixjl:true}{ocolocrqqymld:123,}{uwotqtafprakmexnwn:123,xfsedjwuwrfuxtmdd:"string",} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_070: -------------------------------------------------------------------------------- 1 | {hcfmnuaamn:123mpfeiynrhgemmy:"string",fltddovequclg:true,}{jegxthvbxctq:123hxewpxjdbqqnq:true,}{uwfjlhr:"string",alipjatajmsy:trueqtuqmyk:"string"bpvtwyrshf:"string"}{biunwlqdvocmdp:"string"bkptidaqr:"string"}{kgvtavueosp:truelbnshwbpdlinj:123,}{ckhdrlbjmdqlnepidce:"string",tdrhvvqqxlxn:"string"mkhnucakokg:123ebngotlra:"string",}{cprsreafe:truecvjhhgpowbdpkgoa:"string"exsqlhjgbxdwhhxo:123} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_071: -------------------------------------------------------------------------------- 1 | {slhtbrupdgyq:"string",}{wmcmcskllexsupbrwif:"string",cdugdpcywoy:"string",ycxoarvbcsqljfyxqpb:"string",ynadctfttwrmfyfx:"string",}{bnbgwpirvxyd:true,fyefuwcl:"string"ukayhqkykpjmskqkhay:"string",pvrveisodb:true,}{srxunwtysjeicmtiiom:"string",enmwqtpr:"string",}{ctxmnevppyxivqmy:true}{wnvenlxvpf:"string",cjxskggcny:truexenjsclobofcqw:"string"ifcpit:123,}{qiobluw:"string"txfpuwutxtf:"string"lvstgtalgqfyiduscdp:"string"}["string",123] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_072: -------------------------------------------------------------------------------- 1 | {bbyier:"string",egfpfbrjopkqrqedw:"string",}["string"truetrue] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_073: -------------------------------------------------------------------------------- 1 | {sonjsqrmev:"string",wdeqaktimubgaugmrw:"string"yavgn:"string",lfvyvpwsh:"string",}{iqxprhbwaemoylbmh:true,}{olkteohmoxbgt:123tcpcjo:"string",wswxqmprhmqxu:true,}{hxwfansnf:"string"}{vgmffgbysofwwl:123bdgqsewx:"string",rotifdiptt:truenbopksppoiqxg:true,} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_074: -------------------------------------------------------------------------------- 1 | {rbwcy:true}{qjxfervwkgfcverj:truemwwqfmvfagapdwwmna:"string",}{dgjehrumqscmkgcvll:123,syxrvtahapadvllngte:"string",}{kkwbteexjhfkdaei:"string",}{adqatgsyycam:123,hhjdl:"string"}{uoagbrq:true}{dbupwynaxjtblrt:"string",lxhmvxhmclurdserpo:true,exsllncwksw:true,kldthcbqlnkhsfxhp:true,}{nqjpwtffratfem:"string",chndraitgva:"string"xbqevydjoibyha:"string"}["string","string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_075: -------------------------------------------------------------------------------- 1 | {ugjstmlngpw:trueoxljheusxnjna:123nogywi:"string",}{nmagwlxsniqjrtdcsup:123kaslmacbqgoiavbnuc:true,tfvgceenpsskv:"string"}{voawmckwvxpbbrqejmc:"string",mamwxfv:123,fvftivcbf:123,ndkxcmngcwmfvb:123,}{qtjktqlqxpcqrrm:true,}{llgwsqnymltfkaaybbk:true}{trpslfdlim:true,}{jiyjeslxsm:"string",xaxgqcybwmkidxe:true,}[123,"string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_076: -------------------------------------------------------------------------------- 1 | {lacofdgebqogmhmjwaw:"string"}{rjbdgjpnecfdbsb:123ckrdunugsqjwkbw:123,tjaapmtuesjxsvtasx:true,}{gtspp:"string"sxoeonrpdgrjothu:truevlsfkbrsjpv:123}{gfolhbydfdwbf:123gklkixfwd:true,}{wywcppwgxtc:"string"}{gdajfxwjj:"string"}{yxqncog:123,}{lbxuge:"string",bwhhacxpb:123,bdwyvcu:"string",}{hsqqkfhqbhovycd:123}["string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_077: -------------------------------------------------------------------------------- 1 | {mfsmqdyv:trueudwardx:"string"tyerf:"string"}{ufolxrvju:"string",lusubikrnabnl:123,nyhqskenetbnwsvfgbt:"string"}{agujkvikugexaea:"string"tpbcau:"string",}{rpoylewpnro:true}{lvfjyiqd:123,dafmmnvmgknwolisqvi:"string"}{ytylcfkxblsbgmkr:"string"adcfyxfacormxo:123,}[true,true,] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_078: -------------------------------------------------------------------------------- 1 | {bhsxpqjdrfo:"string"sgxlqvvccjeawwcq:true,jlauspjsxdnojav:"string"}{twnvlgqbuol:"string"ceocidjmdxnlkhu:true}{bnymrumayqgm:"string"sqncqakyn:true,demvlmrmurtxv:"string",ihlovc:123}{nnivkau:"string",nuiov:"string",dehhvroosx:"string",}{xthbqtlikhvxiyroy:123,}[true,123,] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_079: -------------------------------------------------------------------------------- 1 | {sjonfmjudtlkvbb:true}{jqdvtodnfaeaiqjqk:123ijiolwfdnihv:123}{olwyfhrl:true}{fwnesxeubimxsfffxcl:true,}{pmyrvaskpeayitansyt:truenuauqj:"string",}{fetwwakefebgp:"string"gowcdrrsm:"string",vrmuadujgkjewablxgt:"string",}{cmggobtwi:"string"}{eggtlkngusmcvc:123,} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_080: -------------------------------------------------------------------------------- 1 | {msgupnjbutmusydx:"string"kvpaoiigqdhweb:true}{fxqqrmbeapegcfr:true,fodevlwygjswx:"string",} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_081: -------------------------------------------------------------------------------- 1 | {nxdurvyxapuqwtb:123,ogsrpcpj:"string",bfxomupfuxcsajevuhn:123,}{gbpek:"string",ekeke:"string"tsnudekkjjekanq:true}{pgqjcdg:"string"atsdoqgcapa:true,}{npgxgrrftbwgng:123,}{jsnswj:123qwwethbtsr:"string",mdnwdsdntrfffodil:123,suhcnykskih:"string"}{kqrqvekpych:"string"}{yingslwcsrwk:trueseieo:123,}[true] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_082: -------------------------------------------------------------------------------- 1 | {fqqbns:"string",gjbqsnvfgyftigou:123,}{obllwspexhoxybxjhg:123,iebvucsatmtjg:123,dbkpkcsxfgrcdrve:123,unmgts:123,}{quxvdpdhwcvxuyt:"string",hxlutoxspslwoife:123}{gnwqjmnjokvil:trueiwwng:truetjqewjkqohcwydbukej:"string",}{hxekdqcgkvardsj:"string"dhmuelhxbjqdeb:"string"qfmkoewpljaf:truetvfqlp:"string"}{ayxufmejwccdk:123syhbio:123}{nlcsy:"string"}{gdcqjqewpaqdgvlor:true,} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_083: -------------------------------------------------------------------------------- 1 | {sxqmvxmwbsjkbqhr:"string"}["string",123,] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_084: -------------------------------------------------------------------------------- 1 | {iujxnaav:"string"rhxyty:"string",jekdistyn:true}{hcxapfskxqwd:truerdeclpuivjaohsnu:"string",tegpxwathjtbfh:"string"ljpawqgilmbr:123,}{hsxajuohhqyieyhjjgh:"string",holfwj:123}["string","string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_085: -------------------------------------------------------------------------------- 1 | {udlyncijknnmpxnu:"string"mtdangnqtfqx:123,plktkah:"string"tkardfmkoil:"string",}{ldtcrbvmxkvsaqnixvv:123,gohwvvqcjtjgsc:"string",}{eqnslrrbmiitgpm:"string",iruyorhsnp:true,shtssgkpojpkl:true,}{objpsc:"string"}{gmnlyltu:true,}{sctbofwvteuqc:"string"flighsnia:"string",}{wplsl:"string",} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_086: -------------------------------------------------------------------------------- 1 | {nulsrik:truelouswfy:"string",aawuclyeffdvdarx:true,}{yjnnki:"string"kydhhaq:true,ylpsg:truelpbcggqlnefixfvlea:123,}{huscvsxgdascldyxv:trueffxchbxq:"string"tmpgcamltdvbksynj:"string",}{eewfppuerecbjhd:"string"uqkblof:123,oosoewahpa:"string",}{rpmfflpq:"string",eikpltlkkyexoah:"string"csdgovphldwx:truetvbamynmdijowcddei:"string"} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_087: -------------------------------------------------------------------------------- 1 | {ypfufetpwfa:123hyvdiloj:123,}{jugjygiitpli:truehtcmhkirgai:123nytbbwmtmxmqfxvf:"string",omdrhjwnwwnyj:true,}{dslariwwxrogjvygq:"string",}{ivuapkw:123,gsitskyekwsund:truewnetomqxbeeedudgfol:123,}{ebpcsuhluq:123pxghxpqo:"string"cpysnkmvisnrfixvlvs:123ekygcmunakmm:123}{ehpuktkygvphifgfg:true,vkoyhf:"string"}{axxhtckpej:truernsblhwnnydfgsfjtwa:truerskfrrdtw:true,utbwfodfpfoax:123} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_088: -------------------------------------------------------------------------------- 1 | {pdcjtimbxmkrlctnvp:"string",}{khtcvjapbibfqskxlvq:123,nixcdj:true,}{akcrnte:123}{tudxlyeoyiewjgug:"string",etbvdiqpley:123}{adbrypihx:truedxukxmrswj:"string",vjtjscpbckeoqvfdix:"string"ymfepbpnlhdppyhld:true}{ymryhrqhejyysb:"string",wdsjwnqw:"string",ukllwasuxsokychrl:123}{uvsuqqvercuhunjjbvu:trueatqqtwmyffss:"string"rwuapdhfq:"string",ibemkngyiqx:"string",}{wnhthgycrhrxm:"string",wfhapcksokuvbsmyh:"string"kfsoynygcphw:123figmr:123,} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_089: -------------------------------------------------------------------------------- 1 | {fibvpltipk:"string",uaxlq:123qjpfbycowrscb:123,}{qaplpuajgrcvhc:123,urjruekjmax:"string"} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_090: -------------------------------------------------------------------------------- 1 | {esnoyghalxk:123,bkfdki:true,uokrupbnimoyh:"string"}{vdqaidxshogk:123,}{jxrhdjhnbxfdbytk:true,}[123] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_091: -------------------------------------------------------------------------------- 1 | {wdfdrs:123,ocanmnn:"string",yyiqvqf:"string",}{cnhgbsnynhcvolru:"string"rsiaol:123ccprgvu:true}{wtjyprmeqasflttpd:true}{pccdmweqtgg:123,hamqrmenurrdomdyrj:123,yrrfkqreevpkctpb:123qsxlxmxvgc:true,}{gqlgewhkumrtd:truekireqvtdnshdiytvsq:"string",}{txkjwbu:"string",hgitcj:"string"twhupbra:"string"nnhhdpq:true}{dtjaurlnmdakkob:"string"fxyosvl:"string"bdapkrlmkwjyx:true,tcnbby:123,}{nrywgcljtgnupwgbays:truempfuwkqbkpxxfbojn:123}["string","string",true"string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_092: -------------------------------------------------------------------------------- 1 | {wpwdlpb:true,veoubrrjapr:123nwufvpviiwjls:"string"}{nprrbnsjrnkhd:true,}[123,123true"string"] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_093: -------------------------------------------------------------------------------- 1 | {ptkwcrnuwrhmsumd:trueyprleunuwarpdjxdn:true,ulbanqcjkbfdomlc:"string"} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_094: -------------------------------------------------------------------------------- 1 | {atnsnjrvekkqof:123sgibflq:true}{wobcwobcgf:true,bcavlaydng:"string",}{ybxofltpnfbhedtpu:"string"yirtfabtoanlkighy:"string"kjvosv:123}{argnnxdmcne:"string",umqfwmfppvbu:truegakgqnikgysbpft:true,}{etyksd:123,uxhal:"string"eaebcvsmgq:true}{axagnjjygcqugmrmn:true,}{hhvhfxyywbxfryu:true}{nkpirdmcddqowp:123wwhrautsyarusdhousr:"string"}{vyncwiscst:"string",} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_095: -------------------------------------------------------------------------------- 1 | {ytarhitxbx:true}{xqghfdgiyy:123}{alwtjpuleek:"string",fscchwuqjsxwmblpb:123,}{hsubaocrjjfnhj:123kjtknrwgtsgfppt:"string",qrtkbwdmwka:123}{cpyii:"string"tpxbtuggpdkej:"string",}{kegtqqcjmypsfseacnv:true,hneoiejis:"string"vmcsbufvfkx:"string"}{thntx:"string",jxplvkuhvvutaegl:"string",}{kskhhgevovcwcbqq:truebcrbvudkbxagpajhygv:123}{boacuxtbn:"string",exucqxskloswtponife:true,qnkqbescgnokx:"string"}["string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_096: -------------------------------------------------------------------------------- 1 | {merwtbvgxxcfxfrdq:"string",hkffmeqlnegx:truetmxesqndppnrl:123ylgmyicfv:true}{fuyliyrtkmvlhvbe:truehaaikwwrqbijkexexkv:123fxnpwxeqtbdelf:"string"}{lcruqwbisah:"string",hexhguywxexgujih:"string",}{ocmamthfmvambks:trueocsuniqcwxnvk:"string"vjmssh:123,}{gkivmemejuxcxkyur:123hwuxvkquauqxga:truetfxjayvbb:"string"}{vfwsplhbhtaoeroqspt:123,bhhtifjqyamdlpmkbac:true,tgcygufcnialuq:123,}{ilyjjmbpp:"string",brfclf:trueetydeqnil:"string"nhcno:"string"}{vxwavgbxudhwn:trueonovllatprm:123,} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_097: -------------------------------------------------------------------------------- 1 | {cjdgfbtwqxkkbe:true,yftxehpyefmgevbs:trueksminufk:true,bbatyltdkew:true}{fejhydipvwxfktcgfaj:"string"}{aejss:true,}{oqbxpuhobqjfnsla:trueecrarwuihyhdm:"string"rodqgmkgvphe:123nvsbaepxpab:"string",} -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_098: -------------------------------------------------------------------------------- 1 | {eroiauhiiue:"string",dokgedsoafcec:"string",ikqcneterdu:"string"tlcdsxkoksdqukw:"string"}{kotyvttccntpr:truexghifyrbietkoxxhg:true,pvnehcwqedujgqt:true}[true123,"string",] -------------------------------------------------------------------------------- /Corpus/generative_corpus/fuzz_corpus/sample_099: -------------------------------------------------------------------------------- 1 | {moshgmmpbhfebqj:"string"elvtlasdny:123uehepjsnybswh:"string"ulgpvl:"string"}{widsx:"string",kbbxpmdjxhsjwr:123,jlhkvakystkc:true,}{yisquqtroyfew:123,dujjtodktjxynac:123}{dwtqlcsjjpwhdm:"string"}{vvabxqaqam:123ctxhvo:"string"nxekgdjvuixyy:"string"cewclr:true}{xcimxpiwfxhrwihpw:"string"ilparmdmrue:"string",jopffkleklctmw:"string",ansjm:"string"}{cqpnbgdtluu:"string",bdveo:123}{onxda:"string"errysiohuse:"string",tamvfirul:true,}["string"123,] -------------------------------------------------------------------------------- /Corpus/generative_corpus/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::{fs, io}; 2 | use rand::Rng; 3 | use rand::rngs::ThreadRng; 4 | use std::fs::File; 5 | use std::io::Write; 6 | 7 | fn main() { 8 | let corpus = generate_corpus(); 9 | store_corpus(&corpus); 10 | } 11 | 12 | // Generate corpus samples 13 | fn generate_corpus() -> Vec> { 14 | 15 | let mut corpus = vec![]; 16 | let mut rng = rand::thread_rng(); 17 | // Generate JSON samples 18 | for i in 0..100 { 19 | let json = generate_json(&mut rng); 20 | corpus.push(json); 21 | } 22 | // Generate more sample types 23 | // PNG, CSV, XML, MP4, etc 24 | corpus 25 | } 26 | 27 | // Generate random valid JSON 28 | fn generate_json(rng: &mut ThreadRng) -> Vec { 29 | 30 | let mut json = vec![]; 31 | // Randomly generate JSON objects 32 | let num_objects = rng.gen_range(1..10); 33 | for _ in 0..num_objects { 34 | json.push(b'{'); 35 | let num_fields = rng.gen_range(1..5); 36 | for _ in 0..num_fields { 37 | generate_random_string(rng, &mut json); // key 38 | json.push(b':'); 39 | generate_random_value(rng, &mut json); // value 40 | if rng.gen_bool(0.5) { 41 | json.push(b','); 42 | } 43 | } 44 | json.push(b'}'); 45 | } 46 | // Add array 47 | if rng.gen_bool(0.5) { 48 | json.push(b'['); 49 | let num_elements = rng.gen_range(1..5); 50 | for _ in 0..num_elements { 51 | generate_random_value(rng, &mut json); 52 | if rng.gen_bool(0.5) { 53 | json.push(b','); 54 | } 55 | } 56 | json.push(b']'); 57 | } 58 | json 59 | } 60 | 61 | // Generate random strings 62 | fn generate_random_string(rng: &mut ThreadRng, vec: &mut Vec) { 63 | // Generate random length and characters 64 | let len = rng.gen_range(5..20); 65 | for _ in 0..len { 66 | vec.push(rng.gen_range(b'a'..b'z')); 67 | } 68 | } 69 | 70 | // Generate random values 71 | fn generate_random_value(rng: &mut ThreadRng, vec: &mut Vec) { 72 | // Randomly generate primitive values 73 | if rng.gen_bool(0.5) { 74 | vec.extend_from_slice(b"\"string\""); 75 | } else if rng.gen_bool(0.5) { 76 | vec.extend_from_slice(b"123"); 77 | } else { 78 | vec.extend_from_slice(b"true"); 79 | } 80 | } 81 | 82 | // Save generated corpus to disk 83 | fn store_corpus(corpus: &[Vec]) { 84 | let corpus_dir = "fuzz_corpus"; 85 | create_dir_all(corpus_dir).unwrap(); 86 | for (i, sample) in corpus.iter().enumerate() { 87 | let file_name = format!("{}/sample_{:03}", corpus_dir, i); 88 | let mut file = File::create(file_name).unwrap(); 89 | file.write_all(sample).unwrap(); 90 | } 91 | println!("Stored {} samples in {}", corpus.len(), corpus_dir); 92 | } 93 | 94 | fn create_dir_all(path: &str) -> io::Result<()> { 95 | fs::create_dir_all(path) 96 | } -------------------------------------------------------------------------------- /Corpus/hybrid_corpus/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "hybrid_corpus" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /Corpus/hybrid_corpus/README.md: -------------------------------------------------------------------------------- 1 | # Hybrid corpus 2 | 3 | * _A corpus may contain a mix of valid and invalid samples. This provides inputs the application should handle and inputs it should reject._ 4 | 5 | 6 | # Build 7 | 8 | ```bash 9 | $ cargo run . 10 | ``` 11 | 12 | # Output 13 | ```bash 14 | [13:01] raminfp@zenbook:hybrid_corpus (main *%) # cargo run . 15 | Compiling hybrid_corpus v0.1.0 (/home/raminfp/IdeaProjects/Corpus/hybrid_corpus) 16 | Finished dev [unoptimized + debuginfo] target(s) in 0.26s 17 | Running `target/debug/hybrid_corpus .` 18 | Created hybrid corpus in hybrid_corpus 19 | [13:01] raminfp@zenbook:hybrid_corpus (main *%) # exa hybrid_corpus 20 | invalid.png truncated.jpg valid.jpg valid.png 21 | 22 | ``` -------------------------------------------------------------------------------- /Corpus/hybrid_corpus/hybrid_corpus/invalid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/hybrid_corpus/hybrid_corpus/invalid.png -------------------------------------------------------------------------------- /Corpus/hybrid_corpus/hybrid_corpus/truncated.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/hybrid_corpus/hybrid_corpus/truncated.jpg -------------------------------------------------------------------------------- /Corpus/hybrid_corpus/hybrid_corpus/valid.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/hybrid_corpus/hybrid_corpus/valid.jpg -------------------------------------------------------------------------------- /Corpus/hybrid_corpus/hybrid_corpus/valid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/hybrid_corpus/hybrid_corpus/valid.png -------------------------------------------------------------------------------- /Corpus/hybrid_corpus/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::fs; 2 | use std::io::Write; 3 | 4 | fn main() { 5 | 6 | let corpus_dir = "hybrid_corpus"; 7 | fs::create_dir_all(corpus_dir).unwrap(); 8 | 9 | // Valid samples 10 | let valid_png = include_bytes!("valid.png"); 11 | fs::write(format!("{}/valid.png", corpus_dir), valid_png).unwrap(); 12 | 13 | let valid_jpg = include_bytes!("valid.jpg"); 14 | fs::write(format!("{}/valid.jpg", corpus_dir), valid_jpg).unwrap(); 15 | 16 | // Invalid samples 17 | let invalid_png = corrupt_png(valid_png); 18 | fs::write(format!("{}/invalid.png", corpus_dir), invalid_png).unwrap(); 19 | 20 | let truncated_jpg = truncate_sample(valid_jpg, 100); 21 | fs::write(format!("{}/truncated.jpg", corpus_dir), truncated_jpg).unwrap(); 22 | 23 | println!("Created hybrid corpus in {}", corpus_dir); 24 | } 25 | 26 | // Corrupt valid PNG 27 | fn corrupt_png(png: &[u8]) -> Vec { 28 | let mut corrupted = png.to_vec(); 29 | corrupted[5] = 0; // corrupt signature 30 | corrupted 31 | } 32 | 33 | // Truncate sample 34 | fn truncate_sample(data: &[u8], len: usize) -> Vec { 35 | data[..len].to_vec() 36 | } -------------------------------------------------------------------------------- /Corpus/hybrid_corpus/src/valid.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/hybrid_corpus/src/valid.jpg -------------------------------------------------------------------------------- /Corpus/hybrid_corpus/src/valid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/hybrid_corpus/src/valid.png -------------------------------------------------------------------------------- /Corpus/in_memory_corpus/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "in_memory_corpus" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Corpus/in_memory_corpus/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | use std::collections::HashSet; 3 | use rand::prelude::IteratorRandom; 4 | 5 | struct Fuzzer { 6 | corpus: HashSet> 7 | } 8 | 9 | impl Fuzzer { 10 | fn new() -> Fuzzer { 11 | Fuzzer { 12 | corpus: HashSet::new(), 13 | } 14 | } 15 | 16 | fn fuzz(&mut self) -> Vec { 17 | let mut buffer = Vec::new(); 18 | if let Some(seed) = self.corpus.iter().choose(&mut rand::thread_rng()) { 19 | buffer.extend_from_slice(seed); 20 | } 21 | 22 | for _ in 0..100 { 23 | let r = rand::thread_rng().gen_range(0..=255); 24 | buffer.push(r as u8) 25 | } 26 | self.corpus.insert(buffer.clone()); 27 | buffer 28 | } 29 | 30 | } 31 | 32 | fn main() { 33 | let mut fuzzer = Fuzzer::new(); 34 | let seed = b"hello"; 35 | fuzzer.corpus.insert(seed.to_vec()); 36 | for _ in 0..100 { 37 | let input = fuzzer.fuzz(); 38 | println!("{:?}", input); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /Corpus/seed_corpus/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "seed_corpus" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Corpus/seed_corpus/README.md: -------------------------------------------------------------------------------- 1 | # Seed Corpus 2 | 3 | _* _A seed corpus contains a small set of valid and invalid samples to bootstrap the fuzzing process. The fuzzer mutates these initial seeds to expand code coverage.__ 4 | 5 | 6 | # Build 7 | 8 | ```bash 9 | $ cargo run . 10 | ``` 11 | 12 | # Output 13 | ```bash 14 | [13:02] raminfp@zenbook:seed_corpus (main *%) # cargo run . 15 | Updating crates.io index 16 | Finished dev [unoptimized + debuginfo] target(s) in 3.12s 17 | Running `target/debug/seed_corpus .` 18 | Created seed corpus in seed_corpus 19 | [13:03] raminfp@zenbook:seed_corpus (main *%) # exa seed_corpus 20 | seed1.txt seed2.txt seed3.txt 21 | ``` 22 | 23 | -------------------------------------------------------------------------------- /Corpus/seed_corpus/seed_corpus/seed1.txt: -------------------------------------------------------------------------------- 1 | Hello -------------------------------------------------------------------------------- /Corpus/seed_corpus/seed_corpus/seed2.txt: -------------------------------------------------------------------------------- 1 | Hello -------------------------------------------------------------------------------- /Corpus/seed_corpus/seed_corpus/seed3.txt: -------------------------------------------------------------------------------- 1 |  -------------------------------------------------------------------------------- /Corpus/seed_corpus/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::fs; 2 | use std::io::Write; 3 | 4 | fn main() { 5 | let corpus_dir = "seed_corpus"; 6 | fs::create_dir(corpus_dir).unwrap(); 7 | 8 | // A valid text sample 9 | let mut file = fs::File::create(format!("{}/seed1.txt", corpus_dir)).unwrap(); 10 | file.write_all(b"Hello").unwrap(); 11 | // Another valid text sample 12 | let mut file1 = fs::File::create(format!("{}/seed2.txt", corpus_dir)).unwrap(); 13 | file1.write_all(b"Hello").unwrap(); 14 | // A short binary file 15 | let mut file3 = fs::File::create(format!("{}/seed3.txt", corpus_dir)).unwrap(); 16 | file3.write_all(&[0x01, 0x02, 0x02]).unwrap(); 17 | 18 | println!("Created seed corpus in {}", corpus_dir); 19 | 20 | } 21 | -------------------------------------------------------------------------------- /Corpus/targeted_corpus/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "targeted_corpus" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | -------------------------------------------------------------------------------- /Corpus/targeted_corpus/README.md: -------------------------------------------------------------------------------- 1 | # Targeted corpus? 2 | 3 | * **A corpus can be tailored to focus on a specific feature or component of the target application. This allows more targeted fuzzing.** 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | ```bash 13 | [13:05] raminfp@zenbook:targeted_corpus (main +*%) # cargo run . 14 | Compiling targeted_corpus v0.1.0 (/home/raminfp/IdeaProjects/Corpus/targeted_corpus) 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.26s 16 | Running `target/debug/targeted_corpus .` 17 | Created image corpus in image_corpus 18 | [13:05] raminfp@zenbook:targeted_corpus (main +*%) # exa image_corpus/ 19 | invalid.png valid.png 20 | ``` 21 | -------------------------------------------------------------------------------- /Corpus/targeted_corpus/image_corpus/invalid.png: -------------------------------------------------------------------------------- 1 | IHDR -------------------------------------------------------------------------------- /Corpus/targeted_corpus/image_corpus/valid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Corpus/targeted_corpus/image_corpus/valid.png -------------------------------------------------------------------------------- /Coverage/README.md: -------------------------------------------------------------------------------- 1 | # Coverage 2 | 3 | * _Coverage-guided fuzzing is a technique that uses code coverage feedback to guide and optimize the test case generation process in fuzzing._ -------------------------------------------------------------------------------- /Coverage/basic_feedback_driven/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "basic_feedback_driven" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Coverage/basic_feedback_driven/README.md: -------------------------------------------------------------------------------- 1 | # Basic Feedback Driven 2 | 3 | * _A feedback driven fuzzer is a type of fuzz testing tool that uses feedback from the target program to guide and optimize its test case generation_ 4 | 5 | 6 | # Build 7 | 8 | ```bash 9 | $ cargo run . 10 | ``` 11 | 12 | # Output 13 | 14 | ```bash 15 | [13:10] raminfp@zenbook:basic_feedback_driven (main *%) # cargo run . 16 | Compiling basic_feedback_driven v0.1.0 (/home/raminfp/IdeaProjects/Coverage/basic_feedback_driven) 17 | Finished dev [unoptimized + debuginfo] target(s) in 0.26s 18 | Running `target/debug/basic_feedback_driven .` 19 | Coverage Length: 0 20 | Coverage Length: 0 21 | Coverage Length: 1 22 | Coverage Length: 1 23 | Coverage Length: 1 24 | Coverage Length: 2 25 | Coverage Length: 2 26 | Coverage Length: 2 27 | Coverage Length: 2 28 | Coverage Length: 3 29 | Coverage Length: 4 30 | Coverage Length: 4 31 | Coverage Length: 5 32 | Coverage Length: 5 33 | Coverage Length: 6 34 | Coverage Length: 7 35 | Coverage Length: 7 36 | Coverage Length: 7 37 | Coverage Length: 8 38 | Coverage Length: 9 39 | Coverage Length: 9 40 | Coverage Length: 10 41 | Coverage Length: 10 42 | Coverage Length: 10 43 | Coverage Length: 11 44 | Coverage Length: 11 45 | Coverage Length: 11 46 | Coverage Length: 12 47 | Coverage Length: 13 48 | ``` -------------------------------------------------------------------------------- /Coverage/basic_feedback_driven/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | use rand::prelude::SliceRandom; 3 | 4 | // A simple function to fuzz 5 | fn target_function(input: &[u8]) -> bool { 6 | // Dummy implementation: Return true if the input has an even number of bytes 7 | input.len() % 2 == 0 8 | } 9 | 10 | // Feedback-driven fuzzer 11 | fn feedback_driven_fuzz() { 12 | let mut rng = rand::thread_rng(); 13 | let mut corpus: Vec> = Vec::new(); 14 | let mut coverage: Vec> = Vec::new(); 15 | 16 | loop { 17 | // Generate or select a test case from the corpus 18 | let input = if rng.gen_bool(0.5) || corpus.is_empty() { 19 | // Generate a new random test case 20 | let new_input = random_input(&mut rng); 21 | corpus.push(new_input.clone()); 22 | new_input 23 | } else { 24 | // Select a test case from the corpus randomly 25 | corpus.choose(&mut rng).unwrap().clone() 26 | }; 27 | 28 | // Execute the target function with the selected input 29 | let result = target_function(&input); 30 | 31 | // Collect feedback based on code coverage (for this simple example, we only check if the result is true) 32 | if result { 33 | coverage.push(input); 34 | } 35 | 36 | // Do some selection logic here (for this example, we just print the coverage) 37 | println!("Coverage Length: {}", coverage.len()); 38 | 39 | // In a real fuzzer, you would apply mutation strategies, reduce test cases, etc. 40 | // But we skip those details for simplicity in this example. 41 | } 42 | } 43 | 44 | // Generate random input 45 | fn random_input(rng: &mut rand::prelude::ThreadRng) -> Vec { 46 | let length = rng.gen_range(1..=30); 47 | rng.sample_iter(rand::distributions::Standard).take(length).collect() 48 | } 49 | 50 | fn main() { 51 | feedback_driven_fuzz(); 52 | } 53 | -------------------------------------------------------------------------------- /Coverage/block_coverage/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "block_coverage" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Coverage/block_coverage/README.md: -------------------------------------------------------------------------------- 1 | # Block Coverage 2 | 3 | * _A block coverage fuzzer is a type of feedback-driven fuzzer that uses block coverage feedback to guide its test case generation and mutation._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [13:13] raminfp@zenbook:block_coverage (main *%) # cargo run . 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.00s 16 | Running `target/debug/block_coverage .` 17 | Starting fuzzing... 18 | 19 | 20 | ``` -------------------------------------------------------------------------------- /Coverage/block_coverage/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::{thread_rng, Rng}; 2 | use std::collections::HashSet; 3 | 4 | fn function(input: &str) -> i32 { 5 | 6 | let mut x = 0; 7 | 8 | if input.starts_with("a") { // block 1 9 | x += 1; 10 | } else { 11 | x -= 1; 12 | } 13 | 14 | if input.ends_with("z") { // block 2 15 | x += 2; 16 | } else { 17 | x -= 2; 18 | } 19 | 20 | if input.contains("hello") { // block 3 21 | x += 3; 22 | } 23 | 24 | x // return 25 | 26 | } 27 | 28 | struct BlockCoverageFuzzer { 29 | coverage: HashSet, 30 | } 31 | 32 | impl BlockCoverageFuzzer { 33 | 34 | fn new() -> Self { 35 | Self { 36 | coverage: HashSet::new(), 37 | } 38 | } 39 | 40 | fn fuzz(&mut self) { 41 | 42 | let mut rng = thread_rng(); 43 | 44 | loop { 45 | 46 | let mut input = String::new(); 47 | for _ in 0..20 { 48 | input.push(rng.gen()); 49 | } 50 | 51 | let blocks = self.analyze(&input); 52 | self.coverage.extend(blocks); 53 | 54 | if self.coverage.len() == 3 { 55 | break; 56 | } 57 | 58 | } 59 | 60 | } 61 | 62 | fn analyze(&self, input: &str) -> Vec { 63 | 64 | let mut covered = vec![]; 65 | 66 | let x = function(input); 67 | 68 | if x != 0 { 69 | covered.push(1); // block 1 70 | } 71 | 72 | if x.abs() == 2 { 73 | covered.push(2); // block 2 74 | } 75 | 76 | if x >= 3 { 77 | covered.push(3); // block 3 78 | } 79 | 80 | covered 81 | 82 | } 83 | 84 | } 85 | 86 | fn main() { 87 | 88 | let mut fuzzer = BlockCoverageFuzzer::new(); 89 | 90 | println!("Starting fuzzing..."); 91 | 92 | fuzzer.fuzz(); 93 | 94 | println!("Total blocks covered: {}", fuzzer.coverage.len()); 95 | println!("Coverage: {:?}", fuzzer.coverage); 96 | 97 | if fuzzer.coverage.len() == 3 { 98 | println!("Achieved full block coverage!"); 99 | } else { 100 | println!("Did not achieve full coverage"); 101 | } 102 | 103 | } -------------------------------------------------------------------------------- /Coverage/branch_coverage/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "branch_coverage" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Coverage/branch_coverage/README.md: -------------------------------------------------------------------------------- 1 | # Branch Coverage 2 | 3 | * _A branch coverage fuzzer is a more advanced form of feedback-driven fuzzer that uses branch coverage feedback to guide its test case generation._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [13:14] raminfp@zenbook:branch_coverage (main *%) # cargo run . 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.04s 16 | Running `target/debug/branch_coverage .` 17 | ``` -------------------------------------------------------------------------------- /Coverage/branch_coverage/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::{thread_rng, Rng}; 2 | use std::collections::HashSet; 3 | 4 | fn function(input: &str) -> i32 { 5 | 6 | let mut result = 0; 7 | 8 | if input.len() > 10 { 9 | result += 1; 10 | } 11 | 12 | if input.contains('a') { 13 | result += 2; 14 | } else { 15 | result -= 1; 16 | } 17 | 18 | result 19 | 20 | } 21 | 22 | struct BranchCoverageFuzzer { 23 | coverage: HashSet, 24 | } 25 | 26 | impl BranchCoverageFuzzer { 27 | 28 | fn new() -> Self { 29 | Self { 30 | coverage: HashSet::new(), 31 | } 32 | } 33 | 34 | fn fuzz(&mut self) { 35 | 36 | let mut rng = thread_rng(); 37 | 38 | loop { 39 | 40 | let mut input = String::new(); 41 | for _ in 0..20 { 42 | input.push(rng.gen()); 43 | } 44 | 45 | let branches = self.analyze(&input); 46 | self.coverage.extend(branches); 47 | 48 | if self.coverage.len() == 3 { 49 | break; 50 | } 51 | 52 | } 53 | } 54 | 55 | fn analyze(&self, input: &str) -> Vec { 56 | 57 | let mut covered = vec![]; 58 | 59 | let result = function(input); 60 | 61 | if result > 0 { 62 | covered.push(1); 63 | } 64 | 65 | if result == 2 { 66 | covered.push(2); 67 | } else if result < 0 { 68 | covered.push(3); 69 | } 70 | 71 | covered 72 | 73 | } 74 | 75 | } 76 | 77 | fn main() { 78 | 79 | let mut fuzzer = BranchCoverageFuzzer::new(); 80 | 81 | fuzzer.fuzz(); 82 | 83 | println!("Total branches covered: {}", fuzzer.coverage.len()); 84 | println!("Coverage: {:?}", fuzzer.coverage); 85 | 86 | } -------------------------------------------------------------------------------- /Coverage/feedback_driven_fuzzing/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "feedback_driven_fuzzing" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Coverage/feedback_driven_fuzzing/README.md: -------------------------------------------------------------------------------- 1 | # Feedback Driven Fuzzing 2 | 3 | * _Feedback-driven fuzzing is a software testing technique that uses feedback from the target program to guide and optimize the fuzzing process for maximum effectiveness._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [13:16] raminfp@zenbook:feedback_driven_fuzzing (main *%) # cargo run . | more 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.00s 16 | Running `target/debug/feedback_driven_fuzzing .` 17 | Starting fuzzing... 18 | Fuzzer cycles: 100 19 | Corpus size: 99 20 | Unique coverages: 99 21 | Fuzzer cycles: 200 22 | Corpus size: 199 23 | Unique coverages: 199 24 | Fuzzer cycles: 300 25 | Corpus size: 299 26 | Unique coverages: 299 27 | Fuzzer cycles: 400 28 | Corpus size: 399 29 | Unique coverages: 399 30 | Fuzzer cycles: 500 31 | Corpus size: 499 32 | Unique coverages: 499 33 | Fuzzer cycles: 600 34 | Corpus size: 599 35 | Unique coverages: 599 36 | Fuzzer cycles: 700 37 | Corpus size: 699 38 | Unique coverages: 699 39 | Fuzzer cycles: 800 40 | Corpus size: 799 41 | Unique coverages: 799 42 | Fuzzer cycles: 900 43 | Corpus size: 899 44 | Unique coverages: 899 45 | Fuzzer cycles: 1000 46 | 47 | ``` -------------------------------------------------------------------------------- /Coverage/function_coverage/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "function_coverage" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Coverage/function_coverage/README.md: -------------------------------------------------------------------------------- 1 | # Function Coverage 2 | 3 | * _Function coverage is a code coverage metric used in fuzzing that tracks whether each function in the code has been executed at least once by the test inputs generated_ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [13:17] raminfp@zenbook:function_coverage (main *%) # cargo run . 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.04s 16 | Running `target/debug/function_coverage .` 17 | Coverage: {2, 1} 18 | 19 | ``` -------------------------------------------------------------------------------- /Coverage/function_coverage/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::{thread_rng, Rng}; 2 | use std::collections::HashSet; 3 | 4 | fn function_1(input: &str) -> bool { 5 | input.len() > 5 6 | } 7 | 8 | fn function_2(input: &str) -> i32 { 9 | if input.contains("a") { 10 | 1 11 | } else { 12 | -1 13 | } 14 | } 15 | 16 | struct FunctionCoverageFuzzer { 17 | coverage: HashSet, 18 | } 19 | 20 | impl FunctionCoverageFuzzer { 21 | 22 | fn new() -> Self { 23 | Self { 24 | coverage: HashSet::new(), 25 | } 26 | } 27 | 28 | fn fuzz(&mut self) { 29 | let mut rng = thread_rng(); 30 | 31 | loop { 32 | let rng = rng.clone(); // clone rng here 33 | let input: String = rng.sample_iter(&rand::distributions::Alphanumeric) 34 | .take(30) 35 | .map(char::from) 36 | .collect(); 37 | 38 | if function_1(&input) { 39 | self.coverage.insert(1); 40 | } 41 | 42 | let num = function_2(&input); 43 | if num != 0 { 44 | self.coverage.insert(2); 45 | } 46 | 47 | if self.coverage.len() == 2 { 48 | break; 49 | } 50 | } 51 | } 52 | 53 | } 54 | 55 | 56 | fn main() { 57 | let mut fuzzer = FunctionCoverageFuzzer::new(); 58 | fuzzer.fuzz(); 59 | 60 | println!("Coverage: {:?}", fuzzer.coverage); 61 | } -------------------------------------------------------------------------------- /Coverage/loop_coverage/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "loop_coverage" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Coverage/loop_coverage/README.md: -------------------------------------------------------------------------------- 1 | # Loop Coverage 2 | 3 | * _Loop coverage is a code coverage metric used in fuzzing that focuses on executing the loops in the code under test._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [13:17] raminfp@zenbook:loop_coverage (main *%) # cargo run . 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.01s 16 | Running `target/debug/loop_coverage .` 17 | Starting fuzzing... 18 | Total loops covered: 3 19 | Coverage: {3, 2, 1} 20 | Achieved full loop coverage! 21 | 22 | ``` -------------------------------------------------------------------------------- /Coverage/loop_coverage/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::{thread_rng, Rng}; 2 | use std::collections::HashSet; 3 | 4 | fn function(input: &str) { 5 | 6 | let mut sum = 0; 7 | 8 | for chr in input.chars() { // loop 1 9 | sum += chr as i32; 10 | } 11 | 12 | let mut i = 0; 13 | while i < input.len() { // loop 2 14 | sum += i as i32; 15 | i += 1; 16 | } 17 | 18 | loop { // loop 3 19 | sum += 1; 20 | break; 21 | } 22 | 23 | } 24 | 25 | struct LoopCoverageFuzzer { 26 | coverage: HashSet, 27 | } 28 | 29 | impl LoopCoverageFuzzer { 30 | 31 | fn new() -> Self { 32 | Self { 33 | coverage: HashSet::new(), 34 | } 35 | } 36 | 37 | fn fuzz(&mut self) { 38 | 39 | let mut rng = thread_rng(); 40 | 41 | loop { 42 | let rng = rng.clone(); 43 | let input: String = rng.sample_iter(&rand::distributions::Alphanumeric) 44 | .take(30) 45 | .map(char::from) 46 | .collect(); 47 | 48 | let loops = self.analyze(&input); 49 | self.coverage.extend(loops); 50 | 51 | if self.coverage.len() == 3 { 52 | break; 53 | } 54 | 55 | } 56 | 57 | } 58 | 59 | fn analyze(&self, input: &str) -> Vec { 60 | 61 | let mut covered = vec![]; 62 | 63 | function(input); 64 | 65 | if !input.is_empty() { 66 | covered.push(1); // for loop 67 | } 68 | 69 | if input.len() > 0 { 70 | covered.push(2); // while loop 71 | } 72 | 73 | covered.push(3); // infinite loop 74 | 75 | covered 76 | 77 | } 78 | 79 | } 80 | 81 | fn main() { 82 | let mut fuzzer = LoopCoverageFuzzer::new(); 83 | 84 | println!("Starting fuzzing..."); 85 | 86 | fuzzer.fuzz(); 87 | 88 | println!("Total loops covered: {}", fuzzer.coverage.len()); 89 | println!("Coverage: {:?}", fuzzer.coverage); 90 | 91 | if fuzzer.coverage.len() == 3 { 92 | println!("Achieved full loop coverage!"); 93 | } else { 94 | println!("Did not achieve full coverage"); 95 | } 96 | } -------------------------------------------------------------------------------- /Coverage/path_coverage/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "path_coverage" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Coverage/path_coverage/README.md: -------------------------------------------------------------------------------- 1 | # Path Coverage 2 | 3 | * _Path coverage is an advanced code coverage metric used in fuzzing that tracks exercised program execution paths through the code._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [13:18] raminfp@zenbook:path_coverage (main *%) # cargo run . 15 | Compiling path_coverage v0.1.0 (/home/raminfp/IdeaProjects/Coverage/path_coverage) 16 | Finished dev [unoptimized + debuginfo] target(s) in 0.41s 17 | Running `target/debug/path_coverage .` 18 | Fuzzing: input = short, path = 2 19 | Fuzzing: input = short, path = 2 20 | Fuzzing: input = short, path = 2 21 | Fuzzing: input = , path = 0 22 | Fuzzing: input = short, path = 2 23 | Fuzzing: input = 􏕟𚑋緙𹫆󓮴򊙞񳎑򈐸𕦦󷸦򃱆񰂾񬗲򥥮󁚾䡿􃄛񆝟򩇆򜻩, path = 1 24 | Coverage: {1, 2, 0} 25 | 26 | ``` -------------------------------------------------------------------------------- /Coverage/path_coverage/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | use std::collections::HashSet; 3 | 4 | /* 5 | fn process(input: &str) -> i32 { 6 | if input.is_empty() { 7 | return -1; 8 | } 9 | 10 | if input.len() > 10 { 11 | return 1; 12 | } 13 | 14 | 0 15 | } 16 | 17 | Input is empty -> return -1 18 | Input length > 10 -> return 1 19 | All other inputs -> return 0 20 | 21 | #[test] 22 | fn test_process() { 23 | assert_eq!(process(""), -1); // path 1 24 | assert_eq!(process("hello"), 0); // path 3 25 | assert_eq!(process("long input"), 1); // path 2 26 | } 27 | 28 | */ 29 | 30 | #[derive(Debug, PartialEq)] 31 | enum Status { 32 | Ok, 33 | Err, 34 | } 35 | 36 | fn process(input: &str) -> Status { 37 | if input.is_empty() { // path 0 38 | Status::Err 39 | } else if input.len() > 10 { // Path 1 40 | Status::Ok 41 | } else { 42 | Status::Err // Path 2 43 | } 44 | } 45 | 46 | struct PathCoverageFuzzer { 47 | coverage: HashSet, 48 | } 49 | 50 | impl PathCoverageFuzzer { 51 | 52 | fn new() -> Self { 53 | Self { 54 | coverage: HashSet::new(), 55 | } 56 | } 57 | 58 | fn fuzz(&mut self) { 59 | let mut rng = rand::thread_rng(); 60 | 61 | loop { 62 | let input = match rng.gen_range(0..4) { 63 | 0 => "".to_string(), // empty string 64 | 1 => { // long string 65 | let mut s = String::new(); 66 | for _ in 0..20 { 67 | s.push(rng.gen::()); 68 | } 69 | s 70 | } 71 | _ => "short".to_string(), // short string 72 | }; 73 | let path = self.analyze(&input); 74 | println!("Fuzzing: input = {}, path = {}", input, path); 75 | 76 | self.coverage.insert(path); 77 | 78 | if self.coverage.len() == 3 { 79 | break; 80 | } 81 | } 82 | } 83 | 84 | fn analyze(&self, input: &str) -> usize { 85 | match process(input) { 86 | Status::Err if input.is_empty() => 0, 87 | Status::Ok if input.len() > 10 => 1, 88 | // Status::Ok if input.contains('a') => 2, 89 | Status::Err => 2, 90 | Status::Ok => 3 91 | } 92 | } 93 | 94 | } 95 | 96 | fn main() { 97 | let mut fuzzer = PathCoverageFuzzer::new(); 98 | fuzzer.fuzz(); 99 | 100 | println!("Coverage: {:?}", fuzzer.coverage); 101 | // Output : Coverage: {2, 0, 1} 102 | } -------------------------------------------------------------------------------- /Coverage/predicate_coverage/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "predicate_coverage" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" -------------------------------------------------------------------------------- /Coverage/predicate_coverage/README.md: -------------------------------------------------------------------------------- 1 | # Predicate Coverage 2 | 3 | * _Predicate coverage is a code coverage metric used in fuzzing that focuses on exercising the boolean predicate expressions in conditional statements and loops._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [13:18] raminfp@zenbook:predicate_coverage (main *%) # cargo run . 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.04s 16 | Running `target/debug/predicate_coverage .` 17 | Starting fuzzing... 18 | Total predicates covered: 3 19 | Coverage: {1, 2, 3} 20 | Achieved full predicate coverage! 21 | 22 | ``` -------------------------------------------------------------------------------- /Coverage/predicate_coverage/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::{thread_rng, Rng}; 2 | use std::collections::HashSet; 3 | 4 | fn function(input: &str) -> bool { 5 | 6 | let pred1 = input.len() > 10; 7 | let pred2 = input.contains("foo"); 8 | let pred3 = input.starts_with("bar"); 9 | 10 | pred1 || pred2 || pred3 11 | 12 | } 13 | 14 | struct PredicateCoverageFuzzer { 15 | coverage: HashSet, 16 | } 17 | 18 | impl PredicateCoverageFuzzer { 19 | 20 | fn new() -> Self { 21 | Self { 22 | coverage: HashSet::new(), 23 | } 24 | } 25 | 26 | fn fuzz(&mut self) { 27 | 28 | let mut rng = thread_rng(); 29 | 30 | loop { 31 | let rng = rng.clone(); 32 | let input: String = rng.sample_iter(&rand::distributions::Alphanumeric) 33 | .take(30) 34 | .map(char::from) 35 | .collect(); 36 | 37 | let predicates = self.analyze(&input); 38 | self.coverage.extend(predicates); 39 | 40 | if self.coverage.len() == 3 { 41 | break; 42 | } 43 | 44 | } 45 | 46 | } 47 | 48 | fn analyze(&self, input: &str) -> Vec { 49 | 50 | let mut covered = vec![]; 51 | 52 | let res = function(input); 53 | 54 | let pred1 = input.len() > 10; 55 | if pred1 { 56 | covered.push(1); 57 | } 58 | 59 | let pred2 = input.contains("foo"); 60 | if pred2 { 61 | covered.push(2); 62 | } 63 | 64 | let pred3 = input.starts_with("bar"); 65 | if pred3 { 66 | covered.push(3); 67 | } 68 | 69 | covered 70 | 71 | } 72 | 73 | } 74 | 75 | 76 | fn main() { 77 | 78 | let mut fuzzer = PredicateCoverageFuzzer::new(); 79 | 80 | println!("Starting fuzzing..."); 81 | 82 | fuzzer.fuzz(); 83 | 84 | println!("Total predicates covered: {}", fuzzer.coverage.len()); 85 | println!("Coverage: {:?}", fuzzer.coverage); 86 | 87 | if fuzzer.coverage.len() == 3 { 88 | println!("Achieved full predicate coverage!"); 89 | } else { 90 | println!("Did not achieve full coverage"); 91 | } 92 | 93 | } -------------------------------------------------------------------------------- /Coverage/statement_coverage/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "statement_coverage" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Coverage/statement_coverage/README.md: -------------------------------------------------------------------------------- 1 | # Statement Coverage 2 | 3 | * _Statement coverage is a code coverage metric used in fuzzing that tracks whether each executable statement in the code has been executed by at least one test input._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [13:20] raminfp@zenbook:statement_coverage (main +*%) # cargo run . 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.04s 16 | Running `target/debug/statement_coverage .` 17 | Coverage: {0, 2, 1} 18 | 19 | ``` -------------------------------------------------------------------------------- /Coverage/statement_coverage/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | use std::collections::HashSet; 3 | 4 | fn process(input: &str) -> bool { 5 | let _a = input.contains('a'); 6 | let _b = input.len() > 10; 7 | let _c = input.is_empty(); 8 | 9 | _a || _b || _c 10 | } 11 | 12 | struct StatementCoverageFuzzer { 13 | coverage: HashSet, 14 | } 15 | 16 | impl StatementCoverageFuzzer { 17 | fn new() -> Self { 18 | Self { 19 | coverage: HashSet::new(), 20 | } 21 | } 22 | 23 | fn fuzz(&mut self) { 24 | let mut rng = rand::thread_rng(); 25 | 26 | loop { 27 | let mut input = String::new(); 28 | for _ in 0..20 { 29 | input.push(rng.gen()); 30 | } 31 | let stmts = self.analyze(&input); 32 | 33 | self.coverage.extend(stmts); 34 | 35 | if self.coverage.len() == 3 { 36 | break; 37 | } 38 | } 39 | } 40 | 41 | fn analyze(&self, input: &str) -> Vec { 42 | let mut covered = vec![]; 43 | 44 | let a = input.contains('a'); 45 | covered.push(0); 46 | 47 | let b = input.len() > 10; 48 | covered.push(1); 49 | 50 | let c = input.is_empty(); 51 | covered.push(2); 52 | 53 | covered 54 | } 55 | 56 | } 57 | 58 | fn main() { 59 | let mut fuzzer = StatementCoverageFuzzer::new(); 60 | fuzzer.fuzz(); 61 | 62 | println!("Coverage: {:?}", fuzzer.coverage); 63 | } 64 | -------------------------------------------------------------------------------- /Executor/README.md: -------------------------------------------------------------------------------- 1 | # Executor 2 | 3 | * _An executor fuzzer is a type of blackbox fuzzing technique that focuses on fuzzing the input interfaces of a complete system or program._ 4 | 5 | -------------------------------------------------------------------------------- /Executor/fork-based_fuzzer/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "fork-based_fuzzer" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Executor/fork-based_fuzzer/README.md: -------------------------------------------------------------------------------- 1 | # Fork Based Fuzzer 2 | 3 | * _A fork-based fuzzer is a type of coverage-guided fuzzer that uses fork() system calls to test each input in a separate process._ 4 | 5 | 6 | # Build 7 | 8 | ```bash 9 | $ cargo run . 10 | ``` 11 | 12 | # Output 13 | 14 | ```bash 15 | [16:07] raminfp@zenbook:fork-based_fuzzer (main *) # cargo run . 16 | Finished dev [unoptimized + debuginfo] target(s) in 0.01s 17 | Running `target/debug/fork-based_fuzzer .` 18 | Starting fuzzer... 19 | Test case #1 20 | Crashed! 6 21 | Test case #2 22 | Crashed! 6 23 | Test case #3 24 | Crashed! 6 25 | Test case #4 26 | Crashed! 6 27 | Test case #5 28 | Crashed! 6 29 | Test case #6 30 | Crashed! 6 31 | Test case #7 32 | Crashed! 6 33 | Test case #8 34 | Crashed! 6 35 | Test case #9 36 | Crashed! 6 37 | Test case #10 38 | Crashed! 6 39 | Test case #11 40 | Crashed! 6 41 | Test case #12 42 | Crashed! 6 43 | Test case #13 44 | Crashed! 6 45 | Test case #14 46 | Crashed! 6 47 | Test case #15 48 | Crashed! 6 49 | Test case #16 50 | Crashed! 6 51 | Test case #17 52 | ^CCrashed! 6 53 | Test case #18 54 | Crashed! 6 55 | Test case #19 56 | Crashed! 6 57 | Test case #20 58 | Crashed! 6 59 | Test case #21 60 | Crashed! 6 61 | Test case #22 62 | Crashed! 6 63 | Test case #23 64 | 65 | ``` -------------------------------------------------------------------------------- /Executor/fork-based_fuzzer/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | use std::process::{Command, ExitStatus, Stdio}; 3 | use std::io::Write; 4 | use std::os::unix::ffi::OsStringExt; 5 | use std::io::{ErrorKind}; 6 | use std::os::unix::process::ExitStatusExt; 7 | 8 | const MAX_LEN: usize = 200; 9 | 10 | fn main() { 11 | println!("Starting fuzzer..."); 12 | let mut iteration = 0; 13 | // fuzzing loop until found a crash 14 | loop { 15 | let random_string = generate_random_string(MAX_LEN); 16 | iteration += 1; 17 | println!("Test case #{}", iteration); 18 | let status = run_target(&random_string); 19 | handle_child_exit(status); 20 | 21 | } 22 | } 23 | 24 | fn generate_random_string(length: usize) -> String { 25 | let mut rng = rand::thread_rng(); 26 | std::iter::repeat_with(|| rng.sample(rand::distributions::Alphanumeric)) 27 | .map(char::from) 28 | .take(length) 29 | .collect() 30 | } 31 | 32 | fn run_target(testcase: &str) -> ExitStatus { 33 | 34 | let output = Command::new("./target1") 35 | .arg(testcase) 36 | .output() 37 | .expect("failed to execute process"); 38 | output.status 39 | } 40 | 41 | fn handle_child_exit(status_code: ExitStatus) { 42 | 43 | let exit_code = status_code.signal(); 44 | match exit_code { 45 | Some(exit_code) => { 46 | println!("Crashed! {}", exit_code); 47 | } 48 | None => { 49 | println!("Exited due to signal"); 50 | } 51 | } 52 | 53 | } 54 | -------------------------------------------------------------------------------- /Executor/fork-based_fuzzer/target.c: -------------------------------------------------------------------------------- 1 | // gcc -o target target.c 2 | #include 3 | #include 4 | 5 | int main(int argc, char** argv) { 6 | char buf[10]; 7 | 8 | if(argc < 2) { 9 | printf("No input provided\n"); 10 | return 1; 11 | } 12 | 13 | strcpy(buf, argv[1]); 14 | 15 | printf("Input was: %s\n", buf); 16 | 17 | return 0; 18 | } -------------------------------------------------------------------------------- /Executor/fork-based_fuzzer/target1: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Executor/fork-based_fuzzer/target1 -------------------------------------------------------------------------------- /Executor/process_level_parallelism/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | -------------------------------------------------------------------------------- /Executor/process_level_parallelism/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "process_level_parallelism" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | [dependencies] 8 | rayon = "1.5" 9 | rand = "0.8.5" -------------------------------------------------------------------------------- /Executor/process_level_parallelism/README.md: -------------------------------------------------------------------------------- 1 | # Process Level Parallelism 2 | 3 | * _Process-level parallelism refers to a fuzzing optimization technique where multiple instances of the target application are forked and fuzzed in parallel to increase throughput._ 4 | 5 | 6 | # Build 7 | 8 | ```bash 9 | $ cargo run . 10 | ``` 11 | 12 | # Output 13 | 14 | ```bash 15 | [16:10] raminfp@zenbook:process_level_parallelism (main *) # cargo run . | more 16 | Finished dev [unoptimized + debuginfo] target(s) in 0.01s 17 | Running `target/debug/process_level_parallelism .` 18 | Process 1: Found a vulnerability with input [98, 105, 13, 65, 64, 33, 237, 243, 42, 192, 222, 65, 87, 217, 76, 132 19 | , 178, 222, 87, 108, 148, 208, 187, 127, 239, 203, 32, 139, 118, 39, 226, 0, 226, 183, 194, 168, 127] 20 | Process 3: Found a vulnerability with input [164, 0, 11, 76, 77, 62, 120, 117, 166, 42, 204, 50, 24, 87, 94, 144, 21 | 50, 43, 38, 180, 240, 198, 229, 225, 53, 210, 172, 95, 194, 56, 179, 68, 15, 177, 215, 146, 51, 181] 22 | Process 3: Found a vulnerability with input [74, 97, 183, 233, 87, 145, 127, 215, 172, 137, 218, 220, 162, 110, 81 23 | , 221, 70, 13, 34, 92, 184, 170, 188, 101, 123, 159, 192, 113, 109, 42, 65, 1, 121, 119, 170, 99, 253, 120, 58, 24 24 | 7, 100, 11, 205, 164, 68, 79] 25 | Process 1: Found a vulnerability with input [70, 188, 70, 213, 39, 98, 187, 43, 251, 46, 71, 26, 122, 100, 111, 42 26 | , 196, 57, 21, 17, 73, 18, 247, 34, 30, 148, 67, 189, 197, 237, 45, 221, 232, 31] 27 | Process 2: Found a vulnerability with input [208, 148, 57, 85, 211, 61, 144, 147, 249, 58, 228, 154, 35, 212, 51, 28 | 181, 188, 35, 226, 253, 63, 191, 177, 137, 7, 94, 92, 76, 58, 26, 165] 29 | Process 0: Found a vulnerability with input [232, 58, 135, 126, 223, 12, 165, 217, 46, 102, 34, 81, 212, 35, 182, 30 | 29, 6, 134, 75, 126, 4, 128, 142, 187, 25, 195, 40, 86, 85, 101, 220, 50, 6, 204, 254, 39, 71, 151, 238, 129, 99, 31 | 133, 1, 251, 138, 94, 245, 243] 32 | Process 1: Found a vulnerability with input [221, 205, 90, 17, 81, 178, 85, 239, 54, 56, 79, 176, 36, 193, 145, 25 33 | 5, 239, 18, 48, 184, 65, 46, 188, 165, 17, 81, 254, 229, 76, 171, 123, 199, 226, 42, 125, 62, 113, 107, 131, 127, 34 | 29, 193, 81, 84] 35 | Process 0: Found a vulnerability with input [107, 114, 200, 72, 17, 204, 217, 146, 232, 47, 195, 128, 85, 126, 187 36 | , 241, 209, 49, 121, 47, 204, 42, 31, 171, 103, 181, 84, 150, 156, 203, 219, 193, 100, 223, 48, 145, 79, 1, 200, 6 37 | 1, 218, 180, 23, 31] 38 | Process 1: Found a vulnerability with input [247, 29, 223, 164, 106, 147, 58, 184, 72, 174, 205, 17, 190, 85, 189, 39 | 83, 69, 0, 222, 205, 162, 205, 185, 202, 109, 96, 223, 158, 4, 25, 159, 21, 35, 156, 58, 16, 48, 207] 40 | Process 2: Found a vulnerability with input [119, 22, 203, 88, 93, 21, 186, 97, 100, 123, 11, 90, 74, 198, 82, 85, 41 | 22, 160, 129, 126, 23, 221, 243, 109, 13, 90, 86, 157, 4, 24, 14, 59, 176, 88] 42 | Process 1: Found a vulnerability with input [175, 110, 92, 37, 176, 61, 168, 38, 224, 17, 109, 124, 105, 254, 216, 43 | 225, 200, 2, 225, 192, 145, 117, 198, 158, 143, 87, 168, 210, 197, 136, 7, 239, 10, 209, 142, 41, 145, 142, 209, 44 | 76] 45 | Process 2: Found a vulnerability with input [141, 246, 121, 178, 128, 110, 43, 93, 223, 93, 247, 164, 222, 176, 15 46 | 1, 228, 57, 131, 131, 58, 35, 96, 101, 211, 24, 97, 25, 128, 22, 252, 124, 11, 9, 165, 114, 194, 164, 242, 200, 76 47 | , 153, 253, 135, 96, 108, 25] 48 | 49 | ``` -------------------------------------------------------------------------------- /Executor/process_level_parallelism/src/main.rs: -------------------------------------------------------------------------------- 1 | use rayon::prelude::*; 2 | use std::time::Duration; 3 | use rand::Rng; 4 | 5 | fn main() { 6 | // Number of parallel fuzzing processes 7 | let num_processes = 4; 8 | 9 | // Launch multiple processes in parallel 10 | (0..num_processes).into_par_iter().for_each(|process_id| { 11 | 12 | let mut rng = rand::thread_rng(); 13 | 14 | // Fuzzing loop for each process 15 | loop { 16 | // Generate a random input 17 | let random_input: Vec = (0..rng.gen_range(1..50)).map(|_| rng.gen()).collect(); 18 | 19 | let result = test_input(&random_input); 20 | if result { 21 | println!("Process {}: Found a vulnerability with input {:?}", process_id, random_input); 22 | } 23 | } 24 | }); 25 | } 26 | 27 | // Target func 28 | fn test_input(input: &[u8]) -> bool { 29 | std::thread::sleep(Duration::from_millis(10)); 30 | input.len() > 30 31 | } 32 | -------------------------------------------------------------------------------- /Executor/target_input/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "target_input" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" -------------------------------------------------------------------------------- /Executor/target_input/README.md: -------------------------------------------------------------------------------- 1 | # target input/path 2 | 3 | * _The target/input fuzzer is a simple but effective fuzzing strategy that mutates or tweaks the existing input files or data samples for a target application._ 4 | 5 | 6 | # Build 7 | 8 | ```bash 9 | $ cargo run . 10 | ``` 11 | 12 | # Output 13 | 14 | ```bash 15 | [16:11] raminfp@zenbook:target_input (main *) # cargo run . 16 | Finished dev [unoptimized + debuginfo] target(s) in 0.00s 17 | Running `target/debug/target_input .` 18 | Input bytes: Output { status: ExitStatus(unix_wait_status(0)), stdout: "Input value: LCX3wpkS4i\n", stderr: "" } 19 | Stdout: Input value: LCX3wpkS4i 20 | 21 | Stderr: 22 | [16:11] raminfp@zenbook:target_input (main *) # 23 | ``` -------------------------------------------------------------------------------- /Executor/target_input/program.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char *argv[]) { 4 | if(argc > 1) { 5 | printf("Input value: %s\n", argv[1]); 6 | } else { 7 | printf("No input value provided\n"); 8 | } 9 | 10 | return 0; 11 | } -------------------------------------------------------------------------------- /Executor/target_input/src/main.rs: -------------------------------------------------------------------------------- 1 | // use std::process::Command; 2 | // 3 | // fn main() { 4 | // let input_value = "hello"; 5 | // 6 | // let output = Command::new("./target_program") 7 | // .arg(input_value) 8 | // .output() 9 | // .expect("failed to execute process"); 10 | // 11 | // println!("Status: {}", output.status); 12 | // println!("Stdout: {}", String::from_utf8_lossy(&output.stdout)); 13 | // println!("Stderr: {}", String::from_utf8_lossy(&output.stderr)); 14 | // } 15 | 16 | use std::process::{Command, Stdio}; 17 | use rand::Rng; 18 | 19 | const MAX_LEN:usize = 256; 20 | 21 | fn generate_random_testcase_byte(length: usize) -> Vec { 22 | let mut rng = rand::thread_rng(); 23 | let mut bytes = Vec::with_capacity(length); 24 | 25 | for _ in 0..length { 26 | bytes.push(rng.gen()); 27 | } 28 | 29 | bytes 30 | } 31 | 32 | fn generate_random_string(length: usize) -> String { 33 | let mut rng = rand::thread_rng(); 34 | std::iter::repeat_with(|| rng.sample(rand::distributions::Alphanumeric)) 35 | .map(char::from) 36 | .take(length) 37 | .collect() 38 | } 39 | 40 | fn main() { 41 | // let input_bytes = b"hello"; 42 | // let input_bytes = generate_random_string(MAX_LEN); 43 | // let input_bytes = b"hello\n".to_vec(); 44 | // let input_str = String::from_utf8(input_bytes.to_vec()).unwrap(); 45 | 46 | let random_string = generate_random_string(10); 47 | let output = Command::new("./target_program") 48 | .arg(random_string) 49 | .output() 50 | .expect("failed to execute process"); 51 | 52 | println!("Input bytes: {:x?}", &output); 53 | // Print stdout and stderr 54 | println!("Stdout: {}", String::from_utf8_lossy(&output.stdout)); 55 | println!("Stderr: {}", String::from_utf8_lossy(&output.stderr)); 56 | } -------------------------------------------------------------------------------- /Executor/target_input/target_program: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Executor/target_input/target_program -------------------------------------------------------------------------------- /Executor/thread_level_parallelism/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | -------------------------------------------------------------------------------- /Executor/thread_level_parallelism/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "thread_level_parallelism" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Executor/thread_level_parallelism/README.md: -------------------------------------------------------------------------------- 1 | # Thread-Level Parallelism 2 | 3 | * _Thread-level parallelism refers to a fuzzing optimization where mutiple concurrent threads are leveraged to increase fuzzing performance_ 4 | 5 | 6 | # Build 7 | 8 | ```bash 9 | $ cargo run . 10 | ``` 11 | 12 | # Output 13 | 14 | ```bash 15 | [16:12] raminfp@zenbook:thread_level_parallelism (main *) # cargo run . 16 | Compiling thread_level_parallelism v0.1.0 (/home/raminfp/IdeaProjects/Executor/thread_level_parallelism) 17 | Finished dev [unoptimized + debuginfo] target(s) in 3.46s 18 | Running `target/debug/thread_level_parallelism .` 19 | Thread 1: Found a vulnerability with input [86, 250, 175, 127, 247, 56, 31, 231, 28, 0, 104, 250, 152, 1, 65, 20, 203, 253, 178, 41, 110, 14, 4, 108, 167, 186, 252, 235, 49, 249, 151, 208, 31] 20 | Thread 0: Found a vulnerability with input [127, 28, 209, 62, 231, 30, 88, 97, 54, 199, 87, 177, 191, 69, 180, 5, 248, 59, 151, 92, 3, 90, 84, 216, 78, 213, 253, 9, 58, 251, 40, 201, 69, 45, 190, 75, 64, 219] 21 | Thread 3: Found a vulnerability with input [21, 181, 102, 199, 159, 196, 88, 202, 131, 131, 60, 117, 116, 33, 64, 34, 80, 62, 199, 222, 33, 46, 108, 117, 195, 212, 152, 122, 92, 142, 105, 127, 166] 22 | Thread 2: Found a vulnerability with input [211, 205, 88, 56, 143, 53, 202, 205, 168, 102, 22, 169, 180, 69, 97, 40, 98, 160, 176, 197, 227, 79, 108, 47, 20, 99, 224, 111, 114, 133, 10, 23, 88, 227, 116, 249, 17, 176, 142, 147, 82, 64, 124, 250] 23 | 24 | ``` -------------------------------------------------------------------------------- /Executor/thread_level_parallelism/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::thread; 2 | use std::time::Duration; 3 | use rand::Rng; 4 | 5 | fn main() { 6 | // Number of parallel fuzzing threads 7 | let num_threads = 4; 8 | 9 | // Create a vector to hold the thread handles 10 | let mut handles = vec![]; 11 | 12 | // Launch multiple threads in parallel 13 | for thread_id in 0..num_threads { 14 | let handle = thread::spawn(move || { 15 | let mut rng = rand::thread_rng(); 16 | // Fuzzing loop for each thread 17 | loop { 18 | let random_input: Vec = (0..rng.gen_range(1..50)).map(|_| rng.gen()).collect(); 19 | let result = test_input(&random_input); 20 | if result { 21 | println!("Thread {}: Found a vulnerability with input {:?}", thread_id, random_input); 22 | break; 23 | } 24 | } 25 | }); 26 | 27 | handles.push(handle); 28 | } 29 | // Wait for all threads to finish 30 | for handle in handles { 31 | handle.join().unwrap(); 32 | } 33 | } 34 | 35 | // Target func 36 | fn test_input(input: &[u8]) -> bool { 37 | 38 | std::thread::sleep(Duration::from_millis(10)); 39 | input.len() > 30 40 | } 41 | -------------------------------------------------------------------------------- /Executor/wget_fuzzer/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "wget_fuzzer" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.4" 10 | -------------------------------------------------------------------------------- /Executor/wget_fuzzer/README.md: -------------------------------------------------------------------------------- 1 | # Path Fuzzer (wget) 2 | 3 | * _The target/input fuzzer is a simple but effective fuzzing strategy that mutates or tweaks the existing input files or data samples for a target application._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | 12 | # Output 13 | 14 | ```bash 15 | [16:24] raminfp@zenbook:wget_fuzzer (main *) # cargo run . 16 | Compiling wget_fuzzer v0.1.0 (/home/raminfp/IdeaProjects/Executor/wget_fuzzer) 17 | Finished dev [unoptimized + debuginfo] target(s) in 0.23s 18 | Running `target/debug/wget_fuzzer .` 19 | http://www.qxkhoqrmcbpsagrpx.com 20 | http://www.fionetowvogrympn.com 21 | http://www.xolxzivdtzbysiz.com 22 | http://www.gkufhoqoyhq.com 23 | http://www.annramujvfpzh.com 24 | http://www.nljfrk.com 25 | http://www.gcfueqpk.com 26 | http://www.hlcgwc.com 27 | http://www.qtbmnzgyqbgyjnbqpew.com 28 | 29 | ``` 30 | -------------------------------------------------------------------------------- /Executor/wget_fuzzer/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::process::Command; 2 | use rand::Rng; 3 | use rand::prelude::*; 4 | use rand::seq::SliceRandom; 5 | 6 | 7 | fn main() { 8 | loop { 9 | // Generate a random URL as input for wget. 10 | let url = generate_random_url(); 11 | println!("{}", url); 12 | // Run wget with the generated URL as the argument. 13 | let output = Command::new("wget") 14 | .arg("--no-check-certificate") 15 | .arg(url) 16 | .output(); 17 | 18 | // Check for any error output. 19 | if let Err(err) = output { 20 | eprintln!("wget failed: {}", err); 21 | } 22 | } 23 | } 24 | 25 | fn generate_random_url() -> String { 26 | let mut rng = rand::thread_rng(); 27 | let url_length = rng.gen_range(5..=20); // Generate URL length between 5 and 20 characters. 28 | 29 | let charset: Vec = "abcdefghijklmnopqrstuvwxyz".chars().collect(); 30 | let url: String = (0..url_length) 31 | .map(|_| { 32 | // Generate a random ASCII character between 'a' and 'z'. 33 | *charset.choose(&mut rng).unwrap() 34 | }) 35 | .collect(); 36 | 37 | format!("http://www.{}.com", url) 38 | } -------------------------------------------------------------------------------- /Monitor/README.md: -------------------------------------------------------------------------------- 1 | # Monitoring 2 | 3 | * _Monitoring fuzzing refers to observing and tracking various metrics during the fuzzing process to assess progress, detect issues, and tune the fuzzing_ -------------------------------------------------------------------------------- /Monitor/log_fuzzing_events/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "log_fuzzing_events" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | simplelog = "0.12.1" 11 | log = "*" -------------------------------------------------------------------------------- /Monitor/log_fuzzing_events/README.md: -------------------------------------------------------------------------------- 1 | # Fuzzing Events 2 | 3 | * _Record when fuzzing starts/ends, when crashes occur, when interesting test cases are found, etc._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [16:35] raminfp@zenbook:log_fuzzing_events (main *) # cargo run . 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.01s 16 | Running `target/debug/log_fuzzing_events .` 17 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 18 | note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace 19 | 13:05:10 [ERROR] Fuzzer crashed! 20 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 21 | 13:05:10 [ERROR] Fuzzer crashed! 22 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 23 | 13:05:10 [ERROR] Fuzzer crashed! 24 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 25 | 13:05:10 [ERROR] Fuzzer crashed! 26 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 27 | 13:05:10 [ERROR] Fuzzer crashed! 28 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 29 | 13:05:10 [ERROR] Fuzzer crashed! 30 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 31 | 13:05:10 [ERROR] Fuzzer crashed! 32 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 33 | 13:05:10 [ERROR] Fuzzer crashed! 34 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 35 | 13:05:10 [ERROR] Fuzzer crashed! 36 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 37 | 13:05:10 [ERROR] Fuzzer crashed! 38 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 39 | 13:05:10 [ERROR] Fuzzer crashed! 40 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 41 | 13:05:10 [ERROR] Fuzzer crashed! 42 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 43 | 13:05:10 [ERROR] Fuzzer crashed! 44 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 45 | 13:05:10 [ERROR] Fuzzer crashed! 46 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 47 | 13:05:10 [ERROR] Fuzzer crashed! 48 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 49 | 13:05:10 [ERROR] Fuzzer crashed! 50 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 51 | 13:05:10 [ERROR] Fuzzer crashed! 52 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 53 | 13:05:10 [ERROR] Fuzzer crashed! 54 | thread 'main' panicked at 'Crash!', src/main.rs:11:9 55 | 56 | ``` -------------------------------------------------------------------------------- /Monitor/log_fuzzing_events/src/main.rs: -------------------------------------------------------------------------------- 1 | #[macro_use] 2 | extern crate log; 3 | extern crate simplelog; 4 | use simplelog::*; 5 | use std::fs::File; 6 | use rand::Rng; 7 | 8 | // Fuzz target 9 | fn fuzz(data: &[u8]) { 10 | if data[0] == 0 { 11 | panic!("Crash!"); 12 | } 13 | } 14 | 15 | fn main() { 16 | 17 | // Initialize logger 18 | CombinedLogger::init( 19 | vec![ 20 | TermLogger::new(LevelFilter::Warn, Config::default(), TerminalMode::Mixed, ColorChoice::Auto), 21 | WriteLogger::new(LevelFilter::Info, Config::default(), File::create("fuzz.log").unwrap()), 22 | ] 23 | ).unwrap(); 24 | 25 | let mut rng = rand::thread_rng(); 26 | 27 | loop { 28 | let mut bytes = [0u8; 64]; 29 | rng.fill(&mut bytes); 30 | 31 | info!("Starting iteration"); 32 | 33 | if let Err(_) = std::panic::catch_unwind(|| { 34 | fuzz(&bytes); 35 | }) { 36 | error!("Fuzzer crashed!"); 37 | } else { 38 | info!("Iteration completed successfully"); 39 | } 40 | } 41 | } -------------------------------------------------------------------------------- /Monitor/log_test_cases/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "log_test_cases" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Monitor/log_test_cases/README.md: -------------------------------------------------------------------------------- 1 | # Log test cases? 2 | 3 | * _Log the test input bytes that trigger crashes or interesting behavior to files for further analysis._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 15 | Fuzzer crashed! 16 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 17 | Fuzzer crashed! 18 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 19 | Fuzzer crashed! 20 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 21 | Fuzzer crashed! 22 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 23 | Fuzzer crashed! 24 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 25 | Fuzzer crashed! 26 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 27 | Fuzzer crashed! 28 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 29 | Fuzzer crashed! 30 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 31 | Fuzzer crashed! 32 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 33 | Fuzzer crashed! 34 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 35 | Fuzzer crashed! 36 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 37 | Fuzzer crashed! 38 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 39 | Fuzzer crashed! 40 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 41 | Fuzzer crashed! 42 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 43 | Fuzzer crashed! 44 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 45 | Fuzzer crashed! 46 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 47 | Fuzzer crashed! 48 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 49 | Fuzzer crashed! 50 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 51 | Fuzzer crashed! 52 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 53 | Fuzzer crashed! 54 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 55 | Fuzzer crashed! 56 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 57 | Fuzzer crashed! 58 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 59 | Fuzzer crashed! 60 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 61 | Fuzzer crashed! 62 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 63 | Fuzzer crashed! 64 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 65 | Fuzzer crashed! 66 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 67 | Fuzzer crashed! 68 | thread 'main' panicked at 'Crash!', src/main.rs:8:9 69 | 70 | ``` -------------------------------------------------------------------------------- /Monitor/log_test_cases/crash-cases.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raminfp/fuzzer-development-with-rust/1d1434248004c1a4059bb93e1e8766fb3138145e/Monitor/log_test_cases/crash-cases.txt -------------------------------------------------------------------------------- /Monitor/log_test_cases/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | use std::fs::File; 3 | use std::io::Write; 4 | 5 | // Fuzz target 6 | fn fuzz(data: &[u8]) { 7 | if data[0] == 0 { 8 | panic!("Crash!"); 9 | } 10 | } 11 | 12 | fn main() { 13 | 14 | let mut rng = rand::thread_rng(); 15 | 16 | let mut crashes = 0; 17 | 18 | loop { 19 | 20 | let mut bytes = [0u8; 32]; 21 | rng.fill(&mut bytes); 22 | 23 | if let Err(_) = std::panic::catch_unwind(|| { 24 | fuzz(&bytes); 25 | }) { 26 | crashes += 1; 27 | println!("Fuzzer crashed!"); 28 | 29 | let mut file = File::create("crash-cases.txt").unwrap(); 30 | file.write_all(&bytes).unwrap(); 31 | } 32 | 33 | } 34 | 35 | } -------------------------------------------------------------------------------- /Monitor/panic_crash/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "panic_crash" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" -------------------------------------------------------------------------------- /Monitor/panic_crash/README.md: -------------------------------------------------------------------------------- 1 | # Crash 2 | 3 | * _A crash in fuzzing refers to the target application crashing or abruptly terminating due to the fuzzed or mutated input that was provided to it_ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | Crash detected on iteration 198924 15 | Iterations: 199000, Crashes: 778 16 | thread 'main' panicked at 'Crash!', src/main.rs:9:9 17 | Crash detected on iteration 199415 18 | thread 'main' panicked at 'Crash!', src/main.rs:9:9 19 | Crash detected on iteration 199729 20 | thread 'main' panicked at 'Crash!', src/main.rs:9:9 21 | Crash detected on iteration 199911 22 | Iterations: 200000, Crashes: 781 23 | thread 'main' panicked at 'Crash!', src/main.rs:9:9 24 | Crash detected on iteration 200492 25 | Iterations: 201000, Crashes: 782 26 | thread 'main' panicked at 'Crash!', src/main.rs:9:9 27 | Crash detected on iteration 201807 28 | thread 'main' panicked at 'Crash!', src/main.rs:9:9 29 | Crash detected on iteration 201815 30 | thread 'main' panicked at 'Crash!', src/main.rs:9:9 31 | Crash detected on iteration 201817 32 | Iterations: 202000, Crashes: 785 33 | thread 'main' panicked at 'Crash!', src/main.rs:9:9 34 | Crash detected on iteration 202150 35 | thread 'main' panicked at 'Crash!', src/main.rs:9:9 36 | Crash detected on iteration 202343 37 | thread 'main' panicked at 'Crash!', src/main.rs:9:9 38 | Crash detected on iteration 202378 39 | 40 | ``` -------------------------------------------------------------------------------- /Monitor/panic_crash/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | use std::panic; 3 | 4 | 5 | // The target function we want to fuzz 6 | fn fuzz_target(data: &[u8]) { 7 | // Code that might panic 8 | if data[0] == 0 { 9 | panic!("Crash!"); 10 | // sotre in file 11 | } 12 | 13 | // Do something with input data 14 | } 15 | 16 | fn main() { 17 | 18 | let mut rng = rand::thread_rng(); 19 | let mut iterations = 0; 20 | let mut crashes = 0; 21 | 22 | println!("Starting fuzzer"); 23 | 24 | loop { 25 | let mut bytes = [0u8; 64]; 26 | 27 | rng.fill(&mut bytes); 28 | 29 | iterations += 1; 30 | 31 | let result = panic::catch_unwind(|| { 32 | fuzz_target(&bytes); 33 | }); 34 | 35 | if result.is_err() { 36 | crashes += 1; 37 | println!("Crash detected on iteration {}", iterations); 38 | // Can log crashing input here 39 | } 40 | 41 | // Add mutations of bytes here 42 | 43 | if iterations % 1000 == 0 { 44 | println!("Iterations: {}, Crashes: {}", iterations, crashes); 45 | } 46 | } 47 | } -------------------------------------------------------------------------------- /Monitor/sanity_checks/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "sanity_checks" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | sysinfo = "0.29.7" 11 | tokio = "1.29.1" 12 | -------------------------------------------------------------------------------- /Monitor/sanity_checks/README.md: -------------------------------------------------------------------------------- 1 | # Sanity Checks 2 | 3 | * _A hang in fuzzing refers to the target application freezing or becoming unresponsive due to some input generated during fuzzing_ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | Finished dev [unoptimized + debuginfo] target(s) in 12.91s 15 | Running `target/debug/sanity_checks` 16 | Fuzz timeout! 17 | Iterations: 1, Crashes detected: 0, Elapsed time: 20.01s, CPU usage: 13.779259 18 | 19 | ``` -------------------------------------------------------------------------------- /Monitor/sanity_checks/src/main.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | use io::Write; 3 | use rand::Rng; 4 | use std::time::{Duration, Instant}; 5 | use sysinfo::{System, SystemExt}; 6 | use sysinfo::CpuExt; 7 | use std::thread::sleep_ms; 8 | 9 | 10 | 11 | struct PerfStats { 12 | start: Instant, 13 | fuzz_iterations: u32, 14 | crashes: u32, 15 | cpu_usage: f32, 16 | } 17 | 18 | impl PerfStats { 19 | 20 | fn new() -> Self { 21 | let t = System::new_all(); 22 | Self { 23 | start: Instant::now(), 24 | fuzz_iterations: 0, 25 | crashes: 0, 26 | cpu_usage: t.global_cpu_info().cpu_usage(), 27 | } 28 | } 29 | 30 | fn record_crash(&mut self) { 31 | self.crashes += 1; 32 | } 33 | 34 | fn finish(&self) { 35 | let duration = self.start.elapsed(); 36 | println!("Iterations: {}, Crashes detected: {}, Elapsed time: {:.2?}, CPU usage: {}", 37 | self.fuzz_iterations, self.crashes, duration, self.cpu_usage); 38 | } 39 | } 40 | 41 | // Fuzz target 42 | fn fuzz(data: &[u8]) { 43 | sleep_ms(10000); 44 | if data[0] == 0 { 45 | panic!("Crash!"); 46 | } 47 | } 48 | 49 | 50 | fn fuzz_with_timeout(data: &[u8]) { 51 | 52 | let start = Instant::now(); 53 | fuzz(data); 54 | let duration = start.elapsed(); 55 | match duration { 56 | d if d > Duration::from_secs(5) => { 57 | println!("Fuzz timeout!"); 58 | }, 59 | _ => (), 60 | } 61 | 62 | } 63 | 64 | fn main() { 65 | 66 | let mut rng = rand::thread_rng(); 67 | let mut stats = PerfStats::new(); 68 | 69 | loop { 70 | 71 | let mut bytes = [0u8; 32]; 72 | rng.fill(&mut bytes); 73 | stats.fuzz_iterations += 1; 74 | 75 | // Timeout check 76 | fuzz_with_timeout(&bytes); 77 | 78 | if let Err(_) = std::panic::catch_unwind(|| { 79 | fuzz(&bytes); 80 | }) { 81 | stats.record_crash(); 82 | } 83 | stats.finish(); 84 | 85 | } 86 | } -------------------------------------------------------------------------------- /Monitor/sysinfo_test/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "sysinfo_test" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | sysinfo = "0.29.7" -------------------------------------------------------------------------------- /Monitor/sysinfo_test/README.md: -------------------------------------------------------------------------------- 1 | # Sysinfo 2 | 3 | * _Sysinfo or system information in fuzzing refers to collecting details about the environment and system where fuzzing is being performed._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [16:42] raminfp@zenbook:sysinfo_test (main) # cargo run 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.01s 16 | Running `target/debug/sysinfo_test` 17 | Getting processes' information... 18 | Done. 19 | To get the commands' list, enter 'help'. 20 | > help 21 | == Help menu == 22 | help : show this menu 23 | signals : show the available signals 24 | refresh : reloads all processes information 25 | refresh [pid] : reloads corresponding process information 26 | refresh_disks : reloads only disks information 27 | refresh_users : reloads only users information 28 | refresh_networks : reloads only networks information 29 | show [pid | name] : show information of the given process corresponding to [pid | name] 30 | kill [pid] [signal]: send [signal] to the process with this [pid]. 0 < [signal] < 32 31 | cpus : Displays CPUs state 32 | memory : Displays memory state 33 | temperature : Displays components' temperature 34 | disks : Displays disks' information 35 | network : Displays network' information 36 | all : Displays all process name and pid 37 | uptime : Displays system uptime 38 | boot_time : Displays system boot time 39 | vendor_id : Displays CPU vendor id 40 | brand : Displays CPU brand 41 | load_avg : Displays system load average 42 | frequency : Displays CPU frequency 43 | users : Displays all users and their groups 44 | system : Displays system information (such as name, version and hostname) 45 | pid : Display this example's PID 46 | quit : Exit the program 47 | > cpus 48 | number of physical cores: 4 49 | total CPU usage: 13.624922% 50 | Cpu { name: "cpu0", CPU usage: 0.0, frequency: 3315, vendor ID: "GenuineIntel", brand: "Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz" } 51 | Cpu { name: "cpu1", CPU usage: 0.0, frequency: 3400, vendor ID: "GenuineIntel", brand: "Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz" } 52 | Cpu { name: "cpu2", CPU usage: 0.0, frequency: 3400, vendor ID: "GenuineIntel", brand: "Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz" } 53 | Cpu { name: "cpu3", CPU usage: 0.0, frequency: 3300, vendor ID: "GenuineIntel", brand: "Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz" } 54 | Cpu { name: "cpu4", CPU usage: 0.0, frequency: 3290, vendor ID: "GenuineIntel", brand: "Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz" } 55 | Cpu { name: "cpu5", CPU usage: 0.0, frequency: 3401, vendor ID: "GenuineIntel", brand: "Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz" } 56 | Cpu { name: "cpu6", CPU usage: 0.0, frequency: 3301, vendor ID: "GenuineIntel", brand: "Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz" } 57 | Cpu { name: "cpu7", CPU usage: 0.0, frequency: 3400, vendor ID: "GenuineIntel", brand: "Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz" } 58 | 59 | ``` -------------------------------------------------------------------------------- /Monitor/track_statistics/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "track_statistics" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" -------------------------------------------------------------------------------- /Monitor/track_statistics/README.md: -------------------------------------------------------------------------------- 1 | # Track Statistics 2 | 3 | * _Tracking statistics and metrics is important in fuzzing to measure progress, effectiveness, and guide optimization._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | Iterations: 404400, Crashes: 1619, Duration: 683.068459ms 15 | Iterations: 404500, Crashes: 1619, Duration: 683.243411ms 16 | Iterations: 404600, Crashes: 1619, Duration: 683.416157ms 17 | Iterations: 404700, Crashes: 1619, Duration: 683.592143ms 18 | Iterations: 404800, Crashes: 1619, Duration: 683.766659ms 19 | thread 'main' panicked at 'Crash!', src/main.rs:14:9 20 | Iterations: 404900, Crashes: 1620, Duration: 683.984433ms 21 | Iterations: 405000, Crashes: 1620, Duration: 684.168334ms 22 | Iterations: 405100, Crashes: 1620, Duration: 684.353465ms 23 | Iterations: 405200, Crashes: 1620, Duration: 684.540648ms 24 | Iterations: 405300, Crashes: 1620, Duration: 684.728361ms 25 | Iterations: 405400, Crashes: 1620, Duration: 684.919743ms 26 | thread 'main' panicked at 'Crash!', src/main.rs:14:9 27 | thread 'main' panicked at 'Crash!', src/main.rs:14:9 28 | Iterations: 405500, Crashes: 1622, Duration: 685.156631ms 29 | Iterations: 405600, Crashes: 1622, Duration: 685.325019ms 30 | Iterations: 405700, Crashes: 1622, Duration: 685.490191ms 31 | Iterations: 405800, Crashes: 1622, Duration: 685.655595ms 32 | thread 'main' panicked at 'Crash!', src/main.rs:14:9 33 | Iterations: 405900, Crashes: 1623, Duration: 685.833477ms 34 | Iterations: 406000, Crashes: 1623, Duration: 686.015053ms 35 | Iterations: 406100, Crashes: 1623, Duration: 686.174719ms 36 | Iterations: 406200, Crashes: 1623, Duration: 686.333121ms 37 | thread 'main' panicked at 'Crash!', src/main.rs:14:9 38 | Iterations: 406300, Crashes: 1624, Duration: 686.505011ms 39 | Iterations: 406400, Crashes: 1624, Duration: 686.663543ms 40 | Iterations: 406500, Crashes: 1624, Duration: 686.821723ms 41 | Iterations: 406600, Crashes: 1624, Duration: 686.981492ms 42 | thread 'main' panicked at 'Crash!', src/main.rs:14:9 43 | Iterations: 406700, Crashes: 1625, Duration: 687.155282ms 44 | Iterations: 406800, Crashes: 1625, Duration: 687.313633ms 45 | Iterations: 406900, Crashes: 1625, Duration: 687.471874ms 46 | Iterations: 407000, Crashes: 1625, Duration: 687.63ms 47 | Iterations: 407100, Crashes: 1625, Duration: 687.78826ms 48 | Iterations: 407200, Crashes: 1625, Duration: 687.946412ms 49 | thread 'main' panicked at 'Crash!', src/main.rs:14:9 50 | thread 'main' panicked at 'Crash!', src/main.rs:14:9 51 | Iterations: 407300, Crashes: 1627, Duration: 688.130895ms 52 | Iterations: 407400, Crashes: 1627, Duration: 688.296362ms 53 | thread 'main' panicked at 'Crash!', src/main.rs:14:9 54 | Iterations: 407500, Crashes: 1628, Duration: 688.478637ms 55 | Iterations: 407600, Crashes: 1628, Duration: 688.656729ms 56 | thread 'main' panicked at 'Crash!', src/main.rs:14:9 57 | Iterations: 407700, Crashes: 1629, Duration: 688.858374ms 58 | Iterations: 407800, Crashes: 1629, Duration: 689.05478ms 59 | Iterations: 407900, Crashes: 1629, Duration: 689.241047ms 60 | 61 | ``` -------------------------------------------------------------------------------- /Monitor/track_statistics/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | use std::time::Instant; 3 | 4 | struct FuzzerStats { 5 | start_time: Instant, 6 | num_iterations: usize, 7 | crashes_detected: usize, 8 | } 9 | 10 | // The target function we want to fuzz 11 | fn fuzz_target(data: &[u8]) { 12 | // Code that might panic 13 | if data[0] == 0 { 14 | panic!("Crash!"); 15 | } 16 | // Do something with input data 17 | } 18 | 19 | fn main() { 20 | 21 | let mut rng = rand::thread_rng(); 22 | 23 | let mut stats = FuzzerStats { 24 | start_time: Instant::now(), 25 | num_iterations: 0, 26 | crashes_detected: 0, 27 | }; 28 | 29 | loop { 30 | 31 | let mut bytes = [0u8; 64]; 32 | 33 | rng.fill(&mut bytes); 34 | 35 | stats.num_iterations += 1; 36 | 37 | if let Err(_) = std::panic::catch_unwind(|| { 38 | fuzz_target(&bytes); 39 | }) { 40 | stats.crashes_detected += 1; 41 | } 42 | 43 | if stats.num_iterations % 100 == 0 { 44 | let elapsed = stats.start_time.elapsed(); 45 | println!("Iterations: {}, Crashes: {}, Duration: {:?}", 46 | stats.num_iterations, stats.crashes_detected, elapsed); 47 | } 48 | 49 | } 50 | 51 | } -------------------------------------------------------------------------------- /Monitor/use_profiling/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "use_profiling" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | sysinfo = "0.29.7" -------------------------------------------------------------------------------- /Monitor/use_profiling/README.md: -------------------------------------------------------------------------------- 1 | # Use Profiling 2 | 3 | * _Leverage profiling crates like 'puffin' to get runtime statistics on code execution inside fuzz target._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | Iterations: 105682, Crashes detected: 367, Elapsed time: 814.52ms, CPU usage: 13.738561 15 | Iterations: 105683, Crashes detected: 367, Elapsed time: 814.52ms, CPU usage: 13.738561 16 | Iterations: 105684, Crashes detected: 367, Elapsed time: 814.52ms, CPU usage: 13.738561 17 | Iterations: 105685, Crashes detected: 367, Elapsed time: 814.53ms, CPU usage: 13.738561 18 | Iterations: 105686, Crashes detected: 367, Elapsed time: 814.53ms, CPU usage: 13.738561 19 | Iterations: 105687, Crashes detected: 367, Elapsed time: 814.53ms, CPU usage: 13.738561 20 | Iterations: 105688, Crashes detected: 367, Elapsed time: 814.53ms, CPU usage: 13.738561 21 | Iterations: 105689, Crashes detected: 367, Elapsed time: 814.54ms, CPU usage: 13.738561 22 | Iterations: 105690, Crashes detected: 367, Elapsed time: 814.55ms, CPU usage: 13.738561 23 | Iterations: 105691, Crashes detected: 367, Elapsed time: 814.55ms, CPU usage: 13.738561 24 | Iterations: 105692, Crashes detected: 367, Elapsed time: 814.55ms, CPU usage: 13.738561 25 | Iterations: 105693, Crashes detected: 367, Elapsed time: 814.56ms, CPU usage: 13.738561 26 | Iterations: 105694, Crashes detected: 367, Elapsed time: 814.56ms, CPU usage: 13.738561 27 | Iterations: 105695, Crashes detected: 367, Elapsed time: 814.56ms, CPU usage: 13.738561 28 | Iterations: 105696, Crashes detected: 367, Elapsed time: 814.56ms, CPU usage: 13.738561 29 | Iterations: 105697, Crashes detected: 367, Elapsed time: 814.57ms, CPU usage: 13.738561 30 | Iterations: 105698, Crashes detected: 367, Elapsed time: 814.58ms, CPU usage: 13.738561 31 | Iterations: 105699, Crashes detected: 367, Elapsed time: 814.58ms, CPU usage: 13.738561 32 | Iterations: 105700, Crashes detected: 367, Elapsed time: 814.58ms, CPU usage: 13.738561 33 | Iterations: 105701, Crashes detected: 367, Elapsed time: 814.58ms, CPU usage: 13.738561 34 | Iterations: 105702, Crashes detected: 367, Elapsed time: 814.59ms, CPU usage: 13.738561 35 | Iterations: 105703, Crashes detected: 367, Elapsed time: 814.59ms, CPU usage: 13.738561 36 | Iterations: 105704, Crashes detected: 367, Elapsed time: 814.59ms, CPU usage: 13.738561 37 | Iterations: 105705, Crashes detected: 367, Elapsed time: 814.60ms, CPU usage: 13.738561 38 | Iterations: 105706, Crashes detected: 367, Elapsed time: 814.60ms, CPU usage: 13.738561 39 | Iterations: 105707, Crashes detected: 367, Elapsed time: 814.60ms, CPU usage: 13.738561 40 | 41 | ``` -------------------------------------------------------------------------------- /Monitor/use_profiling/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | use std::time::{Instant}; 3 | use sysinfo::{System, SystemExt}; 4 | use sysinfo::CpuExt; 5 | 6 | 7 | struct PerfStats { 8 | start: Instant, 9 | fuzz_iterations: u32, 10 | crashes: u32, 11 | cpu_usage: f32, 12 | } 13 | 14 | impl PerfStats { 15 | 16 | fn new() -> Self { 17 | let t = System::new_all(); 18 | Self { 19 | start: Instant::now(), 20 | fuzz_iterations: 0, 21 | crashes: 0, 22 | cpu_usage: t.global_cpu_info().cpu_usage(), 23 | } 24 | } 25 | 26 | fn record_crash(&mut self) { 27 | self.crashes += 1; 28 | } 29 | 30 | fn finish(&self) { 31 | let duration = self.start.elapsed(); 32 | println!("Iterations: {}, Crashes detected: {}, Elapsed time: {:.2?}, CPU usage: {}", 33 | self.fuzz_iterations, self.crashes, duration, self.cpu_usage); 34 | } 35 | 36 | fn record_cpu(&mut self) { 37 | let t = System::new_all(); 38 | let cpu = t.global_cpu_info().cpu_usage(); 39 | self.cpu_usage = cpu 40 | } 41 | 42 | } 43 | 44 | // Fuzz target 45 | fn fuzz(data: &[u8]) { 46 | if data[0] == 0 { 47 | panic!("Crash!"); 48 | } 49 | } 50 | 51 | fn main() { 52 | 53 | 54 | let mut rng = rand::thread_rng(); 55 | let mut stats = PerfStats::new(); 56 | 57 | loop { 58 | 59 | let mut bytes = [0u8; 32]; 60 | rng.fill(&mut bytes); 61 | 62 | stats.fuzz_iterations += 1; 63 | // stats.record_cpu(); 64 | if let Err(_) = std::panic::catch_unwind(|| { 65 | fuzz(&bytes); 66 | }) { 67 | stats.record_crash(); 68 | } 69 | stats.finish(); 70 | 71 | } 72 | } -------------------------------------------------------------------------------- /Mutation/README.md: -------------------------------------------------------------------------------- 1 | # Mutation 2 | 3 | * _Mutation is the process of taking an initial seed input and modifying it to generate new test cases in fuzzing_ -------------------------------------------------------------------------------- /Mutation/arithmetic_mutate/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "arithmetic_mutate" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Mutation/arithmetic_mutate/README.md: -------------------------------------------------------------------------------- 1 | # Arithmetic Mutation 2 | 3 | * _Mutations are applied to numerical values by performing basic arithmetic operations, such as addition, subtraction, multiplication, and division._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [16:44] raminfp@zenbook:arithmetic_mutate (main +) # cargo run 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.05s 16 | Running `target/debug/arithmetic_mutate` 17 | input: [1, 2, 3, 4] 18 | input: [0, 2, 3, 4] 19 | 20 | ``` -------------------------------------------------------------------------------- /Mutation/arithmetic_mutate/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | 3 | fn arithmetic_mutate(input: &mut [u8]) { 4 | let mut rng = rand::thread_rng(); 5 | // Pick a random byte to mutate 6 | let index = rng.gen_range(0..input.len()); 7 | let op = rng.gen_range(0..4); 8 | match op { 9 | 0 => input[index] += 1, 10 | 1 => input[index] -= 1, 11 | 2 => input[index] *=2, 12 | 3 => input[index] /= 2, 13 | _ => {} 14 | }; 15 | } 16 | 17 | fn main() { 18 | let mut input = vec![1,2,3,4]; 19 | println!("input: {:?}", &input); 20 | arithmetic_mutate(&mut input); 21 | println!("input: {:?}", &input); 22 | 23 | 24 | } 25 | -------------------------------------------------------------------------------- /Mutation/bitmask_mutation/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "bitmask_mutation" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | -------------------------------------------------------------------------------- /Mutation/bitmask_mutation/README.md: -------------------------------------------------------------------------------- 1 | # Bitmask Mutation 2 | 3 | * _Specific bits in the input data are masked or modified using predefined bit masks._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [16:45] raminfp@zenbook:bitmask_mutation (main +*) # cargo run 15 | Compiling bitmask_mutation v0.1.0 (/home/raminfp/IdeaProjects/Mutation/bitmask_mutation) 16 | Finished dev [unoptimized + debuginfo] target(s) in 0.36s 17 | Running `target/debug/bitmask_mutation` 18 | Original input: [85, 170] 19 | Mutated input: [152, 170] 20 | 21 | ``` -------------------------------------------------------------------------------- /Mutation/bitmask_mutation/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::Rng; 2 | 3 | fn bitmask_mutate(input: &mut Vec) { 4 | let mut rng = rand::thread_rng(); 5 | // Generate random bitmask 6 | let mask: u8 = rng.gen(); 7 | // Choose random byte to mutate 8 | let index = rng.gen_range(0..input.len()); 9 | // Apply bitmask mutation 10 | input[index] ^= mask; 11 | } 12 | 13 | fn main() { 14 | let mut input = vec![0b01010101, 0b10101010]; 15 | println!("Original input: {:?}", &input); 16 | bitmask_mutate(&mut input); 17 | println!("Mutated input: {:?}", &input); 18 | } 19 | -------------------------------------------------------------------------------- /Mutation/gen_rand_mutation/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "gen_rand_mutation" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" 10 | 11 | -------------------------------------------------------------------------------- /Mutation/gen_rand_mutation/README.md: -------------------------------------------------------------------------------- 1 | # Random Mutation 2 | 3 | * _This simple approach involves randomly modifying bytes or bits in the input data to create mutated test cases._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [16:45] raminfp@zenbook:gen_rand_mutation (main +*) # cargo run 15 | Compiling gen_rand_mutation v0.1.0 (/home/raminfp/IdeaProjects/Mutation/gen_rand_mutation) 16 | Finished dev [unoptimized + debuginfo] target(s) in 0.40s 17 | Running `target/debug/gen_rand_mutation` 18 | Original String: Hello, World! 19 | Mutated String: Hello,򏒰World! 20 | Mutated String: Hello񧞍 World! 21 | Mutated String: Hell𚽂, World! 22 | Mutated String: Hello, Wrld! 23 | Mutated String: Hell󔆍o, World! 24 | Mutated String: He󥒗llo, World! 25 | Mutated String: Helo, World! 26 | Mutated String: Hello, Wold! 27 | Mutated String: Hello, W񜡅orld! 28 | Mutated String: 􎬦Hello, World! 29 | 30 | ``` -------------------------------------------------------------------------------- /Mutation/gen_rand_mutation_byte/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "gen_rand_mutation_byte" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.5" -------------------------------------------------------------------------------- /Mutation/gen_rand_mutation_byte/README.md: -------------------------------------------------------------------------------- 1 | # Byte Flip 2 | 3 | * _In this technique, random bytes in the input data are flipped (i.e., a 0 is changed to 1 or vice versa)._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [16:45] raminfp@zenbook:gen_rand_mutation_byte (main +*) # cargo run 15 | Compiling gen_rand_mutation_byte v0.1.0 (/home/raminfp/IdeaProjects/Mutation/gen_rand_mutation_byte) 16 | Finished dev [unoptimized + debuginfo] target(s) in 0.38s 17 | Running `target/debug/gen_rand_mutation_byte` 18 | Original Data: [1, 35, 69, 103, 137] 19 | Mutated Data: [1, 35, 69, 103, 153] 20 | Mutated Data: [1, 35, 69, 103, 200, 137] 21 | Mutated Data: [1, 69, 103, 137] 22 | Mutated Data: [1, 69, 103, 137] 23 | Mutated Data: [1, 35, 69, 233, 103, 137] 24 | Mutated Data: [35, 69, 103, 137] 25 | Mutated Data: [1, 35, 69, 103, 137, 97] 26 | Mutated Data: [1, 35, 69, 137] 27 | Mutated Data: [1, 3, 69, 103, 137] 28 | Mutated Data: [1, 35, 69, 137] 29 | 30 | ``` -------------------------------------------------------------------------------- /Mutation/gen_rand_mutation_byte/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::{Rng, SeedableRng}; 2 | use rand::rngs::StdRng; 3 | 4 | // let input: u8 = 44; // Binary: 00101100 5 | // let bit_position = 3; 6 | // 7 | // // Flipping the 4th bit using bitwise XOR 8 | 9 | // let mutated_byte = input ^ (1 << bit_position); 10 | // 11 | // println!("Original byte: {:08b}", input); 12 | // println!("Mutated byte: {:08b}", mutated_byte); 13 | 14 | 15 | // Function to mutate a byte array randomly 16 | fn random_mutate_bytes(input: &[u8]) -> Vec { 17 | let mut rng = StdRng::from_entropy(); 18 | let mutation_type = rng.gen_range(0..=2); // 0: Byte Flip, 1: Byte Insertion, 2: Byte Deletion 19 | 20 | match mutation_type { 21 | 0 => { 22 | // Byte Flip: Choose a random byte and flip one bit randomly 23 | let position = rng.gen_range(0..input.len()); 24 | let bit_position = rng.gen_range(0..8); 25 | let mutated_byte = input[position] ^ (1 << bit_position); 26 | 27 | input 28 | .iter() 29 | .enumerate() 30 | .map(|(i, &byte)| if i == position { mutated_byte } else { byte }) 31 | .collect() 32 | } 33 | 1 => { 34 | // Byte Insertion: Insert a random byte at a random position 35 | let position = rng.gen_range(0..=input.len()); 36 | let new_byte: u8 = rng.gen(); 37 | input 38 | .iter() 39 | .take(position) 40 | .chain(std::iter::once(&new_byte)) 41 | .chain(input.iter().skip(position)) 42 | .cloned() 43 | .collect() 44 | } 45 | 2 => { 46 | // Byte Deletion: Remove a random byte at a random position 47 | if input.is_empty() { 48 | input.to_vec() 49 | } else { 50 | let position = rng.gen_range(0..input.len()); 51 | input 52 | .iter() 53 | .enumerate() 54 | .filter(|(i, _)| *i != position) 55 | .map(|(_, &byte)| byte) 56 | .collect() 57 | } 58 | } 59 | _ => input.to_vec(), 60 | } 61 | } 62 | 63 | fn main() { 64 | let original_data: Vec = vec![0x01, 0x23, 0x45, 0x67, 0x89]; 65 | println!("Original Data: {:?}", original_data); 66 | 67 | for _ in 0..10 { 68 | let mutated_data = random_mutate_bytes(&original_data); 69 | println!("Mutated Data: {:?}", mutated_data); 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /Mutation/mutated_seed_files/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "mutated_seed_files" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | rand = "0.8.4" 10 | 11 | -------------------------------------------------------------------------------- /Mutation/mutated_seed_files/README.md: -------------------------------------------------------------------------------- 1 | # Mutated Seed Files 2 | 3 | * _Mutations are applied to seed files, which are valid inputs or test cases that are modified to create new test cases._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [16:46] raminfp@zenbook:mutated_seed_files (main +*) # cargo run 15 | Finished dev [unoptimized + debuginfo] target(s) in 0.05s 16 | Running `target/debug/mutated_seed_files` 17 | mutated_seed_1.txt created successfully! 18 | mutated_seed_2.txt created successfully! 19 | mutated_seed_3.txt created successfully! 20 | mutated_seed_4.txt created successfully! 21 | mutated_seed_5.txt created successfully! 22 | 23 | ``` -------------------------------------------------------------------------------- /Mutation/mutated_seed_files/original_seed.txt: -------------------------------------------------------------------------------- 1 | 10 2 | 20 3 | 30 4 | 40 5 | 50 -------------------------------------------------------------------------------- /Mutation/mutated_seed_files/src/main.rs: -------------------------------------------------------------------------------- 1 | use rand::{Rng, SeedableRng}; 2 | use rand::distributions::Uniform; 3 | use rand::rngs::StdRng; 4 | use std::fs; 5 | use std::io::{self}; 6 | use std::error::Error; 7 | 8 | const MUTATION_AMOUNT: i32 = 10; // The range of mutations (-10 to +10) 9 | 10 | fn main() -> Result<(), Box> { 11 | // Read the seed file 12 | let original_seed = read_seed_file("original_seed.txt")?; 13 | 14 | // Generate and write the mutated seed files 15 | for i in 1..=5 { 16 | let mutated_seed = mutate_seed(&original_seed)?; 17 | write_seed_file(mutated_seed, format!("mutated_seed_{}.txt", i))?; 18 | } 19 | 20 | Ok(()) 21 | } 22 | 23 | fn read_seed_file(filename: &str) -> Result, Box> { 24 | let contents = fs::read_to_string(filename)?; 25 | let seed: Vec = contents 26 | .lines() 27 | .map(|line| line.trim().parse::()) 28 | .collect::>()?; 29 | Ok(seed) 30 | } 31 | 32 | fn mutate_seed(seed: &[i32]) -> Result, Box> { 33 | let mut rng = StdRng::from_entropy(); 34 | let mutation_range = Uniform::new_inclusive(-MUTATION_AMOUNT, MUTATION_AMOUNT); 35 | 36 | let mutated_seed: Vec = seed 37 | .iter() 38 | .map(|&num| num + rng.sample(mutation_range)) 39 | .collect(); 40 | 41 | Ok(mutated_seed) 42 | } 43 | 44 | fn write_seed_file(seed: Vec, filename: String) -> Result<(), io::Error> { 45 | let contents = seed 46 | .iter() 47 | .map(|num| num.to_string()) 48 | .collect::>() 49 | .join("\n"); 50 | 51 | fs::write(filename.clone(), contents)?; 52 | println!("{} created successfully!", filename); 53 | Ok(()) 54 | } 55 | -------------------------------------------------------------------------------- /Mutation/token_mutation/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "token_mutation" 3 | version = "0.1.0" 4 | edition = "2021" 5 | 6 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 7 | 8 | [dependencies] 9 | regex = "1.3" -------------------------------------------------------------------------------- /Mutation/token_mutation/README.md: -------------------------------------------------------------------------------- 1 | # Token Mutation 2 | 3 | * _Fuzzing targets specific tokens in the input data, like keywords or identifiers, and replaces them with different values._ 4 | 5 | # Build 6 | 7 | ```bash 8 | $ cargo run . 9 | ``` 10 | 11 | # Output 12 | 13 | ```bash 14 | [16:46] raminfp@zenbook:token_mutation (main +*) # cargo run 15 | Compiling token_mutation v0.1.0 (/home/raminfp/IdeaProjects/Mutation/token_mutation) 16 | Finished dev [unoptimized + debuginfo] target(s) in 1.04s 17 | Running `target/debug/token_mutation` 18 | 19 | fn main() { 20 | when true { 21 | println!("It's true!"); 22 | } 23 | } 24 | 25 | 26 | ``` -------------------------------------------------------------------------------- /Mutation/token_mutation/src/main.rs: -------------------------------------------------------------------------------- 1 | use regex::Regex; 2 | 3 | fn fuzz_keyword(input: &str) -> String { 4 | // Define a regex pattern to match the keyword "if" 5 | let pattern = Regex::new(r"\bif\b").unwrap(); 6 | 7 | // Define the replacement value (in this case, "when") 8 | let replacement = "when"; 9 | 10 | // Use the `replace_all` method to find and replace the matched tokens 11 | let fuzzed_input = pattern.replace_all(input, replacement); 12 | 13 | fuzzed_input.to_string() 14 | } 15 | 16 | fn main() { 17 | let input_code = r#" 18 | fn main() { 19 | if true { 20 | println!("It's true!"); 21 | } 22 | } 23 | "#; 24 | 25 | let fuzzed_code = fuzz_keyword(input_code); 26 | println!("{}", fuzzed_code); 27 | } 28 | --------------------------------------------------------------------------------