initial commit

common/src/tlseng/etype.rs

@@ -0,0 +1,49 @@
+// --- Core Handshake Identifiers ---
+/// ClientHello handshake message type
+pub const HANDSHAKE_TYPE_CLIENT_HELLO: u8 = 0x01;
+pub const HANDSHAKE_TYPE_SERVER_HELLO: u8 = 0x02;
+
+// --- TLS Extension Type Codes (IANA) ---
+/// Server Name Indication (SNI) - maps a hostname to the IP
+pub const EXT_TYPE_SNI: u16 = 0x0000;
+/// Certificate Status Request (OCSP Stapling)
+pub const EXT_STATUS_REQUEST: u16 = 0x0005;
+/// Supported Elliptic Curves (Named Groups)
+pub const EXT_SUPPORTED_GROUPS: u16 = 0x000a;
+/// Supported Point Formats (Legacy, but required for compatibility)
+pub const EXT_EC_POINT_FORMATS: u16 = 0x000b;
+/// Signature Algorithms the client can verify
+pub const EXT_SIGNATURE_ALGORITHMS: u16 = 0x000d;
+/// Application-Layer Protocol Negotiation (h2, http/1.1)
+pub const EXT_ALPN: u16 = 0x0010;
+/// Signed Certificate Timestamp (SCT) - used for Certificate Transparency
+pub const EXT_SIGNED_CERT_TIMESTAMP: u16 = 0x0012;
+/// Padding extension to avoid MTU issues or fingerprinting
+pub const EXT_PADDING: u16 = 0x0015;
+/// Extended Master Secret - prevents MITM key synchronization attacks
+pub const EXT_EXTENDED_MASTER_SECRET: u16 = 0x0017;
+/// Certificate Compression (Used by modern browsers like Chrome)
+pub const EXT_COMPRESS_CERTIFICATE: u16 = 0x001b;
+/// Delegated Credentials (RFC 9345)
+pub const EXT_DELEGATED_CREDENTIAL: u16 = 0x0022;
+///SESSION TICKET
+pub const EXT_SESSION_TICKET: u16 = 0x0023;
+/// Negotiated TLS Versions (Crucial for TLS 1.3)
+pub const EXT_SUPPORTED_VERSIONS: u16 = 0x002b;
+/// Pre-Shared Key (PSK) Exchange Modes
+pub const EXT_PSK_KEY_EXCHANGE_MODES: u16 = 0x002d;
+/// Key Share - carries the Diffie-Hellman public keys
+pub const EXT_KEY_SHARE: u16 = 0x0033;
+/// Application Settings (ALPS) - Chrome specific protocol settings
+pub const EXT_ALPS: u16 = 0x44cd;
+
+// --- Compatibility & Anti-Detection (Fingerprinting) ---
+/// Secure Renegotiation Indication (RFC 5746)
+pub const EXT_RENEGOTIATION_INFO: u16 = 0xff01;
+
+/// GREASE (Generate Random Extensions And Sustain Extensibility)
+/// Used to prevent server bugs where unknown extensions cause failures.
+pub const GREASE_IDENTIFIERS: [u16; 16] = [
+    0x0A0A, 0x1A1A, 0x2A2A, 0x3A3A, 0x4A4A, 0x5A5A, 0x6A6A, 0x7A7A, 0x8A8A, 0x9A9A, 0xAAAA, 0xBABA,
+    0xCACA, 0xDADA, 0xEAEA, 0xFAFA,
+];

common/src/tlseng/extension.rs

