비교 퍼징 병렬 Rust 도구

Jan 24 2023

나는 이전에 Rust의 "두려움 없는 동시성"을 사용하여 ripunzip이라는 도구를 만드는 방법에 대해 썼습니다. (여기에 몇 가지 성능 결과가 있습니다.)

나는 이전에 Rust의 "두려움 없는 동시성"을 사용하여 ripunzip이라는 도구를 만드는 방법에 대해 썼습니다 . (여기에 몇 가지 성능 결과가 있습니다 .)

병렬이 아닌 일반 압축 해제와 동일한 방식으로 작동하는지 어떻게 확인할 수 있습니까? 예상치 못한 상황에서도?

대답: 비교 퍼징 . Fuzzing은 일반적으로 보안 버그를 찾는 데 사용되는 기술입니다. Rust의 안전하지 않은 코드에서 버그를 찾는 데 사용할 수 있는 방법에 대한 레시피가 있습니다 . 그러나 두 가지 구현이 동일한 방식으로 작동하는지 확인하는 데 사용할 수도 있습니다.

이것은 우리가 기존 도구의 더 빠른 버전을 만들려고 하는 경우에 적합하며 퍼징은 꽤 재미있습니다. 특히 놀라운 arbitrary 크레이트가 있는 Rust에서 그렇습니다 .

계획은 다음과 같습니다.

크레이트를 ripunzip사용하여 zip 파일을 포함하여 에 대한 모든 입력을 설명합니다.arbitrary
ripunzip해당 입력을 기반으로 실행
또한 일반 단일 스레드를 사용하여 동일한 파일의 압축을 풉니다.zip-rs
둘 다 성공했는지 또는 둘 다 실패했는지 확인
압축을 푼 디렉터리를 비교합니다. 다르면 충돌!

다음은 . 먼저 입력 데이터를 살펴보겠습니다.


#[derive(arbitrary::Arbitrary, Eq, PartialEq, Hash, Debug, Clone)]
struct ZipMemberFilename(/* details omitted... described later */);

#[derive(Eq, PartialEq, Hash, Debug, Clone, Copy, arbitrary::Arbitrary)]
enum CompressionMethod {
    Stored,
    Deflated,
    Bzip2,
    Zstd,
}

#[derive(arbitrary::Arbitrary, Debug, Clone)]
struct Inputs {
    // HashMap to ensure unique filenames in zip
    zip_members: HashMap<ZipMemberFilename, Vec<u8>>,
    compression_method: CompressionMethod,
    single_threaded: bool,
}

이는 Arbitrary코드가 불투명한 이진 blob에서 이 구조를 구성하기 위해 생성됨을 의미합니다. 이러한 바이너리 Blob은 libfuzzer 에 의해 생성되며 , 결정적으로 커버리지 지침에 따라 가능한 한 많은 프로그램을 점진적으로 탐색하도록 수정 및 재수정됩니다.

HashMap, 벡터 및 사용자 지정 열거형과 같은 꽤 복잡한 입력이 있습니다 . Arbitrary모두 생성할 수 있을 만큼 똑똑합니다.

이제 fuzzer 자체는 본질적으로 사소합니다. 말 그대로 zip을 만들고 압축을 두 번 풀고 출력을 비교하기만 하면 됩니다.

fuzz_target!(|input: Inputs| {
    let progress_reporter = ripunzip::NullProgressReporter;
    let tempdir = tempfile::tempdir().unwrap();
    let output_directory = tempdir.path().join("out_ripunzip");
    let output_directory_unzip = tempdir.path().join("out_unzip");
    std::fs::create_dir_all(&output_directory).unwrap();
    let options = ripunzip::UnzipOptions {
        single_threaded: input.single_threaded,
        output_directory: Some(output_directory.clone()),
    };
    let zipfile = tempdir.path().join("file.zip");
    let mut zip_data = Vec::new();
    create_zip(&mut zip_data, &input.zip_members, input.compression_method);
    let mut file = std::fs::File::create(&zipfile).unwrap();
    file.write_all(&zip_data).unwrap();
    drop(file);
    let file = std::fs::File::open(&zipfile).unwrap();
    let ripunzip_result: Result<(), anyhow::Error> = (|| {
        let ripunzip = ripunzip::UnzipEngine::for_file(file, options, progress_reporter)?;
        ripunzip.unzip()
    })();
    let unziprs_result = unzip_with_zip_rs(&zipfile, &output_directory_unzip);
    match unziprs_result {
        Err(err) => {
            if ripunzip_result.is_ok() {
                panic!("ripunzip succeeded; plain unzip gave {:?}", err)
            }
        }
        Ok(_) => {
            ripunzip_result.unwrap();
            let ripunzip_paths = recursive_lsdir(&output_directory);
            let unzip_paths = recursive_lsdir(&output_directory_unzip);
            // We do not currently compare the actual zip file contents.
            // It seems unlikely that this would be a failure mode where
            // ripunzip would differ from zip-rs.
            assert_eq!(ripunzip_paths, unzip_paths);
        }
    }
});

fn recursive_lsdir(dir: &Path) -> HashSet<std::path::PathBuf> {
    walkdir::WalkDir::new(dir)
        .into_iter()
        .filter_map(|e| e.ok())
        .map(|e| e.path().strip_prefix(dir).unwrap().to_path_buf())
        .collect()
}

// Create a zip file from zip_members into output,
// using the given compression mode. Details omitted.
fn create_zip(output: &mut Vec<u8>, zip_members: &HashMap<ZipMemberFilename, Vec<u8>>, compression_method: CompressionMethod) {
    // ...
}

/// Errors that can occur with a regular zip-rs unzip, details omitted
#[derive(Debug)]
enum ZipRsError {
    // ...
}

/// Unzip the content with standard zip-rs.
fn unzip_with_zip_rs(zipfile_path: &Path, dest_path: &Path) -> Result<(), ZipRsError> {
    // ...
}

#[derive(arbitrary::Arbitrary, Debug, Clone, strum::Display, Hash, Eq, PartialEq)]
enum FilenameSegment {
    Fish,
    A,
    #[strum(serialize = "b")]
    B,
    #[strum(serialize = "31")]
    ThirtyOne,
    #[strum(serialize = "_c")]
    C,
    D,
    #[strum(serialize = "e.txt")]
    ETxt,
}

#[derive(arbitrary::Arbitrary, Eq, PartialEq, Hash, Debug, Clone)]
struct ZipMemberFilename(Vec<FilenameSegment>);

impl Into<String> for &ZipMemberFilename {
    fn into(self) -> String {
        self.0.iter().join("/")
    }
}

이것을 실행하면 어떻게 될까요? fuzzer ferret이 코드베이스 주변을 돌아다니면서 이 유쾌한 출력을 볼 수 있습니다 .