Drop SQLite3MC legacy mode and the SQLCipher differential from the fuzzer (#30)

Author: LucaCappelletti94

README.md

@@ -3,7 +3,7 @@ name = "sqlite3mc-src-fuzz"
 version = "0.0.0"
 edition = "2021"
 publish = false
-description = "Fuzzing SQLite3MC against SQLCipher differentially, its own native ciphers for self-consistency, its rekey support, its WAL journal mode, its ATTACH DATABASE support, its backup API, and its shared-cache mode"
+description = "Fuzzing SQLite3MC's own cipher schemes for self-consistency, its rekey support, its WAL journal mode, its ATTACH DATABASE support, its backup API, and its shared-cache mode"
 
 [package.metadata]
 cargo-fuzz = true
@@ -14,16 +14,8 @@ libfuzzer-sys = "0.4.13"
 
 [build-dependencies]
 cc = "1.5.1"
-sqlcipher-src = "419"
 sqlite3mc-src = { path = ".." }
 
-[[bin]]
-name = "differential"
-path = "fuzz_targets/differential.rs"
-test = false
-doc = false
-bench = false
-
 [[bin]]
 name = "native"
 path = "fuzz_targets/native.rs"

fuzz/Cargo.lock

@@ -1,126 +1,41 @@
-//! Compiles SQLite3MC and SQLCipher into one binary, prefixing each object's globals apart.
+//! Compiles the vendored amalgamation as a plain static library.
 
-use std::{
-    env,
-    fmt::Write as _,
-    fs,
-    path::{Path, PathBuf},
-    process::Command,
-};
-
-struct Side<'a> {
-    prefix: &'a str,
-    source: PathBuf,
-    includes: &'a [&'a Path],
-    defines: &'a [(&'a str, Option<&'a str>)],
-}
+use std::{env, fs, path::PathBuf, process::Command};
 
 fn main() {
     assert_eq!(
         env::var("CARGO_CFG_TARGET_OS").as_deref(),
         Ok("linux"),
-        "the symbol renaming needs ELF objects and GNU-compatible nm and objcopy, so the fuzz crate builds on Linux only"
+        "the fuzz crate builds on Linux only"
     );
     let out = PathBuf::from(env::var_os("OUT_DIR").expect("cargo sets OUT_DIR"));
     let mc_dir = sqlite3mc_src::source_dir();
-    let sc_dir = sqlcipher_src::source_dir();
-    let common = [
+    let mut cc = cc::Build::new();
+    cc.file(mc_dir.join(sqlite3mc_src::SOURCE_FILE))
+        .warnings(false);
+    cc.include(mc_dir);
+    for (name, value) in [
+        ("SQLITE_CORE", None),
         ("SQLITE_TEMP_STORE", Some("2")),
         ("SQLITE_ENABLE_DBPAGE_VTAB", None),
         ("SQLITE_DEFAULT_MEMSTATUS", Some("0")),
-    ];
-    let mc_defines = [common.as_slice(), &[("SQLITE_CORE", None)]].concat();
-    build(
-        &Side {
-            prefix: "mc",
-            source: mc_dir.join(sqlite3mc_src::SOURCE_FILE),
-            includes: &[mc_dir],
-            defines: &mc_defines,
-        },
-        &out,
-    );
-    let crate_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
-    build(
-        &Side {
-            prefix: "sc",
-            source: sqlcipher_unit(crate_dir, sc_dir, &out),
-            includes: &[
-                sc_dir,
-                &sc_dir.join(sqlcipher_src::LIBTOMCRYPT_INCLUDE_DIR),
-                crate_dir,
-            ],
-            defines: &common,
-        },
-        &out,
-    );
-    println!("cargo:rustc-link-search=native={}", out.display());
-    for lib in ["m", "pthread", "dl"] {
-        println!("cargo:rustc-link-lib={lib}");
-    }
-    println!("cargo:rerun-if-changed=build.rs");
-    for file in [
-        "sqlcipher-wrapper.c",
-        "sqlcipher-ltc.h",
-        "sqlcipher-entropy.c",
     ] {
-        println!("cargo:rerun-if-changed={file}");
-    }
-    println!("cargo:rerun-if-env-changed=NM");
-    println!("cargo:rerun-if-env-changed=OBJCOPY");
-}
-
-fn build(side: &Side<'_>, out: &Path) {
-    let mut cc = cc::Build::new();
-    cc.file(&side.source).warnings(false);
-    for include in side.includes {
-        println!("cargo:rerun-if-changed={}", include.display());
-        cc.include(include);
-    }
-    for (name, value) in side.defines {
-        cc.define(name, *value);
+        cc.define(name, value);
     }
     instrument(&mut cc);
     let objects = cc.compile_intermediates();
     let [object] = objects.as_slice() else {
-        panic!(
-            "{} compiled to {} objects",
-            side.source.display(),
-            objects.len()
-        );
+        panic!("the amalgamation compiled to {} objects", objects.len());
     };
-
-    let map = out.join(format!("{}.redefine", side.prefix));
-    fs::write(&map, redefinitions(object, side.prefix)).expect("OUT_DIR is writable");
-    let renamed = out.join(format!("{}.o", side.prefix));
-    run(Command::new(tool("OBJCOPY", "objcopy"))
-        .arg(format!("--redefine-syms={}", map.display()))
-        .arg(object)
-        .arg(&renamed));
-
-    let archive = out.join(format!("lib{}.a", side.prefix));
+    let archive = out.join("libmc.a");
     let _ = fs::remove_file(&archive);
-    run(cc.get_archiver().arg("crs").arg(&archive).arg(&renamed));
-    println!("cargo:rustc-link-lib=static={}", side.prefix);
-}
-
-/// Writes the one translation unit SQLCipher builds from, the wrapper's configuration and SQLCipher, then every
-/// libtomcrypt source in order, then the entropy hook, all sharing one configuration as upstream's single-file
-/// libtomcrypt does.
-fn sqlcipher_unit(crate_dir: &Path, sc_dir: &Path, out: &Path) -> PathBuf {
-    let sources = std::iter::once(crate_dir.join("sqlcipher-wrapper.c"))
-        .chain(
-            sqlcipher_src::LIBTOMCRYPT_SOURCES
-                .iter()
-                .map(|source| sc_dir.join(source)),
-        )
-        .chain(std::iter::once(crate_dir.join("sqlcipher-entropy.c")));
-    let unit = sources.fold(String::new(), |mut unit, source| {
-        let _ = writeln!(unit, "#include \"{}\"", source.display());
-        unit
-    });
-    let path = out.join("sqlcipher-unit.c");
-    fs::write(&path, unit).expect("OUT_DIR is writable");
-    path
+    run(cc.get_archiver().arg("crs").arg(&archive).arg(object));
+    println!("cargo:rustc-link-search=native={}", out.display());
+    println!("cargo:rustc-link-lib=static=mc");
+    for lib in ["m", "pthread", "dl"] {
+        println!("cargo:rustc-link-lib={lib}");
+    }
+    println!("cargo:rerun-if-changed=build.rs");
 }
 
 /// Gives the C side the coverage and sanitizer instrumentation `cargo fuzz` gives the Rust side.
@@ -139,25 +54,7 @@ fn instrument(cc: &mut cc::Build) {
     }
 }
 
