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

quic: update to nom 8.0

Browse Source 
Ticket: #8140
pull/14376/head
Jason Ish 9 months ago committed by Victor Julien
parent 3cb873e3bc
commit 83d8b1d2f8
3 changed files with 35 additions and 35 deletions
Show Stats Download Patch File Download Diff File

12
rust/src/quic/error.rs
Unescape Escape View File

@ -15,7 +15,7 @@
* 02110-1301, USA. * 02110-1301, USA.
*/ */
use nom7::error::{ErrorKind, ParseError}; use nom8::error::{ErrorKind, ParseError};
use std::error::Error; use std::error::Error;
use std::fmt; use std::fmt;
@ -54,12 +54,12 @@ impl fmt::Display for QuicError {
impl Error for QuicError {} impl Error for QuicError {}
impl From<nom7::Err<QuicError>> for QuicError { impl From<nom8::Err<QuicError>> for QuicError {
fn from(err: nom7::Err<QuicError>) -> Self { fn from(err: nom8::Err<QuicError>) -> Self {
match err { match err {
nom7::Err::Incomplete(_) => QuicError::Incomplete, nom8::Err::Incomplete(_) => QuicError::Incomplete,
nom7::Err::Error(e) => e, nom8::Err::Error(e) => e,
nom7::Err::Failure(e) => e, nom8::Err::Failure(e) => e,
} }
} }
} }

30
rust/src/quic/frames.rs
Unescape Escape View File

@ -19,12 +19,12 @@ use super::error::QuicError;
use super::quic::QUIC_MAX_CRYPTO_FRAG_LEN; use super::quic::QUIC_MAX_CRYPTO_FRAG_LEN;
use crate::handshake::HandshakeParams; use crate::handshake::HandshakeParams;
use crate::quic::parser::quic_var_uint; use crate::quic::parser::quic_var_uint;
use nom7::bytes::complete::take; use nom8::bytes::complete::take;
use nom7::combinator::{all_consuming, complete}; use nom8::combinator::{all_consuming, complete};
use nom7::multi::{count, many0}; use nom8::multi::{count, many0};
use nom7::number::complete::{be_u16, be_u32, be_u8, le_u16, le_u32}; use nom8::number::complete::{be_u16, be_u32, be_u8, le_u16, le_u32};
use nom7::sequence::pair; use nom8::sequence::pair;
use nom7::IResult; use nom8::{IResult, Parser};
use num::FromPrimitive; use num::FromPrimitive;
use std::fmt; use std::fmt;
use tls_parser::TlsMessage::Handshake; use tls_parser::TlsMessage::Handshake;
@ -412,19 +412,19 @@ fn parse_crypto_frame(input: &[u8]) -> IResult<&[u8], Frame, QuicError> {
} }
_ => {} _ => {}
} }
return Err(nom7::Err::Error(QuicError::InvalidPacket)); return Err(nom8::Err::Error(QuicError::InvalidPacket));
} }
fn parse_tag(input: &[u8]) -> IResult<&[u8], StreamTag, QuicError> { fn parse_tag(input: &[u8]) -> IResult<&[u8], StreamTag, QuicError> {
let (rest, tag) = be_u32(input)?; let (rest, tag) = be_u32(input)?;
let tag = StreamTag::from_u32(tag).ok_or(nom7::Err::Error(QuicError::StreamTagNoMatch(tag)))?; let tag = StreamTag::from_u32(tag).ok_or(nom8::Err::Error(QuicError::StreamTagNoMatch(tag)))?;
Ok((rest, tag)) Ok((rest, tag))
} }
fn parse_tag_and_offset(input: &[u8]) -> IResult<&[u8], TagOffset, QuicError> { fn parse_tag_and_offset(input: &[u8]) -> IResult<&[u8], TagOffset, QuicError> {
pair(parse_tag, le_u32)(input) pair(parse_tag, le_u32).parse(input)
} }
fn parse_crypto_stream(input: &[u8]) -> IResult<&[u8], Vec<TagValue>, QuicError> { fn parse_crypto_stream(input: &[u8]) -> IResult<&[u8], Vec<TagValue>, QuicError> {
@ -434,7 +434,7 @@ fn parse_crypto_stream(input: &[u8]) -> IResult<&[u8], Vec<TagValue>, QuicError>
let (rest, num_entries) = le_u16(rest)?; let (rest, num_entries) = le_u16(rest)?;
let (rest, _padding) = take(2usize)(rest)?; let (rest, _padding) = take(2usize)(rest)?;
let (rest, tags_offset) = count(complete(parse_tag_and_offset), num_entries.into())(rest)?; let (rest, tags_offset) = count(complete(parse_tag_and_offset), num_entries.into()).parse(rest)?;
// Convert (Tag, Offset) to (Tag, Value) // Convert (Tag, Offset) to (Tag, Value)
let mut tags = Vec::new(); let mut tags = Vec::new();
@ -444,7 +444,7 @@ fn parse_crypto_stream(input: &[u8]) -> IResult<&[u8], Vec<TagValue>, QuicError>
// offsets should be increasing // offsets should be increasing
let value_len = offset let value_len = offset
.checked_sub(previous_offset) .checked_sub(previous_offset)
.ok_or(nom7::Err::Error(QuicError::InvalidPacket))?; .ok_or(nom8::Err::Error(QuicError::InvalidPacket))?;
let (new_rest, value) = take(value_len)(rest)?; let (new_rest, value) = take(value_len)(rest)?;
previous_offset = offset; previous_offset = offset;
@ -484,7 +484,7 @@ fn parse_stream_frame(input: &[u8], frame_ty: u8) -> IResult<&[u8], Frame, QuicE
let (rest, stream_data) = take(data_length)(rest)?; let (rest, stream_data) = take(data_length)(rest)?;
let tags = if let Ok((_, tags)) = all_consuming(parse_crypto_stream)(stream_data) { let tags = if let Ok((_, tags)) = all_consuming(parse_crypto_stream).parse(stream_data) {
Some(tags) Some(tags)
} else { } else {
None None
@ -505,11 +505,11 @@ fn parse_crypto_stream_frame(input: &[u8]) -> IResult<&[u8], Frame, QuicError> {
let (rest, _offset) = quic_var_uint(input)?; let (rest, _offset) = quic_var_uint(input)?;
let (rest, data_length) = quic_var_uint(rest)?; let (rest, data_length) = quic_var_uint(rest)?;
if data_length > u32::MAX as u64 { if data_length > u32::MAX as u64 {
return Err(nom7::Err::Error(QuicError::Unhandled)); return Err(nom8::Err::Error(QuicError::Unhandled));
} }
let (rest, stream_data) = take(data_length as u32)(rest)?; let (rest, stream_data) = take(data_length as u32)(rest)?;
let tags = if let Ok((_, tags)) = all_consuming(parse_crypto_stream)(stream_data) { let tags = if let Ok((_, tags)) = all_consuming(parse_crypto_stream).parse(stream_data) {
Some(tags) Some(tags)
} else { } else {
None None
@ -552,7 +552,7 @@ impl Frame {
pub(crate) fn decode_frames<'a>( pub(crate) fn decode_frames<'a>(
input: &'a [u8], past_frag: &'a [u8], past_fraglen: u32, input: &'a [u8], past_frag: &'a [u8], past_fraglen: u32,
) -> IResult<&'a [u8], Vec<Frame>, QuicError> { ) -> IResult<&'a [u8], Vec<Frame>, QuicError> {
let (rest, mut frames) = all_consuming(many0(complete(Frame::decode_frame)))(input)?; let (rest, mut frames) = all_consuming(many0(complete(Frame::decode_frame))).parse(input)?;
// we use the already seen past fragment data // we use the already seen past fragment data
let mut crypto_max_size = past_frag.len() as u64; let mut crypto_max_size = past_frag.len() as u64;

28
rust/src/quic/parser.rs
Unescape Escape View File

@ -16,10 +16,10 @@
*/ */
use super::error::QuicError; use super::error::QuicError;
use super::frames::Frame; use super::frames::Frame;
use nom7::bytes::complete::take; use nom8::bytes::complete::take;
use nom7::combinator::map; use nom8::combinator::map;
use nom7::number::complete::{be_u24, be_u32, be_u8}; use nom8::number::complete::{be_u24, be_u32, be_u8};
use nom7::IResult; use nom8::{IResult, Parser};
use std::convert::TryFrom; use std::convert::TryFrom;
/* /*
@ -214,7 +214,7 @@ impl QuicHeader {
let version; let version;
if (flags.raw & QUIC_FLAG_VERSION) != 0 { if (flags.raw & QUIC_FLAG_VERSION) != 0 {
let (_, version_buf1) = take(4_usize)(rest)?; let (_, version_buf1) = take(4_usize)(rest)?;
let (rest1, version1) = map(be_u32, QuicVersion)(rest)?; let (rest1, version1) = map(be_u32, QuicVersion).parse(rest)?;
rest = rest1; rest = rest1;
version = version1; version = version1;
version_buf = version_buf1; version_buf = version_buf1;
@ -247,7 +247,7 @@ impl QuicHeader {
}, },
)); ));
} else { } else {
return Err(nom7::Err::Error(QuicError::InvalidPacket)); return Err(nom8::Err::Error(QuicError::InvalidPacket));
} }
} else if !flags.is_long { } else if !flags.is_long {
// Decode short header // Decode short header
@ -267,12 +267,12 @@ impl QuicHeader {
}, },
)); ));
} else { } else {
return Err(nom7::Err::Error(QuicError::InvalidPacket)); return Err(nom8::Err::Error(QuicError::InvalidPacket));
} }
} else { } else {
// Decode Long header // Decode Long header
let (_, version_buf) = take(4_usize)(rest)?; let (_, version_buf) = take(4_usize)(rest)?;
let (rest, version) = map(be_u32, QuicVersion)(rest)?; let (rest, version) = map(be_u32, QuicVersion).parse(rest)?;
let ty = if version == QuicVersion(0) { let ty = if version == QuicVersion(0) {
QuicType::VersionNegotiation QuicType::VersionNegotiation
@ -285,7 +285,7 @@ impl QuicHeader {
0x7d => QuicType::Handshake, 0x7d => QuicType::Handshake,
0x7c => QuicType::ZeroRTT, 0x7c => QuicType::ZeroRTT,
_ => { _ => {
return Err(nom7::Err::Error(QuicError::InvalidPacket)); return Err(nom8::Err::Error(QuicError::InvalidPacket));
} }
} }
} else if version == QuicVersion::V2 { } else if version == QuicVersion::V2 {
@ -295,7 +295,7 @@ impl QuicHeader {
0x03 => QuicType::Handshake, 0x03 => QuicType::Handshake,
0x00 => QuicType::Retry, 0x00 => QuicType::Retry,
_ => { _ => {
return Err(nom7::Err::Error(QuicError::InvalidPacket)); return Err(nom8::Err::Error(QuicError::InvalidPacket));
} }
} }
} else { } else {
@ -306,7 +306,7 @@ impl QuicHeader {
0x02 => QuicType::Handshake, 0x02 => QuicType::Handshake,
0x03 => QuicType::Retry, 0x03 => QuicType::Retry,
_ => { _ => {
return Err(nom7::Err::Error(QuicError::InvalidPacket)); return Err(nom8::Err::Error(QuicError::InvalidPacket));
} }
} }
} }
@ -366,17 +366,17 @@ impl QuicHeader {
let (rest, length) = if has_length { let (rest, length) = if has_length {
let (rest2, plength) = quic_var_uint(rest)?; let (rest2, plength) = quic_var_uint(rest)?;
if plength > rest2.len() as u64 { if plength > rest2.len() as u64 {
return Err(nom7::Err::Error(QuicError::InvalidPacket)); return Err(nom8::Err::Error(QuicError::InvalidPacket));
} }
if let Ok(length) = u16::try_from(plength) { if let Ok(length) = u16::try_from(plength) {
(rest2, length) (rest2, length)
} else { } else {
return Err(nom7::Err::Error(QuicError::InvalidPacket)); return Err(nom8::Err::Error(QuicError::InvalidPacket));
} }
} else if let Ok(length) = u16::try_from(rest.len()) { } else if let Ok(length) = u16::try_from(rest.len()) {
(rest, length) (rest, length)
} else { } else {
return Err(nom7::Err::Error(QuicError::InvalidPacket)); return Err(nom8::Err::Error(QuicError::InvalidPacket));
}; };
Ok(( Ok((

Write Preview
Loading…
Cancel
Save