internet 0.1.0

//! TLS 1.3 Handshake encoding following [RFC 8446].
//!
//! Encoding is supported for the following structures:
//!
//!  - [`HandshakeType`]
//!  - [`Handshake`]
//!  - [`CipherSuite`]
//!  - [`Random`]
//!  - [`ClientHello`]
//!  - [`ServerHello`]
//!  - [`NewSessionTicket`]
//!  - [`EndOfEarlyData`]
//!  - [`EncryptedExtensions`]
//!  - [`SignatureScheme`]
//!  - [`CertificateEntry`]
//!  - [`Certificate`]
//!  - [`CertificateRequest`]
//!  - [`CertificateVerify`]
//!  - [`Finished`]
//!  - [`KeyUpdateRequest`]
//!  - [`KeyUpdate`]
//!
//! [RFC 8446]: https://datatracker.ietf.org/doc/html/rfc8446

use crate::{
    Buf,
    BufError::{self},
    BufMut, BufResult, Codec, Cursor,
    ietf::tls::{LengthPrefix, ProtocolVersion, TlsVec, u24},
    ietf::tls1_3::Extension,
};
use ring::rand::{SecureRandom, SystemRandom};

/// A Handshake Type following [Section 4].
///
/// According to RFC 8446, unknown handshake message types MUST be treated as fatal errors.
/// Therefore, this is implemented as an enum.
///
/// [Section 4]: https://datatracker.ietf.org/doc/html/rfc8446#section-4
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum HandshakeType {
    /// client_hello(1)
    ClientHello = 1,
    /// server_hello(2)
    ServerHello = 2,
    /// new_session_ticket(4)
    NewSessionTicket = 4,
    /// end_of_early_data(5)
    EndOfEarlyData = 5,
    /// encrypted_extensions(8)
    EncryptedExtensions = 8,
    /// certificate(11)
    Certificate = 11,
    /// certificate_request(13)
    CertificateRequest = 13,
    /// certificate_verify(15)
    CertificateVerify = 15,
    /// finished(20)
    Finished = 20,
    /// key_update(24)
    KeyUpdate = 24,
    /// message_hash(254)
    MessageHash = 254,
}

impl Codec for HandshakeType {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        (*self as u8).encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match u8::decode(reader, ())? {
            x if x == (Self::ClientHello as u8) => Ok(Self::ClientHello),
            x if x == (Self::ServerHello as u8) => Ok(Self::ServerHello),
            x if x == (Self::NewSessionTicket as u8) => Ok(Self::NewSessionTicket),
            x if x == (Self::EndOfEarlyData as u8) => Ok(Self::EndOfEarlyData),
            x if x == (Self::EncryptedExtensions as u8) => Ok(Self::EncryptedExtensions),
            x if x == (Self::Certificate as u8) => Ok(Self::Certificate),
            x if x == (Self::CertificateRequest as u8) => Ok(Self::CertificateRequest),
            x if x == (Self::CertificateVerify as u8) => Ok(Self::CertificateVerify),
            x if x == (Self::Finished as u8) => Ok(Self::Finished),
            x if x == (Self::KeyUpdate as u8) => Ok(Self::KeyUpdate),
            x if x == (Self::MessageHash as u8) => Ok(Self::MessageHash),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

/// A Handshake message following [Section 4].
///
/// [Section 4]: https://datatracker.ietf.org/doc/html/rfc8446#section-4
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Handshake {
    /// The type of the handshake message.
    pub msg_type: HandshakeType,
    /// The body of the handshake message.
    pub msg: Vec<u8>,
}

impl Codec for Handshake {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.msg_type.encode(writer, ())?;
        let len = u24::from_usize(self.msg.len())?;
        len.encode(writer, ())?;
        writer.write_slice(&self.msg)
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        let msg_type = HandshakeType::decode(reader, ())?;
        let length_u24 = u24::decode(reader, ())?;
        let length = length_u24.as_usize();

        if reader.remaining() < length {
            return Err(BufError::UnexpectedEof);
        }

        let mut msg = vec![0u8; length];
        reader.read_into(&mut msg)?;

        Ok(Self { msg_type, msg })
    }
}

/// A Cipher Suite following [Appendix B.4].
///
/// Unknown cipher suites in ServerHello MUST be treated as errors.
/// Therefore, this is implemented as an enum.
///
/// [Appendix B.4]: https://datatracker.ietf.org/doc/html/rfc8446#appendix-B.4
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u16)]
pub enum CipherSuite {
    /// TLS_AES_128_GCM_SHA256
    TlsAes128GcmSha256 = 0x1301,
    /// TLS_AES_256_GCM_SHA384
    TlsAes256GcmSha384 = 0x1302,
    /// TLS_CHACHA20_POLY1305_SHA256
    TlsChacha20Poly1305Sha256 = 0x1303,
    /// TLS_AES_128_CCM_SHA256
    TlsAes128CcmSha256 = 0x1304,
    /// TLS_AES_128_CCM_8_SHA256
    TlsAes128Ccm8Sha256 = 0x1305,
    /// TLS_EMPTY_RENEGOTIATION_INFO_SCSV
    TlsEmptyRenegotiationInfoScsv = 0x00FF,
}

