malwaredb 0.3.2

Service for storing malicious, benign, or unknown files and related metadata and relationships.
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

// SPDX-License-Identifier: Apache-2.0

use malwaredb_server::db::types::FileMetadata;

use std::fs::File;
use std::io::Cursor;
use std::path::PathBuf;
use std::process::ExitCode;

use anyhow::Result;
use clap::{Parser, ValueEnum};

#[derive(Clone, ValueEnum, Debug, Eq, PartialEq)]
pub enum Action {
    /// Encode a `CaRT` file
    Encode,

    /// Decode a `CaRT` file
    Decode,
}

#[derive(Parser, Clone, Debug, Eq, PartialEq)]
pub struct CartIO {
    /// Action to be performed, or no action to display `CaRT` information
    #[arg(short, long)]
    pub action: Option<Action>,

    /// Output file
    #[arg(short, long, value_hint = clap::ValueHint::FilePath)]
    pub output: Option<PathBuf>,

    /// File to encode, decode, or preview
    #[arg(value_name = "FILE", value_hint = clap::ValueHint::FilePath)]
    pub file: PathBuf,
}

impl CartIO {
    pub fn execute(&self) -> Result<ExitCode> {
        if self.output.is_none() != self.action.is_none() {
            eprintln!("Action requires an output, and vise-versa");
            return Ok(ExitCode::FAILURE);
        }

        let mut input_file = File::open(&self.file)?;

        if self.output.is_none() && self.action.is_none() {
            let mut output_buffer = Cursor::new(vec![]);

            return if let Ok((header, footer)) =
                cart_container::unpack_stream(&mut input_file, &mut output_buffer, None)
            {
                let data = output_buffer.into_inner();
                let magic = hex::encode(&data[0..10]);
                println!("First ten bytes: {magic}");
                if let Some(meta) = header {
                    if !meta.is_empty() {
                        println!("Header:");
                    }
                    for (key, value) in meta {
                        println!("{key}: {value}");
                    }
                }
                if let Some(meta) = footer {
                    if !meta.is_empty() {
                        println!("Footer:");
                    }
                    for (key, value) in meta {
                        println!("{key}: {value}");
                    }
                }
                Ok(ExitCode::SUCCESS)
            } else {
                eprintln!("{} is not a CaRT file.", self.file.display());
                Ok(ExitCode::FAILURE)
            };
        }

        let output_file = self.output.as_ref().unwrap();
        let mut output_file = File::create(output_file)?;

        match self.action.as_ref().unwrap() {
            Action::Encode => {
                let file_contents = std::fs::read(&self.file)?;
                let report = FileMetadata::new(&file_contents, None);

                let mut output_metadata = cart_container::JsonMap::new();
                output_metadata.insert("sha384".into(), report.sha384.into());
                output_metadata.insert("sha512".into(), report.sha512.into());
                output_metadata.insert("entropy".into(), report.entropy.into());
                cart_container::pack_stream(
                    &mut input_file,
                    &mut output_file,
                    Some(output_metadata),
                    None,
                    cart_container::digesters::default_digesters(),
                    None,
                )?;
            }
            Action::Decode => {
                cart_container::unpack_stream(&mut input_file, &mut output_file, None)?;
            }
        }
        Ok(ExitCode::SUCCESS)
    }
}