@@ -0,0 +1,266 @@
+use bytes::{BufMut, Bytes, BytesMut};
+use rand::Rng;
+
+// Using your provided constants and types
+use crate::tlseng::{
+    etype::*,
+    params::{TlsGroups, TlsSignatures, TlsVersions},
+    profile::profile::BrowserProfile,
+    values::*,
+};
+
+pub struct Extension {
+    pub etype: u16,
+    pub elen: u16,
+    pub data: Bytes,
+}
+
+impl Extension {
+    pub fn new(etype: u16, data: Bytes) -> Self {
+        Self {
+            etype,
+            elen: data.len() as u16,
+            data,
+        }
+    }
+    pub fn pack(etype: u16, data: &[u8]) -> Bytes {
+        let mut ext = BytesMut::with_capacity(4 + data.len());
+        ext.put_u16(etype);
+        ext.put_u16(data.len() as u16);
+        ext.put_slice(data);
+        ext.freeze()
+    }
+}
+
+pub struct ExtensionBuilder {
+    payload: BytesMut,
+}
+
+impl ExtensionBuilder {
+    pub fn new() -> Self {
+        Self {
+            payload: BytesMut::with_capacity(2048),
+        }
+    }
+
+    /// Internal helper to pack and append an extension.
+    fn add_extension(&mut self, etype: u16, data: &[u8]) {
+        let ext = Extension::pack(etype, data);
+        self.payload.put_slice(&ext);
+    }
+
+    /// 0x?a?a - Randomized GREASE
+    pub fn grease(&mut self) {
+        let mut rng = rand::rng();
+        let rnd = Rng::next_u32(&mut rng) % 16;
+        let etype = GREASE_IDENTIFIERS[rnd as usize];
+        self.add_extension(etype, &[]);
+    }
+
+    /// Used for exact hex-matching of GREASE values
+    pub fn grease_fixed(&mut self, etype: u16) {
+        self.add_extension(etype, &[]);
+    }
+
+    /// 0x0000 - SNI
+    pub fn server_name(&mut self, host: &str) {
+        let host_bytes = host.as_bytes();
+        let host_len = host_bytes.len() as u16;
+        let list_inner_len = 1 + 2 + host_len;
+
+        let mut data = BytesMut::with_capacity(2 + list_inner_len as usize);
+        data.put_u16(list_inner_len);
+        data.put_u8(TYPE_HOST_NAME);
+        data.put_u16(host_len);
+        data.put_slice(host_bytes);
+
+        self.add_extension(EXT_TYPE_SNI, &data);
+    }
+
+    /// 0x0017 - Extended Master Secret
+    pub fn extended_main_secret(&mut self) {
+        self.add_extension(EXT_EXTENDED_MASTER_SECRET, &[]);
+    }
+
+    /// 0x000a - Supported Groups
+    pub fn supported_groups(&mut self, groups: TlsGroups) {
+        let mut data = BytesMut::with_capacity(2 + groups.0.len() * 2);
+        data.put_u16((groups.0.len() * 2) as u16);
+        for &g in groups.0 {
+            data.put_u16(g);
+        }
+        self.add_extension(EXT_SUPPORTED_GROUPS, &data);
+    }
+
+    /// 0x000d - Signature Algorithms
+    pub fn signature_algorithms(&mut self, algs: TlsSignatures) {
+        let mut data = BytesMut::with_capacity(2 + algs.0.len() * 2);
+        data.put_u16((algs.0.len() * 2) as u16);
+        for &a in algs.0 {
+            data.put_u16(a);
+        }
+        self.add_extension(EXT_SIGNATURE_ALGORITHMS, &data);
+    }
+
+    /// 0x44cd - ALPS (Application Settings)
+    /// Updated to support specific protocols
+    pub fn application_settings(&mut self, protocols: &[&str]) {
+        let mut data = BytesMut::new();
+        for proto in protocols {
+            let p_bytes = proto.as_bytes();
+            data.put_u8(p_bytes.len() as u8);
+            data.put_slice(p_bytes);
+            data.put_u16(0); // Empty settings per-protocol
+        }
+        self.add_extension(EXT_ALPS, &data);
+    }
+
+    /// 0x002b - Supported Versions
+    pub fn supported_versions(&mut self, versions: TlsVersions) {
+        let mut data = BytesMut::with_capacity(1 + versions.0.len() * 2);
+        data.put_u8((versions.0.len() * 2) as u8);
+        for &v in versions.0 {
+            data.put_u16(v);
+        }
+        self.add_extension(EXT_SUPPORTED_VERSIONS, &data);
+    }
+
+    /// 0x002d - PSK Key Exchange Modes
+    pub fn psk_key_exchange_modes(&mut self) {
+        let mut data = BytesMut::with_capacity(2);
+        data.put_u8(1);
+        data.put_u8(PSK_DHE_KE_MODE);
+        self.add_extension(EXT_PSK_KEY_EXCHANGE_MODES, &data);
+    }
+
+    /// 0x001b - Certificate Compression
+    pub fn compress_certificate(&mut self, algorithms: &[u16]) {
+        let mut data = BytesMut::with_capacity(1 + algorithms.len() * 2);
+        data.put_u8((algorithms.len() * 2) as u8);
+        for &alg in algorithms {
+            data.put_u16(alg);
+        }
+        self.add_extension(EXT_COMPRESS_CERTIFICATE, &data);
+    }
+
+    /// 0x0005 - Status Request
+    pub fn status_request(&mut self) {
+        let mut data = BytesMut::with_capacity(5);
+        data.put_u8(OCSP_STATUS_TYPE);
+        data.put_u16(0); // responder_id_list
+        data.put_u16(0); // request_extensions
+        self.add_extension(EXT_STATUS_REQUEST, &data);
+    }
+
+    /// 0x0033 - Key Share
+    /// Corrected: ClientHello KeyShare has a list length AND a group/key length
+    pub fn key_share(&mut self, public_key: &[u8]) {
+        let mut data = BytesMut::with_capacity(38);
+        data.put_u16(34); // Total Key Share List Length
+        data.put_u16(GROUP_X25519);
+        data.put_u16(32); // Public Key length
+        data.put_slice(public_key);
+        self.add_extension(EXT_KEY_SHARE, &data);
+    }
+
+    /// 0x000b - EC Point Formats
+    pub fn ec_point_formats(&mut self) {
+        let mut data = BytesMut::with_capacity(2);
+        data.put_u8(1);
+        data.put_u8(EC_POINT_FORMAT_UNCOMPRESSED);
+        self.add_extension(EXT_EC_POINT_FORMATS, &data);
+    }
+
+    /// 0x0012 - SCT
+    pub fn signed_certificate_timestamp(&mut self) {
+        self.add_extension(EXT_SIGNED_CERT_TIMESTAMP, &[]);
+    }
+
+    /// 0x0022 - Delegated Credentials
+    pub fn delegated_credential(&mut self, algs: TlsSignatures) {
+        let mut data = BytesMut::with_capacity(2 + algs.0.len() * 2);
+        data.put_u16((algs.0.len() * 2) as u16);
+        for &a in algs.0 {
+            data.put_u16(a);
+        }
+        self.add_extension(EXT_DELEGATED_CREDENTIAL, &data);
+    }
+
+    /// 0x0010 - ALPN
+    pub fn alpn(&mut self, protocols: &[&str]) {
+        let mut list_data = BytesMut::new();
+        for proto in protocols {
+            let bytes = proto.as_bytes();
+            list_data.put_u8(bytes.len() as u8);
+            list_data.put_slice(bytes);
+        }
+        let mut extension_data = BytesMut::new();
+        extension_data.put_u16(list_data.len() as u16);
+        extension_data.put_slice(&list_data);
+        self.add_extension(EXT_ALPN, &extension_data);
+    }
+
+    /// 0x0023 - Session Ticket
+    pub fn session_ticket(&mut self) {
+        self.add_extension(0x0023, &[]);
+    }
+
+    pub fn padding(&mut self, target_size: usize) {
+        // Текущий размер накопленной нагрузки
+        let current_size = self.payload.len();
+
+        // 4 байта резервируем под заголовок самого расширения (Type + Length)
+        if target_size > current_size + 4 {
+            let pad_len = target_size - current_size - 4;
+            let data = vec![0u8; pad_len];
+
+            // Используем pack, как и в других методах
+            let ext = Extension::pack(EXT_PADDING, &data);
+            self.payload.put_slice(&ext);
+        }
+    }
+
+    /// 0xff01 - Renegotiation Info
+    pub fn renegotiation_info(&mut self) {
+        self.add_extension(EXT_RENEGOTIATION_INFO, &[0x00]);
+    }
+
+    pub fn build(&mut self) -> Bytes {
+        self.payload.split().freeze()
+    }
+
+    pub fn apply_profile(&mut self, profile: &BrowserProfile, host: &str, pub_key: &[u8]) {
+        for &ext_id in profile.extension_order {
+            match ext_id {
+                0x0000 => self.server_name(host),
+                0x000a => self.supported_groups(profile.groups),
+                0x000d => self.signature_algorithms(profile.signatures),
+                0x0010 => self.alpn(&["h2", "http/1.1"]),
+                0x0012 => self.signed_certificate_timestamp(),
+                0x0017 => self.extended_main_secret(),
+                0x001b => self.compress_certificate(&[CERT_COMPRESSION_BROTLI]),
+                0x0022 => self.delegated_credential(profile.delegated_signatures),
+                0x0023 => self.session_ticket(),
+                0x002b => self.supported_versions(profile.versions),
+                0x002d => self.psk_key_exchange_modes(),
+                0x0033 => self.key_share(pub_key),
+                0x44cd => self.application_settings(&["h2"]),
+                0x0005 => self.status_request(),
+                0x000b => self.ec_point_formats(),
+                0xff01 => self.renegotiation_info(),
+                // Padding logic
+                0x0015 => {
+                    if profile.is_chromium {
+                        // Standard Chromium behavior: pad to 512 bytes
+                        self.padding(512);
+                    } else {
+                        // Non-chromium might use different logic or no padding
+                        self.add_extension(0x0015, &[]);
+                    }
+                }
+                id if (id & 0x0f0f) == 0x0a0a => self.grease(),
+                _ => {}
+            }
+        }
+    }
+}