impl Codec for CipherSuite {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        (*self as u16).encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match u16::decode(reader, ())? {
            x if x == (Self::TlsAes128GcmSha256 as u16) => Ok(Self::TlsAes128GcmSha256),
            x if x == (Self::TlsAes256GcmSha384 as u16) => Ok(Self::TlsAes256GcmSha384),
            x if x == (Self::TlsChacha20Poly1305Sha256 as u16) => {
                Ok(Self::TlsChacha20Poly1305Sha256)
            }
            x if x == (Self::TlsAes128CcmSha256 as u16) => Ok(Self::TlsAes128CcmSha256),
            x if x == (Self::TlsAes128Ccm8Sha256 as u16) => Ok(Self::TlsAes128Ccm8Sha256),
            x if x == (Self::TlsEmptyRenegotiationInfoScsv as u16) => {
                Ok(Self::TlsEmptyRenegotiationInfoScsv)
            }
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

/// A Random structure following [Section 4.1.2].
///
/// [Section 4.1.2]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.1.2
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Random(pub [u8; 32]);

impl Random {
    /// Generates a new Random structure using a secure random number generator.
    pub fn random() -> Self {
        let mut random = [0u8; 32];
        let rng = SystemRandom::new();
        rng.fill(&mut random).unwrap();
        Self(random)
    }
}

impl Codec for Random {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        writer.write_array(&self.0)
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self(reader.read_array::<32>()?))
    }
}

/// A Client Hello message following [Section 4.1.2].
///
/// [Section 4.1.2]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.1.2
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ClientHello {
    /// The legacy version (Fixed TLS v1.2 since TLS 1.3).
    pub legacy_version: ProtocolVersion,
    /// The random structure.
    pub random: Random,
    /// The legacy session ID.
    pub legacy_session_id: TlsVec<u8, u8>,
    /// The cipher suites.
    pub cipher_suites: TlsVec<CipherSuite, u16>,
    /// The legacy compression methods.
    pub legacy_compression_methods: TlsVec<u8, u8>,
    /// The extensions.
    pub extensions: TlsVec<Extension, u16>,
}

impl ClientHello {
    /// Creates a default ClientHello with common cipher suites and the provided extensions.
    pub fn default(extensions: TlsVec<Extension, u16>) -> Self {
        Self {
            legacy_version: ProtocolVersion::TLS12,
            random: Random::random(),
            legacy_session_id: TlsVec::new(vec![]),
            cipher_suites: TlsVec::new(vec![
                CipherSuite::TlsAes128GcmSha256,
                CipherSuite::TlsChacha20Poly1305Sha256,
            ]),
            legacy_compression_methods: TlsVec::new(vec![0x00]),
            extensions,
        }
    }
}

impl Codec for ClientHello {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.legacy_version.encode(writer, ())?;
        self.random.encode(writer, ())?;
        self.legacy_session_id.encode(writer, ())?;
        self.cipher_suites.encode(writer, ())?;
        self.legacy_compression_methods.encode(writer, ())?;
        self.extensions.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self {
            legacy_version: ProtocolVersion::decode(reader, ())?,
            random: Random::decode(reader, ())?,
            legacy_session_id: TlsVec::<u8, u8>::decode(reader, ())?,
            cipher_suites: TlsVec::<CipherSuite, u16>::decode(reader, ())?,
            legacy_compression_methods: TlsVec::<u8, u8>::decode(reader, ())?,
            extensions: TlsVec::<Extension, u16>::decode(reader, ())?,
        })
    }
}

/// A Server Hello message following [Section 4.1.3].
///
/// [Section 4.1.3]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.1.3
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ServerHello {
    /// The legacy version.
    pub legacy_version: ProtocolVersion,
    /// The random structure.
    pub random: Random,
    /// The legacy session ID echo.
    pub legacy_session_id_echo: TlsVec<u8, u8>,
    /// The cipher suite.
    pub cipher_suite: CipherSuite,
    /// The legacy compression method.
    pub legacy_compression_method: u8,
    /// The extensions.
    pub extensions: TlsVec<Extension, u16>,
}

