[WIP] Define all extension data types

rustfmt.toml

@@ -1 +1,4 @@
 edition = "2021"
+imports_granularity = "crate"
+imports_layout = "vertical"
+reorder_imports = true

src/alert.rs

@@ -1,6 +1,8 @@
-use crate::buffer::CryptoBuffer;
-use crate::parse_buffer::ParseBuffer;
-use crate::TlsError;
+use crate::{
+    buffer::CryptoBuffer,
+    parse_buffer::ParseBuffer,
+    TlsError,
+};
 
 #[derive(Debug, Clone, Copy)]
 #[cfg_attr(feature = "defmt", derive(defmt::Format))]

src/application_data.rs

@@ -1,6 +1,11 @@
-use crate::buffer::*;
-use crate::record::RecordHeader;
-use core::fmt::{Debug, Formatter};
+use crate::{
+    buffer::*,
+    record::RecordHeader,
+};
+use core::fmt::{
+    Debug,
+    Formatter,
+};
 
 pub struct ApplicationData<'a> {
     pub(crate) header: RecordHeader,

src/asynch.rs

@@ -1,26 +1,48 @@
-use crate::common::decrypted_buffer_info::DecryptedBufferInfo;
-use crate::common::decrypted_read_handler::DecryptedReadHandler;
-use crate::connection::*;
-use crate::key_schedule::KeySchedule;
-use crate::key_schedule::{ReadKeySchedule, SharedState, WriteKeySchedule};
-use crate::read_buffer::ReadBuffer;
-use crate::record::{ClientRecord, ClientRecordHeader};
-use crate::record_reader::RecordReader;
-use crate::split::{SplitState, SplitStateContainer};
-use crate::write_buffer::WriteBuffer;
-use crate::TlsError;
-use embedded_io::asynch::BufRead;
-use embedded_io::Error as _;
+use crate::{
+    common::{
+        decrypted_buffer_info::DecryptedBufferInfo,
+        decrypted_read_handler::DecryptedReadHandler,
+    },
+    connection::*,
+    key_schedule::{
+        KeySchedule,
+        ReadKeySchedule,
+        SharedState,
+        WriteKeySchedule,
+    },
+    read_buffer::ReadBuffer,
+    record::{
+        ClientRecord,
+        ClientRecordHeader,
+    },
+    record_reader::RecordReader,
+    split::{
+        SplitState,
+        SplitStateContainer,
+    },
+    write_buffer::WriteBuffer,
+    TlsError,
+};
 use embedded_io::{
-    asynch::{Read as AsyncRead, Write as AsyncWrite},
+    asynch::{
+        BufRead,
+        Read as AsyncRead,
+        Write as AsyncWrite,
+    },
+    Error as _,
     Io,
 };
-use rand_core::{CryptoRng, RngCore};
+use rand_core::{
+    CryptoRng,
+    RngCore,
+};
 
-pub use crate::config::*;
 #[cfg(feature = "std")]
 pub use crate::split::ManagedSplitState;
-pub use crate::split::SplitConnectionState;
+pub use crate::{
+    config::*,
+    split::SplitConnectionState,
+};
 
 /// Type representing an async TLS connection. An instance of this type can
 /// be used to establish a TLS connection, write and read encrypted data over this connection,

src/blocking.rs

