Update to Rust 2021 edition

[hashgood] / src / verify.rs

diff --git a/src/verify.rs b/src/verify.rs
index 3d92964c8a2182ba7402b1129bc337e717ad0f04..25e565f7abebfdf2540d9de42e83f26b80d7d06d 100644 (file)
--- a/src/verify.rs
+++ b/src/verify.rs
@@ -8,7 +8,7 @@ use std::fs::File;
 use std::io;
 use std::io::prelude::*;
 use std::io::BufReader;
 use std::io;
 use std::io::prelude::*;
 use std::io::BufReader;

-use std::path::PathBuf;
+use std::path::Path;

 
 /// Calculate a list of candidate hashes based on the options specified.
 /// If no hash options have been specified returns None.
 
 /// Calculate a list of candidate hashes based on the options specified.
 /// If no hash options have been specified returns None.


@@ -74,7 +74,7 @@ fn get_from_clipboard() -> Result<CandidateHashes, String> {
 }
 
 /// Generate a candidate hash from the digests file specified (could be "-" for STDIN), or throw an error.
 }
 
 /// Generate a candidate hash from the digests file specified (could be "-" for STDIN), or throw an error.

-fn get_from_file(path: &PathBuf) -> Result<CandidateHashes, String> {
+fn get_from_file(path: &Path) -> Result<CandidateHashes, String> {

     // Get a reader for either standard input or the chosen path
     let reader: Box<dyn Read> = if path.to_str() == Some("-") {
         Box::new(std::io::stdin())
     // Get a reader for either standard input or the chosen path
     let reader: Box<dyn Read> = if path.to_str() == Some("-") {
         Box::new(std::io::stdin())


@@ -129,11 +129,11 @@ fn try_parse_hash(s: &str) -> Option<(Algorithm, Vec<u8>)> {
     Some((alg, bytes))
 }
 
     Some((alg, bytes))
 }
 

-fn read_raw_candidate_from_file(line: &str, path: &PathBuf) -> Option<CandidateHashes> {
+fn read_raw_candidate_from_file(line: &str, path: &Path) -> Option<CandidateHashes> {

     let (alg, bytes) = try_parse_hash(line)?;
     Some(CandidateHashes {
         alg,
     let (alg, bytes) = try_parse_hash(line)?;
     Some(CandidateHashes {
         alg,

-        source: VerificationSource::RawFile(path.clone()),
+        source: VerificationSource::RawFile(path.to_string_lossy().to_string()),

         hashes: vec![CandidateHash {
             bytes,
             filename: None,
         hashes: vec![CandidateHash {
             bytes,
             filename: None,


@@ -141,7 +141,7 @@ fn read_raw_candidate_from_file(line: &str, path: &PathBuf) -> Option<CandidateH
     })
 }
 
     })
 }
 

-fn read_coreutils_digests_from_file<I, S>(lines: I, path: &PathBuf) -> Option<CandidateHashes>
+fn read_coreutils_digests_from_file<I, S>(lines: I, path: &Path) -> Option<CandidateHashes>

 where
     I: Iterator<Item = io::Result<S>>,
     S: AsRef<str>,
 where
     I: Iterator<Item = io::Result<S>>,
     S: AsRef<str>,


@@ -159,9 +159,20 @@ where
             // <valid-hash><space><space-or-*><filename>
             let (line_alg, bytes, filename) = match l
                 .find(' ')
             // <valid-hash><space><space-or-*><filename>
             let (line_alg, bytes, filename) = match l
                 .find(' ')

-                .and_then(|space_pos| (l.get(0..space_pos)).zip(l.get(space_pos + 2..)))
+                .and_then(|space_pos| {
+                    // Char before filename should be space for text or * for binary
+                    match l.chars().nth(space_pos + 1) {
+                        Some(' ') | Some('*') => (l.get(..space_pos)).zip(l.get(space_pos + 2..)),
+                        _ => None,
+                    }
+                })

                 .and_then(|(maybe_hash, filename)| {
                 .and_then(|(maybe_hash, filename)| {

-                    try_parse_hash(maybe_hash).map(|(alg, bytes)| (alg, bytes, filename))
+                    // Filename should be in this position without extra whitespace
+                    if filename.trim() == filename {
+                        try_parse_hash(maybe_hash).map(|(alg, bytes)| (alg, bytes, filename))
+                    } else {
+                        None
+                    }

                 }) {
                 Some(t) => t,
                 None => {
                 }) {
                 Some(t) => t,
                 None => {


@@ -196,7 +207,7 @@ where
     // Otherwise all is well and we can return our results
     Some(CandidateHashes {
         alg,
     // Otherwise all is well and we can return our results
     Some(CandidateHashes {
         alg,

-        source: VerificationSource::DigestsFile(path.clone()),
+        source: VerificationSource::DigestsFile(path.to_string_lossy().to_string()),

         hashes,
     })
 }
         hashes,
     })
 }


@@ -273,13 +284,11 @@ pub fn verify_hash<'a>(calculated: &Hash, candidates: &'a CandidateHashes) -> Ve
 
 #[cfg(test)]
 mod tests {
 
 #[cfg(test)]
 mod tests {

-    use std::path::Path;
-

     use super::*;
 
     #[test]
     fn test_read_raw_inputs() {
     use super::*;
 
     #[test]
     fn test_read_raw_inputs() {

-        let example_path: PathBuf = "some_file".into();
+        let example_path = Path::new("some_file");

         let valid_md5 = "d229da563da18fe5d58cd95a6467d584";
         let valid_sha1 = "b314c7ebb7d599944981908b7f3ed33a30e78f3a";
         let valid_sha1_2 = valid_sha1.to_uppercase();
         let valid_md5 = "d229da563da18fe5d58cd95a6467d584";
         let valid_sha1 = "b314c7ebb7d599944981908b7f3ed33a30e78f3a";
         let valid_sha1_2 = valid_sha1.to_uppercase();


@@ -332,7 +341,7 @@ mod tests {
 
         fe6c26d485a3573a1cb0ad0682f5105325a1905f  shasums";
         let lines = shasums.lines().map(|l| std::io::Result::Ok(l));
 
         fe6c26d485a3573a1cb0ad0682f5105325a1905f  shasums";
         let lines = shasums.lines().map(|l| std::io::Result::Ok(l));

-        let path = Path::new("SHASUMS").to_owned();
+        let path = Path::new("SHASUMS");

         let candidates = read_coreutils_digests_from_file(lines, &path);
 
         assert_eq!(
         let candidates = read_coreutils_digests_from_file(lines, &path);
 
         assert_eq!(


@@ -353,8 +362,24 @@ mod tests {
                         filename: Some("shasums".to_owned()),
                     }
                 ],
                         filename: Some("shasums".to_owned()),
                     }
                 ],

-                source: VerificationSource::DigestsFile(path),
+                source: VerificationSource::DigestsFile(path.to_string_lossy().to_string()),

             })
         );
     }
             })
         );
     }

+
+    #[test]
+    fn test_invalid_shasums() {
+        let no_format = "4b91f7a387a6edd4a7c0afb2897f1ca968c9695b cp";
+        let invalid_format = "4b91f7a387a6edd4a7c0afb2897f1ca968c9695b .cp";
+        let extra_space = "4b91f7a387a6edd4a7c0afb2897f1ca968c9695b   cp";
+
+        for digest in [no_format, invalid_format, extra_space] {
+            let lines = digest.lines().map(|l| std::io::Result::Ok(l));
+            assert!(
+                read_coreutils_digests_from_file(lines, Path::new("SHASUMS")).is_none(),
+                "Should be invalid digest: {:?}",
+                digest
+            );
+        }
+    }

 }
 }