refactor: align platform crate boundaries

senbei-engine/src/android/extract/error.rs

@@ -14,7 +14,7 @@ pub enum Error {
     Elf {
         path: PathBuf,
         #[source]
-        source: goblin::error::Error,
+        source: senbei_elf::Error,
     },
     #[error("serialize extraction index: {0}")]
     Json(#[from] serde_json::Error),

senbei-engine/src/android/extract/pipeline.rs

@@ -1,14 +1,12 @@
 use std::collections::{BTreeMap, BTreeSet, HashSet};
-use std::fs::{File, create_dir_all};
-use std::io::Write;
+use std::fs::File;
 use std::path::{Path, PathBuf};
 
 use memmap2::MmapOptions;
 use senbei_crypto::android::{Module9bConfig, decode_container};
 use serde_json::to_vec_pretty;
-use sha2::{Digest, Sha256};
-use tempfile::NamedTempFile;
 
+use super::super::common;
 use super::error::{Error, Result, invalid};
 use super::report::{
     ArtifactReport, DecoderReport, ExtractionReport, ModuleRegistryEntry, RecordReport,
@@ -86,7 +84,7 @@ pub fn extract_stage2(options: &ExtractOptions) -> Result<ExtractionReport> {
             return invalid("refusing to overwrite the protected ELF with Stage 2 output");
         }
     }
-    create_dir_all(&output_dir)
+    std::fs::create_dir_all(&output_dir)
         .map_err(|source| Error::io("create Stage 2 output directory", &output_dir, source))?;
 
     let file = File::open(&input_path)
@@ -497,42 +495,14 @@ fn write_json_atomic(path: &Path, value: &impl serde::Serialize) -> Result<()> {
 }
 
 fn write_atomic(path: &Path, data: &[u8]) -> Result<()> {
-    let parent = path.parent().unwrap_or_else(|| Path::new("."));
-    create_dir_all(parent)
-        .map_err(|source| Error::io("create output directory", parent, source))?;
-    let mut temporary = NamedTempFile::new_in(parent)
-        .map_err(|source| Error::io("create temporary output", parent, source))?;
-    temporary
-        .write_all(data)
-        .and_then(|()| temporary.as_file().sync_all())
-        .map_err(|source| Error::io("write temporary output", temporary.path(), source))?;
-    temporary
-        .persist(path)
-        .map_err(|error| Error::io("replace output", path, error.error))?;
-    Ok(())
+    common::write_atomic(path, data)
+        .map_err(|source| Error::io("write temporary output", path, source))
 }
 
 fn absolute(path: &Path) -> Result<PathBuf> {
-    if path.is_absolute() {
-        Ok(path.to_path_buf())
-    } else {
-        std::env::current_dir()
-            .map(|current| current.join(path))
-            .map_err(|source| Error::io("query current directory", path, source))
-    }
+    common::absolute(path).map_err(|source| Error::io("query current directory", path, source))
 }
 
 fn sha256(data: &[u8]) -> String {
-    let mut digest = Sha256::new();
-    digest.update(data);
-    hex_digest(&digest.finalize())
-}
-/// Lowercase hex of a digest output (sha2 0.11's `Array` no longer formats as
-/// hex directly).
-fn hex_digest(data: &[u8]) -> String {
-    let mut out = String::with_capacity(data.len() * 2);
-    for byte in data {
-        out.push_str(&format!("{byte:02x}"));
-    }
-    out
+    common::sha256(data)
 }

senbei-engine/src/android/extract/probe.rs

@@ -7,9 +7,6 @@ use super::stage1::{self, DEFAULT_CIPHER_CONSTANT, DEFAULT_OUTER_SIZE};
 /// Return whether `data` has a supported protected AArch64 IL2CPP layout.
 #[must_use]
 pub fn is_protected_libil2cpp(data: &[u8]) -> bool {
-    if !stage1::looks_protected(data) {
-        return false;
-    }
     let Ok(stage1) = stage1::inspect(
         data,
         Path::new("<probe>"),

senbei-engine/src/android/extract/stage1.rs

@@ -1,44 +1,13 @@
 use std::path::Path;
 
-use goblin::elf::{Elf, header::EM_AARCH64};
+use senbei_elf::{AARCH64_MACHINE, Error as ElfError, parse};
 
 use super::error::{Error, Result, invalid};
 
-pub(crate) const SHT_LOUSER: u32 = 0x8000_0000;
+pub(crate) use senbei_elf::SHT_LOUSER;
 pub const DEFAULT_CIPHER_CONSTANT: u32 = 0xbf20_165d;
 pub const DEFAULT_OUTER_SIZE: usize = 0x23c;
 
-pub(crate) fn looks_protected(data: &[u8]) -> bool {
-    let Ok(elf) = Elf::parse(data) else {
-        return false;
-    };
-    if elf.header.e_machine != EM_AARCH64
-        || elf
-            .section_headers
-            .iter()
-            .filter(|section| section.sh_type == SHT_LOUSER)
-            .count()
-            != 1
-    {
-        return false;
-    }
-    [
-        ".dynsym",
-        ".dynstr",
-        ".gnu.hash",
-        ".gnu.version",
-        ".gnu.version_r",
-    ]
-    .into_iter()
-    .all(|wanted| {
-        elf.section_headers.iter().any(|section| {
-            elf.shdr_strtab
-                .get_at(section.sh_name)
-                .is_some_and(|name| name == wanted)
-        })
-    })
-}
-
 #[derive(Debug, Clone, Copy)]
 pub(crate) struct Stage1Header {
     pub key: u32,
@@ -70,13 +39,13 @@ pub(crate) fn inspect(
     outer_size: usize,
     cipher_constant: u32,
 ) -> Result<Stage1Result> {
-    let elf = Elf::parse(data).map_err(|source| Error::Elf {
+    let elf = parse(data).map_err(|source: ElfError| Error::Elf {
         path: path.to_path_buf(),
         source,
     })?;
-    if elf.header.e_machine != EM_AARCH64 {
+    if elf.header.e_machine != AARCH64_MACHINE {
         return invalid(format!(
-            "expected AArch64 ELF (machine 0x{EM_AARCH64:X}), got 0x{:X}",
+            "expected AArch64 ELF (machine 0x{AARCH64_MACHINE:X}), got 0x{:X}",
             elf.header.e_machine
         ));
     }
@@ -92,6 +61,15 @@ pub(crate) fn inspect(
             matches.len()
         ));
     }
+    for wanted in senbei_elf::PROBE_SECTION_NAMES {
+        if !elf.section_headers.iter().any(|section| {
+            elf.shdr_strtab
+                .get_at(section.sh_name)
+                .is_some_and(|name| name == wanted)
+        }) {
+            return invalid(format!("protected ELF lacks required section {wanted}"));
+        }
+    }
     let (section_index, section) = matches[0];
     let section_offset = usize::try_from(section.sh_offset)
         .map_err(|_| Error::Invalid("SHT_LOUSER offset exceeds usize".to_owned()))?;