// Author: Frank Honza <frank.honza@dcso.de>
-use std;
-use std::ffi::CString;
-use crate::core::{ALPROTO_UNKNOWN, AppProto, Flow, IPPROTO_TCP};
-use crate::frames::*;
+use super::parser;
use crate::applayer;
use crate::applayer::*;
+use crate::core::{AppProto, Flow, ALPROTO_UNKNOWN, IPPROTO_TCP};
+use crate::frames::*;
use nom7::Err;
-use super::parser;
+use std;
+use std::ffi::CString;
static mut ALPROTO_RFB: AppProto = ALPROTO_UNKNOWN;
state_data: AppLayerStateData,
tx_id: u64,
transactions: Vec<RFBTransaction>,
- state: parser::RFBGlobalState
+ state: parser::RFBGlobalState,
}
impl State<RFBTransaction> for RFBState {
fn get_transaction_by_index(&self, index: usize) -> Option<&RFBTransaction> {
self.transactions.get(index)
}
-
}
impl Default for RFBState {
state_data: AppLayerStateData::new(),
tx_id: 0,
transactions: Vec::new(),
- state: parser::RFBGlobalState::TCServerProtocolVersion
+ state: parser::RFBGlobalState::TCServerProtocolVersion,
}
}
}
fn parse_request(&mut self, flow: *const Flow, stream_slice: StreamSlice) -> AppLayerResult {
-
- let input = stream_slice.as_slice();
+ let input = stream_slice.as_slice();
// We're not interested in empty requests.
if input.is_empty() {
match parser::parse_protocol_version(current) {
Ok((rem, request)) => {
consumed += current.len() - rem.len();
- let _pdu = Frame::new(flow,&stream_slice,current, consumed as i64,RFBFrameType::Pdu as u8);
+ let _pdu = Frame::new(
+ flow,
+ &stream_slice,
+ current,
+ consumed as i64,
+ RFBFrameType::Pdu as u8,
+ );
current = rem;
}
}
Err(Err::Incomplete(_)) => {
- return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32);
+ return AppLayerResult::incomplete(
+ consumed as u32,
+ (current.len() + 1) as u32,
+ );
}
Err(_) => {
return AppLayerResult::err();
match parser::parse_security_type_selection(current) {
Ok((rem, request)) => {
consumed += current.len() - rem.len();
- let _pdu = Frame::new(flow,&stream_slice,current, consumed as i64,RFBFrameType::Pdu as u8);
+ let _pdu = Frame::new(
+ flow,
+ &stream_slice,
+ current,
+ consumed as i64,
+ RFBFrameType::Pdu as u8,
+ );
current = rem;
if let Some(current_transaction) = self.get_current_tx() {
current_transaction.ts_security_type_selection = Some(request);
- current_transaction.chosen_security_type = Some(chosen_security_type as u32);
+ current_transaction.chosen_security_type =
+ Some(chosen_security_type as u32);
} else {
return AppLayerResult::err();
}
}
Err(Err::Incomplete(_)) => {
- return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32);
+ return AppLayerResult::incomplete(
+ consumed as u32,
+ (current.len() + 1) as u32,
+ );
}
Err(_) => {
return AppLayerResult::err();
}
}
}
- parser::RFBGlobalState::TSVncResponse => {
- match parser::parse_vnc_auth(current) {
- Ok((rem, request)) => {
- consumed += current.len() - rem.len();
- let _pdu = Frame::new(flow,&stream_slice,current, consumed as i64,RFBFrameType::Pdu as u8);
-
- current = rem;
-
- self.state = parser::RFBGlobalState::TCSecurityResult;
-
- if let Some(current_transaction) = self.get_current_tx() {
- current_transaction.ts_vnc_response = Some(request);
- } else {
- return AppLayerResult::err();
- }
- }
- Err(Err::Incomplete(_)) => {
- return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32);
- }
- Err(_) => {
+ parser::RFBGlobalState::TSVncResponse => match parser::parse_vnc_auth(current) {
+ Ok((rem, request)) => {
+ consumed += current.len() - rem.len();
+ let _pdu = Frame::new(
+ flow,
+ &stream_slice,
+ current,
+ consumed as i64,
+ RFBFrameType::Pdu as u8,
+ );
+
+ current = rem;
+
+ self.state = parser::RFBGlobalState::TCSecurityResult;
+
+ if let Some(current_transaction) = self.get_current_tx() {
+ current_transaction.ts_vnc_response = Some(request);
+ } else {
return AppLayerResult::err();
}
}
- }
- parser::RFBGlobalState::TSClientInit => {
- match parser::parse_client_init(current) {
- Ok((rem, request)) => {
- consumed += current.len() - rem.len();
- let _pdu = Frame::new(flow,&stream_slice,current, consumed as i64,RFBFrameType::Pdu as u8);
-
- current = rem;
-
- self.state = parser::RFBGlobalState::TCServerInit;
-
- if let Some(current_transaction) = self.get_current_tx() {
- current_transaction.ts_client_init = Some(request);
- } else {
- return AppLayerResult::err();
- }
- }
- Err(Err::Incomplete(_)) => {
- return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32);
- }
- Err(_) => {
+ Err(Err::Incomplete(_)) => {
+ return AppLayerResult::incomplete(
+ consumed as u32,
+ (current.len() + 1) as u32,
+ );
+ }
+ Err(_) => {
+ return AppLayerResult::err();
+ }
+ },
+ parser::RFBGlobalState::TSClientInit => match parser::parse_client_init(current) {
+ Ok((rem, request)) => {
+ consumed += current.len() - rem.len();
+ let _pdu = Frame::new(
+ flow,
+ &stream_slice,
+ current,
+ consumed as i64,
+ RFBFrameType::Pdu as u8,
+ );
+
+ current = rem;
+
+ self.state = parser::RFBGlobalState::TCServerInit;
+
+ if let Some(current_transaction) = self.get_current_tx() {
+ current_transaction.ts_client_init = Some(request);
+ } else {
return AppLayerResult::err();
}
}
- }
+ Err(Err::Incomplete(_)) => {
+ return AppLayerResult::incomplete(
+ consumed as u32,
+ (current.len() + 1) as u32,
+ );
+ }
+ Err(_) => {
+ return AppLayerResult::err();
+ }
+ },
parser::RFBGlobalState::Message => {
//todo implement RFB messages, for now we stop here
return AppLayerResult::err();
let mut current = input;
let mut consumed = 0;
- SCLogDebug!("response_state {}, response_len {}", self.state, input.len());
+ SCLogDebug!(
+ "response_state {}, response_len {}",
+ self.state,
+ input.len()
+ );
loop {
if current.is_empty() {
return AppLayerResult::ok();
match parser::parse_protocol_version(current) {
Ok((rem, request)) => {
consumed += current.len() - rem.len();
- let _pdu = Frame::new(flow,&stream_slice,current, consumed as i64,RFBFrameType::Pdu as u8);
+ let _pdu = Frame::new(
+ flow,
+ &stream_slice,
+ current,
+ consumed as i64,
+ RFBFrameType::Pdu as u8,
+ );
current = rem;
}
}
Err(Err::Incomplete(_)) => {
- return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32);
+ return AppLayerResult::incomplete(
+ consumed as u32,
+ (current.len() + 1) as u32,
+ );
}
Err(_) => {
return AppLayerResult::err();
match parser::parse_supported_security_types(current) {
Ok((rem, request)) => {
consumed += current.len() - rem.len();
- let _pdu = Frame::new(flow,&stream_slice,current, consumed as i64,RFBFrameType::Pdu as u8);
+ let _pdu = Frame::new(
+ flow,
+ &stream_slice,
+ current,
+ consumed as i64,
+ RFBFrameType::Pdu as u8,
+ );
current = rem;
SCLogDebug!(
- "supported_security_types: {}, types: {}", request.number_of_types,
- request.types.iter().map(ToString::to_string).map(|v| v + " ").collect::<String>()
+ "supported_security_types: {}, types: {}",
+ request.number_of_types,
+ request
+ .types
+ .iter()
+ .map(ToString::to_string)
+ .map(|v| v + " ")
+ .collect::<String>()
);
self.state = parser::RFBGlobalState::TSSecurityTypeSelection;
}
}
Err(Err::Incomplete(_)) => {
- return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32);
+ return AppLayerResult::incomplete(
+ consumed as u32,
+ (current.len() + 1) as u32,
+ );
}
Err(_) => {
return AppLayerResult::err();
match parser::parse_server_security_type(current) {
Ok((rem, request)) => {
consumed += current.len() - rem.len();
- let _pdu = Frame::new(flow,&stream_slice,current, consumed as i64,RFBFrameType::Pdu as u8);
+ let _pdu = Frame::new(
+ flow,
+ &stream_slice,
+ current,
+ consumed as i64,
+ RFBFrameType::Pdu as u8,
+ );
current = rem;
if let Some(current_transaction) = self.get_current_tx() {
current_transaction.tc_server_security_type = Some(request);
- current_transaction.chosen_security_type = Some(chosen_security_type);
+ current_transaction.chosen_security_type =
+ Some(chosen_security_type);
} else {
return AppLayerResult::err();
}
}
Err(Err::Incomplete(_)) => {
- return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32);
+ return AppLayerResult::incomplete(
+ consumed as u32,
+ (current.len() + 1) as u32,
+ );
}
Err(_) => {
return AppLayerResult::err();
}
}
}
- parser::RFBGlobalState::TCVncChallenge => {
- match parser::parse_vnc_auth(current) {
- Ok((rem, request)) => {
- consumed += current.len() - rem.len();
- let _pdu = Frame::new(flow,&stream_slice,current, consumed as i64,RFBFrameType::Pdu as u8);
-
- current = rem;
-
- self.state = parser::RFBGlobalState::TSVncResponse;
-
- if let Some(current_transaction) = self.get_current_tx() {
- current_transaction.tc_vnc_challenge = Some(request);
- } else {
- return AppLayerResult::err();
- }
- }
- Err(Err::Incomplete(_)) => {
- return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32);
- }
- Err(_) => {
+ parser::RFBGlobalState::TCVncChallenge => match parser::parse_vnc_auth(current) {
+ Ok((rem, request)) => {
+ consumed += current.len() - rem.len();
+ let _pdu = Frame::new(
+ flow,
+ &stream_slice,
+ current,
+ consumed as i64,
+ RFBFrameType::Pdu as u8,
+ );
+
+ current = rem;
+
+ self.state = parser::RFBGlobalState::TSVncResponse;
+
+ if let Some(current_transaction) = self.get_current_tx() {
+ current_transaction.tc_vnc_challenge = Some(request);
+ } else {
return AppLayerResult::err();
}
}
- }
+ Err(Err::Incomplete(_)) => {
+ return AppLayerResult::incomplete(
+ consumed as u32,
+ (current.len() + 1) as u32,
+ );
+ }
+ Err(_) => {
+ return AppLayerResult::err();
+ }
+ },
parser::RFBGlobalState::TCSecurityResult => {
match parser::parse_security_result(current) {
Ok((rem, request)) => {
consumed += current.len() - rem.len();
- let _pdu = Frame::new(flow,&stream_slice,current, consumed as i64,RFBFrameType::Pdu as u8);
+ let _pdu = Frame::new(
+ flow,
+ &stream_slice,
+ current,
+ consumed as i64,
+ RFBFrameType::Pdu as u8,
+ );
current = rem;
}
}
Err(Err::Incomplete(_)) => {
- return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32);
+ return AppLayerResult::incomplete(
+ consumed as u32,
+ (current.len() + 1) as u32,
+ );
}
Err(_) => {
return AppLayerResult::err();
return AppLayerResult::err();
}
Err(Err::Incomplete(_)) => {
- return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32);
+ return AppLayerResult::incomplete(
+ consumed as u32,
+ (current.len() + 1) as u32,
+ );
}
Err(_) => {
return AppLayerResult::err();
match parser::parse_server_init(current) {
Ok((rem, request)) => {
consumed += current.len() - rem.len();
- let _pdu = Frame::new(flow,&stream_slice,current, consumed as i64,RFBFrameType::Pdu as u8);
+ let _pdu = Frame::new(
+ flow,
+ &stream_slice,
+ current,
+ consumed as i64,
+ RFBFrameType::Pdu as u8,
+ );
current = rem;
}
}
Err(Err::Incomplete(_)) => {
- return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32);
+ return AppLayerResult::incomplete(
+ consumed as u32,
+ (current.len() + 1) as u32,
+ );
}
Err(_) => {
return AppLayerResult::err();
// C exports.
#[no_mangle]
-pub extern "C" fn rs_rfb_state_new(_orig_state: *mut std::os::raw::c_void, _orig_proto: AppProto) -> *mut std::os::raw::c_void {
+pub extern "C" fn rs_rfb_state_new(
+ _orig_state: *mut std::os::raw::c_void, _orig_proto: AppProto,
+) -> *mut std::os::raw::c_void {
let state = RFBState::new();
let boxed = Box::new(state);
return Box::into_raw(boxed) as *mut _;
}
#[no_mangle]
-pub unsafe extern "C" fn rs_rfb_state_tx_free(
- state: *mut std::os::raw::c_void,
- tx_id: u64,
-) {
+pub unsafe extern "C" fn rs_rfb_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
let state = cast_pointer!(state, RFBState);
state.free_tx(tx_id);
}
#[no_mangle]
pub unsafe extern "C" fn rs_rfb_parse_request(
- flow: *const Flow,
- state: *mut std::os::raw::c_void,
- _pstate: *mut std::os::raw::c_void,
- stream_slice: StreamSlice,
- _data: *const std::os::raw::c_void,
+ flow: *const Flow, state: *mut std::os::raw::c_void, _pstate: *mut std::os::raw::c_void,
+ stream_slice: StreamSlice, _data: *const std::os::raw::c_void,
) -> AppLayerResult {
let state = cast_pointer!(state, RFBState);
return state.parse_request(flow, stream_slice);
#[no_mangle]
pub unsafe extern "C" fn rs_rfb_parse_response(
- flow: *const Flow,
- state: *mut std::os::raw::c_void,
- _pstate: *mut std::os::raw::c_void,
- stream_slice: StreamSlice,
- _data: *const std::os::raw::c_void,
+ flow: *const Flow, state: *mut std::os::raw::c_void, _pstate: *mut std::os::raw::c_void,
+ stream_slice: StreamSlice, _data: *const std::os::raw::c_void,
) -> AppLayerResult {
let state = cast_pointer!(state, RFBState);
return state.parse_response(flow, stream_slice);
#[no_mangle]
pub unsafe extern "C" fn rs_rfb_state_get_tx(
- state: *mut std::os::raw::c_void,
- tx_id: u64,
+ state: *mut std::os::raw::c_void, tx_id: u64,
) -> *mut std::os::raw::c_void {
let state = cast_pointer!(state, RFBState);
match state.get_tx(tx_id) {
}
#[no_mangle]
-pub unsafe extern "C" fn rs_rfb_state_get_tx_count(
- state: *mut std::os::raw::c_void,
-) -> u64 {
+pub unsafe extern "C" fn rs_rfb_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
let state = cast_pointer!(state, RFBState);
return state.tx_id;
}
#[no_mangle]
pub unsafe extern "C" fn rs_rfb_tx_get_alstate_progress(
- tx: *mut std::os::raw::c_void,
- _direction: u8,
+ tx: *mut std::os::raw::c_void, _direction: u8,
) -> std::os::raw::c_int {
let tx = cast_pointer!(tx, RFBTransaction);
if tx.complete {
let ip_proto_str = CString::new("tcp").unwrap();
- if AppLayerProtoDetectConfProtoDetectionEnabled(
- ip_proto_str.as_ptr(),
- parser.name,
- ) != 0
- {
+ if AppLayerProtoDetectConfProtoDetectionEnabled(ip_proto_str.as_ptr(), parser.name) != 0 {
let alproto = AppLayerRegisterProtocolDetection(&parser, 1);
ALPROTO_RFB = alproto;
- if AppLayerParserConfParserEnabled(
- ip_proto_str.as_ptr(),
- parser.name,
- ) != 0
- {
+ if AppLayerParserConfParserEnabled(ip_proto_str.as_ptr(), parser.name) != 0 {
let _ = AppLayerRegisterParser(&parser, alproto);
}
SCLogDebug!("Rust rfb parser registered.");
//The buffer values correspond to Server Protocol version: 003.008
// Same buffer is used for both functions due to similar values in request and response
- init_state.parse_response(std::ptr::null(), StreamSlice::from_slice(&buf[0..12], STREAM_START, 0));
+ init_state.parse_response(
+ std::ptr::null(),
+ StreamSlice::from_slice(&buf[0..12], STREAM_START, 0),
+ );
let mut ok_state = parser::RFBGlobalState::TSClientProtocolVersion;
assert_eq!(init_state.state, ok_state);
//The buffer values correspond to Client Protocol version: 003.008
- init_state.parse_request(std::ptr::null(), StreamSlice::from_slice(&buf[0..12], STREAM_START, 0));
+ init_state.parse_request(
+ std::ptr::null(),
+ StreamSlice::from_slice(&buf[0..12], STREAM_START, 0),
+ );
ok_state = parser::RFBGlobalState::TCSupportedSecurityTypes;
assert_eq!(init_state.state, ok_state);
- init_state.parse_response(std::ptr::null(), StreamSlice::from_slice(&buf[12..14], STREAM_START, 0));
+ init_state.parse_response(
+ std::ptr::null(),
+ StreamSlice::from_slice(&buf[12..14], STREAM_START, 0),
+ );
ok_state = parser::RFBGlobalState::TSSecurityTypeSelection;
assert_eq!(init_state.state, ok_state);
- init_state.parse_request(std::ptr::null(), StreamSlice::from_slice(&buf[14..15], STREAM_START, 0));
+ init_state.parse_request(
+ std::ptr::null(),
+ StreamSlice::from_slice(&buf[14..15], STREAM_START, 0),
+ );
ok_state = parser::RFBGlobalState::TCVncChallenge;
assert_eq!(init_state.state, ok_state);
//The buffer values correspond to Server Authentication challenge: 547b7a6f36a154db03a2575c6f2a4ec5
// Same buffer is used for both functions due to similar values in request and response
- init_state.parse_response(std::ptr::null(), StreamSlice::from_slice(&buf[15..31], STREAM_START, 0));
+ init_state.parse_response(
+ std::ptr::null(),
+ StreamSlice::from_slice(&buf[15..31], STREAM_START, 0),
+ );
ok_state = parser::RFBGlobalState::TSVncResponse;
assert_eq!(init_state.state, ok_state);
//The buffer values correspond to Client Authentication response: 547b7a6f36a154db03a2575c6f2a4ec5
- init_state.parse_request(std::ptr::null(), StreamSlice::from_slice(&buf[15..31], STREAM_START, 0));
+ init_state.parse_request(
+ std::ptr::null(),
+ StreamSlice::from_slice(&buf[15..31], STREAM_START, 0),
+ );
ok_state = parser::RFBGlobalState::TCSecurityResult;
assert_eq!(init_state.state, ok_state);
- init_state.parse_response(std::ptr::null(), StreamSlice::from_slice(&buf[31..35], STREAM_START, 0));
+ init_state.parse_response(
+ std::ptr::null(),
+ StreamSlice::from_slice(&buf[31..35], STREAM_START, 0),
+ );
ok_state = parser::RFBGlobalState::TSClientInit;
assert_eq!(init_state.state, ok_state);
- init_state.parse_request(std::ptr::null(), StreamSlice::from_slice(&buf[35..36], STREAM_START, 0));
+ init_state.parse_request(
+ std::ptr::null(),
+ StreamSlice::from_slice(&buf[35..36], STREAM_START, 0),
+ );
ok_state = parser::RFBGlobalState::TCServerInit;
assert_eq!(init_state.state, ok_state);
- init_state.parse_response(std::ptr::null(), StreamSlice::from_slice(&buf[36..90], STREAM_START, 0));
+ init_state.parse_response(
+ std::ptr::null(),
+ StreamSlice::from_slice(&buf[36..90], STREAM_START, 0),
+ );
ok_state = parser::RFBGlobalState::Message;
assert_eq!(init_state.state, ok_state);
}
projects / thirdparty / suricata.git / commitdiff
