vsmtp-config 2.2.1

Next-gen MTA. Secured, Faster and Greener
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

/*
 * vSMTP mail transfer agent
 * Copyright (C) 2022 viridIT SAS
 *
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see https://www.gnu.org/licenses/.
 *
*/
use crate::{
    field::{FieldServerVirtualTls, SecretFile},
    parser::{tls_certificate, tls_private_key},
};
use vsmtp_auth::dkim;

impl<'de> serde::Deserialize<'de> for SecretFile<rustls::PrivateKey> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <String as serde::Deserialize>::deserialize(deserializer)?;
        Ok(Self {
            inner: tls_private_key::from_path(&s).map_err(serde::de::Error::custom)?,
            path: s.into(),
        })
    }
}

impl<'de> serde::Deserialize<'de> for SecretFile<Vec<rustls::Certificate>> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <String as serde::Deserialize>::deserialize(deserializer)?;
        Ok(Self {
            inner: tls_certificate::from_path(&s).map_err(serde::de::Error::custom)?,
            path: s.into(),
        })
    }
}

impl<'de> serde::Deserialize<'de> for SecretFile<rsa::RsaPrivateKey> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <String as serde::Deserialize>::deserialize(deserializer)?;
        Ok(Self {
            inner: <rsa::RsaPrivateKey as rsa::pkcs8::DecodePrivateKey>::read_pkcs8_pem_file(&s)
                .or_else(|_| {
                    <rsa::RsaPrivateKey as rsa::pkcs1::DecodeRsaPrivateKey>::read_pkcs1_pem_file(&s)
                })
                .map_err(serde::de::Error::custom)?,
            path: s.into(),
        })
    }
}

impl<'de> serde::Deserialize<'de> for SecretFile<std::sync::Arc<dkim::PrivateKey>> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let filepath = <String as serde::Deserialize>::deserialize(deserializer)?;

        let rsa =
            <rsa::RsaPrivateKey as rsa::pkcs8::DecodePrivateKey>::read_pkcs8_pem_file(&filepath)
                .or_else(|_| {
                    <rsa::RsaPrivateKey as rsa::pkcs1::DecodeRsaPrivateKey>::read_pkcs1_pem_file(
                        &filepath,
                    )
                });

        if let Ok(rsa) = rsa {
            return Ok(Self {
                inner: std::sync::Arc::new(dkim::PrivateKey::Rsa(Box::new(rsa))),
                path: filepath.into(),
            });
        }

        let content = std::fs::read_to_string(&filepath)
            .map_err(|e| serde::de::Error::custom(format!("Read '{filepath}' produced: '{e}'")))?;

        let content_pem = pem::parse(content).map_err(|e| {
            serde::de::Error::custom(format!("Parsing '{filepath}' produced: '{e}'"))
        })?;

        let ed25519 = ring_compat::ring::signature::Ed25519KeyPair::from_pkcs8_maybe_unchecked(
            &content_pem.contents,
        )
        .map_err(|e| {
            serde::de::Error::custom(format!("Failed to parse '{filepath}' as ed25519: '{e}'"))
        })?;

        Ok(Self {
            inner: std::sync::Arc::new(dkim::PrivateKey::Ed25519(Box::new(ed25519))),
            path: filepath.into(),
        })
    }
}

impl FieldServerVirtualTls {
    /// create a virtual tls configuration from the certificate & private key paths.
    ///
    /// # Errors
    ///
    /// * certificate file not found.
    /// * private key file not found.
    pub fn from_path(certificate: &str, private_key: &str) -> anyhow::Result<Self> {
        Ok(Self {
            certificate: SecretFile::<Vec<rustls::Certificate>> {
                inner: tls_certificate::from_path(certificate)?,
                path: certificate.into(),
            },
            private_key: SecretFile::<rustls::PrivateKey> {
                inner: tls_private_key::from_path(private_key)?,
                path: private_key.into(),
            },
        })
    }
}