rbat 1.0.1

A terminal-native binary analysis tool for security researchers and reverse engineers.
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

//! # Custom Error Types
//!
//! This module defines the [`RbatError`] enumeration which encapsulates all
//! classification, disassembling, scanning, template rendering, and file I/O error states
//! produced by the RBAT core library.

use serde::Serialize;
use thiserror::Error;

/// Represents all possible error conditions returned by the RBAT core library.
#[derive(Debug, Error, Serialize)]
pub enum RbatError {
    /// Standard input/output operations error.
    #[error("I/O error occurred")]
    Io(
        #[from]
        #[serde(serialize_with = "serialize_to_string")]
        std::io::Error,
    ),

    /// Executable binary header parsing failure.
    #[error("Error occurred while parsing binary")]
    ParseError(
        #[from]
        #[serde(serialize_with = "serialize_to_string")]
        goblin::error::Error,
    ),

    /// Capstone disassembly engine failure.
    #[error("Error occurred while disassembling binary bytes")]
    DisassemblerError(
        #[from]
        #[serde(serialize_with = "serialize_to_string")]
        capstone::Error,
    ),

    /// YARA rules compilation failure.
    #[error("Error occurred while compiling YARA rules")]
    YaraCompileError(
        #[from]
        #[serde(serialize_with = "serialize_to_string")]
        yara::errors::YaraError,
    ),

    /// Memory scan execution failure in YARA backend.
    #[error("Error occurred while performing I/O with YARA")]
    YaraIO(
        #[from]
        #[serde(serialize_with = "serialize_to_string")]
        yara::Error,
    ),

    /// Serialization/deserialization failure.
    #[error("Serialization error")]
    SerializationError(
        #[from]
        #[serde(serialize_with = "serialize_to_string")]
        serde_json::Error,
    ),

    /// CLI argument parser validation failure.
    #[error("CLI error")]
    CliError(
        #[from]
        #[serde(serialize_with = "serialize_to_string")]
        clap::error::Error,
    ),

    /// Non-supported formats or corrupted machine layouts.
    #[error("Unsupported binary format: {0}")]
    UnsupportedBinaryFormat(String),

    /// Invalid entry point offsets or overlapping section boundaries.
    #[error("Invalid binary layout: {0}")]
    InvalidBinaryLayout(String),

    /// Executable section missing in elf/pe/macho headers.
    #[error("Missing executable section in binary")]
    MissingExecutableSection,

    /// Missing embedded resource (e.g. YARA rules, mnemonic blacklists).
    #[error("Missing required embedded asset: {0}")]
    MissingAsset(String),

    /// Missing analyzed data needed during reporting or aggregation.
    #[error("Missing analysis data: {0}")]
    MissingAnalysisData(String),

    /// UTF8 decoding failure.
    #[error("Invalid UTF-8 in embedded asset")]
    Utf8Error(
        #[from]
        #[serde(serialize_with = "serialize_to_string")]
        std::string::FromUtf8Error,
    ),

    /// CSV formatter error.
    #[error("csv creation error")]
    ErrorCreatingCsv(
        #[from]
        #[serde(serialize_with = "serialize_to_string")]
        csv::Error,
    ),

    /// Pipeline cancellation indicator.
    #[error("an error occurred which resulted in the cancellation of the analysis process")]
    ErrorAnalysisCancelled,

    /// Askama HTML template compilation failure.
    #[error("HTML template rendering error: {0}")]
    TemplateError(String),

    /// Fullbleed PDF compilation failure.
    #[error("PDF rendering error: {0}")]
    PdfRenderError(String),

    /// JSON serialization failure.
    #[error("JSON error: {0}")]
    JsonError(String),

    /// CSV writer output failure.
    #[error("CSV error: {0}")]
    CsvError(String),
}

fn serialize_to_string<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
where
    T: std::fmt::Display,
    S: serde::Serializer,
{
    serializer.serialize_str(&value.to_string())
}