@@ -1,26 +1,48 @@
-use crate::common::decrypted_buffer_info::DecryptedBufferInfo;
-use crate::common::decrypted_read_handler::DecryptedReadHandler;
-use crate::connection::*;
-use crate::key_schedule::KeySchedule;
-use crate::key_schedule::{ReadKeySchedule, SharedState, WriteKeySchedule};
-use crate::read_buffer::ReadBuffer;
-use crate::record::{ClientRecord, ClientRecordHeader};
-use crate::record_reader::RecordReader;
-use crate::split::{SplitState, SplitStateContainer};
-use crate::write_buffer::WriteBuffer;
-use embedded_io::blocking::BufRead;
-use embedded_io::Error as _;
+use crate::{
+    common::{
+        decrypted_buffer_info::DecryptedBufferInfo,
+        decrypted_read_handler::DecryptedReadHandler,
+    },
+    connection::*,
+    key_schedule::{
+        KeySchedule,
+        ReadKeySchedule,
+        SharedState,
+        WriteKeySchedule,
+    },
+    read_buffer::ReadBuffer,
+    record::{
+        ClientRecord,
+        ClientRecordHeader,
+    },
+    record_reader::RecordReader,
+    split::{
+        SplitState,
+        SplitStateContainer,
+    },
+    write_buffer::WriteBuffer,
+};
 use embedded_io::{
-    blocking::{Read, Write},
+    blocking::{
+        BufRead,
+        Read,
+        Write,
+    },
+    Error as _,
     Io,
 };
-use rand_core::{CryptoRng, RngCore};
+use rand_core::{
+    CryptoRng,
+    RngCore,
+};
 
-pub use crate::config::*;
 #[cfg(feature = "std")]
 pub use crate::split::ManagedSplitState;
-pub use crate::split::SplitConnectionState;
-pub use crate::TlsError;
+pub use crate::{
+    config::*,
+    split::SplitConnectionState,
+    TlsError,
+};
 
 /// Type representing a TLS connection. An instance of this type can
 /// be used to establish a TLS connection, write and read encrypted data over this connection,

src/buffer.rs

@@ -1,6 +1,8 @@
 use crate::TlsError;
-use aes_gcm::aead::Buffer;
-use aes_gcm::Error;
+use aes_gcm::{
+    aead::Buffer,
+    Error,
+};
 
 pub struct CryptoBuffer<'b> {
     buf: &'b mut [u8],

src/change_cipher_spec.rs

@@ -1,6 +1,8 @@
-use crate::buffer::CryptoBuffer;
-use crate::parse_buffer::ParseBuffer;
-use crate::TlsError;
+use crate::{
+    buffer::CryptoBuffer,
+    parse_buffer::ParseBuffer,
+    TlsError,
+};
 use generic_array::ArrayLength;
 
 #[derive(Debug, Copy, Clone)]

src/common/decrypted_read_handler.rs

@@ -3,8 +3,11 @@ use core::ops::Range;
 use generic_array::ArrayLength;
 
 use crate::{
-    alert::AlertDescription, common::decrypted_buffer_info::DecryptedBufferInfo,
-    handshake::ServerHandshake, record::ServerRecord, TlsError,
+    alert::AlertDescription,
+    common::decrypted_buffer_info::DecryptedBufferInfo,
+    handshake::ServerHandshake,
+    record::ServerRecord,
+    TlsError,
 };
 
 pub struct DecryptedReadHandler<'a> {

src/config.rs

@@ -1,20 +1,48 @@
-use crate::cipher_suites::CipherSuite;
-use crate::handshake::certificate::CertificateRef;
-use crate::handshake::certificate_verify::CertificateVerify;
-pub use crate::max_fragment_length::MaxFragmentLength;
-use crate::named_groups::NamedGroup;
-use crate::signature_schemes::SignatureScheme;
-use crate::TlsError;
-use aes_gcm::{AeadInPlace, Aes128Gcm, Aes256Gcm, KeyInit};
+use crate::{
+    cipher_suites::CipherSuite,
+    extensions::extension_data::{
+        signature_algorithms::SignatureScheme,
+        supported_groups::NamedGroup,
+    },
+    handshake::{
+        certificate::CertificateRef,
+        certificate_verify::CertificateVerify,
+    },
+    TlsError,
+};
+use aes_gcm::{
+    AeadInPlace,
+    Aes128Gcm,
+    Aes256Gcm,
+    KeyInit,
+};
 use core::marker::PhantomData;