-/// One `old new` line per global symbol the object defines.
-fn redefinitions(object: &Path, prefix: &str) -> String {
-    let listing = run(Command::new(tool("NM", "nm"))
-        .args(["--defined-only", "--extern-only", "--format=posix"])
-        .arg(object));
-    listing
-        .lines()
-        .filter_map(|line| line.split_whitespace().next())
-        .fold(String::new(), |mut map, name| {
-            let _ = writeln!(map, "{name} {prefix}_{name}");
-            map
-        })
-}
-
-fn tool(var: &str, default: &str) -> String {
-    env::var(var).unwrap_or_else(|_| default.to_owned())
-}
-
-fn run(command: &mut Command) -> String {
+fn run(command: &mut Command) {
     let output = command
         .output()
         .unwrap_or_else(|e| panic!("cannot run {command:?}: {e}"));
@@ -166,5 +63,4 @@ fn run(command: &mut Command) -> String {
         "{command:?} failed: {}",
         String::from_utf8_lossy(&output.stderr)
     );
-    String::from_utf8(output.stdout).expect("tool output is UTF-8")
 }

fuzz/Cargo.toml

@@ -1,2 +1 @@
--�CY�����=wN� ��ת-�>�'l$(��C�[�t�z}��1�y�4p��{һ�����0����oUUW�Պqoߦ-�Ks	[�X� ��.�`ךb����D���w�mh���n0�q(TZa�LX��Eؿ�B*��~,���}�_AZ����ǩ�z�7�q��u2=��u��#-��>[,F]Z��X��މQn;]V�b����?:��K4q���h�
��	��m��
'>�;o�C��=)ûۅ�j4U��,L��x"di�9#���#V�J|wx��4ӈ��b-~/]�9�/�����|��_jQΰ=���2����n�*�s
-�
+��i�s=km�"�?6��Ǘϳ��H�E��i.��d�u4�3�8��JX7�'�(��qRp�0\�ʾ�+1:O@a�JP�po�:G�ydd�iUV�A�'â�+Ƨ�O���3	�ޤ[�듥����A��+�DM�W©�O�q�f���,lO�eL��1!ԟ4�D�=���3��H�j�i}"SD��������Bai�
�Bf�Ke�����Ɲ���㛛��ON���n���5��Z5?���T�T