impl Codec for ServerHello {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.legacy_version.encode(writer, ())?;
        self.random.encode(writer, ())?;
        self.legacy_session_id_echo.encode(writer, ())?;
        self.cipher_suite.encode(writer, ())?;
        self.legacy_compression_method.encode(writer, ())?;
        self.extensions.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self {
            legacy_version: ProtocolVersion::decode(reader, ())?,
            random: Random::decode(reader, ())?,
            legacy_session_id_echo: TlsVec::<u8, u8>::decode(reader, ())?,
            cipher_suite: CipherSuite::decode(reader, ())?,
            legacy_compression_method: u8::decode(reader, ())?,
            extensions: TlsVec::<Extension, u16>::decode(reader, ())?,
        })
    }
}

/// A New Session Ticket message following [Section 4.6.1].
///
/// [Section 4.6.1]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.6.1
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct NewSessionTicket {
    /// The ticket lifetime in seconds.
    pub ticket_lifetime: u32,
    /// The ticket age add.
    pub ticket_age_add: u32,
    /// The ticket nonce.
    pub ticket_nonce: TlsVec<u8, u8>,
    /// The ticket.
    pub ticket: TlsVec<u8, u16>,
    /// The extensions.
    pub extensions: TlsVec<Extension, u16>,
}

impl Codec for NewSessionTicket {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.ticket_lifetime.encode(writer, ())?;
        self.ticket_age_add.encode(writer, ())?;
        self.ticket_nonce.encode(writer, ())?;
        self.ticket.encode(writer, ())?;
        self.extensions.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self {
            ticket_lifetime: u32::decode(reader, ())?,
            ticket_age_add: u32::decode(reader, ())?,
            ticket_nonce: TlsVec::<u8, u8>::decode(reader, ())?,
            ticket: TlsVec::<u8, u16>::decode(reader, ())?,
            extensions: TlsVec::<Extension, u16>::decode(reader, ())?,
        })
    }
}

/// An End Of Early Data message following [Section 4.5].
///
/// [Section 4.5]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.5
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct EndOfEarlyData;

impl Codec for EndOfEarlyData {
    fn encode<W: BufMut>(&self, _writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        Ok(())
    }

    fn decode<R: Buf>(_reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self)
    }
}

/// An Encrypted Extensions message following [Section 4.3.1].
///
/// [Section 4.3.1]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.3.1
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct EncryptedExtensions {
    /// The extensions.
    pub extensions: TlsVec<Extension, u16>,
}

impl Codec for EncryptedExtensions {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.extensions.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self {
            extensions: TlsVec::<Extension, u16>::decode(reader, ())?,
        })
    }
}

/// A Signature Scheme following [Section 4.2.3].
///
/// Unknown schemes are ignored per RFC, so this is a struct with constants.
///
/// [Section 4.2.3]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.2.3
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct SignatureScheme(pub u16);

impl SignatureScheme {
    /// rsa_pkcs1_sha256(0x0401)
    pub const RSA_PKCS1_SHA256: Self = Self(0x0401);
    /// ecdsa_secp256r1_sha256(0x0403)
    pub const ECDSA_SECP256R1_SHA256: Self = Self(0x0403);
    /// ecdsa_secp384r1_sha384(0x0503)
    pub const ECDSA_SECP384R1_SHA384: Self = Self(0x0503);
    /// rsa_pss_rsae_sha256(0x0804)
    pub const RSA_PSS_RSAE_SHA256: Self = Self(0x0804);
    /// rsa_pss_rsae_sha384(0x0805)
    pub const RSA_PSS_RSAE_SHA384: Self = Self(0x0805);
    /// ed25519(0x0807)
    pub const ED25519: Self = Self(0x0807);
}

impl Codec for SignatureScheme {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.0.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self(u16::decode(reader, ())?))
    }
}

/// A Certificate Entry following [Section 4.4.2].
///
/// [Section 4.4.2]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.4.2
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CertificateEntry {
    /// The certificate data.
    pub cert_data: TlsVec<u8, u24>,
    /// The extensions.
    pub extensions: TlsVec<Extension, u16>,
}

impl Codec for CertificateEntry {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.cert_data.encode(writer, ())?;
        self.extensions.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self {
            cert_data: TlsVec::<u8, u24>::decode(reader, ())?,
            extensions: TlsVec::<Extension, u16>::decode(reader, ())?,
        })
    }
}

/// A Certificate message following [Section 4.4.2].
///
/// [Section 4.4.2]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.4.2
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Certificate {
    /// The certificate request context.
    pub certificate_request_context: TlsVec<u8, u8>,
    /// The certificate list.
    pub certificate_list: TlsVec<CertificateEntry, u24>,
}

impl Codec for Certificate {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.certificate_request_context.encode(writer, ())?;
        self.certificate_list.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self {
            certificate_request_context: TlsVec::<u8, u8>::decode(reader, ())?,
            certificate_list: TlsVec::<CertificateEntry, u24>::decode(reader, ())?,
        })
    }
}

