dquic 0.5.0

An IETF quic transport protocol implemented natively using async Rust
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

use std::path::Path;

use rustls::pki_types::{CertificateDer, PrivateKeyDer, pem::PemObject};

pub trait ToCertificate {
    fn to_certificate(self) -> Vec<CertificateDer<'static>>;
}

impl ToCertificate for Vec<CertificateDer<'static>> {
    fn to_certificate(self) -> Vec<CertificateDer<'static>> {
        self
    }
}

impl ToCertificate for &[CertificateDer<'static>] {
    fn to_certificate(self) -> Vec<CertificateDer<'static>> {
        self.to_vec().to_certificate()
    }
}

impl<const N: usize> ToCertificate for [CertificateDer<'static>; N] {
    fn to_certificate(self) -> Vec<CertificateDer<'static>> {
        self.to_vec().to_certificate()
    }
}

impl ToCertificate for CertificateDer<'static> {
    fn to_certificate(self) -> Vec<CertificateDer<'static>> {
        vec![self]
    }
}

impl ToCertificate for &Path {
    fn to_certificate(self) -> Vec<CertificateDer<'static>> {
        let data = std::fs::read(self).expect("Failed to read certificate file");
        if let Ok(certs) = CertificateDer::pem_slice_iter(&data).collect::<Result<Vec<_>, _>>()
            && !certs.is_empty()
        {
            return certs;
        }

        vec![CertificateDer::from(data)]
    }
}

impl ToCertificate for &[u8] {
    fn to_certificate(self) -> Vec<CertificateDer<'static>> {
        if let Ok(certs) = CertificateDer::pem_slice_iter(self).collect::<Result<Vec<_>, _>>()
            && !certs.is_empty()
        {
            return certs;
        }

        vec![CertificateDer::from(self.to_vec())]
    }
}

impl<const N: usize> ToCertificate for &[u8; N] {
    fn to_certificate(self) -> Vec<CertificateDer<'static>> {
        <&[u8]>::to_certificate(self)
    }
}

pub trait ToPrivateKey {
    fn to_private_key(self) -> PrivateKeyDer<'static>;
}

impl ToPrivateKey for PrivateKeyDer<'static> {
    fn to_private_key(self) -> PrivateKeyDer<'static> {
        self
    }
}

impl ToPrivateKey for &PrivateKeyDer<'static> {
    fn to_private_key(self) -> PrivateKeyDer<'static> {
        self.clone_key()
    }
}

impl ToPrivateKey for &Path {
    fn to_private_key(self) -> PrivateKeyDer<'static> {
        let data = std::fs::read(self).expect("failed to read private key file");
        if let Ok(key) = PrivateKeyDer::from_pem_slice(&data) {
            return key;
        }

        PrivateKeyDer::try_from(data)
            .expect("failed to parse private key file as pem or der format")
    }
}

impl ToPrivateKey for &[u8] {
    fn to_private_key(self) -> PrivateKeyDer<'static> {
        if let Ok(key) = PrivateKeyDer::from_pem_slice(self) {
            return key;
        }

        PrivateKeyDer::try_from(self.to_vec())
            .expect("failed to parse private key file as pem or der format")
    }
}

impl<const N: usize> ToPrivateKey for &[u8; N] {
    fn to_private_key(self) -> PrivateKeyDer<'static> {
        <&[u8]>::to_private_key(self)
    }
}