exfiltrate 0.2.1

An embeddable debug tool for 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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

// SPDX-License-Identifier: MIT OR Apache-2.0
use exfiltrate::command::Command;
use exfiltrate_internal::command::{FileInfo, ImageInfo, Response};

struct HelloWorld;
impl Command for HelloWorld {
    fn name(&self) -> &'static str {
        "hello_world"
    }

    fn short_description(&self) -> &'static str {
        "Returns a hello world message.  Use this to test exfiltrate"
    }

    fn full_description(&self) -> &'static str {
        "Returns a hello world message.  Use this to test exfiltrate"
    }

    fn execute(&self, _args: Vec<String>) -> Result<Response, Response> {
        Ok("hello world".into())
    }
}

struct ImageGen;
impl Command for ImageGen {
    fn name(&self) -> &'static str {
        "image_gen"
    }

    fn short_description(&self) -> &'static str {
        "Generates a test image.  Use this to test exfiltrate's image capabilities."
    }

    fn full_description(&self) -> &'static str {
        self.short_description()
    }

    fn execute(&self, _args: Vec<String>) -> Result<Response, Response> {
        let size: u32 = 255;
        let size_u8 = size.try_into().unwrap();
        let mut data = Vec::with_capacity(size as usize * size as usize);
        for r in 0..size_u8 {
            for g in 0..size_u8 {
                let b = 255u8.saturating_sub(r / 2).saturating_sub(g / 2);
                let pixel = rgb::RGBA { r, g, b, a: 255 };
                data.push(pixel);
            }
        }
        Ok(ImageInfo::new(data, size, None).into())
    }
}

struct MultiImageGen;
impl Command for MultiImageGen {
    fn name(&self) -> &'static str {
        "multi_image_gen"
    }

    fn short_description(&self) -> &'static str {
        "Generates multiple test images.  Use this to test exfiltrate's multiple image capabilities."
    }

    fn full_description(&self) -> &'static str {
        self.short_description()
    }

    fn execute(&self, _args: Vec<String>) -> Result<Response, Response> {
        let mut images = Vec::new();

        // Generate 3 different colored images
        for color_shift in 0..3 {
            let size: u32 = 100;
            let size_u8 = size.try_into().unwrap();
            let mut data = Vec::with_capacity(size as usize * size as usize);

            for r in 0..size_u8 {
                for g in 0..size_u8 {
                    let pixel = match color_shift {
                        0 => rgb::RGBA { r, g, b: 0, a: 255 }, // Red-Green gradient
                        1 => rgb::RGBA {
                            r: 0,
                            g,
                            b: r,
                            a: 255,
                        }, // Green-Blue gradient
                        _ => rgb::RGBA {
                            r,
                            g: 0,
                            b: r,
                            a: 255,
                        }, // Red-Blue gradient
                    };
                    data.push(pixel);
                }
            }

            let remark = Some(format!("Test image {}", color_shift + 1));
            images.push(ImageInfo::new(data, size, remark));
        }

        Ok(images.into())
    }
}

struct MultiFileGen;
impl Command for MultiFileGen {
    fn name(&self) -> &'static str {
        "multi_file_gen"
    }

    fn short_description(&self) -> &'static str {
        "Generates multiple test files.  Use this to test exfiltrate's multiple file capabilities."
    }

    fn full_description(&self) -> &'static str {
        self.short_description()
    }

    fn execute(&self, _args: Vec<String>) -> Result<Response, Response> {
        let files = vec![
            FileInfo::new(
                "txt".to_string(),
                Some("First test file".to_string()),
                b"This is the first test file.\nIt has multiple lines.\n".to_vec(),
            ),
            FileInfo::new(
                "txt".to_string(),
                Some("Second test file".to_string()),
                b"This is the second test file.\nWith different content.\n".to_vec(),
            ),
            FileInfo::new(
                "json".to_string(),
                Some("JSON test file".to_string()),
                b"{\"test\": true, \"value\": 123}".to_vec(),
            ),
        ];

        Ok(files.into())
    }
}

fn main() {
    exfiltrate::begin();
    #[cfg(feature = "logwise")]
    {
        logwise::warn_sync!("Hello from logwise!");
    }
    exfiltrate::add_command(HelloWorld);
    exfiltrate::add_command(ImageGen);
    exfiltrate::add_command(MultiImageGen);
    exfiltrate::add_command(MultiFileGen);

    #[cfg(not(target_arch = "wasm32"))]
    std::thread::park();
    //wasm32: atomics.wait cannot be called in this context
}