runar-keys 0.1.0

Standards-compliant X.509 certificates and ECDSA P-256 key management for Runar
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

//! Error types for the certificate system

use thiserror::Error;

/// Result type alias for certificate operations
pub type Result<T> = std::result::Result<T, KeyError>;

/// Comprehensive error types for certificate operations
#[derive(Error, Debug)]
pub enum KeyError {
    #[error("Invalid key format: {0}")]
    InvalidKeyFormat(String),

    #[error("Certificate error: {0}")]
    CertificateError(String),

    #[error("Validation error: {0}")]
    ValidationError(String),

    #[error("Encoding error: {0}")]
    EncodingError(String),

    #[error("Signing error: {0}")]
    SigningError(String),

    #[error("Network error: {0}")]
    NetworkError(String),

    #[error("Unsupported algorithm: {0}")]
    UnsupportedAlgorithm(String),

    #[error("IO error: {0}")]
    IoError(#[from] std::io::Error),

    #[error("PKCS8 error: {0}")]
    Pkcs8Error(#[from] pkcs8::Error),

    #[error("ECDSA error: {0}")]
    EcdsaError(#[from] p256::ecdsa::Error),

    #[error("OpenSSL error: {0}")]
    OpenSslError(#[from] openssl::error::ErrorStack),

    #[error("X509 parser error: {0}")]
    X509ParserError(String),

    #[error("Certificate validation error: {0}")]
    CertificateValidationError(String),

    #[error("Chain validation error: {0}")]
    ChainValidationError(String),

    #[error("Invalid operation: {0}")]
    InvalidOperation(String),

    #[error("Key not found: {0}")]
    KeyNotFound(String),

    #[error("Certificate not found: {0}")]
    CertificateNotFound(String),

    #[error("Encryption error: {0}")]
    EncryptionError(String),

    #[error("Decryption error: {0}")]
    DecryptionError(String),

    #[error("Key derivation error: {0}")]
    KeyDerivationError(String),

    #[error("ECDH error: {0}")]
    EcdhError(String),

    #[error("Symmetric cipher error: {0}")]
    SymmetricCipherError(String),

    #[error("Key already initialized: {0}")]
    KeyAlreadyInitialized(String),
}

// Convert from rcgen errors
impl From<rcgen::Error> for KeyError {
    fn from(err: rcgen::Error) -> Self {
        KeyError::CertificateError(err.to_string())
    }
}

// Convert from x509-parser errors
impl From<x509_parser::error::X509Error> for KeyError {
    fn from(err: x509_parser::error::X509Error) -> Self {
        KeyError::X509ParserError(err.to_string())
    }
}

impl From<x509_parser::nom::Err<x509_parser::error::X509Error>> for KeyError {
    fn from(err: x509_parser::nom::Err<x509_parser::error::X509Error>) -> Self {
        KeyError::X509ParserError(format!("Parse error: {err}"))
    }
}