schnauzer 0.3.5

Library for parsing Mach-O files
Documentation 
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
113
114
115

use super::Printer;
use super::Result;
use crate::auto_enum_fields::*;
use crate::*;
use colored::*;

pub(super) struct DefaultHandler {
    printer: Printer,
}

impl DefaultHandler {
    pub(super) fn new(printer: Printer) -> Self {
        DefaultHandler { printer }
    }
}

impl DefaultHandler {
    pub(super) fn handle_object(&self, object: ObjectType, _other_args: Vec<String>) -> Result<()> {
        self.handle_object_type(object);
        Ok(())
    }
}

impl DefaultHandler {
    fn handle_object_type(&self, obj: ObjectType) {
        match obj {
            ObjectType::Fat(fat) => self.handle_fat(fat),
            ObjectType::MachO(macho) => self.handle_macho(macho, false),
        }
    }

    fn handle_fat(&self, fat: FatObject) {
        for arch in fat.arch_iterator() {
            self.handle_arch(arch);
        }
    }

    fn handle_arch(&self, arch: FatArch) {
        self.printer.print_line(format!("{}", "Fat arch:".bold().bright_white()));

        for field in arch.all_fields() {
            self.printer.out_dashed_field(&field.name, &field.value, 0);
        }
        self.printer
            .out_dashed_field("Mach header", "", 0);

        self.handle_macho(arch.object().unwrap(), true);
    }

    fn handle_macho(&self, macho: MachObject, nested: bool) {
        let level = match nested {
            true => 2,
            false => 1,
        };

        let h = macho.header();
        for field in h.all_fields() {
            self.printer
                .out_dashed_field(&field.name, &field.value, level);
        }
        self.printer
            .out_dashed_field("Load commands", "", level);

        self.handle_load_commands(macho.load_commands_iterator(), level + 1);
    }

    fn handle_load_commands(&self, commands: LoadCommandIterator, level: usize) {
        for (index, cmd) in commands.enumerate() {
            self.printer.out_list_item_dash(level, index);
            self.printer.out_field(
                "cmd".bright_white(),
                fmt_ext::load_command_to_string(cmd.cmd).yellow(),
                " ",
            );
            self.printer.out_field(
                "cmdsize".bright_white(),
                cmd.cmdsize.to_string().yellow(),
                "\n",
            );

            self.handle_command_variant(cmd.variant, level + 1);
        }
    }

    fn handle_command_variant(&self, variant: LcVariant, level: usize) {
        for field in variant.all_fields() {
            self.printer.out_field_dash(level);
            self.printer
                .out_default_colored_field(&field.name, &field.value, "\n");
        }
        match variant {
            LcVariant::Segment32(seg) => self.handle_segment_command(seg, level),
            LcVariant::Segment64(seg) => self.handle_segment_command(seg, level),
            _ => (),
        }
    }

    fn handle_segment_command(&self, seg: LcSegment, level: usize) {
        if seg.nsects > 0 {
            self.printer
                .out_dashed_field("Sections", "", level);
        }
        for section in seg.sections_iterator() {
            self.handle_section(section, level + 1);
            self.printer.out_tile(level + 1);
        }
    }

    fn handle_section(&self, section: Section, level: usize) {
        for field in section.all_fields() {
            self.printer
                .out_dashed_field(&field.name, &field.value, level + 1);
        }
    }
}