Use nom for parsing. Fixes datrs#3

Cargo.toml

@@ -11,3 +11,7 @@ readme = "README.md"
 [dependencies]
 failure = "0.1.1"
 byteorder = "1.2.1"
+
+[dependencies.nom]
+version = "~3.2.1"
+features = ["verbose-errors"]

src/header.rs

@@ -2,6 +2,8 @@ extern crate byteorder;
 
 use self::byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use failure::Error;
+use nom::IResult;
+use parsers;
 use std::io::Cursor;
 
 /// Algorithm used for hashing the data.
@@ -42,14 +44,14 @@ pub enum FileType {
 }
 
 /// SLEEP Protocol version.
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum ProtocolVersion {
  /// The version specified as per the paper released in 2017-09.
  V0,
 }
 
 /// Structural representation of 32 byte SLEEP headers.
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub struct Header {
  /// Type of file.
  pub file_type: FileType,
@@ -76,6 +78,11 @@ impl Header {
  }
  }
 
+ /// Parses a 32 byte buffer slice into a valid Header.
+ pub fn from_bytes(buf: &[u8]) -> IResult<&[u8], Header> {
+ parsers::header(buf)
+ }
+
  /// Parse a 32 byte buffer slice into a valid Header.
  pub fn from_vec(buffer: &[u8]) -> Result<Header, Error> {
  ensure!(buffer.len() == 32, "buffer should be 32 bytes");

src/lib.rs

@@ -5,8 +5,11 @@
 
 #[macro_use]
 extern crate failure;
+#[macro_use]
+extern crate nom;
 
 mod header;
+mod parsers;
 
 pub use header::*;
 

src/parsers.rs

@@ -0,0 +1,131 @@
+use header::*;
+use nom::{be_u16, be_u8, rest};
+use std::str;
+
+const HEADER_LENGTH: usize = 32;
+const VERIFY_TRAILING_ZEROS: bool = true;
+
+named!(
+ file_type<FileType>,
+ switch!(be_u8,
+ 0 => value!(FileType::BitField) |
+ 1 => value!(FileType::Signatures) |
+ 2 => value!(FileType::Tree)
+ )
+);
+
+named!(
+ protocol_version<ProtocolVersion>,
+ switch!(be_u8,
+ 0 => value!(ProtocolVersion::V0)
+ )
+);
+
+named!(
+ pub header<Header>,
+ flat_map!(
+ take!(HEADER_LENGTH),
+ do_parse!(
+ tag!(b"\x05\x02\x57") >>
+ file_type: file_type >>
+ protocol_version: protocol_version >>
+ entry_size: be_u16 >>
+
+ algorithm_len: be_u8 >>
+ algorithm: switch!(map_res!(take!(algorithm_len), str::from_utf8),
+ "BLAKE2b" => value!(HashType::BLAKE2b) |
+ "Ed25519" => value!(HashType::Ed25519) |
+ "" => value!(HashType::None)
+ ) >>
+
+ verify!(rest, |bytes: &[u8]| {
+ let header_consumed = bytes.len() + algorithm_len as usize + 8 == HEADER_LENGTH;
+ let trailing_zeros = !VERIFY_TRAILING_ZEROS || bytes.iter().all(|&b| b == 0u8);
+ header_consumed && trailing_zeros
+ }) >>
+
+ (Header {
+ file_type,
+ protocol_version,
+ entry_size,
+ hash_type: algorithm,
+ })
+ )
+ )
+);
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ use nom::IResult::Done;
+
+ #[test]
+ fn parse_file_type() {
+ assert_eq!(
+ file_type(b"\x00"),
+ Done(&[][..], FileType::BitField)
+ );
+ assert_eq!(
+ file_type(b"\x01"),
+ Done(&[][..], FileType::Signatures)
+ );
+ assert_eq!(
+ file_type(b"\x02"),
+ Done(&[][..], FileType::Tree)
+ );
+ assert!(file_type(b"\xff").is_err());
+ }
+
+ #[test]
+ fn parse_header() {
+ fn mk_header(prefix: &[u8]) -> [u8; 32] {
+ let mut h = [0u8; 32];
+ h[0..prefix.len()].clone_from_slice(prefix);
+ h
+ }
+
+ assert_eq!(
+ header(&mk_header(
+ b"\x05\x02W\x01\x00\x00\x28\x07BLAKE2b"
+ )),
+ Done(
+ &[][..],
+ Header {
+ file_type: FileType::Signatures,
+ protocol_version: ProtocolVersion::V0,
+ entry_size: 40,
+ hash_type: HashType::BLAKE2b
+ }
+ )
+ );
+ assert_eq!(
+ header(&mk_header(
+ b"\x05\x02W\x01\x00\x00\x28\x07BLAKE2b"
+ )).unwrap()
+ .1
+ .hash_type,
+ HashType::BLAKE2b
+ );
+ assert_eq!(
+ header(&mk_header(
+ b"\x05\x02W\x01\x00\x00\x28\x07Ed25519"
+ )).unwrap()
+ .1
+ .hash_type,
+ HashType::Ed25519
+ );
+ assert_eq!(
+ header(&mk_header(b"\x05\x02W\x01\x00\x00\x28\x00"))
+ .unwrap()
+ .1
+ .hash_type,
+ HashType::None
+ );
+ assert!(header(&mk_header(b"\x05\x02W\x01\x00\x00\x28\x01B")).is_err());
+ assert!(header(&mk_header(b"\x05\x02W\x01\x00\x00\x28\x01B")).is_err());
+
+ let h = b"\x05\x02W\x01\x00\x00\x28\x19BLAKE2bXXXXXXXXXXXXXXXXXX";
+ assert!(header(h).is_incomplete());
+ }
+}

tests/invalid.rs

@@ -0,0 +1,14 @@
+extern crate sleep_parser;
+
+use sleep_parser::*;
+
+#[test]
+fn issue_3() {
+ // https://github.com/datrs/sleep-parser/issues/3
+
+ let data = b"\x05\x02W\x01\x00\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xfb\x03p\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xb0\xbb9\xb0\xf5\xf5";
+ assert!(Header::from_bytes(data).is_incomplete());
+
+ let data = b"\x05\x02W\x01\x00\x00\x00\x12\x12\x12\x00\x00S\xc3\xcf\x8a2\xcc\xd1\xce9\xc4K\x9343\x00602\xb5\x07";
+ assert!(Header::from_bytes(data).is_err());
+}