Method exploit_transform

src/program/libfuzzer.rs:154–194

transform the programs be more exploitable. transform all array/scalar arguments be fuzzable and consider their constraints.

(&mut self)

    // transform the programs be more exploitable.
    // transform all array/scalar arguments be fuzzable and consider their constraints.
    fn exploit_transform(&mut self) -> Result<()> {
        log::info!("Transform the correct programs to fuzzers with Constraints!");
        if crate::program::infer::load_constraints(&self.deopt).is_err() {
            let succ_programs =
                crate::deopt::utils::read_sort_dir(&self.deopt.get_library_succ_seed_dir()?)?;
            self.init_corpus_before_constraint_infer(&succ_programs)?;
            crate::program::infer::infer_constraints(&succ_programs, &self.deopt)?;
        }

        let core = max_cpu_count();

        let mut test_corpus = vec![];
        let mut new_programs = vec![];
        for program in self.programs.iter() {
            if let Ok(corpora) = find_testbed_corpora(program, &self.deopt) {
                test_corpus.push(corpora);
                new_programs.push(program.to_path_buf());
            } else {
                log::error!("Failed to find testbed corpora for program: {program:?}, skip it and continue...");
            }
        }
        self.programs = new_programs;

        let executor = Executor::default();
        let mut tasks = Vec::new();
        let mut task_corpus = Vec::new();
        for (i, program) in self.programs.iter().enumerate() {
            let corpora = &test_corpus[i];
            let i = i + 1;
            tasks.push(program.clone());
            task_corpus.push(corpora.to_path_buf());

            if i % core == 0 || i == self.programs.len() {
                executor.concurrent_transform(&tasks, core, true, &task_corpus)?;
                tasks.clear();
                task_corpus.clear();
                log::debug!("transformed {i}/{}", self.programs.len());
            }
        }
        Ok(())
    }

    pub fn synthesis(&mut self) -> Result<()> {
        log::info!("synthesis huge fuzzers!");