common/src/tlseng/mod.rs

@@ -0,0 +1,6 @@
+pub mod etype;
+pub mod extension;
+mod params;
+pub mod profile;
+pub mod tls;
+mod values;

common/src/tlseng/params.rs

@@ -0,0 +1,8 @@
+#[derive(Clone, Copy)]
+pub struct TlsGroups(pub &'static [u16]);
+
+#[derive(Clone, Copy)]
+pub struct TlsSignatures(pub &'static [u16]);
+
+#[derive(Clone, Copy)]
+pub struct TlsVersions(pub &'static [u16]);

common/src/tlseng/profile/groups/chrome_groups.rs

@@ -0,0 +1,51 @@
+use crate::tlseng::etype::*;
+use crate::tlseng::params::{TlsGroups, TlsSignatures};
+use crate::tlseng::values::{
+    GROUP_SECP256R1, GROUP_SECP384R1, GROUP_X25519, SIG_ECDSA_SECP256R1_SHA256,
+    SIG_ECDSA_SECP384R1_SHA384, SIG_RSA_PKCS1_SHA256, SIG_RSA_PKCS1_SHA384, SIG_RSA_PKCS1_SHA512,
+    SIG_RSA_PSS_RSAE_SHA256, SIG_RSA_PSS_RSAE_SHA384, SIG_RSA_PSS_RSAE_SHA512,
+};
+
+pub const CHROME_GROUPS: TlsGroups =
+    TlsGroups(&[0xaaaa, GROUP_X25519, GROUP_SECP256R1, GROUP_SECP384R1]);
+
+pub const CHROME_SIGNATURES: TlsSignatures = TlsSignatures(&[
+    SIG_ECDSA_SECP256R1_SHA256,
+    SIG_RSA_PSS_RSAE_SHA256,
+    SIG_RSA_PKCS1_SHA256,
+    SIG_ECDSA_SECP384R1_SHA384,
+    SIG_RSA_PSS_RSAE_SHA384,
+    SIG_RSA_PKCS1_SHA384,
+    SIG_RSA_PSS_RSAE_SHA512,
+    SIG_RSA_PKCS1_SHA512,
+]);
+
+pub const CHROME_DELEGATED_ALGS: TlsSignatures = TlsSignatures(&[
+    SIG_ECDSA_SECP256R1_SHA256,
+    SIG_RSA_PSS_RSAE_SHA256,
+    SIG_RSA_PKCS1_SHA256,
+    SIG_ECDSA_SECP384R1_SHA384,
+    SIG_RSA_PSS_RSAE_SHA384,
+    SIG_RSA_PKCS1_SHA384,
+]);
+
+pub const CHROME_ALPN_PROTOCOLS: &[&str] = &["h2", "http/1.1"];
+
+pub const CHROMIUM_EXT_ORDER: &[u16] = &[
+    0xaaaa,                     // GREASE
+    EXT_TYPE_SNI,               // 0x0000
+    EXT_EXTENDED_MASTER_SECRET, // 0x0017
+    EXT_SESSION_TICKET,         // SessionTicket
+    EXT_SUPPORTED_GROUPS,       // 0x000a
+    EXT_EC_POINT_FORMATS,       // 0x000b
+    EXT_SIGNATURE_ALGORITHMS,   // 0x000d
+    EXT_ALPN,                   // 0x0010
+    EXT_ALPS,                   // 0x44cd
+    EXT_STATUS_REQUEST,         // 0x0005
+    EXT_KEY_SHARE,              // 0x0033
+    EXT_SUPPORTED_VERSIONS,     // 0x002b
+    EXT_PSK_KEY_EXCHANGE_MODES, // 0x002d
+    EXT_COMPRESS_CERTIFICATE,   // 0x001b
+    EXT_SIGNED_CERT_TIMESTAMP,  // 0x0012
+    EXT_DELEGATED_CREDENTIAL,   // 0x0022
+];

common/src/tlseng/profile/groups/edge_groups.rs

@@ -0,0 +1,61 @@
+use crate::tlseng::etype::*;
+use crate::tlseng::params::{TlsGroups, TlsSignatures};
+use crate::tlseng::values::{
+    GROUP_SECP256R1, GROUP_SECP384R1, GROUP_X25519, SIG_ECDSA_SECP256R1_SHA256,
+    SIG_ECDSA_SECP384R1_SHA384, SIG_RSA_PKCS1_SHA256, SIG_RSA_PKCS1_SHA384, SIG_RSA_PKCS1_SHA512,
+    SIG_RSA_PSS_RSAE_SHA256, SIG_RSA_PSS_RSAE_SHA384, SIG_RSA_PSS_RSAE_SHA512,
+};
+
+// --- MICROSOFT EDGE ---
+// Edge often mirrors Chrome exactly but sometimes removes specific
+// experimental GREASE values or adds Windows-specific signature prefs.
+pub const EDGE_GROUPS: TlsGroups = TlsGroups(&[
+    0x0a0a, // GREASE
+    GROUP_X25519,
+    GROUP_SECP256R1,
+    GROUP_SECP384R1,
+]);
+
+pub const EDGE_SIGNATURES: TlsSignatures = TlsSignatures(&[
+    SIG_ECDSA_SECP256R1_SHA256,
+    SIG_RSA_PSS_RSAE_SHA256,
+    SIG_RSA_PKCS1_SHA256,
+    SIG_ECDSA_SECP384R1_SHA384,
+    SIG_RSA_PSS_RSAE_SHA384,
+    SIG_RSA_PKCS1_SHA384,
+    SIG_RSA_PSS_RSAE_SHA512,
+    SIG_RSA_PKCS1_SHA512,
+]);
+
+pub const EDGE_DELEGATED_ALGS: TlsSignatures = TlsSignatures(&[
+    SIG_ECDSA_SECP256R1_SHA256,
+    SIG_RSA_PSS_RSAE_SHA256,
+    SIG_RSA_PKCS1_SHA256,
+    SIG_ECDSA_SECP384R1_SHA384,
+    SIG_RSA_PSS_RSAE_SHA384,
+    SIG_RSA_PKCS1_SHA384,
+]);
+
+pub const EDGE_ALPN_PROTOCOLS: &[&str] = &["h2", "http/1.1"];
+
+// Microsoft Edge Extension Order (Chromium v130+)
+pub const EDGE_EXT_ORDER: &[u16] = &[
+    0x1a1a,                     // GREASE
+    EXT_TYPE_SNI,               // 0x0000
+    EXT_EXTENDED_MASTER_SECRET, // 0x0017
+    EXT_SESSION_TICKET,         // 0x0023
+    EXT_SUPPORTED_GROUPS,       // 0x000a
+    EXT_EC_POINT_FORMATS,       // 0x000b
+    EXT_SIGNATURE_ALGORITHMS,   // 0x000d
+    EXT_ALPN,                   // 0x0010
+    EXT_ALPS,                   // 0x44cd
+    EXT_STATUS_REQUEST,         // 0x0005
+    EXT_KEY_SHARE,              // 0x0033
+    EXT_SUPPORTED_VERSIONS,     // 0x002b
+    EXT_PSK_KEY_EXCHANGE_MODES, // 0x002d
+    EXT_COMPRESS_CERTIFICATE,   // 0x001b
+    EXT_SIGNED_CERT_TIMESTAMP,  // 0x0012
+    EXT_DELEGATED_CREDENTIAL,   // 0x0022
+    EXT_PADDING,                // 0x0015
+    0x3a3a,                     // GREASE
+];

common/src/tlseng/profile/groups/mod.rs

@@ -0,0 +1,3 @@
+pub mod chrome_groups;
+pub mod edge_groups;
+pub mod shared;

common/src/tlseng/profile/groups/shared.rs

@@ -0,0 +1,3 @@
+use crate::tlseng::params::TlsVersions;
+
+pub const MODERN_VERSIONS: TlsVersions = TlsVersions(&[0x0304, 0x0303]);

common/src/tlseng/profile/mod.rs

@@ -0,0 +1,3 @@
+mod groups;
+pub mod profile;
+pub mod versions;

common/src/tlseng/profile/profile.rs

@@ -0,0 +1,14 @@
+use crate::tlseng::params::{TlsGroups, TlsSignatures, TlsVersions};
+
+/// Represents a complete TLS fingerprint profile for a specific browser.
+pub struct BrowserProfile {
+    pub name: &'static str,
+    pub groups: TlsGroups,
+    pub signatures: TlsSignatures,
+    pub delegated_signatures: TlsSignatures,
+    pub versions: TlsVersions,
+    pub alpn: &'static [&'static str],
+    /// The specific order of Extension IDs (e.g., [0x0000, 0x0017, ...])
+    pub extension_order: &'static [u16],
+    pub is_chromium: bool,
+}

common/src/tlseng/profile/versions.rs

@@ -0,0 +1,45 @@
+use crate::tlseng::{
+    params::TlsVersions,
+    profile::{
+        groups::{
+            chrome_groups::{
+                CHROME_ALPN_PROTOCOLS, CHROME_DELEGATED_ALGS, CHROME_GROUPS, CHROME_SIGNATURES,
+                CHROMIUM_EXT_ORDER,
+            },
+            edge_groups::{
+                EDGE_ALPN_PROTOCOLS, EDGE_DELEGATED_ALGS, EDGE_EXT_ORDER, EDGE_GROUPS,
+                EDGE_SIGNATURES,
+            },
+            shared::MODERN_VERSIONS,
+        },
+        profile::BrowserProfile,
+    },
+};
+
+// --- Versions ---
+pub const TLS_13_ONLY: TlsVersions = TlsVersions(&[0x0304]);
+
+// --- CHROME 131 PROFILE ---
+pub const CHROME_131: BrowserProfile = BrowserProfile {
+    name: "Chrome 131 (Windows)",
+    groups: CHROME_GROUPS,
+    signatures: CHROME_SIGNATURES,
+    alpn: CHROME_ALPN_PROTOCOLS,
+    delegated_signatures: CHROME_DELEGATED_ALGS,
+    versions: TLS_13_ONLY,
+    extension_order: CHROMIUM_EXT_ORDER,
+    is_chromium: true,
+};
+
+// --- FIREFOX 133 PROFILE (Example) ---
+// Note: Firefox uses different groups and no ALPS
+pub const EDGE_PROFILE: BrowserProfile = BrowserProfile {
+    name: "Edge",
+    groups: EDGE_GROUPS,
+    signatures: EDGE_SIGNATURES, // Usually identical to Chrome
+    alpn: EDGE_ALPN_PROTOCOLS,
+    delegated_signatures: EDGE_DELEGATED_ALGS,
+    versions: MODERN_VERSIONS,
+    extension_order: EDGE_EXT_ORDER,
+    is_chromium: true,
+};

common/src/tlseng/tls.rs

@@ -0,0 +1,232 @@
+use bytes::{BufMut, Bytes, BytesMut};
+
+use crate::{
+    tlseng::etype::{HANDSHAKE_TYPE_CLIENT_HELLO, HANDSHAKE_TYPE_SERVER_HELLO},
+    utils::u24::U24,
+};
+
+/// TLS Content Types as defined in the TLS Record Protocol.
+/// These identify what is contained within the TLS Record payload.
+#[repr(u8)]
+#[derive(Copy, Clone, Debug)]
+pub enum ContentType {
+    /// Handshake messages (e.g., ClientHello, ServerHello)
+    Handshake = 0x16,
+    /// Encrypted application data (the actual traffic)
+    ApplicationData = 0x17,
+    /// Notification messages (e.g., CloseNotify or error signals)
+    Alert = 0x15,
+}
+
+impl TryFrom<u8> for ContentType {
+    type Error = &'static str;
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0x16 => Ok(ContentType::Handshake),
+            0x17 => Ok(ContentType::ApplicationData),
+            0x15 => Ok(ContentType::Alert),
+            _ => Err("This is not ContentType"),
+        }
+    }
+}
+
+/// Known TLS protocol versions.
+/// Note: TLS 1.3 often uses legacy versions in headers for compatibility.
+#[repr(u16)]
+#[derive(Copy, Clone, Debug)]
+pub enum ProtocolVersion {
+    Tls10 = 0x0301,
+    Tls12 = 0x0303,
+    Tls13 = 0x0304,
+}
+
+impl TryFrom<u16> for ProtocolVersion {
+    type Error = &'static str;
+    fn try_from(value: u16) -> Result<Self, Self::Error> {
+        match value {
+            0x0301 => Ok(ProtocolVersion::Tls10),
+            0x0303 => Ok(ProtocolVersion::Tls12),
+            0x0304 => Ok(ProtocolVersion::Tls13),
+            _ => Err("This is not Protocol Version"),
+        }
+    }
+}
+
+pub struct ApplicationData {
+    pub length: usize,
+    pub payload: Bytes,
+}
+
+pub enum HelloType {
+    Client = 0x00,
+    Server = 0x01,
+}
+
+impl TryFrom<u8> for HelloType {
+    type Error = &'static str;
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0x00 => Ok(HelloType::Client),
+            0x01 => Ok(HelloType::Server),
+            _ => Err("This is not Hello header"),
+        }
+    }
+}
+
+pub struct HelloHeader {
+    pub header_type: HelloType,
+    pub len: U24,
+    pub body: Bytes,
+}
+
+/// Represents the ClientHello Handshake message.
+/// This is the first message sent by a client to initiate a TLS connection.
+pub struct ClientHello {
+    /// The maximum version supported (legacy field in TLS 1.3)
+    pub version: ProtocolVersion,
+    /// 32 bytes of client-generated entropy
+    pub random: [u8; 32],
+    /// Legacy session ID (used in TLS 1.3 for middlebox compatibility)
+    pub session_id: Bytes,
+    /// List of cryptographic ciphers the client supports
+    pub cipher_suites: Vec<u16>,
+    /// Opaque block of extensions generated by ExtensionBuilder
+    pub extensions: Bytes,
+}
+
+impl ClientHello {
+    /// Serializes the ClientHello message into its wire format.
+    /// Includes the 4-byte Handshake header (Type + Length).
+    pub fn serialize(&self) -> Bytes {
+        let mut buf = BytesMut::with_capacity(512 + self.extensions.len());
+
+        // Handshake Type: 0x01 (ClientHello)
+        buf.put_u8(HANDSHAKE_TYPE_CLIENT_HELLO);
+
+        // Handshake Length Placeholder:
+        // Handshake messages use a 24-bit (3 byte) length field.
+        let length_pos = buf.len();
+        buf.put_bytes(0, 3);
+
+        // Protocol Version:
+        // For TLS 1.3, this is traditionally pinned to 0x0303 (TLS 1.2)
+        // to prevent middleboxes from dropping the packet.
+        buf.put_u16(0x0303);
+        buf.put_slice(&self.random);
+
+        // Legacy Session ID:
+        // Formatted as Length (1 byte) + ID bytes.
+        buf.put_u8(self.session_id.len() as u8);
+        buf.put_slice(&self.session_id);
+
+        // Cipher Suites:
+        // Formatted as Total Length (2 bytes) + Suite IDs (2 bytes each).
+        buf.put_u16((self.cipher_suites.len() * 2) as u16);
+        for &suite in &self.cipher_suites {
+            buf.put_u16(suite);
+        }
+
+        // Legacy Compression Methods:
+        // Always 1 byte of length (1) followed by the 'Null' method (0x00).
+        buf.put_u8(1);
+        buf.put_u8(0x00);
+
+        // Extensions Block:
+        // Formatted as Total Length (2 bytes) + Extension Data.
+        buf.put_u16(self.extensions.len() as u16);
+        buf.put_slice(&self.extensions);
+
+        // Patch the Handshake Length:
+        // We calculate the length of everything after the 3-byte placeholder.
+        let total_len = (buf.len() - length_pos - 3) as u32;
+        let len_bytes = total_len.to_be_bytes();
+        // Copy the last 3 bytes of the big-endian u32 into the placeholder.
+        buf[length_pos..length_pos + 3].copy_from_slice(&len_bytes[1..4]);
+
+        buf.freeze()
+    }
+}
+
+pub struct ServerHello {
+    pub version: ProtocolVersion,
+    pub random: [u8; 32],
+    pub session_id: Bytes,
+    pub cipher_suite: u16,
+    pub extensions: Bytes,
+}
+
+impl ServerHello {
+    pub fn serialize(&self) -> Bytes {
+        let mut buf = BytesMut::with_capacity(256 + self.extensions.len());
+
+        // 1. Handshake Type: 0x02 (ServerHello)
+        buf.put_u8(HANDSHAKE_TYPE_SERVER_HELLO);
+
+        // 2. Placeholder для u24 длины
+        let length_pos = buf.len();
+        buf.put_bytes(0, 3);
+
+        // 3. Тело ServerHello
+        buf.put_u16(ProtocolVersion::Tls12 as u16); // Legacy 0x0303
+        buf.put_slice(&self.random);
+
+        // Session ID
+        buf.put_u8(self.session_id.len() as u8);
+        buf.put_slice(&self.session_id);
+
+        // Выбранный Cipher Suite (в отличие от клиента, тут только ОДИН)
+        buf.put_u16(self.cipher_suite);
+
+        // Compression: всегда 0x00
+        buf.put_u8(0);
+
+        // Extensions
+        buf.put_u16(self.extensions.len() as u16);
+        buf.put_slice(&self.extensions);
+
+        // 4. Патчим длину (переиспользуем твой метод)
+        let total_len = (buf.len() - length_pos - 3) as u32;
+        let len_bytes = total_len.to_be_bytes();
+        buf[length_pos..length_pos + 3].copy_from_slice(&len_bytes[1..4]);
+
+        buf.freeze()
+    }
+}
+
+/// The TLS Record Layer structure.
+/// This is the outer envelope that wraps all TLS messages sent over the wire.
+#[derive(Debug)]
+pub struct TlsRecord {
+    /// The type of data contained (Handshake, ApplicationData, etc.)
+    pub content_type: ContentType,
+    /// The record layer version (usually 0x0301 for legacy support)
+    pub version: ProtocolVersion,
+
+    pub len: u16,
+    /// The actual data being transported (e.g., a serialized ClientHello)
+    pub payload: Bytes,
+}
+
+impl TlsRecord {
+    pub fn new(content_type: ContentType, version: ProtocolVersion, payload: Bytes) -> Self {
+        Self {
+            content_type,
+            version,
+            len: payload.len() as u16,
+            payload,
+        }
+    }
+
+    /// Serializes the Record Layer header and payload.
+    /// Wire Format: [Type (1)] [Version (2)] [Length (2)] [Payload (N)]
+    pub fn serialize(&self) -> Bytes {
+        let mut buf = BytesMut::with_capacity(5 + self.payload.len());
+
+        buf.put_u8(self.content_type as u8);
+        buf.put_u16(self.version as u16);
+        buf.put_u16(self.payload.len() as u16);
+        buf.put_slice(&self.payload);
+
+        buf.freeze()
+    }
+}

