osslsigncode 0.1.0

In-process Rust bindings for the vendored osslsigncode Authenticode implementation
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

//! Cryptographic digest and related typed values.
//!
//! ```
//! use osslsigncode::{Digest, LeafHash};
//!
//! assert_eq!(Digest::default(), Digest::Sha256);
//! assert_eq!(Digest::Sha256.to_string(), "sha256");
//!
//! let leaf = LeafHash { digest: Digest::Sha1, hex: "deadbeef" };
//! assert_eq!(leaf.digest, Digest::Sha1);
//! assert_eq!(leaf.hex, "deadbeef");
//! assert_eq!(leaf.to_string(), "sha1:deadbeef");
//! ```

use std::fmt;

/// Digest algorithm used for Authenticode hashing.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Hash)]
#[non_exhaustive]
pub enum Digest {
    /// MD5.
    Md5,
    /// SHA-1.
    Sha1,
    /// SHA-256.
    #[default]
    Sha256,
    /// SHA-384.
    Sha384,
    /// SHA-512.
    Sha512,
}

impl AsRef<str> for Digest {
    fn as_ref(&self) -> &str {
        match self {
            Self::Md5 => "md5",
            Self::Sha1 => "sha1",
            Self::Sha256 => "sha256",
            Self::Sha384 => "sha384",
            Self::Sha512 => "sha512",
        }
    }
}

impl fmt::Display for Digest {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_ref())
    }
}

/// Microsoft Internet Explorer 4.x CAB permission level.
///
/// Upstream only supports [`JpLevel::Low`].
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
#[non_exhaustive]
pub enum JpLevel {
    Low,
    Medium,
    High,
}

impl AsRef<str> for JpLevel {
    fn as_ref(&self) -> &str {
        match self {
            Self::Low => "low",
            Self::Medium => "medium",
            Self::High => "high",
        }
    }
}

impl fmt::Display for JpLevel {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_ref())
    }
}

/// Required leaf-certificate digest for [`crate::Verify`].
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub struct LeafHash<'a> {
    /// Digest algorithm.
    pub digest: Digest,
    /// Hex-encoded hash of the leaf certificate.
    pub hex: &'a str,
}

impl fmt::Display for LeafHash<'_> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(formatter, "{}:{}", self.digest, self.hex)
    }
}