threatflux-binary-analysis 0.2.0

Comprehensive binary analysis library with multi-format support, disassembly, and security analysis
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

//! Raw binary format parser

use crate::{
    types::{
        Architecture, BinaryFormat as Format, BinaryMetadata, Endianness, Export, Import, Section,
        SectionPermissions, SectionType, SecurityFeatures, Symbol,
    },
    BinaryFormatParser, BinaryFormatTrait, Result,
};

/// Raw binary format parser
pub struct RawParser;

impl BinaryFormatParser for RawParser {
    fn parse(data: &[u8]) -> Result<Box<dyn BinaryFormatTrait>> {
        Ok(Box::new(RawBinary::new(data)))
    }

    fn can_parse(_data: &[u8]) -> bool {
        true // Raw parser can handle any data
    }
}

/// Raw binary representation
pub struct RawBinary {
    #[allow(dead_code)]
    data: Vec<u8>,
    metadata: BinaryMetadata,
    sections: Vec<Section>,
}

impl RawBinary {
    fn new(data: &[u8]) -> Self {
        let metadata = BinaryMetadata {
            size: data.len(),
            format: Format::Raw,
            architecture: Architecture::Unknown,
            entry_point: None,
            base_address: Some(0),
            timestamp: None,
            compiler_info: None,
            endian: Endianness::Little,
            security_features: SecurityFeatures::default(),
        };

        // Create a single section for the entire data
        let sections = vec![Section {
            name: ".data".to_string(),
            address: 0,
            size: data.len() as u64,
            offset: 0,
            permissions: SectionPermissions {
                read: true,
                write: false,
                execute: false,
            },
            section_type: SectionType::Data,
            data: if data.len() <= 1024 {
                Some(data.to_vec())
            } else {
                None
            },
        }];

        Self {
            data: data.to_vec(),
            metadata,
            sections,
        }
    }
}

impl BinaryFormatTrait for RawBinary {
    fn format_type(&self) -> Format {
        Format::Raw
    }

    fn architecture(&self) -> Architecture {
        Architecture::Unknown
    }

    fn entry_point(&self) -> Option<u64> {
        None
    }

    fn sections(&self) -> &[Section] {
        &self.sections
    }

    fn symbols(&self) -> &[Symbol] {
        &[] // No symbols in raw binary
    }

    fn imports(&self) -> &[Import] {
        &[] // No imports in raw binary
    }

    fn exports(&self) -> &[Export] {
        &[] // No exports in raw binary
    }

    fn metadata(&self) -> &BinaryMetadata {
        &self.metadata
    }
}