-use digest::core_api::BlockSizeUser;
-use digest::{Digest, FixedOutput, OutputSizeUser, Reset};
+use digest::{
+    core_api::BlockSizeUser,
+    Digest,
+    FixedOutput,
+    OutputSizeUser,
+    Reset,
+};
 use generic_array::ArrayLength;
 use heapless::Vec;
-use rand_core::{CryptoRng, RngCore};
-pub use sha2::Sha256;
-pub use sha2::Sha384;
-use typenum::{Sum, U10, U12, U16, U32};
+use rand_core::{
+    CryptoRng,
+    RngCore,
+};
+pub use sha2::{
+    Sha256,
+    Sha384,
+};
+use typenum::{
+    Sum,
+    U10,
+    U12,
+    U16,
+    U32,
+};
+
+pub use crate::extensions::extension_data::max_fragment_length::MaxFragmentLength;
 
 const TLS_RECORD_MAX: usize = 16384;
 pub const TLS_RECORD_OVERHEAD: usize = 128;

src/connection.rs

@@ -1,22 +1,46 @@
-use crate::config::{TlsCipherSuite, TlsConfig, TlsVerifier};
-use crate::handshake::{ClientHandshake, ServerHandshake};
-use crate::key_schedule::{HashOutputSize, KeySchedule, ReadKeySchedule, WriteKeySchedule};
-use crate::record::{ClientRecord, ServerRecord};
-use crate::record_reader::RecordReader;
-use crate::write_buffer::WriteBuffer;
-use crate::TlsError;
 use crate::{
     alert::*,
-    handshake::{certificate::CertificateRef, certificate_request::CertificateRequest},
+    config::{
+        TlsCipherSuite,
+        TlsConfig,
+        TlsVerifier,
+    },
+    handshake::{
+        certificate::CertificateRef,
+        certificate_request::CertificateRequest,
+        ClientHandshake,
+        ServerHandshake,
+    },
+    key_schedule::{
+        HashOutputSize,
+        KeySchedule,
+        ReadKeySchedule,
+        WriteKeySchedule,
+    },
+    record::{
+        ClientRecord,
+        ServerRecord,
+    },
+    record_reader::RecordReader,
+    write_buffer::WriteBuffer,
+    TlsError,
 };
 use core::fmt::Debug;
 use embedded_io::Error as _;
-use rand_core::{CryptoRng, RngCore};
+use rand_core::{
+    CryptoRng,
+    RngCore,
+};
 
-use embedded_io::blocking::{Read as BlockingRead, Write as BlockingWrite};
+use embedded_io::blocking::{
+    Read as BlockingRead,
+    Write as BlockingWrite,
+};
 
 #[cfg(feature = "async")]
-use embedded_io::asynch::{Read as AsyncRead, Write as AsyncWrite};
+use embedded_io::asynch::Read as AsyncRead;
+#[cfg(feature = "async")]
+use embedded_io::asynch::Write as AsyncWrite;
 
 use crate::application_data::ApplicationData;
 // use crate::handshake::certificate_request::CertificateRequest;
@@ -38,7 +62,11 @@ use crate::content_types::ContentType;
 // use crate::handshake::new_session_ticket::NewSessionTicket;
 // use crate::handshake::server_hello::ServerHello;
 use crate::parse_buffer::ParseBuffer;
-use aes_gcm::aead::{AeadCore, AeadInPlace, KeyInit};
+use aes_gcm::aead::{
+    AeadCore,
+    AeadInPlace,
+    KeyInit,
+};
 
 pub(crate) fn decrypt_record<CipherSuite>(
     key_schedule: &mut ReadKeySchedule<CipherSuite>,

src/crypto_engine.rs

@@ -1,5 +1,7 @@
-use crate::application_data::ApplicationData;
-use crate::named_groups::NamedGroup;
+use crate::{
+    application_data::ApplicationData,
+    extensions::extension_data::supported_groups::NamedGroup,
+};
 use p256::ecdh::SharedSecret;
 
 pub struct CryptoEngine {