8 files changed, 50 insertions, 22 deletions

diff --git a/src/error.rs b/src/error.rs
index 97a4e62..518b0e9 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -17,6 +17,15 @@ impl<E: Error> From<io::Error> for ArchiveError<E> {
     }
 }
 
+impl<E: Error + PartialEq> PartialEq<E> for ArchiveError<E> {
+    fn eq(&self, other: &E) -> bool {
+        match self {
+            Self::Archivator { error, .. } => error == other,
+            _ => false,
+        }
+    }
+}
+
 impl<E: Error> Display for ArchiveError<E> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
diff --git a/src/utils/read.rs b/src/utils/read.rs
index 185758a..491c89c 100644
--- a/src/utils/read.rs
+++ b/src/utils/read.rs
@@ -10,14 +10,14 @@ impl<R: Read> ReadUtils for R {
     #[inline]
     fn read_arr<const S: usize>(&mut self) -> Result<[u8; S], std::io::Error> {
         let mut arr = [0; S];
-        self.read(&mut arr)?;
+        self.read_exact(&mut arr)?;
         Ok(arr)
     }
 
     #[inline]
     fn read_vec(&mut self, size: usize) -> Result<Vec<u8>, std::io::Error> {
         let mut vec = vec![0; size];
-        self.read(&mut vec)?;
+        self.read_exact(&mut vec)?;
         Ok(vec)
     }
 }
