tlsh-rs 0.1.0

Pure Rust TLSH implementation with library and CLI support.
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

use crate::{TlshDigest, TlshProfile};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HashOutputFormat {
    Text,
    Json,
}

impl HashOutputFormat {
    pub fn from_cli_name(name: &str) -> Option<Self> {
        match name {
            "text" => Some(Self::Text),
            "json" => Some(Self::Json),
            _ => None,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CompareOutputFormat {
    Text,
    Json,
    Sarif,
}

impl CompareOutputFormat {
    pub fn from_cli_name(name: &str) -> Option<Self> {
        match name {
            "text" => Some(Self::Text),
            "json" => Some(Self::Json),
            "sarif" => Some(Self::Sarif),
            _ => None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Command {
    Hash(HashCommand),
    HashMany(HashManyCommand),
    Diff(DiffCommand),
    Xref(XrefCommand),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HashCommand {
    pub profile: TlshProfile,
    pub raw: bool,
    pub format: HashOutputFormat,
    pub input: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HashManyCommand {
    pub profile: TlshProfile,
    pub raw: bool,
    pub format: HashOutputFormat,
    pub inputs: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DiffCommand {
    pub profile: TlshProfile,
    pub include_length: bool,
    pub format: CompareOutputFormat,
    pub left: String,
    pub right: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct XrefCommand {
    pub profile: TlshProfile,
    pub include_length: bool,
    pub format: CompareOutputFormat,
    pub threshold: Option<i32>,
    pub inputs: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HashRecord {
    pub input: String,
    pub profile: TlshProfile,
    pub raw: bool,
    pub digest: TlshDigest,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SimilarityFinding {
    pub left_label: String,
    pub right_label: String,
    pub diff: i32,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ComparisonReport {
    pub profile: TlshProfile,
    pub include_length: bool,
    pub findings: Vec<SimilarityFinding>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Output {
    Hash(HashRecord, HashOutputFormat),
    HashMany(Vec<HashRecord>, HashOutputFormat),
    Diff(ComparisonReport, CompareOutputFormat),
    Xref(ComparisonReport, CompareOutputFormat),
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn output_formats_parse_cli_names() {
        assert_eq!(
            HashOutputFormat::from_cli_name("text"),
            Some(HashOutputFormat::Text)
        );
        assert_eq!(
            HashOutputFormat::from_cli_name("json"),
            Some(HashOutputFormat::Json)
        );
        assert_eq!(HashOutputFormat::from_cli_name("sarif"), None);
        assert_eq!(
            CompareOutputFormat::from_cli_name("text"),
            Some(CompareOutputFormat::Text)
        );
        assert_eq!(
            CompareOutputFormat::from_cli_name("json"),
            Some(CompareOutputFormat::Json)
        );
        assert_eq!(
            CompareOutputFormat::from_cli_name("sarif"),
            Some(CompareOutputFormat::Sarif)
        );
        assert_eq!(CompareOutputFormat::from_cli_name("wat"), None);
    }
}