aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rust/rfb: convert parser to nom7 functions

Browse Source
pull/6971/head
Pierre Chifflier 5 years ago committed by Victor Julien
parent 377ce6b679
commit 3493537ec3
2 changed files with 111 additions and 154 deletions
Show Stats Download Patch File Download Diff File

241
rust/src/rfb/parser.rs
Unescape Escape View File

@ -18,8 +18,11 @@
// Author: Frank Honza <frank.honza@dcso.de> // Author: Frank Honza <frank.honza@dcso.de>
use std::fmt; use std::fmt;
use nom::*; use std::str;
use nom::number::streaming::*; use nom7::bytes::streaming::take;
use nom7::combinator::map_res;
use nom7::number::streaming::*;
use nom7::*;
pub enum RFBGlobalState { pub enum RFBGlobalState {
TCServerProtocolVersion, TCServerProtocolVersion,
@ -110,155 +113,109 @@ pub struct ServerInit {
pub name: Vec<u8> pub name: Vec<u8>
} }
named!(pub parse_protocol_version<ProtocolVersion>, pub fn parse_protocol_version(i: &[u8]) -> IResult<&[u8], ProtocolVersion> {
do_parse!( let (i, _rfb_string) = map_res(take(3_usize), str::from_utf8)(i)?;
_rfb_string: take_str!(3) let (i, _) = be_u8(i)?;
>> be_u8 let (i, major) = map_res(take(3_usize), str::from_utf8)(i)?;
>> major: take_str!(3) let (i, _) = be_u8(i)?;
>> be_u8 let (i, minor) = map_res(take(3_usize), str::from_utf8)(i)?;
>> minor: take_str!(3) let (i, _) = be_u8(i)?;
>> be_u8 Ok((i, ProtocolVersion{ major: major.to_string(), minor: minor.to_string(), }))
>> ( }
ProtocolVersion{
major: major.to_string(), pub fn parse_supported_security_types(i: &[u8]) -> IResult<&[u8], SupportedSecurityTypes> {
minor: minor.to_string(), let (i, number_of_types) = be_u8(i)?;
} let (i, types) = take(number_of_types as usize)(i)?;
) Ok((
) i,
);
named!(pub parse_supported_security_types<SupportedSecurityTypes>,
do_parse!(
number_of_types: be_u8
>> types: take!(number_of_types)
>> (
SupportedSecurityTypes{ SupportedSecurityTypes{
number_of_types: number_of_types, number_of_types,
types: types.to_vec() types: types.to_vec()
} }
) ))
) }
);
pub fn parse_server_security_type(i: &[u8]) -> IResult<&[u8], ServerSecurityType> {
named!(pub parse_server_security_type<ServerSecurityType>, let (i, security_type) = be_u32(i)?;
do_parse!( Ok((i, ServerSecurityType{ security_type, }))
security_type: be_u32 }
>> (
ServerSecurityType{ pub fn parse_vnc_auth(i: &[u8]) -> IResult<&[u8], VncAuth> {
security_type: security_type, 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)?;
named!(pub parse_vnc_auth<VncAuth>, Ok((i, SecurityTypeSelection { security_type }))
do_parse!( }
secret: take!(16)
>> ( pub fn parse_security_result(i: &[u8]) -> IResult<&[u8], SecurityResult> {
VncAuth { let (i, status) = be_u32(i)?;
secret: secret.to_vec() 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)?;
named!(pub parse_security_type_selection<SecurityTypeSelection>, Ok((
do_parse!( i,
security_type: be_u8
>> (
SecurityTypeSelection {
security_type: security_type
}
)
)
);
named!(pub parse_security_result<SecurityResult>,
do_parse!(
status: be_u32
>> (
SecurityResult {
status: status
}
)
)
);
named!(pub parse_failure_reason<FailureReason>,
do_parse!(
reason_length: be_u32
>> reason_string: take_str!(reason_length)
>> (
FailureReason { FailureReason {
reason_string: reason_string.to_string() reason_string: reason_string.to_string()
} }
) ))
) }
);
pub fn parse_client_init(i: &[u8]) -> IResult<&[u8], ClientInit> {
named!(pub parse_client_init<ClientInit>, let (i, shared) = be_u8(i)?;
do_parse!( Ok((i, ClientInit { shared }))
shared: be_u8 }
>> (
ClientInit { pub fn parse_pixel_format(i: &[u8]) -> IResult<&[u8], PixelFormat> {
shared: shared 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)?;
named!(pub parse_pixel_format<PixelFormat>, let (i, blue_max) = be_u16(i)?;
do_parse!( let (i, red_shift) = be_u8(i)?;
bits_per_pixel: be_u8 let (i, green_shift) = be_u8(i)?;
>> depth: be_u8 let (i, blue_shift) = be_u8(i)?;
>> big_endian_flag: be_u8 let (i, _) = take(3_usize)(i)?;
>> true_colour_flag: be_u8 let format = PixelFormat {
>> red_max: be_u16 bits_per_pixel,
>> green_max: be_u16 depth,
>> blue_max: be_u16 big_endian_flag,
>> red_shift: be_u8 true_colour_flag,
>> green_shift: be_u8 red_max,
>> blue_shift: be_u8 green_max,
>> take!(3) blue_max,
>> ( red_shift,
PixelFormat { green_shift,
bits_per_pixel: bits_per_pixel, blue_shift,
depth: depth, };
big_endian_flag: big_endian_flag, Ok((i, format))
true_colour_flag: true_colour_flag, }
red_max: red_max,
green_max: green_max, pub fn parse_server_init(i: &[u8]) -> IResult<&[u8], ServerInit> {
blue_max: blue_max, let (i, width) = be_u16(i)?;
red_shift: red_shift, let (i, height) = be_u16(i)?;
green_shift: green_shift, let (i, pixel_format) = parse_pixel_format(i)?;
blue_shift: blue_shift, let (i, name_length) = be_u32(i)?;
} let (i, name) = take(name_length as usize)(i)?;
) let init = ServerInit {
) width,
); height,
pixel_format,
named!(pub parse_server_init<ServerInit>, name_length,
do_parse!( name: name.to_vec()
width: be_u16 };
>> height: be_u16 Ok((i, init))
>> 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()
}
)
)
);
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use nom::*;
use super::*; use super::*;
/// Simple test of some valid data. /// Simple test of some valid data.

24
rust/src/rfb/rfb.rs
Unescape Escape View File

@ -22,7 +22,7 @@ use std::ffi::CString;
use crate::core::{ALPROTO_UNKNOWN, AppProto, Flow, IPPROTO_TCP}; use crate::core::{ALPROTO_UNKNOWN, AppProto, Flow, IPPROTO_TCP};
use crate::applayer; use crate::applayer;
use crate::applayer::*; use crate::applayer::*;
use nom; use nom7::Err;
use super::parser; use super::parser;
static mut ALPROTO_RFB: AppProto = ALPROTO_UNKNOWN; static mut ALPROTO_RFB: AppProto = ALPROTO_UNKNOWN;
@ -174,7 +174,7 @@ impl RFBState {
return AppLayerResult::err(); return AppLayerResult::err();
} }
} }
Err(nom::Err::Incomplete(_)) => { 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(_) => { Err(_) => {
@ -202,7 +202,7 @@ impl RFBState {
return AppLayerResult::err(); return AppLayerResult::err();
} }
} }
Err(nom::Err::Incomplete(_)) => { 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(_) => { Err(_) => {
@ -224,7 +224,7 @@ impl RFBState {
return AppLayerResult::err(); return AppLayerResult::err();
} }
} }
Err(nom::Err::Incomplete(_)) => { 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(_) => { Err(_) => {
@ -246,7 +246,7 @@ impl RFBState {
return AppLayerResult::err(); return AppLayerResult::err();
} }
} }
Err(nom::Err::Incomplete(_)) => { 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(_) => { Err(_) => {
@ -300,7 +300,7 @@ impl RFBState {
return AppLayerResult::err(); return AppLayerResult::err();
} }
} }
Err(nom::Err::Incomplete(_)) => { 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(_) => { Err(_) => {
@ -330,7 +330,7 @@ impl RFBState {
return AppLayerResult::err(); return AppLayerResult::err();
} }
} }
Err(nom::Err::Incomplete(_)) => { 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(_) => { Err(_) => {
@ -364,7 +364,7 @@ impl RFBState {
return AppLayerResult::err(); return AppLayerResult::err();
} }
} }
Err(nom::Err::Incomplete(_)) => { 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(_) => { Err(_) => {
@ -386,7 +386,7 @@ impl RFBState {
return AppLayerResult::err(); return AppLayerResult::err();
} }
} }
Err(nom::Err::Incomplete(_)) => { 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(_) => { Err(_) => {
@ -414,7 +414,7 @@ impl RFBState {
// TODO: Event: unknown security result value // TODO: Event: unknown security result value
} }
} }
Err(nom::Err::Incomplete(_)) => { 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(_) => { Err(_) => {
@ -432,7 +432,7 @@ impl RFBState {
} }
return AppLayerResult::err(); return AppLayerResult::err();
} }
Err(nom::Err::Incomplete(_)) => { 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(_) => { Err(_) => {
@ -456,7 +456,7 @@ impl RFBState {
return AppLayerResult::err(); return AppLayerResult::err();
} }
} }
Err(nom::Err::Incomplete(_)) => { 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(_) => { Err(_) => {

Write Preview
Loading…
Cancel
Save