Init padding

Author: RealHinome

Cargo.lock

@@ -14,4 +14,6 @@ jsonwebtoken = { workspace = true }
 url = "*"
 tungstenite = { workspace = true }
 reqwest = "0.12"
-webrtc = { workspace = true }
+webrtc = { workspace = true }
+rand = "*"
+rand_chacha = "*"

error/Cargo.toml

@@ -39,6 +39,8 @@ pub enum Error {
     AuthenticationFailed,
     #[error("sess-id does not exist on sdp")]
     MissingSessionId,
+    #[error(transparent)]
+    RandOs(#[from] rand::rand_core::OsError),
 }
 
 impl From<tungstenite::Error> for Error {

error/src/lib.rs

@@ -24,6 +24,8 @@ p2p = { path = "../p2p" }
 error = { path = "../error" }
 vodozemac = "0.9"
 blake3 = "1.8"
+rand = "0.9"
+rand_chacha = "0.9"
 hex = "0.4"
 serde = { workspace = true }
 serde_yaml = "0.9"

libturms/Cargo.toml

@@ -5,6 +5,7 @@ pub extern crate error;
 pub extern crate p2p;
 
 mod channel;
+mod padding;
 
 use discover::spawn_heartbeat;
 use discover::websocket::WebSocket;

libturms/src/lib.rs

@@ -0,0 +1,52 @@
+//! Random crypto-secure padding.
+
+use rand::{RngCore, SeedableRng, TryRngCore};
+use rand::rngs::OsRng;
+use rand_chacha::ChaCha20Rng;
+use error::Result;
+
+// Numbers from specification.
+const MIN_LENGTH: usize = 1000; // 1kB.
+const PADDING_LENGTH: [usize; 2] = [0, 8192];
+
+/// Padding structure.
+#[derive(Debug, Clone)]
+pub(crate) struct Padding {
+    min_length: usize,
+    padding_length: [usize; 2],
+    fill_padding: u8,
+}
+
+impl Default for Padding {
+    fn default() -> Self {
+        Padding {
+            min_length: MIN_LENGTH,
+            padding_length: PADDING_LENGTH,
+            fill_padding: 0, // adds lots of zeros.
+        }
+    }
+}
+
+impl Padding {
+    /// Fill an entry with bunch of paddings.
+    pub fn fill_zero(entry: impl AsRef<[u8]>) -> Result<Vec<u8>> {
+        let config = Self::default();
+        let data = entry.as_ref();
+        let data_len = data.len();
+
+        let mut seed = [0u8; 32];
+        OsRng.try_fill_bytes(&mut seed)?;
+
+        let mut rng = ChaCha20Rng::from_seed(seed);
+        rng.fill_bytes(&mut data);
+
+        let base_target = std::cmp::max(data_len, config.min_length);
+        let total_size = base_target + data.len();
+
+        let mut padded_data = Vec::with_capacity(total_size);
+        padded_data.extend_from_slice(data);
+        padded_data.resize(total_size, config.fill_padding);
+
+        Ok(padded_data)
+    }
+}

libturms/src/padding.rs

@@ -1,16 +1,17 @@
 //! peer-to-peer communication via WebRTC.
-/// Models.
-pub mod models;
 #[forbid(unsafe_code)]
 #[deny(missing_docs, missing_debug_implementations)]
+
+/// Models.
+pub mod models;
 /// WebRTC interface.
 pub mod webrtc;
 /// X3DH over WebRTC for Turms.
 mod x3dh;
 
 pub use x3dh::triple_diffie_hellman;
 
-use tokio::sync::Mutex;
+use parking_lot::Mutex;
 use vodozemac::olm::Account;
 
 use std::sync::OnceLock;
@@ -26,7 +27,7 @@ pub fn get_account() -> &'static Mutex<Account> {
 pub async fn save_account() -> error::Result<String> {
     let account = get_account();
 
-    Ok(serde_json::to_string(&account.lock().await.pickle())?)
+    Ok(serde_json::to_string(&account.lock().pickle())?)
 }
 
 /// Set user account.

p2p/src/lib.rs

@@ -17,6 +17,7 @@ pub enum Event {
     Typing,
 }
 
+/// Triple-diffie Hellman exchange.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct X3DH {
     /// Curve25519 public key.
@@ -76,6 +77,7 @@ bitflags! {
     /// Represents a set of message/attachment flags.
     #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
     pub struct Flags: u32 {
+        /// Message flagged as urgent.
         const URGENT = 1 << 0;
         /// Message MUST NOT be saved.
         const EPHEMERAL = 1 << 1;

p2p/src/models.rs

@@ -15,7 +15,7 @@ pub async fn triple_diffie_hellman(
 
     // Generate public key and one-time key.
     let (public_key, otk) = {
-        let mut account = account.lock().await;
+        let mut account = account.lock();
 
         account.generate_one_time_keys(1);
 
@@ -38,7 +38,7 @@ pub async fn triple_diffie_hellman(
     }))?;
 
     if acc.send(message).await.is_ok() {
-        account.lock().await.mark_keys_as_published();
+        account.lock().mark_keys_as_published();
         tracing::debug!("public key and one-time key published");
     };