From 21d07e192c0f054e6cc1cb90df0543a0de60dc06 Mon Sep 17 00:00:00 2001 From: Danny McClanahan <1305167+cosmicexplorer@users.noreply.github.com> Date: Sat, 18 May 2024 08:09:37 -0400 Subject: [PATCH] add ExtraFieldMagic and Zip64ExtraFieldBlock --- src/spec.rs | 37 +++++++++++++++ src/types.rs | 126 +++++++++++++++++++++++++++++++++++++++++++-------- src/write.rs | 68 ++++++++++----------------- 3 files changed, 169 insertions(+), 62 deletions(-) diff --git a/src/spec.rs b/src/spec.rs index 94104096..f4a516fc 100644 --- a/src/spec.rs +++ b/src/spec.rs @@ -56,6 +56,43 @@ pub(crate) const CENTRAL_DIRECTORY_END_SIGNATURE: Magic = Magic::literal(0x06054 pub const ZIP64_CENTRAL_DIRECTORY_END_SIGNATURE: Magic = Magic::literal(0x06064b50); pub(crate) const ZIP64_CENTRAL_DIRECTORY_END_LOCATOR_SIGNATURE: Magic = Magic::literal(0x07064b50); +/// Similar to [`Magic`], but used for extra field tags as per section 4.5.3 of APPNOTE.TXT. +#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)] +#[repr(transparent)] +pub struct ExtraFieldMagic(u16); + +/* TODO: maybe try to use this for parsing extra fields as well as writing them? */ +#[allow(dead_code)] +impl ExtraFieldMagic { + pub(crate) const fn literal(x: u16) -> Self { + Self(x) + } + + #[inline(always)] + pub(crate) const fn from_le_bytes(bytes: [u8; 2]) -> Self { + Self(u16::from_le_bytes(bytes)) + } + + #[inline(always)] + pub(crate) const fn to_le_bytes(self) -> [u8; 2] { + self.0.to_le_bytes() + } + + #[allow(clippy::wrong_self_convention)] + #[inline(always)] + pub(crate) fn from_le(self) -> Self { + Self(u16::from_le(self.0)) + } + + #[allow(clippy::wrong_self_convention)] + #[inline(always)] + pub(crate) fn to_le(self) -> Self { + Self(u16::to_le(self.0)) + } +} + +pub const ZIP64_EXTRA_FIELD_TAG: ExtraFieldMagic = ExtraFieldMagic::literal(0x0001); + pub const ZIP64_BYTES_THR: u64 = u32::MAX as u64; pub const ZIP64_ENTRY_THR: usize = u16::MAX as usize; diff --git a/src/types.rs b/src/types.rs index 07954379..9679968c 100644 --- a/src/types.rs +++ b/src/types.rs @@ -3,6 +3,7 @@ use crate::cp437::FromCp437; use crate::write::{FileOptionExtension, FileOptions}; use path::{Component, Path, PathBuf}; use std::fmt; +use std::mem; use std::path; use std::sync::{Arc, OnceLock}; @@ -706,27 +707,25 @@ impl ZipFileData { }) | if self.encrypted { 1u16 << 0 } else { 0 } } - pub(crate) fn local_block(&self) -> ZipResult { - let (compressed_size, uncompressed_size) = if self.large_file { - (spec::ZIP64_BYTES_THR as u32, spec::ZIP64_BYTES_THR as u32) - } else { - ( - self.compressed_size.try_into().unwrap(), - self.uncompressed_size.try_into().unwrap(), - ) - }; - - let mut extra_field_length = self.extra_field_len(); + fn clamp_size_field(&self, field: u64) -> u32 { if self.large_file { - /* TODO: magic number */ - extra_field_length += 20; + spec::ZIP64_BYTES_THR as u32 + } else { + field.min(spec::ZIP64_BYTES_THR).try_into().unwrap() } - if extra_field_length + self.central_extra_field_len() > u16::MAX as usize { - return Err(ZipError::InvalidArchive( - "Local + central extra data fields are too large", - )); - } - let extra_field_length: u16 = extra_field_length.try_into().unwrap(); + } + + pub(crate) fn local_block(&self) -> ZipResult { + let compressed_size: u32 = self.clamp_size_field(self.compressed_size); + let uncompressed_size: u32 = self.clamp_size_field(self.uncompressed_size); + + let extra_block_len: usize = self + .zip64_extra_field_block() + .map(|block| block.full_size()) + .unwrap_or(0); + let extra_field_length: u16 = (self.extra_field_len() + extra_block_len) + .try_into() + .map_err(|_| ZipError::InvalidArchive("Extra data field is too large"))?; let last_modified_time = self .last_modified_time @@ -786,6 +785,48 @@ impl ZipFileData { .unwrap(), } } + + pub fn zip64_extra_field_block(&self) -> Option { + let uncompressed_size: Option = + if self.uncompressed_size > spec::ZIP64_BYTES_THR || self.large_file { + Some(spec::ZIP64_BYTES_THR) + } else { + None + }; + let compressed_size: Option = + if self.compressed_size > spec::ZIP64_BYTES_THR || self.large_file { + Some(spec::ZIP64_BYTES_THR) + } else { + None + }; + let header_start: Option = if self.header_start > spec::ZIP64_BYTES_THR { + Some(spec::ZIP64_BYTES_THR) + } else { + None + }; + + let mut size: u16 = 0; + if uncompressed_size.is_some() { + size += mem::size_of::() as u16; + } + if compressed_size.is_some() { + size += mem::size_of::() as u16; + } + if header_start.is_some() { + size += mem::size_of::() as u16; + } + if size == 0 { + return None; + } + + Some(Zip64ExtraFieldBlock { + magic: spec::ZIP64_EXTRA_FIELD_TAG, + size, + uncompressed_size, + compressed_size, + header_start, + }) + } } #[derive(Copy, Clone, Debug)] @@ -882,6 +923,53 @@ impl Block for ZipLocalEntryBlock { ]; } +#[derive(Copy, Clone, Debug)] +pub(crate) struct Zip64ExtraFieldBlock { + magic: spec::ExtraFieldMagic, + size: u16, + uncompressed_size: Option, + compressed_size: Option, + header_start: Option, + // Excluded fields: + // u32: disk start number +} + +impl Zip64ExtraFieldBlock { + pub fn full_size(&self) -> usize { + assert!(self.size > 0); + self.size as usize + mem::size_of::() + mem::size_of::() + } + + pub fn serialize(self) -> Box<[u8]> { + let Self { + magic, + size, + uncompressed_size, + compressed_size, + header_start, + } = self; + + let full_size = self.full_size(); + + let mut ret = Vec::with_capacity(full_size); + ret.extend(magic.to_le_bytes()); + ret.extend(u16::to_le_bytes(size)); + + if let Some(uncompressed_size) = uncompressed_size { + ret.extend(u64::to_le_bytes(uncompressed_size)); + } + if let Some(compressed_size) = compressed_size { + ret.extend(u64::to_le_bytes(compressed_size)); + } + if let Some(header_start) = header_start { + ret.extend(u64::to_le_bytes(header_start)); + } + debug_assert_eq!(ret.len(), full_size); + + ret.into_boxed_slice() + } +} + /// The encryption specification used to encrypt a file with AES. /// /// According to the [specification](https://www.winzip.com/win/en/aes_info.html#winzip11) AE-2 diff --git a/src/write.rs b/src/write.rs index acaf4d8c..4c98858b 100644 --- a/src/write.rs +++ b/src/write.rs @@ -8,7 +8,9 @@ use crate::result::{ZipError, ZipResult}; use crate::spec::{self, Block}; #[cfg(feature = "aes-crypto")] use crate::types::AesMode; -use crate::types::{ffi, AesVendorVersion, DateTime, ZipFileData, ZipRawValues, DEFAULT_VERSION}; +use crate::types::{ + ffi, AesVendorVersion, DateTime, ZipFileData, ZipLocalEntryBlock, ZipRawValues, DEFAULT_VERSION, +}; use crate::write::ffi::S_IFLNK; #[cfg(any(feature = "_deflate-any", feature = "bzip2", feature = "zstd",))] use core::num::NonZeroU64; @@ -1818,12 +1820,10 @@ fn validate_extra_data(header_id: u16, data: &[u8]) -> ZipResult<()> { fn write_local_zip64_extra_field(writer: &mut T, file: &ZipFileData) -> ZipResult<()> { // This entry in the Local header MUST include BOTH original // and compressed file size fields. - writer.write_u16_le(0x0001)?; - writer.write_u16_le(16)?; - writer.write_u64_le(file.uncompressed_size)?; - writer.write_u64_le(file.compressed_size)?; - // Excluded fields: - // u32: disk start number + assert!(file.large_file); + let block = file.zip64_extra_field_block().unwrap(); + let block = block.serialize(); + writer.write_all(&block)?; Ok(()) } @@ -1831,52 +1831,34 @@ fn update_local_zip64_extra_field( writer: &mut T, file: &ZipFileData, ) -> ZipResult<()> { - let zip64_extra_field = file.header_start + 30 + file.file_name_raw.len() as u64; - writer.seek(SeekFrom::Start(zip64_extra_field + 4))?; - writer.write_u64_le(file.uncompressed_size)?; - writer.write_u64_le(file.compressed_size)?; - // Excluded fields: - // u32: disk start number + assert!(file.large_file); + + let zip64_extra_field = file.header_start + + mem::size_of::() as u64 + + file.file_name_raw.len() as u64; + + writer.seek(SeekFrom::Start(zip64_extra_field))?; + + let block = file.zip64_extra_field_block().unwrap(); + let block = block.serialize(); + writer.write_all(&block)?; Ok(()) } -/* TODO: make this use the Block trait somehow! */ fn write_central_zip64_extra_field(writer: &mut T, file: &ZipFileData) -> ZipResult { // The order of the fields in the zip64 extended // information record is fixed, but the fields MUST // only appear if the corresponding Local or Central // directory record field is set to 0xFFFF or 0xFFFFFFFF. - let mut size = 0; - let uncompressed_size = file.uncompressed_size > spec::ZIP64_BYTES_THR; - let compressed_size = file.compressed_size > spec::ZIP64_BYTES_THR; - let header_start = file.header_start > spec::ZIP64_BYTES_THR; - if uncompressed_size { - size += 8; - } - if compressed_size { - size += 8; - } - if header_start { - size += 8; - } - if size > 0 { - writer.write_u16_le(0x0001)?; - writer.write_u16_le(size)?; - size += 4; - - if uncompressed_size { - writer.write_u64_le(file.uncompressed_size)?; + match file.zip64_extra_field_block() { + None => Ok(0), + Some(block) => { + let block = block.serialize(); + writer.write_all(&block)?; + let len: u16 = block.len().try_into().unwrap(); + Ok(len) } - if compressed_size { - writer.write_u64_le(file.compressed_size)?; - } - if header_start { - writer.write_u64_le(file.header_start)?; - } - // Excluded fields: - // u32: disk start number } - Ok(size) } #[cfg(not(feature = "unreserved"))]