From 3493537ec3db0a2cae5aeeab7fffd0552ffce231 Mon Sep 17 00:00:00 2001 From: Pierre Chifflier Date: Wed, 19 Jan 2022 11:16:40 +0100 Subject: [PATCH] rust/rfb: convert parser to nom7 functions --- rust/src/rfb/parser.rs | 241 +++++++++++++++++------------------------ rust/src/rfb/rfb.rs | 24 ++-- 2 files changed, 111 insertions(+), 154 deletions(-) diff --git a/rust/src/rfb/parser.rs b/rust/src/rfb/parser.rs index 8aed9c7f81..786b831a14 100644 --- a/rust/src/rfb/parser.rs +++ b/rust/src/rfb/parser.rs @@ -18,8 +18,11 @@ // Author: Frank Honza use std::fmt; -use nom::*; -use nom::number::streaming::*; +use std::str; +use nom7::bytes::streaming::take; +use nom7::combinator::map_res; +use nom7::number::streaming::*; +use nom7::*; pub enum RFBGlobalState { TCServerProtocolVersion, @@ -110,155 +113,109 @@ pub struct ServerInit { pub name: Vec } -named!(pub parse_protocol_version, - do_parse!( - _rfb_string: take_str!(3) - >> be_u8 - >> major: take_str!(3) - >> be_u8 - >> minor: take_str!(3) - >> be_u8 - >> ( - ProtocolVersion{ - major: major.to_string(), - minor: minor.to_string(), - } - ) - ) -); - -named!(pub parse_supported_security_types, - do_parse!( - number_of_types: be_u8 - >> types: take!(number_of_types) - >> ( +pub fn parse_protocol_version(i: &[u8]) -> IResult<&[u8], ProtocolVersion> { + let (i, _rfb_string) = map_res(take(3_usize), str::from_utf8)(i)?; + let (i, _) = be_u8(i)?; + let (i, major) = map_res(take(3_usize), str::from_utf8)(i)?; + let (i, _) = be_u8(i)?; + let (i, minor) = map_res(take(3_usize), str::from_utf8)(i)?; + let (i, _) = be_u8(i)?; + Ok((i, ProtocolVersion{ major: major.to_string(), minor: minor.to_string(), })) +} + +pub fn parse_supported_security_types(i: &[u8]) -> IResult<&[u8], SupportedSecurityTypes> { + let (i, number_of_types) = be_u8(i)?; + let (i, types) = take(number_of_types as usize)(i)?; + Ok(( + i, SupportedSecurityTypes{ - number_of_types: number_of_types, + number_of_types, types: types.to_vec() } - ) - ) -); - -named!(pub parse_server_security_type, - do_parse!( - security_type: be_u32 - >> ( - ServerSecurityType{ - security_type: security_type, - } - ) - ) -); - -named!(pub parse_vnc_auth, - do_parse!( - secret: take!(16) - >> ( - VncAuth { - secret: secret.to_vec() - } - ) - ) -); - -named!(pub parse_security_type_selection, - do_parse!( - security_type: be_u8 - >> ( - SecurityTypeSelection { - security_type: security_type - } - ) - ) -); - -named!(pub parse_security_result, - do_parse!( - status: be_u32 - >> ( - SecurityResult { - status: status - } - ) - ) -); - -named!(pub parse_failure_reason, - do_parse!( - reason_length: be_u32 - >> reason_string: take_str!(reason_length) - >> ( + )) +} + +pub fn parse_server_security_type(i: &[u8]) -> IResult<&[u8], ServerSecurityType> { + let (i, security_type) = be_u32(i)?; + Ok((i, ServerSecurityType{ security_type, })) +} + +pub fn parse_vnc_auth(i: &[u8]) -> IResult<&[u8], VncAuth> { + let (i, secret) = take(16_usize)(i)?; + Ok((i, VncAuth { secret: secret.to_vec() })) +} + +pub fn parse_security_type_selection(i: &[u8]) -> IResult<&[u8], SecurityTypeSelection> { + let (i, security_type) = be_u8(i)?; + Ok((i, SecurityTypeSelection { security_type })) +} + +pub fn parse_security_result(i: &[u8]) -> IResult<&[u8], SecurityResult> { + let (i, status) = be_u32(i)?; + Ok((i, SecurityResult { status })) +} + +pub fn parse_failure_reason(i: &[u8]) -> IResult<&[u8], FailureReason> { + let (i, reason_length) = be_u32(i)?; + let (i, reason_string) = map_res(take(reason_length as usize), str::from_utf8)(i)?; + Ok(( + i, FailureReason { reason_string: reason_string.to_string() } - ) - ) -); - -named!(pub parse_client_init, - do_parse!( - shared: be_u8 - >> ( - ClientInit { - shared: shared - } - ) - ) -); - -named!(pub parse_pixel_format, - do_parse!( - bits_per_pixel: be_u8 - >> depth: be_u8 - >> big_endian_flag: be_u8 - >> true_colour_flag: be_u8 - >> red_max: be_u16 - >> green_max: be_u16 - >> blue_max: be_u16 - >> red_shift: be_u8 - >> green_shift: be_u8 - >> blue_shift: be_u8 - >> take!(3) - >> ( - PixelFormat { - bits_per_pixel: bits_per_pixel, - depth: depth, - big_endian_flag: big_endian_flag, - true_colour_flag: true_colour_flag, - red_max: red_max, - green_max: green_max, - blue_max: blue_max, - red_shift: red_shift, - green_shift: green_shift, - blue_shift: blue_shift, - } - ) - ) -); - -named!(pub parse_server_init, - do_parse!( - width: be_u16 - >> height: be_u16 - >> pixel_format: parse_pixel_format - >> name_length: be_u32 - >> name: take!(name_length) - >> ( - ServerInit { - width: width, - height: height, - pixel_format: pixel_format, - name_length: name_length, - name: name.to_vec() - } - ) - ) -); + )) +} + +pub fn parse_client_init(i: &[u8]) -> IResult<&[u8], ClientInit> { + let (i, shared) = be_u8(i)?; + Ok((i, ClientInit { shared })) +} + +pub fn parse_pixel_format(i: &[u8]) -> IResult<&[u8], PixelFormat> { + let (i, bits_per_pixel) = be_u8(i)?; + let (i, depth) = be_u8(i)?; + let (i, big_endian_flag) = be_u8(i)?; + let (i, true_colour_flag) = be_u8(i)?; + let (i, red_max) = be_u16(i)?; + let (i, green_max) = be_u16(i)?; + let (i, blue_max) = be_u16(i)?; + let (i, red_shift) = be_u8(i)?; + let (i, green_shift) = be_u8(i)?; + let (i, blue_shift) = be_u8(i)?; + let (i, _) = take(3_usize)(i)?; + let format = PixelFormat { + bits_per_pixel, + depth, + big_endian_flag, + true_colour_flag, + red_max, + green_max, + blue_max, + red_shift, + green_shift, + blue_shift, + }; + Ok((i, format)) +} + +pub fn parse_server_init(i: &[u8]) -> IResult<&[u8], ServerInit> { + let (i, width) = be_u16(i)?; + let (i, height) = be_u16(i)?; + let (i, pixel_format) = parse_pixel_format(i)?; + let (i, name_length) = be_u32(i)?; + let (i, name) = take(name_length as usize)(i)?; + let init = ServerInit { + width, + height, + pixel_format, + name_length, + name: name.to_vec() + }; + Ok((i, init)) +} #[cfg(test)] mod tests { - use nom::*; use super::*; /// Simple test of some valid data. diff --git a/rust/src/rfb/rfb.rs b/rust/src/rfb/rfb.rs index 1f95e00162..e0e3cefa0a 100644 --- a/rust/src/rfb/rfb.rs +++ b/rust/src/rfb/rfb.rs @@ -22,7 +22,7 @@ use std::ffi::CString; use crate::core::{ALPROTO_UNKNOWN, AppProto, Flow, IPPROTO_TCP}; use crate::applayer; use crate::applayer::*; -use nom; +use nom7::Err; use super::parser; static mut ALPROTO_RFB: AppProto = ALPROTO_UNKNOWN; @@ -174,7 +174,7 @@ impl RFBState { return AppLayerResult::err(); } } - Err(nom::Err::Incomplete(_)) => { + Err(Err::Incomplete(_)) => { return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32); } Err(_) => { @@ -202,7 +202,7 @@ impl RFBState { return AppLayerResult::err(); } } - Err(nom::Err::Incomplete(_)) => { + Err(Err::Incomplete(_)) => { return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32); } Err(_) => { @@ -224,7 +224,7 @@ impl RFBState { return AppLayerResult::err(); } } - Err(nom::Err::Incomplete(_)) => { + Err(Err::Incomplete(_)) => { return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32); } Err(_) => { @@ -246,7 +246,7 @@ impl RFBState { return AppLayerResult::err(); } } - Err(nom::Err::Incomplete(_)) => { + Err(Err::Incomplete(_)) => { return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32); } Err(_) => { @@ -300,7 +300,7 @@ impl RFBState { return AppLayerResult::err(); } } - Err(nom::Err::Incomplete(_)) => { + Err(Err::Incomplete(_)) => { return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32); } Err(_) => { @@ -330,7 +330,7 @@ impl RFBState { return AppLayerResult::err(); } } - Err(nom::Err::Incomplete(_)) => { + Err(Err::Incomplete(_)) => { return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32); } Err(_) => { @@ -364,7 +364,7 @@ impl RFBState { return AppLayerResult::err(); } } - Err(nom::Err::Incomplete(_)) => { + Err(Err::Incomplete(_)) => { return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32); } Err(_) => { @@ -386,7 +386,7 @@ impl RFBState { return AppLayerResult::err(); } } - Err(nom::Err::Incomplete(_)) => { + Err(Err::Incomplete(_)) => { return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32); } Err(_) => { @@ -414,7 +414,7 @@ impl RFBState { // TODO: Event: unknown security result value } } - Err(nom::Err::Incomplete(_)) => { + Err(Err::Incomplete(_)) => { return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32); } Err(_) => { @@ -432,7 +432,7 @@ impl RFBState { } return AppLayerResult::err(); } - Err(nom::Err::Incomplete(_)) => { + Err(Err::Incomplete(_)) => { return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32); } Err(_) => { @@ -456,7 +456,7 @@ impl RFBState { return AppLayerResult::err(); } } - Err(nom::Err::Incomplete(_)) => { + Err(Err::Incomplete(_)) => { return AppLayerResult::incomplete(consumed as u32, (current.len() + 1) as u32); } Err(_) => {