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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

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

use super::IntoNonce;
use crate::credentials::Credentials;
use s2n_quic_core::{assume, packet::KeyPhase};

#[derive(Clone, Debug)]
pub struct Key {
    credentials: Credentials,
    tag_len: usize,
}

impl Key {
    #[inline]
    pub fn new(credentials: Credentials) -> Self {
        Self {
            credentials,
            tag_len: 16,
        }
    }
}

impl super::encrypt::Key for Key {
    #[inline]
    fn credentials(&self) -> &Credentials {
        &self.credentials
    }

    #[inline]
    fn key_phase(&self) -> KeyPhase {
        KeyPhase::Zero
    }

    #[inline]
    fn tag_len(&self) -> usize {
        self.tag_len
    }

    #[inline]
    fn encrypt<N: IntoNonce>(
        &self,
        _nonce: N,
        _header: &[u8],
        extra_payload: Option<&[u8]>,
        payload_and_tag: &mut [u8],
    ) {
        if let Some(extra_payload) = extra_payload {
            let offset = payload_and_tag.len() - self.tag_len() - extra_payload.len();
            let dest = &mut payload_and_tag[offset..];
            unsafe {
                assume!(dest.len() == extra_payload.len() + self.tag_len);
            }
            let (dest, tag) = dest.split_at_mut(extra_payload.len());
            dest.copy_from_slice(extra_payload);
            tag.fill(0);
        }
    }

    #[inline]
    fn retransmission_tag(
        &self,
        _original_packet_number: u64,
        _retransmission_packet_number: u64,
        _tag_out: &mut [u8],
    ) {
        // no-op
    }
}

impl super::decrypt::Key for Key {
    #[inline]
    fn credentials(&self) -> &Credentials {
        &self.credentials
    }

    #[inline]
    fn tag_len(&self) -> usize {
        self.tag_len
    }

    #[inline]
    fn decrypt<N: IntoNonce>(
        &self,
        _key_phase: KeyPhase,
        _nonce: N,
        _header: &[u8],
        payload_in: &[u8],
        _tag: &[u8],
        payload_out: &mut bytes::buf::UninitSlice,
    ) -> Result<(), super::decrypt::Error> {
        payload_out.copy_from_slice(payload_in);
        Ok(())
    }

    #[inline]
    fn decrypt_in_place<N: IntoNonce>(
        &self,
        _key_phase: KeyPhase,
        _nonce: N,
        _header: &[u8],
        _payload_and_tag: &mut [u8],
    ) -> Result<(), super::decrypt::Error> {
        Ok(())
    }

    #[inline]
    fn retransmission_tag(
        &self,
        _key_phase: KeyPhase,
        _original_packet_number: u64,
        _retransmission_packet_number: u64,
        _tag_out: &mut [u8],
    ) {
        // no-op
    }
}