From e6ee69c7da1eae1d1cbc95e8355196672b882ff1 Mon Sep 17 00:00:00 2001 From: Philippe Antoine Date: Thu, 18 Jun 2026 08:57:49 +0200 Subject: [PATCH] rust: format all files except the ones with #[rustfmt::skip] Ticket: 3836 --- rust/src/applayer.rs | 161 ++++++++++++++++++++++++---------------- rust/src/common.rs | 4 +- rust/src/conf.rs | 9 ++- rust/src/core.rs | 39 ++++++---- rust/src/debug.rs | 2 +- rust/src/encryption.rs | 2 +- rust/src/feature.rs | 1 - rust/src/filetracker.rs | 121 ++++++++++++++++++------------ rust/src/frames.rs | 2 +- rust/src/handshake.rs | 34 ++++++--- rust/src/jsonbuilder.rs | 8 +- rust/src/kerberos.rs | 19 +++-- rust/src/lib.rs | 70 ++++++++--------- rust/src/lua.rs | 1 - rust/src/util.rs | 3 +- 15 files changed, 268 insertions(+), 208 deletions(-) diff --git a/rust/src/applayer.rs b/rust/src/applayer.rs index 91a213a352..8a9c28d08b 100644 --- a/rust/src/applayer.rs +++ b/rust/src/applayer.rs @@ -17,18 +17,16 @@ //! Parser registration functions and common interface module. -use std; use crate::core::STREAM_TOSERVER; use crate::direction::Direction; use crate::flow::Flow; -use std::os::raw::{c_void,c_char,c_int}; +use std; +use std::os::raw::{c_char, c_int, c_void}; // Make the AppLayerEvent derive macro available to users importing // AppLayerEvent from this module. pub use suricata_derive::AppLayerEvent; -use suricata_sys::sys::{ - AppLayerGetTxIterState, AppLayerParserState, AppProto, -}; +use suricata_sys::sys::{AppLayerGetTxIterState, AppLayerParserState, AppProto}; pub use suricata_sys::sys::{ AppLayerGetFileState, AppLayerGetTxIterTuple, AppLayerResult, AppLayerStateData, @@ -37,68 +35,70 @@ pub use suricata_sys::sys::{ pub use suricata_ffi::cast_pointer; -pub use suricata_ffi::{export_tx_data_get, export_state_data_get}; +pub use suricata_ffi::{export_state_data_get, export_tx_data_get}; -pub use suricata_ffi::applayer::{AppLayerEvent, AppLayerEventType, AppLayerResultRust, AppLayerTxData, StreamSliceRust}; +pub use suricata_ffi::applayer::{ + AppLayerEvent, AppLayerEventType, AppLayerResultRust, AppLayerTxData, StreamSliceRust, +}; /// Rust parser declaration #[repr(C)] pub struct RustParser { /// Parser name. - pub name: *const c_char, + pub name: *const c_char, /// Default port - pub default_port: *const c_char, + pub default_port: *const c_char, /// IP Protocol (core::IPPROTO_UDP, core::IPPROTO_TCP, etc.) - pub ipproto: u8, + pub ipproto: u8, /// Probing function, for packets going to server - pub probe_ts: Option, + pub probe_ts: Option, /// Probing function, for packets going to client - pub probe_tc: Option, + pub probe_tc: Option, /// Minimum frame depth for probing - pub min_depth: u16, + pub min_depth: u16, /// Maximum frame depth for probing - pub max_depth: u16, + pub max_depth: u16, /// Allocation function for a new state - pub state_new: StateAllocFn, + pub state_new: StateAllocFn, /// Function called to free a state - pub state_free: StateFreeFn, + pub state_free: StateFreeFn, /// Parsing function, for packets going to server - pub parse_ts: ParseFn, + pub parse_ts: ParseFn, /// Parsing function, for packets going to client - pub parse_tc: ParseFn, + pub parse_tc: ParseFn, /// Get the current transaction count - pub get_tx_count: StateGetTxCntFn, + pub get_tx_count: StateGetTxCntFn, /// Get a transaction - pub get_tx: StateGetTxFn, + pub get_tx: StateGetTxFn, /// Function called to free a transaction - pub tx_free: StateTxFreeFn, + pub tx_free: StateTxFreeFn, /// Progress values at which the tx is considered complete in a direction - pub tx_comp_st_ts: c_int, - pub tx_comp_st_tc: c_int, + pub tx_comp_st_ts: c_int, + pub tx_comp_st_tc: c_int, /// Function returning the current transaction progress - pub tx_get_progress: StateGetProgressFn, + pub tx_get_progress: StateGetProgressFn, /// Function to get an event id from a description - pub get_eventinfo: Option, + pub get_eventinfo: Option, /// Function to get an event description from an event id pub get_eventinfo_byid: Option, /// Function to allocate local storage - pub localstorage_new: Option, + pub localstorage_new: Option, /// Function to free local storage - pub localstorage_free: Option, + pub localstorage_free: Option, /// Function to get files - pub get_tx_files: Option, + pub get_tx_files: Option, /// Function to get the TX iterator - pub get_tx_iterator: Option, + pub get_tx_iterator: Option, pub get_state_data: GetStateDataFn, pub get_tx_data: GetTxDataFn, @@ -124,36 +124,51 @@ pub trait AppLayerGetFileStateRust { impl AppLayerGetFileStateRust for AppLayerGetFileState { fn err() -> AppLayerGetFileState { - AppLayerGetFileState { fc: std::ptr::null_mut(), cfg: std::ptr::null() } + AppLayerGetFileState { + fc: std::ptr::null_mut(), + cfg: std::ptr::null(), + } } } -pub type ParseFn = unsafe extern "C" fn (flow: *mut Flow, - state: *mut c_void, - pstate: *mut AppLayerParserState, - stream_slice: StreamSlice, - data: *mut c_void) -> AppLayerResult; -pub type ProbeFn = unsafe extern "C" fn (flow: *const Flow, flags: u8, input:*const u8, input_len: u32, rdir: *mut u8) -> AppProto; -pub type StateAllocFn = unsafe extern "C" fn (*mut c_void, AppProto) -> *mut c_void; -pub type StateFreeFn = unsafe extern "C" fn (*mut c_void); -pub type StateTxFreeFn = unsafe extern "C" fn (*mut c_void, u64); -pub type StateGetTxFn = unsafe extern "C" fn (*mut c_void, u64) -> *mut c_void; -pub type StateGetTxCntFn = unsafe extern "C" fn (*mut c_void) -> u64; -pub type StateGetProgressFn = unsafe extern "C" fn (*mut c_void, u8) -> c_int; -pub type GetEventInfoFn = unsafe extern "C" fn (*const c_char, event_id: *mut u8, *mut AppLayerEventType) -> c_int; -pub type GetEventInfoByIdFn = unsafe extern "C" fn (event_id: u8, *mut *const c_char, *mut AppLayerEventType) -> c_int; -pub type LocalStorageNewFn = unsafe extern "C" fn () -> *mut c_void; -pub type LocalStorageFreeFn = unsafe extern "C" fn (*mut c_void); -pub type GetTxFilesFn = unsafe extern "C" fn (*mut c_void, u8) -> AppLayerGetFileState; -pub type GetTxIteratorFn = unsafe extern "C" fn (ipproto: u8, alproto: AppProto, - state: *mut c_void, - min_tx_id: u64, - max_tx_id: u64, - istate: *mut AppLayerGetTxIterState) - -> AppLayerGetTxIterTuple; +pub type ParseFn = unsafe extern "C" fn( + flow: *mut Flow, + state: *mut c_void, + pstate: *mut AppLayerParserState, + stream_slice: StreamSlice, + data: *mut c_void, +) -> AppLayerResult; +pub type ProbeFn = unsafe extern "C" fn( + flow: *const Flow, + flags: u8, + input: *const u8, + input_len: u32, + rdir: *mut u8, +) -> AppProto; +pub type StateAllocFn = unsafe extern "C" fn(*mut c_void, AppProto) -> *mut c_void; +pub type StateFreeFn = unsafe extern "C" fn(*mut c_void); +pub type StateTxFreeFn = unsafe extern "C" fn(*mut c_void, u64); +pub type StateGetTxFn = unsafe extern "C" fn(*mut c_void, u64) -> *mut c_void; +pub type StateGetTxCntFn = unsafe extern "C" fn(*mut c_void) -> u64; +pub type StateGetProgressFn = unsafe extern "C" fn(*mut c_void, u8) -> c_int; +pub type GetEventInfoFn = + unsafe extern "C" fn(*const c_char, event_id: *mut u8, *mut AppLayerEventType) -> c_int; +pub type GetEventInfoByIdFn = + unsafe extern "C" fn(event_id: u8, *mut *const c_char, *mut AppLayerEventType) -> c_int; +pub type LocalStorageNewFn = unsafe extern "C" fn() -> *mut c_void; +pub type LocalStorageFreeFn = unsafe extern "C" fn(*mut c_void); +pub type GetTxFilesFn = unsafe extern "C" fn(*mut c_void, u8) -> AppLayerGetFileState; +pub type GetTxIteratorFn = unsafe extern "C" fn( + ipproto: u8, + alproto: AppProto, + state: *mut c_void, + min_tx_id: u64, + max_tx_id: u64, + istate: *mut AppLayerGetTxIterState, +) -> AppLayerGetTxIterTuple; pub type GetTxDataFn = unsafe extern "C" fn(*mut c_void) -> *mut suricata_sys::sys::AppLayerTxData; pub type GetStateDataFn = unsafe extern "C" fn(*mut c_void) -> *mut AppLayerStateData; -pub type ApplyTxConfigFn = unsafe extern "C" fn (*mut c_void, *mut c_void, c_int, AppLayerTxConfig); +pub type ApplyTxConfigFn = unsafe extern "C" fn(*mut c_void, *mut c_void, c_int, AppLayerTxConfig); pub type GetFrameIdByName = unsafe extern "C" fn(*const c_char) -> c_int; pub type GetFrameNameById = unsafe extern "C" fn(u8) -> *const c_char; pub type GetStateIdByName = unsafe extern "C" fn(*const c_char, u8) -> c_int; @@ -163,7 +178,7 @@ use suricata_sys::sys::{AppLayerParser, SCAppLayerRegisterParser}; #[allow(non_snake_case)] pub fn AppLayerRegisterParser(parser: &RustParser, alproto: AppProto) -> c_int { - let det = AppLayerParser{ + let det = AppLayerParser { name: parser.name, default_port: parser.default_port, ip_proto: parser.ipproto, @@ -204,13 +219,15 @@ pub fn AppLayerRegisterParser(parser: &RustParser, alproto: AppProto) -> c_int { GetStateIdByName: parser.get_state_id_by_name, GetStateNameById: parser.get_state_name_by_id, }; - unsafe {SCAppLayerRegisterParser(&det, alproto) } + unsafe { SCAppLayerRegisterParser(&det, alproto) } } use suricata_sys::sys::{AppLayerProtocolDetect, SCAppLayerRegisterProtocolDetection}; -pub fn applayer_register_protocol_detection(parser: &RustParser, enable_default: c_int) -> AppProto { - let det = AppLayerProtocolDetect{ +pub fn applayer_register_protocol_detection( + parser: &RustParser, enable_default: c_int, +) -> AppProto { + let det = AppLayerProtocolDetect { name: parser.name, default_port: parser.default_port, ip_proto: parser.ipproto, @@ -219,14 +236,14 @@ pub fn applayer_register_protocol_detection(parser: &RustParser, enable_default: min_depth: parser.min_depth, max_depth: parser.max_depth, }; - unsafe {SCAppLayerRegisterProtocolDetection(&det, enable_default) } + unsafe { SCAppLayerRegisterProtocolDetection(&det, enable_default) } } pub use suricata_ffi::applayer::{ APP_LAYER_PARSER_BYPASS_READY, APP_LAYER_PARSER_EOF_TC, APP_LAYER_PARSER_EOF_TS, APP_LAYER_PARSER_NO_INSPECTION, APP_LAYER_PARSER_NO_INSPECTION_PAYLOAD, - APP_LAYER_PARSER_NO_REASSEMBLY, APP_LAYER_PARSER_OPT_ACCEPT_GAPS, - APP_LAYER_TX_SKIP_INSPECT_TS, APP_LAYER_TX_SKIP_INSPECT_TC, + APP_LAYER_PARSER_NO_REASSEMBLY, APP_LAYER_PARSER_OPT_ACCEPT_GAPS, APP_LAYER_TX_SKIP_INSPECT_TC, + APP_LAYER_TX_SKIP_INSPECT_TS, }; pub const _APP_LAYER_TX_INSPECTED_TS: u8 = BIT_U8!(2); @@ -251,7 +268,9 @@ pub trait AppLayerFrameType { /// Create a frame type variant from a u8. /// /// None will be returned if there is no matching enum variant. - fn from_u8(value: u8) -> Option where Self: std::marker::Sized; + fn from_u8(value: u8) -> Option + where + Self: std::marker::Sized; /// Return the u8 value of the enum where the first entry has the value of 0. fn as_u8(&self) -> u8; @@ -259,14 +278,19 @@ pub trait AppLayerFrameType { /// Create a frame type variant from a &str. /// /// None will be returned if there is no matching enum variant. - fn from_str(s: &str) -> Option where Self: std::marker::Sized; + fn from_str(s: &str) -> Option + where + Self: std::marker::Sized; /// Return a pointer to a C string of the enum variant suitable as-is for /// FFI. fn to_cstring(&self) -> *const std::os::raw::c_char; /// Converts a C string formatted name to a frame type ID. - unsafe extern "C" fn ffi_id_from_name(name: *const std::os::raw::c_char) -> i32 where Self: Sized { + unsafe extern "C" fn ffi_id_from_name(name: *const std::os::raw::c_char) -> i32 + where + Self: Sized, + { if name.is_null() { return -1; } @@ -279,8 +303,13 @@ pub trait AppLayerFrameType { } /// Converts a variant ID to an FFI safe name. - extern "C" fn ffi_name_from_id(id: u8) -> *const std::os::raw::c_char where Self: Sized { - Self::from_u8(id).map(|s| s.to_cstring()).unwrap_or_else(std::ptr::null) + extern "C" fn ffi_name_from_id(id: u8) -> *const std::os::raw::c_char + where + Self: Sized, + { + Self::from_u8(id) + .map(|s| s.to_cstring()) + .unwrap_or_else(std::ptr::null) } } diff --git a/rust/src/common.rs b/rust/src/common.rs index 1434e869a7..1ab892f007 100644 --- a/rust/src/common.rs +++ b/rust/src/common.rs @@ -113,9 +113,7 @@ pub fn to_hex(input: &[u8]) -> String { } #[no_mangle] -pub unsafe extern "C" fn SCToHex( - output: *mut u8, out_len: usize, input: *const u8, in_len: usize, -) { +pub unsafe extern "C" fn SCToHex(output: *mut u8, out_len: usize, input: *const u8, in_len: usize) { if out_len < 2 * in_len + 1 { return; } diff --git a/rust/src/conf.rs b/rust/src/conf.rs index d74ce1c56c..f1a609c074 100644 --- a/rust/src/conf.rs +++ b/rust/src/conf.rs @@ -31,12 +31,12 @@ use std::ptr; use std::str; use suricata_sys::sys::SCConfGetChildValue; use suricata_sys::sys::SCConfGetChildValueBool; -use suricata_sys::sys::SCConfGetNode; -use suricata_sys::sys::SCConfNode; -use suricata_sys::sys::SCConfNodeLookupChild; use suricata_sys::sys::SCConfGetFirstNode; use suricata_sys::sys::SCConfGetNextNode; +use suricata_sys::sys::SCConfGetNode; use suricata_sys::sys::SCConfGetValueNode; +use suricata_sys::sys::SCConfNode; +use suricata_sys::sys::SCConfNodeLookupChild; pub fn conf_get_node(key: &str) -> Option { let key = if let Ok(key) = CString::new(key) { @@ -179,7 +179,8 @@ pub fn get_memval(arg: &str) -> Result { let r: IResult<&str, (f64, &str)> = ( preceded(multispace0, double), preceded(multispace0, verify(not_line_ending, |c: &str| c.len() < 4)), - ).parse(arg); + ) + .parse(arg); if let Ok(r) = r { val = (r.1).0; unit = (r.1).1; diff --git a/rust/src/core.rs b/rust/src/core.rs index b811d56e2e..950803c71c 100644 --- a/rust/src/core.rs +++ b/rust/src/core.rs @@ -17,46 +17,50 @@ //! This module exposes items from the core "C" code to Rust. -use suricata_sys::sys::{AppProto, AppProtoEnum}; #[cfg(not(test))] use suricata_sys::sys::SCAppLayerParserTriggerRawStreamInspection; +use suricata_sys::sys::{AppProto, AppProtoEnum}; use crate::flow::Flow; pub use suricata_sys::sys::AppLayerEventType; -pub use suricata_ffi::STREAM_START; +pub use suricata_ffi::STREAM_DEPTH; pub use suricata_ffi::STREAM_EOF; -pub use suricata_ffi::STREAM_TOSERVER; -pub use suricata_ffi::STREAM_TOCLIENT; pub use suricata_ffi::STREAM_GAP; -pub use suricata_ffi::STREAM_DEPTH; pub use suricata_ffi::STREAM_MIDSTREAM; +pub use suricata_ffi::STREAM_START; +pub use suricata_ffi::STREAM_TOCLIENT; +pub use suricata_ffi::STREAM_TOSERVER; -pub const ALPROTO_UNKNOWN : AppProto = AppProtoEnum::ALPROTO_UNKNOWN as AppProto; -pub const ALPROTO_FAILED : AppProto = AppProtoEnum::ALPROTO_FAILED as AppProto; +pub const ALPROTO_UNKNOWN: AppProto = AppProtoEnum::ALPROTO_UNKNOWN as AppProto; +pub const ALPROTO_FAILED: AppProto = AppProtoEnum::ALPROTO_FAILED as AppProto; pub use suricata_ffi::IPPROTO_TCP; pub use suricata_ffi::IPPROTO_UDP; - -macro_rules!BIT_U8 { - ($x:expr) => (1 << $x); +macro_rules! BIT_U8 { + ($x:expr) => { + 1 << $x + }; } /*unused macro_rules!BIT_U16 { ($x:expr) => (1 << $x); }*/ -macro_rules!BIT_U32 { - ($x:expr) => (1 << $x); +macro_rules! BIT_U32 { + ($x:expr) => { + 1 << $x + }; } -macro_rules!BIT_U64 { - ($x:expr) => (1 << $x); +macro_rules! BIT_U64 { + ($x:expr) => { + 1 << $x + }; } - // // Function types for calls into C. // @@ -77,4 +81,7 @@ pub(crate) fn sc_app_layer_parser_trigger_raw_stream_inspection(flow: *mut Flow, } #[cfg(test)] -pub(crate) fn sc_app_layer_parser_trigger_raw_stream_inspection(_flow: *const Flow, _direction: i32) {} +pub(crate) fn sc_app_layer_parser_trigger_raw_stream_inspection( + _flow: *const Flow, _direction: i32, +) { +} diff --git a/rust/src/debug.rs b/rust/src/debug.rs index ecee7f5da8..4cb13dce6f 100644 --- a/rust/src/debug.rs +++ b/rust/src/debug.rs @@ -19,9 +19,9 @@ use std::path::Path; -use suricata_sys::sys::SCLogLevel; #[cfg(not(test))] use suricata_sys::sys::SCError; +use suricata_sys::sys::SCLogLevel; pub static mut LEVEL: SCLogLevel = SCLogLevel::SC_LOG_NOTSET; diff --git a/rust/src/encryption.rs b/rust/src/encryption.rs index b9620b7e27..33a9b1dd14 100644 --- a/rust/src/encryption.rs +++ b/rust/src/encryption.rs @@ -35,4 +35,4 @@ impl std::str::FromStr for EncryptionHandling { _ => Err(()), } } -} \ No newline at end of file +} diff --git a/rust/src/feature.rs b/rust/src/feature.rs index 49ca9a76d7..de03f2a4c9 100644 --- a/rust/src/feature.rs +++ b/rust/src/feature.rs @@ -48,7 +48,6 @@ mod real { use std::ffi::CString; use suricata_sys::sys::{SCRequiresFeature, SCSigTableHasKeyword}; - /// Check for a feature returning true if found. pub fn requires(feature: &str) -> bool { if let Ok(feature) = CString::new(feature) { diff --git a/rust/src/filetracker.rs b/rust/src/filetracker.rs index 3ae65eecb5..820683662f 100644 --- a/rust/src/filetracker.rs +++ b/rust/src/filetracker.rs @@ -28,9 +28,9 @@ //! Author: Victor Julien use crate::core::*; -use std::collections::HashMap; -use std::collections::hash_map::Entry::{Occupied, Vacant}; use crate::filecontainer::*; +use std::collections::hash_map::Entry::{Occupied, Vacant}; +use std::collections::HashMap; #[derive(Debug)] struct FileChunk { @@ -47,11 +47,10 @@ impl FileChunk { } } -#[derive(Debug)] -#[derive(Default)] +#[derive(Debug, Default)] pub struct FileTransferTracker { pub tracked: u64, - cur_ooo: u64, // how many bytes do we have queued from ooo chunks + cur_ooo: u64, // how many bytes do we have queued from ooo chunks track_id: u32, chunk_left: u32, @@ -76,7 +75,7 @@ pub struct FileTransferTracker { impl FileTransferTracker { pub fn new() -> FileTransferTracker { FileTransferTracker { - chunks:HashMap::new(), + chunks: HashMap::new(), ..Default::default() } } @@ -89,28 +88,28 @@ impl FileTransferTracker { return self.file_open || self.file_is_truncated || self.file_closed; } - fn open(&mut self, config: &'static SuricataFileContext, name: &[u8]) -> i32 - { - let r = self.file.file_open(config, self.track_id, name, self.file_flags); + fn open(&mut self, config: &'static SuricataFileContext, name: &[u8]) -> i32 { + let r = self + .file + .file_open(config, self.track_id, name, self.file_flags); if r == 0 { self.file_open = true; } r } - pub fn close(&mut self, config: &'static SuricataFileContext) - { + pub fn close(&mut self, config: &'static SuricataFileContext) { if !self.file_is_truncated { SCLogDebug!("closing file with id {}", self.track_id); - self.file.file_close(config, &self.track_id, self.file_flags); + self.file + .file_close(config, &self.track_id, self.file_flags); } self.file_open = false; self.file_closed = true; self.tracked = 0; } - pub fn trunc (&mut self, config: &'static SuricataFileContext) - { + pub fn trunc(&mut self, config: &'static SuricataFileContext) { if self.file_is_truncated || !self.file_open { return; } @@ -123,22 +122,30 @@ impl FileTransferTracker { self.cur_ooo = 0; } - pub fn new_chunk(&mut self, config: &'static SuricataFileContext, - name: &[u8], data: &[u8], chunk_offset: u64, chunk_size: u32, - fill_bytes: u8, is_last: bool, xid: &u32) -> u32 - { + pub fn new_chunk( + &mut self, config: &'static SuricataFileContext, name: &[u8], data: &[u8], + chunk_offset: u64, chunk_size: u32, fill_bytes: u8, is_last: bool, xid: &u32, + ) -> u32 { if self.chunk_left != 0 || self.fill_bytes != 0 { SCLogDebug!("current chunk incomplete: truncating"); self.trunc(config); } - SCLogDebug!("NEW CHUNK: chunk_size {} fill_bytes {}", chunk_size, fill_bytes); + SCLogDebug!( + "NEW CHUNK: chunk_size {} fill_bytes {}", + chunk_size, + fill_bytes + ); // for now assume that is_last means its really the last chunk // so no out of order chunks coming after. This means that if // the last chunk is out or order, we've missed chunks before. if chunk_offset != self.tracked { - SCLogDebug!("NEW CHUNK IS OOO: expected {}, got {}", self.tracked, chunk_offset); + SCLogDebug!( + "NEW CHUNK IS OOO: expected {}, got {}", + self.tracked, + chunk_offset + ); if is_last { SCLogDebug!("last chunk is out of order, this means we missed data before"); self.trunc(config); @@ -172,8 +179,9 @@ impl FileTransferTracker { /// update the file tracker /// If gap_size > 0 'data' should not be used. /// return how much we consumed of data - pub fn update(&mut self, config: &'static SuricataFileContext, data: &[u8], gap_size: u32) -> u32 - { + pub fn update( + &mut self, config: &'static SuricataFileContext, data: &[u8], gap_size: u32, + ) -> u32 { if self.file_is_truncated { let consumed = std::cmp::min(data.len() as u32, self.chunk_left); self.chunk_left = self.chunk_left.saturating_sub(data.len() as u32); @@ -182,7 +190,12 @@ impl FileTransferTracker { let mut consumed = 0_usize; let is_gap = gap_size > 0; if is_gap || gap_size > 0 { - SCLogDebug!("is_gap {} size {} ooo? {}", is_gap, gap_size, self.chunk_is_ooo); + SCLogDebug!( + "is_gap {} size {} ooo? {}", + is_gap, + gap_size, + self.chunk_is_ooo + ); } if self.chunk_left == 0 && self.fill_bytes == 0 { @@ -192,7 +205,7 @@ impl FileTransferTracker { self.close(config); self.chunk_is_last = false; } - return 0 + return 0; } else if self.chunk_left == 0 { SCLogDebug!("FILL BYTES {} from prev run", self.fill_bytes); if data.len() >= self.fill_bytes as usize { @@ -205,7 +218,7 @@ impl FileTransferTracker { SCLogDebug!("CHUNK(pre) fill bytes now still {}", self.fill_bytes); } SCLogDebug!("FILL BYTES: returning {}", consumed); - return consumed as u32 + return consumed as u32; } SCLogDebug!("UPDATE: data {} chunk_left {}", data.len(), self.chunk_left); @@ -216,24 +229,26 @@ impl FileTransferTracker { if !self.chunk_is_ooo { let res = self.file.file_append(config, &self.track_id, d, is_gap); match res { - 0 => { }, - -2 => { + 0 => {} + -2 => { self.file_is_truncated = true; - }, + } _ => { SCLogDebug!("got error so truncating file"); self.file_is_truncated = true; - }, + } } self.tracked += self.chunk_left as u64; } else { - SCLogDebug!("UPDATE: appending data {} to ooo chunk at offset {}/{}", - d.len(), self.cur_ooo_chunk_offset, self.tracked); + SCLogDebug!( + "UPDATE: appending data {} to ooo chunk at offset {}/{}", + d.len(), + self.cur_ooo_chunk_offset, + self.tracked + ); let c = match self.chunks.entry(self.cur_ooo_chunk_offset) { - Vacant(entry) => { - entry.insert(FileChunk::new(self.chunk_left)) - }, + Vacant(entry) => entry.insert(FileChunk::new(self.chunk_left)), Occupied(entry) => entry.into_mut(), }; self.cur_ooo += d.len() as u64; @@ -267,31 +282,42 @@ impl FileTransferTracker { Some(c) => { self.in_flight -= c.chunk.len() as u64; - let res = self.file.file_append(config, &self.track_id, &c.chunk, c.contains_gap); + let res = self.file.file_append( + config, + &self.track_id, + &c.chunk, + c.contains_gap, + ); match res { - 0 => { }, - -2 => { + 0 => {} + -2 => { self.file_is_truncated = true; - }, + } _ => { SCLogDebug!("got error so truncating file"); self.file_is_truncated = true; - }, + } } self.tracked += c.chunk.len() as u64; self.cur_ooo -= c.chunk.len() as u64; SCLogDebug!("STORED OOO CHUNK at offset {}, tracked now {}, stored len {}", _offset, self.tracked, c.chunk.len()); - }, + } _ => { - SCLogDebug!("NO STORED CHUNK found at _offset {}", self.tracked); + SCLogDebug!( + "NO STORED CHUNK found at _offset {}", + self.tracked + ); break; - }, + } }; } } else { - SCLogDebug!("UPDATE: complete ooo chunk. Offset {}", self.cur_ooo_chunk_offset); + SCLogDebug!( + "UPDATE: complete ooo chunk. Offset {}", + self.cur_ooo_chunk_offset + ); self.chunk_is_ooo = false; self.cur_ooo_chunk_offset = 0; @@ -304,19 +330,18 @@ impl FileTransferTracker { } else { SCLogDebug!("NOT last chunk, keep going"); } - } else { if !self.chunk_is_ooo { let res = self.file.file_append(config, &self.track_id, data, is_gap); match res { - 0 => { }, - -2 => { + 0 => {} + -2 => { self.file_is_truncated = true; - }, + } _ => { SCLogDebug!("got error so truncating file"); self.file_is_truncated = true; - }, + } } self.tracked += data.len() as u64; } else { diff --git a/rust/src/frames.rs b/rust/src/frames.rs index 4f32b94af5..524eb03ef9 100644 --- a/rust/src/frames.rs +++ b/rust/src/frames.rs @@ -27,9 +27,9 @@ use crate::flow::Flow; #[cfg(not(test))] use std::os::raw::c_void; +use suricata_sys::sys::{SCAppLayerFrameAddEventById, SCAppLayerFrameSetLengthById}; #[cfg(not(test))] use suricata_sys::sys::{SCAppLayerFrameNewByRelativeOffset, SCAppLayerFrameSetTxIdById}; -use suricata_sys::sys::{SCAppLayerFrameAddEventById, SCAppLayerFrameSetLengthById}; pub struct Frame { pub id: i64, diff --git a/rust/src/handshake.rs b/rust/src/handshake.rs index 345ae40096..2f0cb4b159 100644 --- a/rust/src/handshake.rs +++ b/rust/src/handshake.rs @@ -194,7 +194,7 @@ pub extern "C" fn SCTLSHandshakeNew() -> *mut HandshakeParams { } #[no_mangle] -pub unsafe extern "C" fn SCTLSHandshakeIsEmpty(hs: & HandshakeParams) -> bool { +pub unsafe extern "C" fn SCTLSHandshakeIsEmpty(hs: &HandshakeParams) -> bool { *hs == HandshakeParams::default() } @@ -233,48 +233,58 @@ pub unsafe extern "C" fn SCTLSHandshakeFree(hs: &mut HandshakeParams) { } #[no_mangle] -pub unsafe extern "C" fn SCTLSHandshakeLogVersion(hs: &HandshakeParams, js: *mut JsonBuilder) -> bool { +pub unsafe extern "C" fn SCTLSHandshakeLogVersion( + hs: &HandshakeParams, js: *mut JsonBuilder, +) -> bool { if js.is_null() { return false; } - return hs.log_version(js.as_mut().unwrap()).is_ok() + return hs.log_version(js.as_mut().unwrap()).is_ok(); } #[no_mangle] -pub unsafe extern "C" fn SCTLSHandshakeLogCiphers(hs: &HandshakeParams, js: *mut JsonBuilder) -> bool { +pub unsafe extern "C" fn SCTLSHandshakeLogCiphers( + hs: &HandshakeParams, js: *mut JsonBuilder, +) -> bool { if js.is_null() { return false; } - return hs.log_ciphers(js.as_mut().unwrap()).is_ok() + return hs.log_ciphers(js.as_mut().unwrap()).is_ok(); } #[no_mangle] -pub unsafe extern "C" fn SCTLSHandshakeLogFirstCipher(hs: &HandshakeParams, js: *mut JsonBuilder) -> bool { +pub unsafe extern "C" fn SCTLSHandshakeLogFirstCipher( + hs: &HandshakeParams, js: *mut JsonBuilder, +) -> bool { if js.is_null() { return false; } - return hs.log_first_cipher(js.as_mut().unwrap()).is_ok() + return hs.log_first_cipher(js.as_mut().unwrap()).is_ok(); } #[no_mangle] -pub unsafe extern "C" fn SCTLSHandshakeLogExtensions(hs: &HandshakeParams, js: *mut JsonBuilder) -> bool { +pub unsafe extern "C" fn SCTLSHandshakeLogExtensions( + hs: &HandshakeParams, js: *mut JsonBuilder, +) -> bool { if js.is_null() { return false; } - return hs.log_exts(js.as_mut().unwrap()).is_ok() + return hs.log_exts(js.as_mut().unwrap()).is_ok(); } #[no_mangle] -pub unsafe extern "C" fn SCTLSHandshakeLogSigAlgs(hs: &HandshakeParams, js: *mut JsonBuilder) -> bool { +pub unsafe extern "C" fn SCTLSHandshakeLogSigAlgs( + hs: &HandshakeParams, js: *mut JsonBuilder, +) -> bool { if js.is_null() { return false; } - return hs.log_sig_algs(js.as_mut().unwrap()).is_ok() + return hs.log_sig_algs(js.as_mut().unwrap()).is_ok(); } #[no_mangle] pub unsafe extern "C" fn SCTLSHandshakeLogALPNs( - hs: &HandshakeParams, js: *mut JsonBuilder, ptr: *const c_char + hs: &HandshakeParams, js: *mut JsonBuilder, ptr: *const c_char, ) -> bool { if js.is_null() { return false; diff --git a/rust/src/jsonbuilder.rs b/rust/src/jsonbuilder.rs index f4638bee62..fe0a48634c 100644 --- a/rust/src/jsonbuilder.rs +++ b/rust/src/jsonbuilder.rs @@ -587,17 +587,17 @@ impl JsonBuilder { b'\r' => { self.push_str("\\r")?; } - b'\n'=> { + b'\n' => { self.push_str("\\n")?; } - b'"'=> { + b'"' => { self.push_str("\\\"")?; } - b'\\'=> { + b'\\' => { self.push_str("\\\\")?; } _ => { - if !x.is_ascii() || x.is_ascii_control() { + if !x.is_ascii() || x.is_ascii_control() { self.push('.')?; } else { self.push(x as char)?; diff --git a/rust/src/kerberos.rs b/rust/src/kerberos.rs index 45a3c525a5..d852e36b93 100644 --- a/rust/src/kerberos.rs +++ b/rust/src/kerberos.rs @@ -17,14 +17,14 @@ //! Kerberos parser wrapper module. -use nom7::IResult; -use nom7::error::{ErrorKind, ParseError}; -use nom7::number::streaming::le_u16; +use asn1_rs::FromDer; use der_parser; use der_parser::der::parse_der_oid; use der_parser::error::BerError; use kerberos_parser::krb5::{ApReq, PrincipalName, Realm}; -use asn1_rs::FromDer; +use nom7::error::{ErrorKind, ParseError}; +use nom7::number::streaming::le_u16; +use nom7::IResult; #[derive(Debug)] pub enum SecBlobError { @@ -55,12 +55,11 @@ pub struct Kerberos5Ticket { pub sname: PrincipalName, } -fn parse_kerberos5_request_do(blob: &[u8]) -> IResult<&[u8], ApReq<'_>, SecBlobError> -{ - let (_,b) = der_parser::parse_der(blob).map_err(nom7::Err::convert)?; - let blob = b.as_slice().or( - Err(nom7::Err::Error(SecBlobError::KrbFmtError)) - )?; +fn parse_kerberos5_request_do(blob: &[u8]) -> IResult<&[u8], ApReq<'_>, SecBlobError> { + let (_, b) = der_parser::parse_der(blob).map_err(nom7::Err::convert)?; + let blob = b + .as_slice() + .or(Err(nom7::Err::Error(SecBlobError::KrbFmtError)))?; let parser = |i| { let (i, _base_o) = parse_der_oid(i)?; let (i, _tok_id) = le_u16(i)?; diff --git a/rust/src/lib.rs b/rust/src/lib.rs index 10c65e66a2..124bef2814 100644 --- a/rust/src/lib.rs +++ b/rust/src/lib.rs @@ -21,34 +21,26 @@ //! the components written in Rust. #![cfg_attr(feature = "strict", deny(warnings))] - // Allow these patterns as its a style we like. #![allow(clippy::needless_return)] #![allow(clippy::let_and_return)] #![allow(clippy::uninlined_format_args)] - // We find this is beyond what the linter should flag. #![allow(clippy::items_after_test_module)] - // We find this makes sense at time. #![allow(clippy::module_inception)] - // The match macro is not always more clear. But its use is // recommended where it makes sense. #![allow(clippy::match_like_matches_macro)] - // Something we should be conscious of, but due to interfacing with C // is unavoidable at this time. #![allow(clippy::too_many_arguments)] - // This would be nice, but having this lint enables causes // clippy --fix to make changes that don't meet our MSRV. #![allow(clippy::derivable_impls)] - // TODO: All unsafe functions should have a safety doc, even if its // just due to FFI. #![allow(clippy::missing_safety_doc)] - // Allow unknown lints, our MSRV doesn't know them all, for // example static_mut_refs. #![allow(unknown_lints)] @@ -59,17 +51,17 @@ extern crate suricata_ffi; extern crate bitflags; extern crate byteorder; extern crate crc; -extern crate memchr; extern crate lru; +extern crate memchr; #[macro_use] extern crate num_derive; extern crate widestring; extern crate der_parser; extern crate kerberos_parser; +extern crate ldap_parser; extern crate tls_parser; extern crate x509_parser; -extern crate ldap_parser; #[macro_use] extern crate suricata_derive; @@ -85,61 +77,61 @@ pub mod conf; pub mod jsonbuilder; #[macro_use] pub mod applayer; -pub mod frames; +pub mod detect; pub mod filecontainer; pub mod filetracker; +pub mod frames; pub mod kerberos; -pub mod detect; pub mod utils; +pub mod encryption; +pub mod handshake; pub mod ja4; pub mod tls_version; -pub mod handshake; -pub mod encryption; pub mod lua; +pub mod dcerpc; pub mod dnp3; pub mod dns; -pub mod mdns; -pub mod nfs; pub mod ftp; -pub mod smb; pub mod krb; -pub mod dcerpc; +pub mod mdns; pub mod modbus; +pub mod nfs; +pub mod smb; pub mod ike; pub mod snmp; -pub mod ntp; -pub mod tftp; +pub mod applayertemplate; +pub mod asn1; +pub mod bittorrent_dht; pub mod dhcp; -pub mod sip; -pub mod rfb; +pub mod enip; +pub mod feature; +pub mod ffi; +pub mod flow; +pub mod http2; +pub mod ldap; +pub mod lzma; +pub mod mime; pub mod mqtt; +pub mod ntp; pub mod pgsql; -pub mod telnet; -pub mod websocket; -pub mod enip; pub mod pop3; -pub mod applayertemplate; -pub mod rdp; -pub mod x509; -pub mod asn1; -pub mod mime; -pub mod ssh; -pub mod http2; pub mod quic; -pub mod bittorrent_dht; -pub mod lzma; -pub mod util; -pub mod ffi; -pub mod feature; +pub mod rdp; +pub mod rfb; pub mod sctp; pub mod sdp; -pub mod ldap; -pub mod flow; +pub mod sip; +pub mod ssh; +pub mod telnet; +pub mod tftp; +pub mod util; +pub mod websocket; +pub mod x509; pub use suricata_ffi::direction; pub mod llmnr; diff --git a/rust/src/lua.rs b/rust/src/lua.rs index 5b8eca5740..db7af15aa3 100644 --- a/rust/src/lua.rs +++ b/rust/src/lua.rs @@ -38,7 +38,6 @@ pub struct LuaState { } impl LuaState { - pub fn newtable(&self) { unsafe { lua_createtable(self.lua, 0, 0); diff --git a/rust/src/util.rs b/rust/src/util.rs index 2cb2da17ce..f4809d17a9 100644 --- a/rust/src/util.rs +++ b/rust/src/util.rs @@ -41,7 +41,8 @@ fn is_alphanumeric_or_hyphen(chr: u8) -> bool { fn parse_domain_label(i: &[u8]) -> IResult<&[u8], ()> { let (i, _) = verify(take_while1(is_alphanumeric_or_hyphen), |x: &[u8]| { x[0].is_alpha() && x[x.len() - 1] != b'-' - }).parse(i)?; + }) + .parse(i)?; return Ok((i, ())); }