s2n-quic-dc 0.44.1

Internal crate used by s2n-quic
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

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

use crate::path::secret::{Map, Opener, Sealer};
use core::{fmt, sync::atomic::Ordering};
use crossbeam_epoch::{pin, Atomic};

// TODO support key updates
pub struct Crypto {
    sealer: Atomic<Sealer>,
    opener: Atomic<Opener>,
    map: Map,
}

impl fmt::Debug for Crypto {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Crypto")
            .field("sealer", &self.sealer)
            .field("opener", &self.opener)
            .finish()
    }
}

impl Crypto {
    #[inline]
    pub fn new(sealer: Sealer, opener: Opener, map: &Map) -> Self {
        let sealer = Atomic::new(sealer);
        let opener = Atomic::new(opener);
        Self {
            sealer,
            opener,
            map: map.clone(),
        }
    }

    #[inline(always)]
    pub fn tag_len(&self) -> usize {
        16
    }

    #[inline]
    pub fn map(&self) -> &Map {
        &self.map
    }

    #[inline]
    pub fn seal_with<R>(&self, seal: impl FnOnce(&Sealer) -> R) -> R {
        let pin = pin();
        let sealer = self.seal_pin(&pin);
        seal(sealer)
    }

    #[inline]
    fn seal_pin<'a>(&self, pin: &'a crossbeam_epoch::Guard) -> &'a Sealer {
        let sealer = self.sealer.load(Ordering::Acquire, pin);
        unsafe { sealer.deref() }
    }

    #[inline]
    pub fn open_with<R>(&self, open: impl FnOnce(&Opener) -> R) -> R {
        let pin = pin();
        let opener = self.open_pin(&pin);
        open(opener)
    }

    #[inline]
    fn open_pin<'a>(&self, pin: &'a crossbeam_epoch::Guard) -> &'a Opener {
        let opener = self.opener.load(Ordering::Acquire, pin);
        unsafe { opener.deref() }
    }
}

impl Drop for Crypto {
    #[inline]
    fn drop(&mut self) {
        use crossbeam_epoch::Shared;
        let pin = pin();
        let sealer = self.sealer.swap(Shared::null(), Ordering::AcqRel, &pin);
        let opener = self.opener.swap(Shared::null(), Ordering::AcqRel, &pin);

        // no need to drop either one
        if sealer.is_null() && opener.is_null() {
            return;
        }

        unsafe {
            pin.defer_unchecked(move || {
                drop(sealer.try_into_owned());
                drop(opener.try_into_owned());
            })
        }
    }
}