feat: Implement by_path*() methods on ZipArchive (#382)

* Implement by_path*() methods.

* Refactor by_path tests.

* fix: test requires aes-crypto

* fix: Move `use zip::AesMode` and declaration of `PASSWORD` into the test that uses them, since they're not used when the `aes-crypto` feature isn't enabled

---------

Co-authored-by: Chris Hennick <[email protected]>
Co-authored-by: hennickc <[email protected]>

Author: neumann-paulmann

src/read.rs

@@ -1021,6 +1021,36 @@ impl<R: Read + Seek> ZipArchive<R> {
         self.shared.files.get_index_of(name)
     }
 
+    /// Search for a file entry by path, decrypt with given password
+    ///
+    /// # Warning
+    ///
+    /// The implementation of the cryptographic algorithms has not
+    /// gone through a correctness review, and you should assume it is insecure:
+    /// passwords used with this API may be compromised.
+    ///
+    /// This function sometimes accepts wrong password. This is because the ZIP spec only allows us
+    /// to check for a 1/256 chance that the password is correct.
+    /// There are many passwords out there that will also pass the validity checks
+    /// we are able to perform. This is a weakness of the ZipCrypto algorithm,
+    /// due to its fairly primitive approach to cryptography.
+    pub fn by_path_decrypt<T: AsRef<Path>>(
+        &mut self,
+        path: T,
+        password: &[u8],
+    ) -> ZipResult<ZipFile<'_, R>> {
+        self.index_for_path(path)
+            .ok_or(ZipError::FileNotFound)
+            .and_then(|index| self.by_index_with_optional_password(index, Some(password)))
+    }
+
+    /// Search for a file entry by path
+    pub fn by_path<T: AsRef<Path>>(&mut self, path: T) -> ZipResult<ZipFile<'_, R>> {
+        self.index_for_path(path)
+            .ok_or(ZipError::FileNotFound)
+            .and_then(|index| self.by_index_with_optional_password(index, None))
+    }
+
     /// Get the index of a file entry by path, if it's present.
     #[inline(always)]
     pub fn index_for_path<T: AsRef<Path>>(&self, path: T) -> Option<usize> {

tests/by_path.rs

@@ -0,0 +1,54 @@
+use std::io::{Cursor, Read, Write};
+use std::path::Path;
+use zip::read::ZipFile;
+use zip::write::SimpleFileOptions;
+use zip::{ZipArchive, ZipWriter};
+
+const DIRECTORY_NAME: &str = "test_directory";
+const FILE_NAME: &str = "hello_world.txt";
+const LOREM_IPSUM: &[u8] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+
+#[test]
+fn by_path() {
+    let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
+    let mut archive = create_archive(options);
+    let path = Path::new(DIRECTORY_NAME).join(FILE_NAME);
+    let file = archive.by_path(path).unwrap();
+    validate_file(file);
+}
+
+#[test]
+#[cfg(feature = "aes-crypto")]
+fn by_path_decrypt() {
+    use zip::AesMode;
+
+    const PASSWORD: &str = "helloworld";
+
+    let options = SimpleFileOptions::default()
+        .compression_method(zip::CompressionMethod::Stored)
+        .with_aes_encryption(AesMode::Aes128, PASSWORD);
+    let mut archive = create_archive(options);
+    let path = Path::new(DIRECTORY_NAME).join(FILE_NAME);
+    let file = archive.by_path_decrypt(path, PASSWORD.as_bytes()).unwrap();
+    validate_file(file);
+}
+
+fn create_archive(options: SimpleFileOptions) -> ZipArchive<Cursor<Vec<u8>>> {
+    let mut buf = Vec::new();
+    let mut zip = ZipWriter::new(Cursor::new(&mut buf));
+    zip.add_directory(DIRECTORY_NAME, options).unwrap();
+    zip.start_file(format!("{DIRECTORY_NAME}/{FILE_NAME}"), options)
+        .unwrap();
+    zip.write_all(LOREM_IPSUM).unwrap();
+    zip.finish().unwrap();
+    ZipArchive::new(Cursor::new(buf)).unwrap()
+}
+
+fn validate_file<T>(mut file: ZipFile<T>)
+where
+    T: Read,
+{
+    let mut file_buf = Vec::new();
+    file.read_to_end(&mut file_buf).unwrap();
+    assert_eq!(LOREM_IPSUM, file_buf);
+}