/// A Certificate Request message following [Section 4.3.2].
///
/// [Section 4.3.2]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.3.2
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CertificateRequest {
    /// The certificate request context.
    pub certificate_request_context: TlsVec<u8, u8>,
    /// The extensions.
    pub extensions: TlsVec<Extension, u16>,
}

impl Codec for CertificateRequest {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.certificate_request_context.encode(writer, ())?;
        self.extensions.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self {
            certificate_request_context: TlsVec::<u8, u8>::decode(reader, ())?,
            extensions: TlsVec::<Extension, u16>::decode(reader, ())?,
        })
    }
}

/// A Certificate Verify message following [Section 4.4.3].
///
/// [Section 4.4.3]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.4.3
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CertificateVerify {
    /// The signature algorithm.
    pub algorithm: SignatureScheme,
    /// The signature.
    pub signature: TlsVec<u8, u16>,
}

impl Codec for CertificateVerify {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.algorithm.encode(writer, ())?;
        self.signature.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self {
            algorithm: SignatureScheme::decode(reader, ())?,
            signature: TlsVec::<u8, u16>::decode(reader, ())?,
        })
    }
}

/// A Finished message following [Section 4.4.4].
///
/// [Section 4.4.4]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.4.4
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Finished {
    /// The verify data.
    pub verify_data: Vec<u8>,
}

impl Codec for Finished {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.verify_data.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self {
            verify_data: Vec::<u8>::decode(reader, ())?,
        })
    }
}

/// A Key Update Request following [Section 4.6.3].
///
/// Unknown values MUST be treated as illegal_parameter errors.
/// Therefore, this is implemented as an enum.
///
/// [Section 4.6.3]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.6.3
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum KeyUpdateRequest {
    /// update_not_requested(0)
    UpdateNotRequested = 0,
    /// update_requested(1)
    UpdateRequested = 1,
}

impl Codec for KeyUpdateRequest {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        (*self as u8).encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        match u8::decode(reader, ())? {
            x if x == (Self::UpdateNotRequested as u8) => Ok(Self::UpdateNotRequested),
            x if x == (Self::UpdateRequested as u8) => Ok(Self::UpdateRequested),
            _ => Err(BufError::UnexpectedValue),
        }
    }
}

/// A Key Update message following [Section 4.6.3].
///
/// [Section 4.6.3]: https://datatracker.ietf.org/doc/html/rfc8446#section-4.6.3
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct KeyUpdate {
    /// The key update request.
    pub request_update: KeyUpdateRequest,
}

impl Codec for KeyUpdate {
    fn encode<W: BufMut>(&self, writer: &mut Cursor<W>, _: ()) -> BufResult<()> {
        self.request_update.encode(writer, ())
    }

    fn decode<R: Buf>(reader: &mut Cursor<R>, _: ()) -> BufResult<Self> {
        Ok(Self {
            request_update: KeyUpdateRequest::decode(reader, ())?,
        })
    }
}

#[cfg(test)]
mod tests {
    use core::fmt::Debug;

    use super::{CipherSuite, HandshakeType, KeyUpdateRequest};
    use crate::{Codec, Cursor};

    fn codec_roundtrip<T: Codec<C> + Debug + Eq, C: Copy>(
        etalon_struct: T,
        etalon_bytes: &[u8],
        context: C,
    ) {
        let mut encoded_bytes = vec![];
        {
            let writer = &mut Cursor::new(&mut encoded_bytes);
            etalon_struct.encode(writer, context).unwrap();
        }
        assert_eq!(etalon_bytes, &encoded_bytes);

        let decoded_struct = {
            let reader = &mut Cursor::new(&mut encoded_bytes);
            T::decode(reader, context).unwrap()
        };
        assert_eq!(etalon_struct, decoded_struct);

        encoded_bytes.fill(0x00);
        {
            let writer = &mut Cursor::new(&mut encoded_bytes);
            decoded_struct.encode(writer, context).unwrap();
        }
        assert_eq!(etalon_bytes, &encoded_bytes);
    }

    #[test]
    fn handshake_type() {
        let etalon_bytes = &[0x01];
        let etalon_struct = HandshakeType::ClientHello;

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn cipher_suite() {
        let etalon_bytes = &[0x13, 0x01];
        let etalon_struct = CipherSuite::TlsAes128GcmSha256;

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }

    #[test]
    fn key_update_request() {
        let etalon_bytes = &[0x01];
        let etalon_struct = KeyUpdateRequest::UpdateRequested;

        codec_roundtrip(etalon_struct, etalon_bytes, ());
    }
}