Merge branch 'master' into support-extra-field

README.md

@@ -1,8 +1,7 @@
 zip-rs
 ======
 
-[![Build Status](https://travis-ci.org/mvdnes/zip-rs.svg?branch=master)](https://travis-ci.org/mvdnes/zip-rs)
+[![Build Status](https://img.shields.io/github/workflow/status/zip-rs/zip/CI)](https://github.com/zip-rs/zip/actions?query=branch%3Amaster+workflow%3ACI)
-[![Build status](https://ci.appveyor.com/api/projects/status/gsnpqcodg19iu253/branch/master?svg=true)](https://ci.appveyor.com/project/mvdnes/zip-rs/branch/master)
 [![Crates.io version](https://img.shields.io/crates/v/zip.svg)](https://crates.io/crates/zip)
 
 [Documentation](http://mvdnes.github.io/rust-docs/zip-rs/zip/index.html)
@@ -65,7 +64,7 @@ Examples
 
 See the [examples directory](examples) for:
    * How to write a file to a zip.
-   * how to write a directory of files to a zip (using [walkdir](https://github.com/BurntSushi/walkdir)).
+   * How to write a directory of files to a zip (using [walkdir](https://github.com/BurntSushi/walkdir)).
    * How to extract a zip file.
    * How to extract a single file from a zip.
    * How to read a zip from the standard input.

examples/extract.rs

@@ -18,8 +18,10 @@ fn real_main() -> i32 {
 
     for i in 0..archive.len() {
         let mut file = archive.by_index(i).unwrap();
-        #[allow(deprecated)]
+        let outpath = match file.enclosed_name() {
-        let outpath = file.sanitized_name();
+            Some(path) => path.to_owned(),
+            None => continue,
+        };
 
         {
             let comment = file.comment();
@@ -29,17 +31,13 @@ fn real_main() -> i32 {
         }
 
         if (&*file.name()).ends_with('/') {
-            println!(
+            println!("File {} extracted to \"{}\"", i, outpath.display());
-                "File {} extracted to \"{}\"",
-                i,
-                outpath.as_path().display()
-            );
             fs::create_dir_all(&outpath).unwrap();
         } else {
             println!(
                 "File {} extracted to \"{}\" ({} bytes)",
                 i,
-                outpath.as_path().display(),
+                outpath.display(),
                 file.size()
             );
             if let Some(p) = outpath.parent() {

examples/file_info.rs

@@ -19,8 +19,13 @@ fn real_main() -> i32 {
 
     for i in 0..archive.len() {
         let file = archive.by_index(i).unwrap();
-        #[allow(deprecated)]
+        let outpath = match file.enclosed_name() {
-        let outpath = file.sanitized_name();
+            Some(path) => path,
+            None => {
+                println!("Entry {} has a suspicious path", file.name());
+                continue;
+            }
+        };
 
         {
             let comment = file.comment();
@@ -33,13 +38,13 @@ fn real_main() -> i32 {
             println!(
                 "Entry {} is a directory with name \"{}\"",
                 i,
-                outpath.as_path().display()
+                outpath.display()
             );
         } else {
             println!(
                 "Entry {} is a file with name \"{}\" ({} bytes)",
                 i,
-                outpath.as_path().display(),
+                outpath.display(),
                 file.size()
             );
         }

src/compression.rs

@@ -10,7 +10,7 @@ use std::fmt;
 ///
 /// When creating ZIP files, you may choose the method to use with
 /// [`zip::write::FileOptions::compression_method`]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum CompressionMethod {
     /// Store the file as is
     Stored,
@@ -25,18 +25,53 @@ pub enum CompressionMethod {
     #[cfg(feature = "bzip2")]
     Bzip2,
     /// Unsupported compression method
-    #[deprecated(
+    #[deprecated(since = "0.5.7", note = "use the constants instead")]
-        since = "0.5.7",
-        note = "implementation details are being removed from the public API"
-    )]
     Unsupported(u16),
 }
-
+#[allow(deprecated, missing_docs)]
+/// All compression methods defined for the ZIP format
+impl CompressionMethod {
+    pub const STORE: Self = CompressionMethod::Stored;
+    pub const SHRINK: Self = CompressionMethod::Unsupported(1);
+    pub const REDUCE_1: Self = CompressionMethod::Unsupported(2);
+    pub const REDUCE_2: Self = CompressionMethod::Unsupported(3);
+    pub const REDUCE_3: Self = CompressionMethod::Unsupported(4);
+    pub const REDUCE_4: Self = CompressionMethod::Unsupported(5);
+    pub const IMPLODE: Self = CompressionMethod::Unsupported(6);
+    #[cfg(any(
+        feature = "deflate",
+        feature = "deflate-miniz",
+        feature = "deflate-zlib"
+    ))]
+    pub const DEFLATE: Self = CompressionMethod::Deflated;
+    #[cfg(not(any(
+        feature = "deflate",
+        feature = "deflate-miniz",
+        feature = "deflate-zlib"
+    )))]
+    pub const DEFLATE: Self = CompressionMethod::Unsupported(8);
+    pub const DEFLATE64: Self = CompressionMethod::Unsupported(9);
+    pub const PKWARE_IMPLODE: Self = CompressionMethod::Unsupported(10);
+    #[cfg(feature = "bzip2")]
+    pub const BZIP2: Self = CompressionMethod::Bzip2;
+    #[cfg(not(feature = "bzip2"))]
+    pub const BZIP2: Self = CompressionMethod::Unsupported(12);
+    pub const LZMA: Self = CompressionMethod::Unsupported(14);
+    pub const IBM_ZOS_CMPSC: Self = CompressionMethod::Unsupported(16);
+    pub const IBM_TERSE: Self = CompressionMethod::Unsupported(18);
+    pub const ZSTD_DEPRECATED: Self = CompressionMethod::Unsupported(20);
+    pub const ZSTD: Self = CompressionMethod::Unsupported(93);
+    pub const MP3: Self = CompressionMethod::Unsupported(94);
+    pub const XZ: Self = CompressionMethod::Unsupported(95);
+    pub const JPEG: Self = CompressionMethod::Unsupported(96);
+    pub const WAVPACK: Self = CompressionMethod::Unsupported(97);
+    pub const PPMD: Self = CompressionMethod::Unsupported(98);
+}
 impl CompressionMethod {
     /// Converts an u16 to its corresponding CompressionMethod
     #[deprecated(
         since = "0.5.7",
-        note = "implementation details are being removed from the public API"
+        note = "use a constant to construct a compression method"
     )]
     pub fn from_u16(val: u16) -> CompressionMethod {
         #[allow(deprecated)]
@@ -58,7 +93,7 @@ impl CompressionMethod {
     /// Converts a CompressionMethod to a u16
     #[deprecated(
         since = "0.5.7",
-        note = "implementation details are being removed from the public API"
+        note = "to match on other compression methods, use a constant"
     )]
     pub fn to_u16(self) -> u16 {
         #[allow(deprecated)]

src/read.rs

@@ -9,6 +9,7 @@ use crate::zipcrypto::ZipCryptoReaderValid;
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::io::{self, prelude::*};
+use std::path::{Component, Path};
 
 use crate::cp437::FromCp437;
 use crate::types::{DateTime, System, ZipFileData};
@@ -80,6 +81,7 @@ impl<'a> CryptoReader<'a> {
 
 enum ZipFileReader<'a> {
     NoReader,
+    Raw(io::Take<&'a mut dyn io::Read>),
     Stored(Crc32Reader<CryptoReader<'a>>),
     #[cfg(any(
         feature = "deflate",
@@ -95,6 +97,7 @@ impl<'a> Read for ZipFileReader<'a> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         match self {
             ZipFileReader::NoReader => panic!("ZipFileReader was in an invalid state"),
+            ZipFileReader::Raw(r) => r.read(buf),
             ZipFileReader::Stored(r) => r.read(buf),
             #[cfg(any(
                 feature = "deflate",
@@ -113,6 +116,7 @@ impl<'a> ZipFileReader<'a> {
     pub fn into_inner(self) -> io::Take<&'a mut dyn Read> {
         match self {
             ZipFileReader::NoReader => panic!("ZipFileReader was in an invalid state"),
+            ZipFileReader::Raw(r) => r,
             ZipFileReader::Stored(r) => r.into_inner().into_inner(),
             #[cfg(any(
                 feature = "deflate",
@@ -129,15 +133,23 @@ impl<'a> ZipFileReader<'a> {
 /// A struct for reading a zip file
 pub struct ZipFile<'a> {
     data: Cow<'a, ZipFileData>,
+    crypto_reader: Option<CryptoReader<'a>>,
     reader: ZipFileReader<'a>,
 }
 
-fn make_reader<'a>(
+fn make_crypto_reader<'a>(
     compression_method: crate::compression::CompressionMethod,
     crc32: u32,
     reader: io::Take<&'a mut dyn io::Read>,
     password: Option<&[u8]>,
-) -> ZipResult<Result<ZipFileReader<'a>, InvalidPassword>> {
+) -> ZipResult<Result<CryptoReader<'a>, InvalidPassword>> {
+    #[allow(deprecated)]
+    {
+        if let CompressionMethod::Unsupported(_) = compression_method {
+            return unsupported_zip_error("Compression method not supported");
+        }
+    }
+
     let reader = match password {
         None => CryptoReader::Plaintext(reader),
         Some(password) => match ZipCryptoReader::new(reader, password).validate(crc32)? {
@@ -145,9 +157,16 @@ fn make_reader<'a>(
             Some(r) => CryptoReader::ZipCrypto(r),
         },
     };
+    Ok(Ok(reader))
+}
 
+fn make_reader<'a>(
+    compression_method: CompressionMethod,
+    crc32: u32,
+    reader: CryptoReader<'a>,
+) -> ZipFileReader<'a> {
     match compression_method {
-        CompressionMethod::Stored => Ok(Ok(ZipFileReader::Stored(Crc32Reader::new(reader, crc32)))),
+        CompressionMethod::Stored => ZipFileReader::Stored(Crc32Reader::new(reader, crc32)),
         #[cfg(any(
             feature = "deflate",
             feature = "deflate-miniz",
@@ -155,20 +174,14 @@ fn make_reader<'a>(
         ))]
         CompressionMethod::Deflated => {
             let deflate_reader = DeflateDecoder::new(reader);
-            Ok(Ok(ZipFileReader::Deflated(Crc32Reader::new(
+            ZipFileReader::Deflated(Crc32Reader::new(deflate_reader, crc32))
-                deflate_reader,
-                crc32,
-            ))))
         }
         #[cfg(feature = "bzip2")]
         CompressionMethod::Bzip2 => {
             let bzip2_reader = BzDecoder::new(reader);
-            Ok(Ok(ZipFileReader::Bzip2(Crc32Reader::new(
+            ZipFileReader::Bzip2(Crc32Reader::new(bzip2_reader, crc32))
-                bzip2_reader,
-                crc32,
-            ))))
         }
-        _ => unsupported_zip_error("Compression method not supported"),
+        _ => panic!("Compression method not supported"),
     }
 }
 
@@ -310,6 +323,44 @@ impl<R: Read + io::Seek> ZipArchive<R> {
             comment: footer.zip_file_comment,
         })
     }
+    /// Extract a Zip archive into a directory, overwriting files if they
+    /// already exist. Paths are sanitized with [`ZipFile::enclosed_name`].
+    ///
+    /// Extraction is not atomic; If an error is encountered, some of the files
+    /// may be left on disk.
+    pub fn extract<P: AsRef<Path>>(&mut self, directory: P) -> ZipResult<()> {
+        use std::fs;
+
+        for i in 0..self.len() {
+            let mut file = self.by_index(i)?;
+            let filepath = file
+                .enclosed_name()
+                .ok_or(ZipError::InvalidArchive("Invalid file path"))?;
+
+            let outpath = directory.as_ref().join(filepath);
+
+            if file.name().ends_with('/') {
+                fs::create_dir_all(&outpath)?;
+            } else {
+                if let Some(p) = outpath.parent() {
+                    if !p.exists() {
+                        fs::create_dir_all(&p)?;
+                    }
+                }
+                let mut outfile = fs::File::create(&outpath)?;
+                io::copy(&mut file, &mut outfile)?;
+            }
+            // Get and Set permissions
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::PermissionsExt;
+                if let Some(mode) = file.unix_mode() {
+                    fs::set_permissions(&outpath, fs::Permissions::from_mode(mode))?;
+                }
+            }
+        }
+        Ok(())
+    }
 
     /// Number of files contained in this zip.
     pub fn len(&self) -> usize {
@@ -420,9 +471,10 @@ impl<R: Read + io::Seek> ZipArchive<R> {
         self.reader.seek(io::SeekFrom::Start(data.data_start))?;
         let limit_reader = (self.reader.by_ref() as &mut dyn Read).take(data.compressed_size);
 
-        match make_reader(data.compression_method, data.crc32, limit_reader, password) {
+        match make_crypto_reader(data.compression_method, data.crc32, limit_reader, password) {
-            Ok(Ok(reader)) => Ok(Ok(ZipFile {
+            Ok(Ok(crypto_reader)) => Ok(Ok(ZipFile {
-                reader,
+                crypto_reader: Some(crypto_reader),
+                reader: ZipFileReader::NoReader,
                 data: Cow::Borrowed(data),
             })),
             Err(e) => Err(e),
@@ -559,6 +611,23 @@ fn parse_extra_field(file: &mut ZipFileData) -> ZipResult<()> {
 
 /// Methods for retrieving information on zip files
 impl<'a> ZipFile<'a> {
+    fn get_reader(&mut self) -> &mut ZipFileReader<'a> {
+        if let ZipFileReader::NoReader = self.reader {
+            let data = &self.data;
+            let crypto_reader = self.crypto_reader.take().expect("Invalid reader state");
+            self.reader = make_reader(data.compression_method, data.crc32, crypto_reader)
+        }
+        &mut self.reader
+    }
+
+    pub(crate) fn get_raw_reader(&mut self) -> &mut dyn Read {
+        if let ZipFileReader::NoReader = self.reader {
+            let crypto_reader = self.crypto_reader.take().expect("Invalid reader state");
+            self.reader = ZipFileReader::Raw(crypto_reader.into_inner())
+        }
+        &mut self.reader
+    }
+
     /// Get the version of the file
     pub fn version_made_by(&self) -> (u8, u8) {
         (
@@ -568,11 +637,24 @@ impl<'a> ZipFile<'a> {
     }
 
     /// Get the name of the file
+    ///
+    /// # Warnings
+    ///
+    /// It is dangerous to use this name directly when extracting an archive.
+    /// It may contain an absolute path (`/etc/shadow`), or break out of the
+    /// current directory (`../runtime`). Carelessly writing to these paths
+    /// allows an attacker to craft a ZIP archive that will overwrite critical
+    /// files.
+    ///
+    /// You can use the [`ZipFile::enclosed_name`] method to validate the name
+    /// as a safe path.
     pub fn name(&self) -> &str {
         &self.data.file_name
     }
 
     /// Get the name of the file, in the raw (internal) byte representation.
+    ///
+    /// The encoding of this data is currently undefined.
     pub fn name_raw(&self) -> &[u8] {
         &self.data.file_name_raw
     }
@@ -582,12 +664,55 @@ impl<'a> ZipFile<'a> {
     #[deprecated(
         since = "0.5.7",
         note = "by stripping `..`s from the path, the meaning of paths can change.
-                You must use a sanitization strategy that's appropriate for your input"
+                `mangled_name` can be used if this behaviour is desirable"
     )]
     pub fn sanitized_name(&self) -> ::std::path::PathBuf {
+        self.mangled_name()
+    }
+
+    /// Rewrite the path, ignoring any path components with special meaning.
+    ///
+    /// - Absolute paths are made relative
+    /// - [`ParentDir`]s are ignored
+    /// - Truncates the filename at a NULL byte
+    ///
+    /// This is appropriate if you need to be able to extract *something* from
+    /// any archive, but will easily misrepresent trivial paths like
+    /// `foo/../bar` as `foo/bar` (instead of `bar`). Because of this,
+    /// [`ZipFile::enclosed_name`] is the better option in most scenarios.
+    ///
+    /// [`ParentDir`]: `Component::ParentDir`
+    pub fn mangled_name(&self) -> ::std::path::PathBuf {
         self.data.file_name_sanitized()
     }
 
+    /// Ensure the file path is safe to use as a [`Path`].
+    ///
+    /// - It can't contain NULL bytes
+    /// - It can't resolve to a path outside the current directory
+    ///   > `foo/../bar` is fine, `foo/../../bar` is not.
+    /// - It can't be an absolute path
+    ///
+    /// This will read well-formed ZIP files correctly, and is resistant
+    /// to path-based exploits. It is recommended over
+    /// [`ZipFile::mangled_name`].
+    pub fn enclosed_name(&self) -> Option<&Path> {
+        if self.data.file_name.contains('\0') {
+            return None;
+        }
+        let path = Path::new(&self.data.file_name);
+        let mut depth = 0usize;
+        for component in path.components() {
+            match component {
+                Component::Prefix(_) | Component::RootDir => return None,
+                Component::ParentDir => depth = depth.checked_sub(1)?,
+                Component::Normal(_) => depth += 1,
+                Component::CurDir => (),
+            }
+        }
+        Some(path)
+    }
+
     /// Get the comment of the file
     pub fn comment(&self) -> &str {
         &self.data.file_comment
@@ -678,7 +803,7 @@ impl<'a> ZipFile<'a> {
 
 impl<'a> Read for ZipFile<'a> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.reader.read(buf)
+        self.get_reader().read(buf)
     }
 }
 
@@ -690,8 +815,16 @@ impl<'a> Drop for ZipFile<'a> {
             let mut buffer = [0; 1 << 16];
 
             // Get the inner `Take` reader so all decryption, decompression and CRC calculation is skipped.
-            let innerreader = ::std::mem::replace(&mut self.reader, ZipFileReader::NoReader);
+            let mut reader: std::io::Take<&mut dyn std::io::Read> = match &mut self.reader {
-            let mut reader: std::io::Take<&mut dyn std::io::Read> = innerreader.into_inner();
+                ZipFileReader::NoReader => {
+                    let innerreader = ::std::mem::replace(&mut self.crypto_reader, None);
+                    innerreader.expect("Invalid reader state").into_inner()
+                }
+                reader => {
+                    let innerreader = ::std::mem::replace(reader, ZipFileReader::NoReader);
+                    innerreader.into_inner()
+                }
+            };
 
             loop {
                 match reader.read(&mut buffer) {
@@ -800,9 +933,13 @@ pub fn read_zipfile_from_stream<'a, R: io::Read>(
 
     let result_crc32 = result.crc32;
     let result_compression_method = result.compression_method;
+    let crypto_reader =
+        make_crypto_reader(result_compression_method, result_crc32, limit_reader, None)?.unwrap();
+
     Ok(Some(ZipFile {
         data: Cow::Owned(result),
-        reader: make_reader(result_compression_method, result_crc32, limit_reader, None)?.unwrap(),
+        crypto_reader: None,
+        reader: make_reader(result_compression_method, result_crc32, crypto_reader),
     }))
 }
 
@@ -921,8 +1058,7 @@ mod test {
 
         for i in 0..zip.len() {
             let zip_file = zip.by_index(i).unwrap();
-            #[allow(deprecated)]
+            let full_name = zip_file.enclosed_name().unwrap();
-            let full_name = zip_file.sanitized_name();
             let file_name = full_name.file_name().unwrap().to_str().unwrap();
             assert!(
                 (file_name.starts_with("dir") && zip_file.is_dir())

src/spec.rs

@@ -66,11 +66,8 @@ impl CentralDirectoryEnd {
                 reader.seek(io::SeekFrom::Current(
                     BYTES_BETWEEN_MAGIC_AND_COMMENT_SIZE as i64,
                 ))?;
-                let comment_length = reader.read_u16::<LittleEndian>()? as u64;
+                let cde_start_pos = reader.seek(io::SeekFrom::Start(pos as u64))?;
-                if file_length - pos - HEADER_SIZE == comment_length {
+                return CentralDirectoryEnd::parse(reader).map(|cde| (cde, cde_start_pos));
-                    let cde_start_pos = reader.seek(io::SeekFrom::Start(pos as u64))?;
-                    return CentralDirectoryEnd::parse(reader).map(|cde| (cde, cde_start_pos));
-                }
             }
             pos = match pos.checked_sub(1) {
                 Some(p) => p,

src/write.rs

@@ -1,6 +1,7 @@
 //! Types for creating ZIP archives
 
 use crate::compression::CompressionMethod;
+use crate::read::ZipFile;
 use crate::result::{ZipError, ZipResult};
 use crate::spec;
 use crate::types::{DateTime, System, ZipFileData, DEFAULT_VERSION};
@@ -69,6 +70,7 @@ pub struct ZipWriter<W: Write + io::Seek> {
     writing_to_file: bool,
     writing_to_extra_field: bool,
     writing_to_central_extra_field_only: bool,
+    writing_raw: bool,
     comment: String,
 }
 
@@ -79,6 +81,12 @@ struct ZipWriterStats {
     bytes_written: u64,
 }
 
+struct ZipRawValues {
+    crc32: u32,
+    compressed_size: u64,
+    uncompressed_size: u64,
+}
+
 /// Metadata for a file to be written
 #[derive(Copy, Clone)]
 pub struct FileOptions {
@@ -223,6 +231,7 @@ impl<W: Write + io::Seek> ZipWriter<W> {
             writing_to_file: false,
             writing_to_extra_field: false,
             writing_to_central_extra_field_only: false,
+            writing_raw: false,
             comment: String::new(),
         }
     }
@@ -236,30 +245,39 @@ impl<W: Write + io::Seek> ZipWriter<W> {
     }
 
     /// Start a new file for with the requested options.
-    fn start_entry<S>(&mut self, name: S, options: FileOptions) -> ZipResult<()>
+    fn start_entry<S>(
+        &mut self,
+        name: S,
+        options: FileOptions,
+        raw_values: Option<ZipRawValues>,
+    ) -> ZipResult<()>
     where
         S: Into<String>,
     {
         self.finish_file()?;
 
+        let raw_values = raw_values.unwrap_or_else(|| ZipRawValues {
+            crc32: 0,
+            compressed_size: 0,
+            uncompressed_size: 0,
+        });
+
         {
             let writer = self.inner.get_plain();
             let header_start = writer.seek(io::SeekFrom::Current(0))?;
 
             let permissions = options.permissions.unwrap_or(0o100644);
-            let file_name = name.into();
-            let file_name_raw = file_name.clone().into_bytes();
             let mut file = ZipFileData {
                 system: System::Unix,
                 version_made_by: DEFAULT_VERSION,
                 encrypted: false,
                 compression_method: options.compression_method,
                 last_modified_time: options.last_modified_time,
-                crc32: 0,
+                crc32: raw_values.crc32,
-                compressed_size: 0,
+                compressed_size: raw_values.compressed_size,
-                uncompressed_size: 0,
+                uncompressed_size: raw_values.uncompressed_size,
-                file_name,
+                file_name: name.into(),
-                file_name_raw,
+                file_name_raw: Vec::new(), // Never used for saving
                 extra_field: Vec::new(),
                 file_comment: String::new(),
                 header_start,
@@ -285,26 +303,29 @@ impl<W: Write + io::Seek> ZipWriter<W> {
 
     fn finish_file(&mut self) -> ZipResult<()> {
         if self.writing_to_extra_field {
-            // Implicitly calling `end_extra_data()` for empty files.
+            // Implicitly calling [`ZipWriter::end_extra_data`] for empty files.
             self.end_extra_data()?;
         }
         self.inner.switch_to(CompressionMethod::Stored)?;
         let writer = self.inner.get_plain();
 
-        let file = match self.files.last_mut() {
+        if !self.writing_raw {
-            None => return Ok(()),
+            let file = match self.files.last_mut() {
-            Some(f) => f,
+                None => return Ok(()),
-        };
+                Some(f) => f,
-        file.crc32 = self.stats.hasher.clone().finalize();
+            };
-        file.uncompressed_size = self.stats.bytes_written;
+            file.crc32 = self.stats.hasher.clone().finalize();
+            file.uncompressed_size = self.stats.bytes_written;
 
-        let file_end = writer.seek(io::SeekFrom::Current(0))?;
+            let file_end = writer.seek(io::SeekFrom::Current(0))?;
-        file.compressed_size = file_end - self.stats.start;
+            file.compressed_size = file_end - self.stats.start;
 
-        update_local_file_header(writer, file)?;
+            update_local_file_header(writer, file)?;
-        writer.seek(io::SeekFrom::Start(file_end))?;
+            writer.seek(io::SeekFrom::Start(file_end))?;
+        }
 
         self.writing_to_file = false;
+        self.writing_raw = false;
         Ok(())
     }
 
@@ -319,7 +340,7 @@ impl<W: Write + io::Seek> ZipWriter<W> {
             options.permissions = Some(0o644);
         }
         *options.permissions.as_mut().unwrap() |= 0o100000;
-        self.start_entry(name, options)?;
+        self.start_entry(name, options, None)?;
         self.inner.switch_to(options.compression_method)?;
         self.writing_to_file = true;
         Ok(())
@@ -372,8 +393,9 @@ impl<W: Write + io::Seek> ZipWriter<W> {
 
     /// Create a file in the archive and start writing its extra data first.
     ///
-    /// Finish writing extra data and start writing file data with `end_extra_data()`. Optionally,
+    /// Finish writing extra data and start writing file data with [`ZipWriter::end_extra_data`].
-    /// distinguish local from central extra data with `end_local_start_central_extra_data()`.
+    /// Optionally, distinguish local from central extra data with
+    /// [`ZipWriter::end_local_start_central_extra_data`].
     ///
     /// Returns the preliminary starting offset of the file data without any extra data allowing to
     /// align the file data by calculating a pad length to be prepended as part of the extra data.
@@ -444,13 +466,13 @@ impl<W: Write + io::Seek> ZipWriter<W> {
             options.permissions = Some(0o644);
         }
         *options.permissions.as_mut().unwrap() |= 0o100000;
-        self.start_entry(name, options)?;
+        self.start_entry(name, options, None)?;
         self.writing_to_file = true;
         self.writing_to_extra_field = true;
         Ok(self.files.last().unwrap().data_start)
     }
 
-    /// End local and start central extra data. Requires `start_file_with_extra_data()`.
+    /// End local and start central extra data. Requires [`ZipWriter::start_file_with_extra_data`].
     ///
     /// Returns the final starting offset of the file data.
     pub fn end_local_start_central_extra_data(&mut self) -> ZipResult<u64> {
@@ -461,7 +483,7 @@ impl<W: Write + io::Seek> ZipWriter<W> {
         Ok(data_start)
     }
 
-    /// End extra data and start file data. Requires `start_file_with_extra_data()`.
+    /// End extra data and start file data. Requires [`ZipWriter::start_file_with_extra_data`].
     ///
     /// Returns the final starting offset of the file data.
     pub fn end_extra_data(&mut self) -> ZipResult<u64> {
@@ -502,6 +524,86 @@ impl<W: Write + io::Seek> ZipWriter<W> {
         Ok(file.data_start)
     }
 
+    /// Add a new file using the already compressed data from a ZIP file being read and renames it, this
+    /// allows faster copies of the `ZipFile` since there is no need to decompress and compress it again.
+    /// Any `ZipFile` metadata is copied and not checked, for example the file CRC.
+
+    /// ```no_run
+    /// use std::fs::File;
+    /// use std::io::{Read, Seek, Write};
+    /// use zip::{ZipArchive, ZipWriter};
+    ///
+    /// fn copy_rename<R, W>(
+    ///     src: &mut ZipArchive<R>,
+    ///     dst: &mut ZipWriter<W>,
+    /// ) -> zip::result::ZipResult<()>
+    /// where
+    ///     R: Read + Seek,
+    ///     W: Write + Seek,
+    /// {
+    ///     // Retrieve file entry by name
+    ///     let file = src.by_name("src_file.txt")?;
+    ///
+    ///     // Copy and rename the previously obtained file entry to the destination zip archive
+    ///     dst.raw_copy_file_rename(file, "new_name.txt")?;
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    pub fn raw_copy_file_rename<S>(&mut self, mut file: ZipFile, name: S) -> ZipResult<()>
+    where
+        S: Into<String>,
+    {
+        let options = FileOptions::default()
+            .last_modified_time(file.last_modified())
+            .compression_method(file.compression());
+        if let Some(perms) = file.unix_mode() {
+            options.unix_permissions(perms);
+        }
+
+        let raw_values = ZipRawValues {
+            crc32: file.crc32(),
+            compressed_size: file.compressed_size(),
+            uncompressed_size: file.size(),
+        };
+
+        self.start_entry(name, options, Some(raw_values))?;
+        self.writing_to_file = true;
+        self.writing_raw = true;
+
+        io::copy(file.get_raw_reader(), self)?;
+
+        Ok(())
+    }
+
+    /// Add a new file using the already compressed data from a ZIP file being read, this allows faster
+    /// copies of the `ZipFile` since there is no need to decompress and compress it again. Any `ZipFile`
+    /// metadata is copied and not checked, for example the file CRC.
+    ///
+    /// ```no_run
+    /// use std::fs::File;
+    /// use std::io::{Read, Seek, Write};
+    /// use zip::{ZipArchive, ZipWriter};
+    ///
+    /// fn copy<R, W>(src: &mut ZipArchive<R>, dst: &mut ZipWriter<W>) -> zip::result::ZipResult<()>
+    /// where
+    ///     R: Read + Seek,
+    ///     W: Write + Seek,
+    /// {
+    ///     // Retrieve file entry by name
+    ///     let file = src.by_name("src_file.txt")?;
+    ///
+    ///     // Copy the previously obtained file entry to the destination zip archive
+    ///     dst.raw_copy_file(file)?;
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    pub fn raw_copy_file(&mut self, file: ZipFile) -> ZipResult<()> {
+        let name = file.name().to_owned();
+        self.raw_copy_file_rename(file, name)
+    }
+
     /// Add a directory entry.
     ///
     /// You can't write data to the file afterwards.
@@ -522,7 +624,7 @@ impl<W: Write + io::Seek> ZipWriter<W> {
             _ => name_as_string + "/",
         };
 
-        self.start_entry(name_with_slash, options)?;
+        self.start_entry(name_with_slash, options, None)?;
         self.writing_to_file = false;
         Ok(())
     }

tests/end_to_end.rs

@@ -1,9 +1,10 @@
 use byteorder::{LittleEndian, WriteBytesExt};
 use std::collections::HashSet;
 use std::io::prelude::*;
-use std::io::Cursor;
+use std::io::{Cursor, Seek};
 use std::iter::FromIterator;
 use zip::write::FileOptions;
+use zip::CompressionMethod;
 
 // This test asserts that after creating a zip file, then reading its contents back out,
 // the extracted data will *always* be exactly the same as the original data.
@@ -11,46 +12,74 @@ use zip::write::FileOptions;
 fn end_to_end() {
     let file = &mut Cursor::new(Vec::new());
 
-    write_to_zip_file(file).expect("file written");
+    write_to_zip(file).expect("file written");
 
-    let file_contents: String = read_zip_file(file).unwrap();
+    check_zip_contents(file, ENTRY_NAME);
-
-    assert!(file_contents.as_bytes() == LOREM_IPSUM);
 }
 
-fn write_to_zip_file(file: &mut Cursor<Vec<u8>>) -> zip::result::ZipResult<()> {
+// This test asserts that after copying a `ZipFile` to a new `ZipWriter`, then reading its
+// contents back out, the extracted data will *always* be exactly the same as the original data.
+#[test]
+fn copy() {
+    let src_file = &mut Cursor::new(Vec::new());
+    write_to_zip(src_file).expect("file written");
+
+    let mut tgt_file = &mut Cursor::new(Vec::new());
+
+    {
+        let mut src_archive = zip::ZipArchive::new(src_file).unwrap();
+        let mut zip = zip::ZipWriter::new(&mut tgt_file);
+
+        {
+            let file = src_archive.by_name(ENTRY_NAME).expect("file found");
+            zip.raw_copy_file(file).unwrap();
+        }
+
+        {
+            let file = src_archive.by_name(ENTRY_NAME).expect("file found");
+            zip.raw_copy_file_rename(file, COPY_ENTRY_NAME).unwrap();
+        }
+    }
+
+    let mut tgt_archive = zip::ZipArchive::new(tgt_file).unwrap();
+
+    check_zip_file_contents(&mut tgt_archive, ENTRY_NAME);
+    check_zip_file_contents(&mut tgt_archive, COPY_ENTRY_NAME);
+}
+
+fn write_to_zip(file: &mut Cursor<Vec<u8>>) -> zip::result::ZipResult<()> {
     let mut zip = zip::ZipWriter::new(file);
 
     zip.add_directory("test/", Default::default())?;
 
     let options = FileOptions::default()
-        .compression_method(zip::CompressionMethod::Stored)
+        .compression_method(CompressionMethod::Stored)
         .unix_permissions(0o755);
     zip.start_file("test/☃.txt", options)?;
     zip.write_all(b"Hello, World!\n")?;
 
-    zip.start_file_with_extra_data("test_with_extra_data/🐢.txt", options)?;
+    zip.start_file_with_extra_data("test_with_extra_data/🐢.txt", Default::default())?;
     zip.write_u16::<LittleEndian>(0xbeef)?;
     zip.write_u16::<LittleEndian>(EXTRA_DATA.len() as u16)?;
     zip.write_all(EXTRA_DATA)?;
     zip.end_extra_data()?;
     zip.write_all(b"Hello, World! Again.\n")?;
 
-    zip.start_file("test/lorem_ipsum.txt", Default::default())?;
+    zip.start_file(ENTRY_NAME, Default::default())?;
     zip.write_all(LOREM_IPSUM)?;
 
     zip.finish()?;
     Ok(())
 }
 
-fn read_zip_file(zip_file: &mut Cursor<Vec<u8>>) -> zip::result::ZipResult<String> {
+fn read_zip<R: Read + Seek>(zip_file: R) -> zip::result::ZipResult<zip::ZipArchive<R>> {
     let mut archive = zip::ZipArchive::new(zip_file).unwrap();
 
     let expected_file_names = [
         "test/",
         "test/☃.txt",
         "test_with_extra_data/🐢.txt",
-        "test/lorem_ipsum.txt",
+        ENTRY_NAME,
     ];
     let expected_file_names = HashSet::from_iter(expected_file_names.iter().map(|&v| v));
     let file_names = archive.file_names().collect::<HashSet<_>>();
@@ -65,13 +94,30 @@ fn read_zip_file(zip_file: &mut Cursor<Vec<u8>>) -> zip::result::ZipResult<Strin
         assert_eq!(file_with_extra_data.extra_data(), extra_data.as_slice());
     }
 
-    let mut file = archive.by_name("test/lorem_ipsum.txt")?;
+    Ok(archive)
+}
+
+fn read_zip_file<R: Read + Seek>(
+    archive: &mut zip::ZipArchive<R>,
+    name: &str,
+) -> zip::result::ZipResult<String> {
+    let mut file = archive.by_name(name)?;
 
     let mut contents = String::new();
     file.read_to_string(&mut contents).unwrap();
     Ok(contents)
 }
 
+fn check_zip_contents(zip_file: &mut Cursor<Vec<u8>>, name: &str) {
+    let mut archive = read_zip(zip_file).unwrap();
+    check_zip_file_contents(&mut archive, name);
+}
+
+fn check_zip_file_contents<R: Read + Seek>(archive: &mut zip::ZipArchive<R>, name: &str) {
+    let file_contents: String = read_zip_file(archive, name).unwrap();
+    assert!(file_contents.as_bytes() == LOREM_IPSUM);
+}
+
 const LOREM_IPSUM : &'static [u8] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. In tellus elit, tristique vitae mattis egestas, ultricies vitae risus. Quisque sit amet quam ut urna aliquet
 molestie. Proin blandit ornare dui, a tempor nisl accumsan in. Praesent a consequat felis. Morbi metus diam, auctor in auctor vel, feugiat id odio. Curabitur ex ex,
 dictum quis auctor quis, suscipit id lorem. Aliquam vestibulum dolor nec enim vehicula, porta tristique augue tincidunt. Vivamus ut gravida est. Sed pellentesque, dolor
@@ -80,3 +126,7 @@ inceptos himenaeos. Maecenas feugiat velit in ex ultrices scelerisque id id nequ
 ";
 
 const EXTRA_DATA: &'static [u8] = b"Extra Data";
+
+const ENTRY_NAME: &str = "test/lorem_ipsum.txt";
+
+const COPY_ENTRY_NAME: &str = "test/lorem_ipsum_renamed.txt";

tests/zip64_large.rs

@@ -195,12 +195,11 @@ fn zip64_large() {
 
     for i in 0..archive.len() {
         let mut file = archive.by_index(i).unwrap();
-        #[allow(deprecated)]
+        let outpath = file.enclosed_name().unwrap();
-        let outpath = file.sanitized_name();
         println!(
             "Entry {} has name \"{}\" ({} bytes)",
             i,
-            outpath.as_path().display(),
+            outpath.display(),
             file.size()
         );
 

tests/zip_comment_garbage.rs

@@ -0,0 +1,30 @@
+// Some zip files can contain garbage after the comment. For example, python zipfile generates
+// it when opening a zip in 'a' mode:
+//
+// >>> from zipfile import ZipFile
+// >>> with ZipFile('comment_garbage.zip', 'a') as z:
+// ...     z.comment = b'long comment bla bla bla'
+// ...
+// >>> with ZipFile('comment_garbage.zip', 'a') as z:
+// ...     z.comment = b'short.'
+// ...
+// >>>
+//
+// Hexdump:
+//
+// 00000000  50 4b 05 06 00 00 00 00  00 00 00 00 00 00 00 00  |PK..............|
+// 00000010  00 00 00 00 06 00 73 68  6f 72 74 2e 6f 6d 6d 65  |......short.omme|
+// 00000020  6e 74 20 62 6c 61 20 62  6c 61 20 62 6c 61        |nt bla bla bla|
+// 0000002e
+
+use std::io;
+use zip::ZipArchive;
+
+#[test]
+fn correctly_handle_zip_with_garbage_after_comment() {
+    let mut v = Vec::new();
+    v.extend_from_slice(include_bytes!("../tests/data/comment_garbage.zip"));
+    let archive = ZipArchive::new(io::Cursor::new(v)).expect("couldn't open test zip file");
+
+    assert_eq!(archive.comment(), "short.".as_bytes());
+}

tests/zip_crypto.rs

@@ -75,8 +75,7 @@ fn encrypted_file() {
             .by_index_decrypt(0, "test".as_bytes())
             .unwrap()
             .unwrap();
-        #[allow(deprecated)]
+        let file_name = file.enclosed_name().unwrap();
-        let file_name = file.sanitized_name();
         assert_eq!(file_name, std::path::PathBuf::from("test.txt"));
 
         let mut data = Vec::new();