checksec 0.0.6

Fast multi-platform (ELF/PE/MachO) binary checksec command line utility and library.
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#[cfg(feature = "color")]
use colored::*;
use serde::{Deserialize, Serialize};
use std::fmt;

use checksec::elf::ElfCheckSecResults;
use checksec::macho::MachOCheckSecResults;
use checksec::pe::PECheckSecResults;

#[derive(Debug, Deserialize, PartialEq, Serialize)]
pub enum BinType {
    Elf32,
    Elf64,
    PE32,
    PE64,
    MachO32,
    MachO64,
}
#[cfg(not(feature = "color"))]
impl fmt::Display for BinType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match *self {
            BinType::Elf32 => write!(f, "ELF32"),
            BinType::Elf64 => write!(f, "ELF64"),
            BinType::PE32 => write!(f, "PE32"),
            BinType::PE64 => write!(f, "PE64"),
            BinType::MachO32 => write!(f, "MachO32"),
            BinType::MachO64 => write!(f, "MachO64"),
        }
    }
}
#[cfg(feature = "color")]
impl fmt::Display for BinType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match *self {
            BinType::Elf32 => write!(f, "{}", "ELF32".bold().underline()),
            BinType::Elf64 => write!(f, "{}", "ELF64".bold().underline()),
            BinType::PE32 => write!(f, "{}", "PE32".bold().underline()),
            BinType::PE64 => write!(f, "{}", "PE64".bold().underline()),
            BinType::MachO32 => write!(f, "{}", "MachO32".bold().underline()),
            BinType::MachO64 => write!(f, "{}", "MachO64".bold().underline()),
        }
    }
}

#[derive(Debug, Deserialize, Serialize)]
pub enum BinSpecificProperties {
    Elf(ElfCheckSecResults),
    PE(PECheckSecResults),
    MachO(MachOCheckSecResults),
}
impl fmt::Display for BinSpecificProperties {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &*self {
            BinSpecificProperties::Elf(b) => write!(f, "{}", b),
            BinSpecificProperties::PE(b) => write!(f, "{}", b),
            BinSpecificProperties::MachO(b) => write!(f, "{}", b),
        }
    }
}

#[derive(Debug, Deserialize, Serialize)]
pub struct Binary {
    pub binarytype: BinType,
    pub file: String,
    pub properties: BinSpecificProperties,
}
#[cfg(not(feature = "color"))]
impl fmt::Display for Binary {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}: | {} | File: {}",
            self.binarytype, self.properties, self.file
        )
    }
}
#[cfg(feature = "color")]
impl fmt::Display for Binary {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}: | {} | {} {}",
            self.binarytype,
            self.properties,
            "File:".bold().underline(),
            self.file.bright_blue()
        )
    }
}
impl Binary {
    pub fn new(
        binarytype: BinType,
        file: String,
        properties: BinSpecificProperties,
    ) -> Binary {
        Binary { binarytype, file, properties }
    }
}

#[derive(Deserialize, Serialize)]
pub struct Binaries {
    pub binaries: Vec<Binary>,
}
impl Binaries {
    pub fn new(binaries: Vec<Binary>) -> Binaries {
        Binaries { binaries }
    }
}

#[derive(Deserialize, Serialize)]
pub struct Process {
    pub pid: usize,
    pub binary: Vec<Binary>,
}
impl Process {
    pub fn new(pid: usize, binary: Vec<Binary>) -> Process {
        Process { pid, binary }
    }
}

#[derive(Deserialize, Serialize)]
pub struct Processes {
    pub processes: Vec<Process>,
}
impl Processes {
    pub fn new(processes: Vec<Process>) -> Processes {
        Processes { processes }
    }
}