diff --git a/src/zip/driver.rs b/src/zip/driver.rs
index 62da39f..631c4ed 100644
--- a/src/zip/driver.rs
+++ b/src/zip/driver.rs
@@ -68,23 +68,23 @@ impl<Io: Read + Seek> ArchiveRead for Zip<Io> {
         let limit = 65557.min(io.seek(SeekFrom::End(0))?) as i64;
         let start = io.seek(SeekFrom::End(-limit))?;
         let pos = start
-            + io.read_vec(limit as usize - 18)?
-                .windows(4)
-                .rposition(|v| u32::from_le_bytes(v.try_into().unwrap()) == 0x06054b50)
-                .ok_or(ZipError::EOCDRNotFound)? as u64;
+            + io.read_vec(
+                (limit as usize)
+                    .checked_sub(18)
+                    .ok_or(ZipError::EocdrNotFound)?,
+            )?
+            .windows(4)
+            .rposition(|v| u32::from_le_bytes(v.try_into().unwrap()) == 0x06054b50)
+            .ok_or(ZipError::EocdrNotFound)? as u64;
 
         // Read eocdr
         io.seek(SeekFrom::Start(pos + 4))?;
         let buf = io.read_arr::<18>()?;
         let eocdr: Eocdr = deserialize(&buf).unwrap();
-        let comment = {
-            let mut buf: Vec<u8> = vec![0; eocdr.comment_len as usize];
-            io.read(&mut buf)?;
-            String::from_cp437(buf)
-        };
+        let comment = String::from_cp437(io.read_vec(eocdr.comment_len as usize)?);
 
         // Try to find eocdr64locator
-        io.seek(SeekFrom::Start(pos - 20))?;
+        io.seek(SeekFrom::Start(pos.saturating_sub(20)))?;
         let buf = io.read_arr::<20>()?;
         let (cd_pointer, cd_size, cd_records) =
             // If locator found then read eocdr64
diff --git a/src/zip/encryption.rs b/src/zip/encryption.rs
index 28a6bdb..76824a1 100644
--- a/src/zip/encryption.rs
+++ b/src/zip/encryption.rs
@@ -72,7 +72,7 @@ impl<Io: Read> WeakDecoder<Io> {
 
     fn decode_byte(&mut self, byte: u8) -> u8 {
         let key = self.key2 | 2;
-        let byte = byte ^ ((key * (key ^ 1)) >> 8) as u8;
+        let byte = byte ^ ((key.wrapping_mul(key ^ 1)) >> 8) as u8;
         self.update_keys(byte);
         byte
     }
diff --git a/src/zip/error.rs b/src/zip/error.rs
index a4b8c2b..525a67b 100644
--- a/src/zip/error.rs
+++ b/src/zip/error.rs
@@ -4,9 +4,9 @@ use std::fmt::Display;
 
 pub type ZipResult<T> = ArchiveResult<T, ZipError>;
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum ZipError {
-    EOCDRNotFound,
+    EocdrNotFound,
     InvalidEOCDR64Signature,
     InvalidFileHeaderSignature,
     InvalidCDRSignature,
@@ -38,7 +38,7 @@ impl From<ZipError> for ArchiveError<ZipError> {
 impl Display for ZipError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::EOCDRNotFound => write!(f, "End of central directory record not found"),
+            Self::EocdrNotFound => write!(f, "End of central directory record not found"),
             Self::InvalidEOCDR64Signature => {
                 write!(
                     f,
diff --git a/tests/files/blank b/tests/files/blank
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/files/blank
diff --git a/tests/files/empty.zip b/tests/files/empty.zip
new file mode 100644
index 0000000..15cb0ec
--- /dev/null
+++ b/tests/files/empty.zip
diff --git a/tests/zip.rs b/tests/zip.rs
index d02e96e..2c8fc56 100644
--- a/tests/zip.rs
+++ b/tests/zip.rs
@@ -1,3 +1,4 @@
+use archivator::zip::ZipError;
 use archivator::{Archive, Zip};
 use std::io::{Read, Seek, SeekFrom};
 
@@ -15,10 +16,12 @@ fn test_zip_passwd() {
         vec!["store", "deflate", "bzip"]
     );
 
-    assert!(archive.get_file_reader_by_name("store").is_err());
+    assert!(archive
+        .get_file_reader_by_name("store")
+        .is_err_and(|e| e == ZipError::PasswordIsNotSpecified));
     assert!(archive
         .get_file_reader_by_name_with_password("store", b"wrong_passwd")
-        .is_err());
+        .is_err_and(|e| e == ZipError::IncorrectPassword));
 
     for (name, check_data) in [
         ("store", "1e643774f40510e37c6f3c451d9d"),
@@ -62,22 +65,25 @@ fn test_zip() {
 
     assert_eq!(f.seek(SeekFrom::Start(0)).unwrap(), 0);
     let mut data = vec![0; 4];
-    f.read(&mut data).unwrap();
+    f.read_exact(&mut data).unwrap();
     assert_eq!(String::from_utf8(data).unwrap(), "test");
 
     assert_eq!(f.seek(SeekFrom::Current(1)).unwrap(), 5);
     let mut data = vec![0; 4];
-    f.read(&mut data).unwrap();
+    f.read_exact(&mut data).unwrap();
     assert_eq!(String::from_utf8(data).unwrap(), "file");
 
     assert_eq!(f.seek(SeekFrom::End(-4)).unwrap(), 10);
     let mut data = vec![0; 4];
-    f.read(&mut data).unwrap();
+    f.read_exact(&mut data).unwrap();
     assert_eq!(String::from_utf8(data).unwrap(), "data");
 
     f.seek(SeekFrom::Start(7)).unwrap();
     assert_eq!(f.seek(SeekFrom::Current(0)).unwrap(), 7);
-    assert!(f.seek(SeekFrom::End(-100)).is_err());
+    assert!(f
+        .seek(SeekFrom::End(-100))
+        .is_err_and(|e| e.get_ref().unwrap().to_string()
+            == "Invalid seek to a negative or overflowing position"));
     assert_eq!(f.seek(SeekFrom::Current(0)).unwrap(), 7);
 
     assert_eq!(f.seek(SeekFrom::Start(100)).unwrap(), 14);
@@ -90,3 +96,16 @@ fn test_zip() {
         assert!(!f.is_seekable() || f.info().name == "store")
     }
 }
+
+#[test]
+fn test_bad_zip() {
+    assert!(Archive::<Zip>::read_from_file("tests/files/blank")
+        .is_err_and(|e| e == ZipError::EocdrNotFound));
+
+    assert_eq!(
+        Archive::<Zip>::read_from_file("tests/files/empty.zip")
+            .unwrap()
+            .len(),
+        0
+    );
+}