common/src/tlseng/values.rs

@@ -0,0 +1,21 @@
+pub const TYPE_HOST_NAME: u8 = 0x00;
+
+pub const GROUP_X25519: u16 = 0x001d;
+pub const GROUP_SECP256R1: u16 = 0x0017;
+pub const GROUP_SECP384R1: u16 = 0x0018;
+
+// Signature Algorithms (Signature Schemes)
+pub const SIG_ECDSA_SECP256R1_SHA256: u16 = 0x0403;
+pub const SIG_RSA_PSS_RSAE_SHA256: u16 = 0x0804;
+pub const SIG_RSA_PKCS1_SHA256: u16 = 0x0401;
+pub const SIG_ECDSA_SECP384R1_SHA384: u16 = 0x0503;
+pub const SIG_RSA_PSS_RSAE_SHA384: u16 = 0x0805;
+pub const SIG_RSA_PKCS1_SHA384: u16 = 0x0501;
+pub const SIG_RSA_PSS_RSAE_SHA512: u16 = 0x0806;
+pub const SIG_RSA_PKCS1_SHA512: u16 = 0x0601;
+
+// Versions & Modes
+pub const PSK_DHE_KE_MODE: u8 = 0x01;
+pub const CERT_COMPRESSION_BROTLI: u16 = 0x0002;
+pub const OCSP_STATUS_TYPE: u8 = 0x01;
+pub const EC_POINT_FORMAT_UNCOMPRESSED: u8 = 0x00;