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
100
101
102
103
104
105
106
107
108
109
110
111
112

use goblin::mach::{cputype::get_arch_from_flag, Mach, MultiArch};

use crate::error::Error;

/// Mach-O fat binary reader
#[derive(Debug)]
pub struct FatReader<'a> {
    buffer: &'a [u8],
    fat: MultiArch<'a>,
}

impl<'a> FatReader<'a> {
    /// Parse a Mach-O FAT binary from a buffer
    pub fn new(buffer: &'a [u8]) -> Result<Self, Error> {
        match Mach::parse(buffer)? {
            Mach::Fat(fat) => Ok(Self { buffer, fat }),
            Mach::Binary(_) => Err(Error::NotFatBinary),
        }
    }

    /// Extract thin binary by arch name
    pub fn extract(&self, arch_name: &str) -> Option<&'a [u8]> {
        if let Some((cpu_type, _cpu_subtype)) = get_arch_from_flag(arch_name) {
            return self
                .fat
                .find_cputype(cpu_type)
                .unwrap_or_default()
                .map(|arch| arch.slice(self.buffer));
        }
        None
    }
}

#[cfg(test)]
mod test {
    use std::fs;

    use goblin::Object;

    use super::FatReader;
    use crate::error::Error;

    #[test]
    fn test_fat_reader_dylib() {
        let buf = fs::read("tests/fixtures/simplefat.dylib").unwrap();
        let reader = FatReader::new(&buf);
        assert!(reader.is_ok());
    }

    #[test]
    fn test_fat_reader_exe() {
        let buf = fs::read("tests/fixtures/simplefat").unwrap();
        let reader = FatReader::new(&buf);
        assert!(reader.is_ok());
    }

    #[test]
    fn test_fat_reader_ar() {
        let buf = fs::read("tests/fixtures/simplefat.a").unwrap();
        let reader = FatReader::new(&buf);
        assert!(reader.is_ok());
    }

    #[test]
    fn test_fat_reader_not_fat() {
        let buf = fs::read("tests/fixtures/thin_x86_64").unwrap();
        let reader = FatReader::new(&buf);
        assert!(reader.is_err());
        assert!(matches!(reader.unwrap_err(), Error::NotFatBinary));

        let buf = fs::read("tests/fixtures/thin_arm64").unwrap();
        let reader = FatReader::new(&buf);
        assert!(reader.is_err());
        assert!(matches!(reader.unwrap_err(), Error::NotFatBinary));
    }

    #[test]
    fn test_fat_reader_extract_dylib() {
        let buf = fs::read("tests/fixtures/simplefat.dylib").unwrap();
        let reader = FatReader::new(&buf).unwrap();
        let x86_64 = reader.extract("x86_64").unwrap();
        let x86_64_obj = Object::parse(x86_64).unwrap();
        assert!(matches!(x86_64_obj, Object::Mach(_)));
        let arm64 = reader.extract("arm64").unwrap();
        let arm64_obj = Object::parse(arm64).unwrap();
        assert!(matches!(arm64_obj, Object::Mach(_)));
    }

    #[test]
    fn test_fat_reader_extract_exe() {
        let buf = fs::read("tests/fixtures/simplefat").unwrap();
        let reader = FatReader::new(&buf).unwrap();
        let x86_64 = reader.extract("x86_64").unwrap();
        let x86_64_obj = Object::parse(x86_64).unwrap();
        assert!(matches!(x86_64_obj, Object::Mach(_)));
        let arm64 = reader.extract("arm64").unwrap();
        let arm64_obj = Object::parse(arm64).unwrap();
        assert!(matches!(arm64_obj, Object::Mach(_)));
    }

    #[test]
    fn test_fat_reader_extract_ar() {
        let buf = fs::read("tests/fixtures/simplefat.a").unwrap();
        let reader = FatReader::new(&buf).unwrap();
        let x86_64 = reader.extract("x86_64").unwrap();
        let x86_64_obj = Object::parse(x86_64).unwrap();
        assert!(matches!(x86_64_obj, Object::Archive(_)));
        let arm64 = reader.extract("arm64").unwrap();
        let arm64_obj = Object::parse(arm64).unwrap();
        assert!(matches!(arm64_obj, Object::Archive(_)));
    }
}