rust/smb: convert to nom 8

Author: jasonish

rust/src/smb/auth.rs

@@ -20,19 +20,19 @@ use crate::kerberos::*;
 use crate::smb::ntlmssp_records::*;
 use crate::smb::smb::*;
 
-use nom7::{Err, IResult};
+use nom8::{Err, IResult};
 use der_parser::ber::BerObjectContent;
 use der_parser::der::{parse_der_oid, parse_der_sequence};
 
 fn parse_secblob_get_spnego(blob: &[u8]) -> IResult<&[u8], &[u8], SecBlobError>
 {
-    let (rem, base_o) = der_parser::parse_der(blob).map_err(Err::convert)?;
+    let (rem, base_o) = der_parser::parse_der(blob).map_err(|_| Err::Error(SecBlobError::NotSpNego))?;
     SCLogDebug!("parse_secblob_get_spnego: base_o {:?}", base_o);
     let d = match base_o.content.as_slice() {
         Err(_) => { return Err(Err::Error(SecBlobError::NotSpNego)); },
         Ok(d) => d,
     };
-    let (next, o) = parse_der_oid(d).map_err(Err::convert)?;
+    let (next, o) = parse_der_oid(d).map_err(|_| Err::Error(SecBlobError::NotSpNego))?;
     SCLogDebug!("parse_secblob_get_spnego: sub_o {:?}", o);
 
     let oid = match o.content.as_oid() {
@@ -59,7 +59,7 @@ fn parse_secblob_get_spnego(blob: &[u8]) -> IResult<&[u8], &[u8], SecBlobError>
 
 fn parse_secblob_spnego_start(blob: &[u8]) -> IResult<&[u8], &[u8], SecBlobError>
 {
-    let (rem, o) = der_parser::parse_der(blob).map_err(Err::convert)?;
+    let (rem, o) = der_parser::parse_der(blob).map_err(|_| Err::Error(SecBlobError::NotSpNego))?;
     let d = match o.content.as_slice() {
         Ok(d) => {
             SCLogDebug!("d: next data len {}",d.len());

rust/src/smb/dcerpc_records.rs

@@ -15,16 +15,15 @@
  * 02110-1301, USA.
  */
 
-use crate::common::nom7::bits;
+use nom8::bits::bits;
 use crate::smb::error::SmbError;
-use nom7::bits::streaming::take as take_bits;
-use nom7::bytes::streaming::take;
-use nom7::combinator::{cond, rest};
-use nom7::multi::count;
-use nom7::number::Endianness;
-use nom7::number::streaming::{be_u16, le_u8, le_u16, le_u32, u16, u32};
-use nom7::sequence::tuple;
-use nom7::{Err, IResult};
+use nom8::bits::streaming::take as take_bits;
+use nom8::bytes::streaming::take;
+use nom8::combinator::{cond, rest};
+use nom8::multi::count;
+use nom8::number::Endianness;
+use nom8::number::streaming::{be_u16, le_u8, le_u16, le_u32, u16, u32};
+use nom8::{Err, IResult};
 
 #[derive(Debug,PartialEq, Eq)]
 pub struct DceRpcResponseRecord<'a> {
@@ -36,11 +35,12 @@ pub struct DceRpcResponseRecord<'a> {
 pub fn parse_dcerpc_response_record(i:&[u8], frag_len: u16 )
     -> IResult<&[u8], DceRpcResponseRecord<'_>, SmbError>
 {
+    use nom8::Parser;
     if frag_len < 24 {
         return Err(Err::Error(SmbError::RecordTooSmall));
     }
-    let (i, _) = take(8_usize)(i)?;
-    let (i, data) = take(frag_len - 24)(i)?;
+    let (i, _) = take(8_usize).parse(i)?;
+    let (i, data) = take(frag_len - 24).parse(i)?;
     let record = DceRpcResponseRecord { data };
     Ok((i, record))
 }
@@ -57,14 +57,15 @@ pub struct DceRpcRequestRecord<'a> {
 pub fn parse_dcerpc_request_record(i:&[u8], frag_len: u16, little: bool)
     -> IResult<&[u8], DceRpcRequestRecord<'_>, SmbError>
 {
+    use nom8::Parser;
     if frag_len < 24 {
         return Err(Err::Error(SmbError::RecordTooSmall));
     }
-    let (i, _) = take(4_usize)(i)?;
+    let (i, _) = take(4_usize).parse(i)?;
     let endian = if little { Endianness::Little } else { Endianness::Big };
-    let (i, context_id) = u16(endian)(i)?;
-    let (i, opnum) = u16(endian)(i)?;
-    let (i, data) = take(frag_len - 24)(i)?;
+    let (i, context_id) = u16(endian).parse(i)?;
+    let (i, opnum) = u16(endian).parse(i)?;
+    let (i, data) = take(frag_len - 24).parse(i)?;
     let record = DceRpcRequestRecord { opnum, context_id, data };
     Ok((i, record))
 }
@@ -77,13 +78,14 @@ pub struct DceRpcBindIface<'a> {
 }
 
 pub fn parse_dcerpc_bind_iface(i: &[u8]) -> IResult<&[u8], DceRpcBindIface<'_>> {
-    let (i, _ctx_id) = le_u16(i)?;
-    let (i, _num_trans_items) = le_u8(i)?;
-    let (i, _) = take(1_usize)(i)?; // reserved
-    let (i, interface) = take(16_usize)(i)?;
-    let (i, ver) = le_u16(i)?;
-    let (i, ver_min) = le_u16(i)?;
-    let (i, _) = take(20_usize)(i)?;
+    use nom8::Parser;
+    let (i, _ctx_id) = le_u16.parse(i)?;
+    let (i, _num_trans_items) = le_u8.parse(i)?;
+    let (i, _) = take(1_usize).parse(i)?; // reserved
+    let (i, interface) = take(16_usize).parse(i)?;
+    let (i, ver) = le_u16.parse(i)?;
+    let (i, ver_min) = le_u16.parse(i)?;
+    let (i, _) = take(20_usize).parse(i)?;
     let res = DceRpcBindIface {
         iface:interface,
         ver,
@@ -93,13 +95,14 @@ pub fn parse_dcerpc_bind_iface(i: &[u8]) -> IResult<&[u8], DceRpcBindIface<'_>>
 }
 
 pub fn parse_dcerpc_bind_iface_big(i: &[u8]) -> IResult<&[u8], DceRpcBindIface<'_>> {
-    let (i, _ctx_id) = le_u16(i)?;
-    let (i, _num_trans_items) = le_u8(i)?;
-    let (i, _) = take(1_usize)(i)?; // reserved
-    let (i, interface) = take(16_usize)(i)?;
-    let (i, ver_min) = be_u16(i)?;
-    let (i, ver) = be_u16(i)?;
-    let (i, _) = take(20_usize)(i)?;
+    use nom8::Parser;
+    let (i, _ctx_id) = le_u16.parse(i)?;
+    let (i, _num_trans_items) = le_u8.parse(i)?;
+    let (i, _) = take(1_usize).parse(i)?; // reserved
+    let (i, interface) = take(16_usize).parse(i)?;
+    let (i, ver_min) = be_u16.parse(i)?;
+    let (i, ver) = be_u16.parse(i)?;
+    let (i, _) = take(20_usize).parse(i)?;
     let res = DceRpcBindIface {
         iface:interface,
         ver,
@@ -115,12 +118,13 @@ pub struct DceRpcBindRecord<'a> {
 }
 
 pub fn parse_dcerpc_bind_record(i: &[u8]) -> IResult<&[u8], DceRpcBindRecord<'_>> {
-    let (i, _max_xmit_frag) = le_u16(i)?;
-    let (i, _max_recv_frag) = le_u16(i)?;
-    let (i, _assoc_group) = take(4_usize)(i)?;
-    let (i, num_ctx_items) = le_u8(i)?;
-    let (i, _) = take(3_usize)(i)?; // reserved
-    let (i, ifaces) = count(parse_dcerpc_bind_iface, num_ctx_items as usize)(i)?;
+    use nom8::Parser;
+    let (i, _max_xmit_frag) = le_u16.parse(i)?;
+    let (i, _max_recv_frag) = le_u16.parse(i)?;
+    let (i, _assoc_group) = take(4_usize).parse(i)?;
+    let (i, num_ctx_items) = le_u8.parse(i)?;
+    let (i, _) = take(3_usize).parse(i)?; // reserved
+    let (i, ifaces) = count(parse_dcerpc_bind_iface, num_ctx_items as usize).parse(i)?;
     let record = DceRpcBindRecord {
         num_ctx_items,
         ifaces,
@@ -129,12 +133,13 @@ pub fn parse_dcerpc_bind_record(i: &[u8]) -> IResult<&[u8], DceRpcBindRecord<'_>
 }
 
 pub fn parse_dcerpc_bind_record_big(i: &[u8]) -> IResult<&[u8], DceRpcBindRecord<'_>> {
-    let (i, _max_xmit_frag) = be_u16(i)?;
-    let (i, _max_recv_frag) = be_u16(i)?;
-    let (i, _assoc_group) = take(4_usize)(i)?;
-    let (i, num_ctx_items) = le_u8(i)?;
-    let (i, _) = take(3_usize)(i)?; // reserved
-    let (i, ifaces) = count(parse_dcerpc_bind_iface_big, num_ctx_items as usize)(i)?;
+    use nom8::Parser;
+    let (i, _max_xmit_frag) = be_u16.parse(i)?;
+    let (i, _max_recv_frag) = be_u16.parse(i)?;
+    let (i, _assoc_group) = take(4_usize).parse(i)?;
+    let (i, num_ctx_items) = le_u8.parse(i)?;
+    let (i, _) = take(3_usize).parse(i)?; // reserved
+    let (i, ifaces) = count(parse_dcerpc_bind_iface_big, num_ctx_items as usize).parse(i)?;
     let record = DceRpcBindRecord {
         num_ctx_items,
         ifaces,
@@ -151,10 +156,11 @@ pub struct DceRpcBindAckResult<'a> {
 }
 
 pub fn parse_dcerpc_bindack_result(i: &[u8]) -> IResult<&[u8], DceRpcBindAckResult<'_>> {
-    let (i, ack_result) = le_u16(i)?;
-    let (i, ack_reason) = le_u16(i)?;
-    let (i, transfer_syntax) = take(16_usize)(i)?;
-    let (i, syntax_version) = le_u32(i)?;
+    use nom8::Parser;
+    let (i, ack_result) = le_u16.parse(i)?;
+    let (i, ack_reason) = le_u16.parse(i)?;
+    let (i, transfer_syntax) = take(16_usize).parse(i)?;
+    let (i, syntax_version) = le_u32.parse(i)?;
     let res = DceRpcBindAckResult {
         ack_result,
         ack_reason,
@@ -171,16 +177,17 @@ pub struct DceRpcBindAckRecord<'a> {
 }
 
 pub fn parse_dcerpc_bindack_record(i: &[u8]) -> IResult<&[u8], DceRpcBindAckRecord<'_>> {
-    let (i, _max_xmit_frag) = le_u16(i)?;
-    let (i, _max_recv_frag) = le_u16(i)?;
-    let (i, _assoc_group) = take(4_usize)(i)?;
-    let (i, sec_addr_len) = le_u16(i)?;
-    let (i, _) = take(sec_addr_len)(i)?;
+    use nom8::Parser;
+    let (i, _max_xmit_frag) = le_u16.parse(i)?;
+    let (i, _max_recv_frag) = le_u16.parse(i)?;
+    let (i, _assoc_group) = take(4_usize).parse(i)?;
+    let (i, sec_addr_len) = le_u16.parse(i)?;
+    let (i, _) = take(sec_addr_len).parse(i)?;
     let topad = sec_addr_len.wrapping_add(2) % 4;
-    let (i, _) = cond(topad != 0, take(4 - topad))(i)?;
-    let (i, num_results) = le_u8(i)?;
-    let (i, _) = take(3_usize)(i)?; // padding
-    let (i, results) = count(parse_dcerpc_bindack_result, num_results as usize)(i)?;
+    let (i, _) = cond(topad != 0, take(4 - topad)).parse(i)?;
+    let (i, num_results) = le_u8.parse(i)?;
+    let (i, _) = take(3_usize).parse(i)?; // padding
+    let (i, results) = count(parse_dcerpc_bindack_result, num_results as usize).parse(i)?;
     let record = DceRpcBindAckRecord {
         num_results,
         results,
@@ -207,32 +214,37 @@ pub struct DceRpcRecord<'a> {
 }
 
 fn parse_dcerpc_flags1(i:&[u8]) -> IResult<&[u8],(u8,u8,u8)> {
-    bits(tuple((
+    use nom8::Parser;
+    use nom8::error::Error;
+    bits::<_, _, Error<_>, _, _>((
         take_bits(6u8),
         take_bits(1u8),   // last (1)
         take_bits(1u8),
-    )))(i)
+    )).parse(i)
 }
 
 fn parse_dcerpc_flags2(i:&[u8]) -> IResult<&[u8],(u32,u32,u32)> {
-    bits(tuple((
+    use nom8::Parser;
+    use nom8::error::Error;
+    bits::<_, _, Error<_>, _, _>((
        take_bits(3u32),
        take_bits(1u32),     // endianness
        take_bits(28u32),
-    )))(i)
+    )).parse(i)
 }
 
 pub fn parse_dcerpc_record(i: &[u8]) -> IResult<&[u8], DceRpcRecord<'_>> {
-    let (i, version_major) = le_u8(i)?;
-    let (i, version_minor) = le_u8(i)?;
-    let (i, packet_type) = le_u8(i)?;
+    use nom8::Parser;
+    let (i, version_major) = le_u8.parse(i)?;
+    let (i, version_minor) = le_u8.parse(i)?;
+    let (i, packet_type) = le_u8.parse(i)?;
     let (i, packet_flags) = parse_dcerpc_flags1(i)?;
     let (i, data_rep) = parse_dcerpc_flags2(i)?;
     let endian = if data_rep.1 == 0 { Endianness::Big } else { Endianness::Little };
-    let (i, frag_len) = u16(endian)(i)?;
-    let (i, _auth) = u16(endian)(i)?;
-    let (i, call_id) = u32(endian)(i)?;
-    let (i, data) = rest(i)?;
+    let (i, frag_len) = u16(endian).parse(i)?;
+    let (i, _auth) = u16(endian).parse(i)?;
+    let (i, call_id) = u32(endian).parse(i)?;
+    let (i, data) = rest.parse(i)?;
     let record = DceRpcRecord {
         version_major,
         version_minor,

rust/src/smb/error.rs

@@ -16,7 +16,7 @@
  */
 
 // Author: Pierre Chifflier <chifflier@wzdftpd.net>
-use nom7::error::{ErrorKind, ParseError};
+use nom8::error::{ErrorKind, ParseError};
 
 #[derive(Debug)]
 pub enum SmbError {

rust/src/smb/nbss_records.rs

@@ -15,10 +15,10 @@
  * 02110-1301, USA.
  */
 
-use nom7::bytes::streaming::take;
-use nom7::combinator::rest;
-use nom7::number::streaming::be_u32;
-use nom7::IResult;
+use nom8::bytes::streaming::take;
+use nom8::combinator::rest;
+use nom8::number::streaming::be_u32;
+use nom8::IResult;
 
 pub const NBSS_MSGTYPE_SESSION_MESSAGE:         u8 = 0x00;
 pub const NBSS_MSGTYPE_SESSION_REQUEST:         u8 = 0x81;
@@ -60,10 +60,11 @@ impl NbssRecord<'_> {
 }
 
 pub fn parse_nbss_record(i: &[u8]) -> IResult<&[u8], NbssRecord<'_>> {
-    let (i, buf) = be_u32(i)?;
+    use nom8::Parser;
+    let (i, buf) = be_u32.parse(i)?;
     let message_type = (buf >> 24) as u8;
     let length = buf & 0xff_ffff;
-    let (i, data) = take(length as usize)(i)?;
+    let (i, data) = take(length as usize).parse(i)?;
     let record = NbssRecord {
         message_type,
         length,
@@ -73,10 +74,11 @@ pub fn parse_nbss_record(i: &[u8]) -> IResult<&[u8], NbssRecord<'_>> {
 }
 
 pub fn parse_nbss_record_partial(i: &[u8]) -> IResult<&[u8], NbssRecord<'_>> {
-    let (i, buf) = be_u32(i)?;
+    use nom8::Parser;
+    let (i, buf) = be_u32.parse(i)?;
     let message_type = (buf >> 24) as u8;
     let length = buf & 0xff_ffff;
-    let (i, data) = rest(i)?;
+    let (i, data) = rest.parse(i)?;
     let record = NbssRecord {
         message_type,
         length,
@@ -89,7 +91,7 @@ pub fn parse_nbss_record_partial(i: &[u8]) -> IResult<&[u8], NbssRecord<'_>> {
 mod tests {
 
     use super::*;
-    use nom7::Err;
+    use nom8::Err;
 
     #[test]
     fn test_parse_nbss_record() {