coffeeldr 0.3.4

A COFF (Common Object File Format) loader written in Rust
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
131
132
133
134
135
136
137
138
139
140
141

//! Errors returned by this crate.
//!
//! This module contains the definitions for all error types returned by this crate.

use alloc::string::String;
use thiserror::Error;

/// Result alias for CoffeeLdr operations.
pub type Result<T> = core::result::Result<T, CoffeeLdrError>;

/// Represents all possible errors that can occur in the COFF loader.
#[derive(Debug, Error)]
pub enum CoffeeLdrError {
    /// Generic error with descriptive message.
    #[error("{0}")]
    Msg(String),

    /// Error returned by the `binrw` parser while reading or deserializing COFF data.
    #[error("binrw error: {0}")]
    Binrw(binrw::Error),

    /// Hexadecimal encoding or decoding failure.
    #[error("hex error: {0}")]
    Hex(hex::FromHexError),

    /// I/O read or write failure.
    #[error("io error: {0}")]
    Io(binrw::io::Error),

    /// Nested COFF parsing or validation error.
    #[error("coff error: {0}")]
    CoffError(#[from] CoffError),

    /// Memory allocation failure.
    #[error("memory allocation error: code {0}")]
    MemoryAllocationError(u32),

    /// Memory protection or permission failure.
    #[error("memory protection error: code {0}")]
    MemoryProtectionError(u32),

    /// Invalid or malformed symbol format.
    #[error("invalid symbol format: '{0}'")]
    InvalidSymbolFormat(String),

    /// Unsupported relocation type.
    #[error("invalid relocation type: {0}")]
    InvalidRelocationType(u16),

    /// Symbol not found during resolution.
    #[error("symbol not found: '{0}'")]
    FunctionNotFound(String),

    /// Internal symbol could not be resolved.
    #[error("internal symbol not found: '{0}'")]
    FunctionInternalNotFound(String),

    /// Target module could not be resolved.
    #[error("module not found: '{0}'")]
    ModuleNotFound(String),

    /// Failed to parse or load COFF file.
    #[error("error loading COFF file")]
    ParsingError,

    /// Architecture mismatch between file and host.
    #[error("arch mismatch: expected {expected}, actual {actual}")]
    ArchitectureMismatch { expected: &'static str, actual: &'static str },

    /// File contains more symbols than supported.
    #[error("too many symbols (max {0})")]
    TooManySymbols(usize),

    /// Failed to parse symbol entry.
    #[error("symbol parse error: '{0}'")]
    ParseError(String),

    /// Symbol ignored due to missing required prefix.
    #[error("symbol ignored (missing required prefix)")]
    SymbolIgnored,

    /// Error reading or flushing output buffer.
    #[error("output read error")]
    OutputError,

    /// `.text` section could not be located.
    #[error("missing .text section in target module")]
    StompingTextSectionNotFound,

    /// COFF too large to overwrite target module.
    #[error("stomping size overflow")]
    StompingSizeOverflow,

    /// Missing base address during module stomping.
    #[error("missing base address for target section")]
    MissingStompingBaseAddress,
}

/// Represents specific errors during COFF parsing or validation.
#[derive(Debug, Error)]
pub enum CoffError {
    /// File could not be opened or read.
    #[error("file read error: {0}")]
    FileReadError(String),

    /// COFF header is invalid or missing.
    #[error("invalid COFF header")]
    InvalidCoffFile,

    /// COFF symbol table could not be read.
    #[error("invalid COFF symbols")]
    InvalidCoffSymbolsFile,

    /// COFF section headers are invalid or missing.
    #[error("invalid COFF section headers")]
    InvalidCoffSectionFile,

    /// Architecture not supported (expected x64 or x86).
    #[error("unsupported architecture")]
    UnsupportedArchitecture,

    /// Invalid section or symbol count.
    #[error("invalid number of sections or symbols")]
    InvalidSectionsOrSymbols,

    /// Section count exceeds supported limit.
    #[error("section limit exceeded (max 96)")]
    SectionLimitExceeded,
}

impl From<hex::FromHexError> for CoffeeLdrError {
    fn from(err: hex::FromHexError) -> Self {
        CoffeeLdrError::Hex(err)
    }
}

impl From<binrw::io::Error> for CoffeeLdrError {
    fn from(err: binrw::io::Error) -> Self {
        CoffeeLdrError::Binrw(binrw::Error::Io(err))
    }
}