diff --git a/src/extra_fields/extended_timestamp.rs b/src/extra_fields/extended_timestamp.rs new file mode 100644 index 00000000..e5e3fb70 --- /dev/null +++ b/src/extra_fields/extended_timestamp.rs @@ -0,0 +1,88 @@ +use std::io::Read; + +use byteorder::LittleEndian; +use byteorder::ReadBytesExt; + +use crate::result::{ZipError, ZipResult}; + +/// extended timestamp, as described in + +#[derive(Debug, Clone)] +pub struct ExtendedTimestamp { + mod_time: Option, + ac_time: Option, + cr_time: Option, +} + +impl ExtendedTimestamp { + /// creates an extended timestamp struct by reading the required bytes from the reader. + /// + /// This method assumes that the length has already been read, therefore + /// it must be passed as an argument + pub fn try_from_reader(reader: &mut R, len: u16) -> ZipResult + where + R: Read, + { + let flags = reader.read_u8()?; + + // the `flags` field refers to the local headers and might not correspond + // to the len field. If the length field is 1+4, we assume that only + // the modification time has been set + + // > Those times that are present will appear in the order indicated, but + // > any combination of times may be omitted. (Creation time may be + // > present without access time, for example.) TSize should equal + // > (1 + 4*(number of set bits in Flags)), as the block is currently + // > defined. + if len != 5 && len as u32 != 1 + 4 * flags.count_ones() { + //panic!("found len {len} and flags {flags:08b}"); + return Err(ZipError::UnsupportedArchive( + "flags and len don't match in extended timestamp field", + )); + } + + if flags & 0b11111000 != 0 { + return Err(ZipError::UnsupportedArchive( + "found unsupported timestamps in the extended timestamp header", + )); + } + + let mod_time = if (flags & 0b00000001u8 == 0b00000001u8) || len == 5 { + Some(reader.read_u32::()?) + } else { + None + }; + + let ac_time = if flags & 0b00000010u8 == 0b00000010u8 && len > 5 { + Some(reader.read_u32::()?) + } else { + None + }; + + let cr_time = if flags & 0b00000100u8 == 0b00000100u8 && len > 5 { + Some(reader.read_u32::()?) + } else { + None + }; + Ok(Self { + mod_time, + ac_time, + cr_time, + }) + } + + /// returns the last modification timestamp + pub fn mod_time(&self) -> Option<&u32> { + self.mod_time.as_ref() + } + + /// returns the last access timestamp + pub fn ac_time(&self) -> Option<&u32> { + self.ac_time.as_ref() + } + + /// returns the creation timestamp + pub fn cr_time(&self) -> Option<&u32> { + self.cr_time.as_ref() + } +} diff --git a/src/extra_fields/mod.rs b/src/extra_fields/mod.rs new file mode 100644 index 00000000..145cfade --- /dev/null +++ b/src/extra_fields/mod.rs @@ -0,0 +1,28 @@ +//! types for extra fields + +/// marker trait to denote the place where this extra field has been stored +pub trait ExtraFieldVersion {} + +/// use this to mark extra fields specified in a local header + +#[derive(Debug, Clone)] +pub struct LocalHeaderVersion; + +/// use this to mark extra fields specified in the central header + +#[derive(Debug, Clone)] +pub struct CentralHeaderVersion; + +impl ExtraFieldVersion for LocalHeaderVersion {} +impl ExtraFieldVersion for CentralHeaderVersion {} + +mod extended_timestamp; + +pub use extended_timestamp::*; + +/// contains one extra field +#[derive(Debug, Clone)] +pub enum ExtraField { + /// extended timestamp, as described in + ExtendedTimestamp(ExtendedTimestamp), +} diff --git a/src/lib.rs b/src/lib.rs index baf29a1c..8ece3c20 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -39,12 +39,14 @@ mod aes_ctr; mod compression; mod cp437; mod crc32; +pub mod extra_fields; pub mod read; pub mod result; mod spec; mod types; pub mod write; mod zipcrypto; +pub use extra_fields::ExtraField; #[doc = "Unstable APIs\n\ \ diff --git a/src/read.rs b/src/read.rs index 0a39faef..25ff7f4d 100644 --- a/src/read.rs +++ b/src/read.rs @@ -5,6 +5,7 @@ use crate::aes::{AesReader, AesReaderValid}; use crate::compression::CompressionMethod; use crate::cp437::FromCp437; use crate::crc32::Crc32Reader; +use crate::extra_fields::{ExtendedTimestamp, ExtraField}; use crate::read::zip_archive::Shared; use crate::result::{ZipError, ZipResult}; use crate::spec; @@ -836,6 +837,7 @@ fn central_header_to_zip_file_inner( external_attributes: external_file_attributes, large_file: false, aes_mode: None, + extra_fields: Vec::new(), }; match parse_extra_field(&mut result) { @@ -918,6 +920,17 @@ fn parse_extra_field(file: &mut ZipFileData) -> ZipResult<()> { CompressionMethod::from_u16(compression_method) }; } + 0x5455 => { + // extended timestamp + // https://libzip.org/specifications/extrafld.txt + + file.extra_fields.push(ExtraField::ExtendedTimestamp( + ExtendedTimestamp::try_from_reader(&mut reader, len)?, + )); + + // the reader for ExtendedTimestamp consumes `len` bytes + len_left = 0; + } _ => { // Other fields are ignored } @@ -1087,6 +1100,11 @@ impl<'a> ZipFile<'a> { pub fn central_header_start(&self) -> u64 { self.data.central_header_start } + + /// iterate through all extra fields + pub fn extra_data_fields(&self) -> impl Iterator { + self.data.extra_fields.iter() + } } impl<'a> Read for ZipFile<'a> { @@ -1114,6 +1132,7 @@ impl<'a> Drop for ZipFile<'a> { } }; + #[allow(clippy::unused_io_amount)] loop { match reader.read(&mut buffer) { Ok(0) => break, @@ -1204,6 +1223,7 @@ pub fn read_zipfile_from_stream<'a, R: Read>(reader: &'a mut R) -> ZipResult, + + /// extra fields, see + pub extra_fields: Vec, } impl ZipFileData { @@ -544,6 +548,7 @@ mod test { external_attributes: 0, large_file: false, aes_mode: None, + extra_fields: Vec::new(), }; assert_eq!(data.file_name_sanitized(), PathBuf::from("path/etc/passwd")); } diff --git a/src/write.rs b/src/write.rs index 0051f253..b5bb7278 100644 --- a/src/write.rs +++ b/src/write.rs @@ -696,6 +696,7 @@ impl ZipWriter { external_attributes: permissions << 16, large_file: options.large_file, aes_mode: None, + extra_fields: Vec::new(), }; let index = self.insert_file_data(file)?; let file = &mut self.files[index]; diff --git a/tests/data/extended_timestamp.zip b/tests/data/extended_timestamp.zip new file mode 100644 index 00000000..aa93eb62 Binary files /dev/null and b/tests/data/extended_timestamp.zip differ diff --git a/tests/zip_extended_timestamp.rs b/tests/zip_extended_timestamp.rs new file mode 100644 index 00000000..983e4fb5 --- /dev/null +++ b/tests/zip_extended_timestamp.rs @@ -0,0 +1,19 @@ +use std::io; +use zip::ZipArchive; + +#[test] +fn test_extended_timestamp() { + let mut v = Vec::new(); + v.extend_from_slice(include_bytes!("../tests/data/extended_timestamp.zip")); + let mut archive = ZipArchive::new(io::Cursor::new(v)).expect("couldn't open test zip file"); + + for field in archive.by_name("test.txt").unwrap().extra_data_fields() { + match field { + zip::ExtraField::ExtendedTimestamp(ts) => { + assert!(ts.ac_time().is_none()); + assert!(ts.cr_time().is_none()); + assert_eq!(*ts.mod_time().unwrap(), 1714635025); + } + } + } +}