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

//! Certificate fields.

use crate::Error;
use core::fmt;

/// Certificate fields.
///
/// This type is primarily used by the certificate builder for reporting
/// errors in certificates.
#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
pub enum Field {
    /// Subject public key
    PublicKey,

    /// Nonce
    Nonce,

    /// Serial number
    Serial,

    /// Certificate type: user or host
    Type,

    /// Key ID
    KeyId,

    /// Valid principals
    ValidPrincipals,

    /// Valid after (Unix time)
    ValidAfter,

    /// Valid before (Unix time)
    ValidBefore,

    /// Critical options
    CriticalOptions,

    /// Extensions
    Extensions,

    /// Signature key (i.e. CA key)
    SignatureKey,

    /// Signature
    Signature,

    /// Comment
    Comment,
}

impl Field {
    /// Get the field name as a string
    pub fn as_str(self) -> &'static str {
        match self {
            Self::PublicKey => "public key",
            Self::Nonce => "nonce",
            Self::Serial => "serial",
            Self::Type => "type",
            Self::KeyId => "key id",
            Self::ValidPrincipals => "valid principals",
            Self::ValidAfter => "valid after",
            Self::ValidBefore => "valid before",
            Self::CriticalOptions => "critical options",
            Self::Extensions => "extensions",
            Self::SignatureKey => "signature key",
            Self::Signature => "signature",
            Self::Comment => "comment",
        }
    }

    /// Get an [`Error`] that this field is invalid.
    pub fn invalid_error(self) -> Error {
        Error::CertificateFieldInvalid(self)
    }
}

impl AsRef<str> for Field {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl fmt::Display for Field {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}