renames and tauri app

2026-03-09 17:51:01 +07:00
parent 6ca47336a1
commit 6f4dd88a8e
62 changed files with 5215 additions and 70 deletions
@@ -0,0 +1,276 @@
+use bytes::{BufMut, Bytes, BytesMut};
+use rand::RngExt;
+
+// Using your provided constants and types
+use crate::tlseng::{
+    consts::{
+        CERT_COMPRESSION_BROTLI, GREASE_IDENTIFIERS, OCSP_STATUS_TYPE, PSK_DHE_KE_MODE,
+        TYPE_HOST_NAME,
+    },
+    profile::BrowserProfile,
+    types::{TlsExtensions, TlsGroups, TlsSignatures, TlsVersions},
+};
+
+#[derive(Debug)]
+pub struct Extension {
+    pub etype: u16,
+    pub elen: u16,
+    pub data: Bytes,
+}
+
+#[derive(Debug)]
+pub struct ExtensionStack {
+    pub extensions: Vec<Extension>,
+}
+
+impl ExtensionStack {
+    pub fn find_by_type(&self, etype: u16) -> Option<Bytes> {
+        self.extensions
+            .iter()
+            .find(|e| e.etype == etype)
+            .map(|e| e.data.clone())
+    }
+}
+
+impl Extension {
+    /// Creates a new Extension from the given parameters.
+    ///
+    /// # Arguments
+    ///
+    /// * `etype`: The type of extension (e.g., EXT_SUPPORTED_VERSIONS).
+    /// * `data`: The actual data being transported (e.g., a serialized list of supported versions).
+    ///
+    /// # Returns
+    ///
+    /// A new Extension structure with the given parameters.
+    pub fn new(etype: u16, data: Bytes) -> Self {
+        Self {
+            etype,
+            elen: data.len() as u16,
+            data,
+        }
+    }
+    /// Packs an extension into a single byte array.
+    ///
+    /// # Arguments
+    ///
+    /// * `etype`: The type of extension (e.g., EXT_SUPPORTED_VERSIONS).
+    /// * `data`: The actual data being transported (e.g., a serialized list of supported versions).
+    ///
+    /// # Returns
+    ///
+    /// A single byte array containing the type and length of the extension, followed by the actual extension 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),
+        }
+    }
+
+    fn add_extension(&mut self, etype: u16, data: &[u8]) {
+        let ext = Extension::pack(etype, data);
+        self.payload.put_slice(&ext);
+    }
+
+    pub fn grease(&mut self) {
+        let mut rng = rand::rng();
+        let rnd = rng.random_range(0..GREASE_IDENTIFIERS.len());
+        let etype = GREASE_IDENTIFIERS[rnd];
+        self.add_extension(etype, &[]);
+    }
+
+    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(TlsExtensions::SNI, &data);
+    }
+
+    pub fn extended_main_secret(&mut self) {
+        self.add_extension(TlsExtensions::EMS, &[]);
+    }
+
+    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(TlsExtensions::SUPPORTED_GROUPS, &data);
+    }
+
+    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(TlsExtensions::SIGNATURE_ALGORITHMS, &data);
+    }
+
+    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(TlsExtensions::SUPPORTED_VERSIONS, &data);
+    }
+
+    pub fn key_share(&mut self, pub_key: &[u8]) {
+        let mut data = BytesMut::with_capacity(38);
+        data.put_u16(34); // Total Key Share List Length
+        data.put_u16(TlsGroups::X25519);
+        data.put_u16(32); // Public Key length
+        data.put_slice(pub_key);
+        self.add_extension(TlsExtensions::KEY_SHARE, &data);
+    }
+
+    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(TlsExtensions::ALPS, &data);
+    }
+
+    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(TlsExtensions::ALPN, &extension_data);
+    }
+
+    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(TlsExtensions::PSK_MODES, &data);
+    }
+
+    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(TlsExtensions::COMPRESS_CERT, &data);
+    }
+
+    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(TlsExtensions::STATUS_REQUEST, &data);
+    }
+
+    pub fn ec_point_formats(&mut self) {
+        let mut data = BytesMut::with_capacity(2);
+        data.put_u8(1);
+        data.put_u8(0x00); // Uncompressed
+        self.add_extension(TlsExtensions::EC_POINT_FORMATS, &data);
+    }
+
+    pub fn signed_certificate_timestamp(&mut self) {
+        self.add_extension(TlsExtensions::SCT, &[]);
+    }
+
+    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(TlsExtensions::DELEGATED_CREDENTIAL, &data);
+    }
+
+    pub fn session_ticket(&mut self) {
+        self.add_extension(TlsExtensions::SESSION_TICKET, &[]);
+    }
+
+    pub fn renegotiation_info(&mut self) {
+        self.add_extension(TlsExtensions::RENEGOTIATION_INFO, &[0x00]);
+    }
+
+    pub fn padding(&mut self, target_size: usize) {
+        let current_size = self.payload.len();
+        if target_size > current_size + 4 {
+            let pad_len = target_size - current_size - 4;
+            let data = vec![0u8; pad_len];
+            self.add_extension(TlsExtensions::PADDING, &data);
+        }
+    }
+
+    pub fn apply_profile(&mut self, profile: &BrowserProfile, host: &str, pub_key: &[u8]) {
+        for &ext_id in &profile.extension_order {
+            match ext_id {
+                TlsExtensions::SNI => self.server_name(host),
+                TlsExtensions::SUPPORTED_GROUPS => self.supported_groups(profile.groups),
+                TlsExtensions::SIGNATURE_ALGORITHMS => {
+                    self.signature_algorithms(profile.signatures)
+                }
+                TlsExtensions::ALPN => self.alpn(profile.alpn),
+                TlsExtensions::SCT => self.signed_certificate_timestamp(),
+                TlsExtensions::EMS => self.extended_main_secret(),
+                TlsExtensions::COMPRESS_CERT => {
+                    self.compress_certificate(&[CERT_COMPRESSION_BROTLI])
+                }
+                TlsExtensions::DELEGATED_CREDENTIAL => {
+                    self.delegated_credential(profile.delegated_signatures)
+                }
+                TlsExtensions::SESSION_TICKET => self.session_ticket(),
+                TlsExtensions::SUPPORTED_VERSIONS => self.supported_versions(profile.versions),
+                TlsExtensions::PSK_MODES => self.psk_key_exchange_modes(),
+                TlsExtensions::KEY_SHARE => self.key_share(pub_key),
+                TlsExtensions::ALPS => self.application_settings(&["h2"]),
+                TlsExtensions::STATUS_REQUEST => self.status_request(),
+                TlsExtensions::EC_POINT_FORMATS => self.ec_point_formats(),
+                TlsExtensions::RENEGOTIATION_INFO => self.renegotiation_info(),
+                TlsExtensions::PADDING => {
+                    if profile.is_chromium {
+                        self.padding(512);
+                    } else {
+                        self.add_extension(TlsExtensions::PADDING, &[]);
+                    }
+                }
+                // Обработка GREASE по маске
+                id if (id & 0x0f0f) == 0x0a0a => self.grease(),
+                _ => {}
+            }
+        }
+    }
+
+    pub fn build(&mut self) -> Bytes {
+        self.payload.split().freeze()
+    }
+}