use std::collections::HashSet;
use std::io::{Cursor, Read, Seek};
use zip::read::HasZipMetadata;
use zip::read::{ArchiveOffset, Config};
use zip::result::ZipResult;
use zip::CompressionMethod;
use zip::ZipArchive;
use crate::io_latch::{Latch, Latched};
use crate::limits::{DIAGNOSTIC_ELISION, MANIFEST_READ_CAP, MIMETYPE_CEILING};
use crate::manifest::parse_manifest;
use crate::types::{
Checksum, ChecksumAlg, Classification, EncryptedKey, EntryEncryption, Kdf, KdfId, PropertyBag,
StartKeyAlg,
};
use crate::uris;
use crate::zip_err;
use crate::zip_tree::{FolderTree, ResolvedKind, StreamAsFolder};
use crate::{Cipher, DetectError, Mode};
struct ZipMember {
name: String,
index: usize,
stored: bool,
data_descriptor: bool,
}
pub fn classify(bytes: &[u8]) -> Result<Classification, DetectError> {
classify_reader(Cursor::new(bytes))
}
pub fn classify_reader<R: Read + Seek>(reader: R) -> Result<Classification, DetectError> {
let latch = Latch::default();
let result = classify_latched(Latched::new(reader, &latch));
match latch.take() {
Some(err) => Err(DetectError::Io(err)),
None => result,
}
}
pub(crate) fn open_archive<R: Read + Seek>(reader: R) -> ZipResult<ZipArchive<R>> {
ZipArchive::with_config(
Config {
archive_offset: ArchiveOffset::Known(0),
},
reader,
)
}
pub(crate) fn classify_latched<R: Read + Seek>(reader: R) -> Result<Classification, DetectError> {
let mut archive = open_archive(reader).map_err(|_| DetectError::NotZip)?;
let members = collect_members(&mut archive)?;
let mut tree = FolderTree::from_zip_names(members.iter().map(|m| m.name.as_str()))
.map_err(|_| DetectError::Zip("Bad Zip File, stream as folder".into()))?;
let zip_has_encrypted_package = tree.root_has_entry("encrypted-package");
let manifest_xml = read_named_member(&mut archive, &members, "META-INF/manifest.xml")?
.ok_or(DetectError::MissingManifest)?;
let bags = parse_manifest(&manifest_xml);
let mimetype = read_mimetype(&mut archive, &members, &tree)?;
let class = stage_b(bags, &mut tree, zip_has_encrypted_package, mimetype)?;
check_stored_data_descriptors(&members, &class)?;
Ok(class)
}
fn collect_members<R: Read + Seek>(
archive: &mut ZipArchive<R>,
) -> Result<Vec<ZipMember>, DetectError> {
let mut members = Vec::new();
let mut seen = HashSet::new();
let mut seen_lower = HashSet::new();
for i in 0..archive.len() {
let file = archive
.by_index(i)
.map_err(|err| DetectError::Zip(zip_err::message(&err)))?;
let meta = file.get_metadata();
if meta.uncompressed_size == 0
&& u8::from(meta.system) == 0
&& meta.external_attributes & 0x10 != 0
{
continue;
}
let name = zip_entry_name(file.name_raw());
if !is_valid_zip_entry_file_name(&name) {
return Err(DetectError::Zip("Zip entry has an invalid name.".into()));
}
if !seen.insert(name.clone()) {
return Err(DetectError::Zip("Duplicate CEN entry".into()));
}
if !seen_lower.insert(name.to_ascii_lowercase()) {
return Err(DetectError::Zip(
"Duplicate CEN entry (case insensitive)".into(),
));
}
members.push(ZipMember {
name,
index: i,
stored: file.compression() == CompressionMethod::Stored,
data_descriptor: meta.is_using_data_descriptor(),
});
}
Ok(members)
}
fn is_valid_zip_entry_file_name(name: &str) -> bool {
let mut dots: i32 = 0;
for (i, c) in name.chars().enumerate() {
match c {
'.' => {
if dots != -1 {
dots += 1;
}
}
'\\' | '?' | '<' | '>' | '"' | '|' | ':' => return false,
'/' => {
if dots == 1 || dots == 2 || i == 0 {
return false;
}
dots = 0;
}
_ => {
dots = -1;
let u = c as u32;
if u < 32 || (0xD800..=0xDFFF).contains(&u) {
return false;
}
}
}
}
dots != 1 && dots != 2
}
fn read_named_member<R: Read + Seek>(
archive: &mut ZipArchive<R>,
members: &[ZipMember],
want: &str,
) -> Result<Option<Vec<u8>>, DetectError> {
let Some(member) = members.iter().find(|m| member_matches_path(&m.name, want)) else {
return Ok(None);
};
let mut file = archive
.by_index(member.index)
.map_err(|err| DetectError::Zip(zip_err::message(&err)))?;
let mut buf = Vec::new();
file.by_ref()
.take(MANIFEST_READ_CAP as u64 + 1)
.read_to_end(&mut buf)
.map_err(|err| DetectError::Zip(err.to_string()))?;
if buf.len() > MANIFEST_READ_CAP {
return Err(DetectError::Zip("zip entry too large".into()));
}
Ok(Some(buf))
}
pub(crate) fn zip_entry_name(raw: &[u8]) -> String {
String::from_utf8_lossy(raw).into_owned()
}
pub(crate) fn member_matches_path(zip_name: &str, want: &str) -> bool {
if zip_name == want {
return true;
}
collapse_slashes(zip_name) == want
}
pub(crate) fn collapse_slashes(name: &str) -> String {
let mut out = String::with_capacity(name.len());
let mut prev_slash = false;
for c in name.chars() {
if c == '/' {
if !prev_slash {
out.push(c);
}
prev_slash = true;
} else {
prev_slash = false;
out.push(c);
}
}
out
}
fn read_mimetype<R: Read + Seek>(
archive: &mut ZipArchive<R>,
members: &[ZipMember],
tree: &FolderTree,
) -> Result<Option<String>, DetectError> {
if !tree.root_has_entry("mimetype") {
return Ok(None);
}
if !tree.root_has_stream("mimetype") {
return Ok(Some(String::new()));
}
let Some(member) = members.iter().find(|m| m.name == "mimetype") else {
return Ok(Some(String::new()));
};
let mut file = archive
.by_index(member.index)
.map_err(|err| DetectError::Zip(zip_err::message(&err)))?;
let mut buf = [0u8; MIMETYPE_CEILING];
let n = file
.read(&mut buf)
.map_err(|err| DetectError::Zip(err.to_string()))?;
Ok(Some(String::from_utf8_lossy(&buf[..n]).into_owned()))
}
fn nonempty(value: Option<&String>) -> bool {
value.map(|s| !s.is_empty()).unwrap_or(false)
}
fn version_ge_12(version: Option<&str>) -> bool {
version.map(|v| v >= "1.2").unwrap_or(false)
}
fn stage_b(
bags: Vec<PropertyBag>,
tree: &mut FolderTree,
zip_has_encrypted_package: bool,
mimetype: Option<String>,
) -> Result<Classification, DetectError> {
let mut key_info = false;
let mut pgp_keys: Vec<EncryptedKey> = Vec::new();
let mut o_first_version = None;
let mut package_encrypted = false;
let mut has_non_encrypted_entries = false;
let mut common = None;
let mut encrypted_entries = Vec::new();
let mut encrypted_package_complete = false;
for bag in bags {
if o_first_version.is_none() {
if let Some(v) = bag.version.as_ref().filter(|s| !s.is_empty()) {
o_first_version = Some(v.clone());
}
}
if let Some(ki) = &bag.key_info {
key_info = true;
if pgp_keys.is_empty() {
pgp_keys = ki.keys.clone();
}
}
if bag.full_path.is_empty() {
continue;
}
let resolved = match tree.resolve(&bag.full_path) {
Ok(r) => r,
Err(StreamAsFolder) => {
return Err(DetectError::Inconsistent(
"stream used as folder in manifest path".into(),
));
}
};
let Some(resolved) = resolved else {
continue;
};
match resolved.kind {
ResolvedKind::Folder => {
tree.set_folder_meta(
&resolved.tree_path,
bag.media_type.clone(),
bag.version.clone(),
);
}
ResolvedKind::Stream => {
tree.mark_from_manifest(&resolved.tree_path, bag.media_type.clone());
if let Some(entry) = accept_row(&bag, key_info, resolved.tree_path.clone()) {
if resolved.tree_path == "encrypted-package" {
encrypted_package_complete = true;
}
let short = short_name(&entry.path);
if !package_encrypted
&& (short == "content.xml" || short == "encrypted-package")
{
package_encrypted = true;
common = Some(entry.clone());
}
encrypted_entries.push(entry);
} else {
has_non_encrypted_entries = true;
}
}
}
}
let mode = if zip_has_encrypted_package && encrypted_package_complete {
Mode::Wholesome
} else if !encrypted_entries.is_empty() {
Mode::PerEntry
} else {
Mode::Plain
};
let root_had_media = nonempty(tree.root_meta().media_type.as_ref());
if let Some(ref mt) = mimetype {
if !root_had_media {
if mt.starts_with("application/vnd.") {
let version = if !nonempty(tree.root_meta().version.as_ref()) {
o_first_version.clone()
} else {
tree.root_meta().version.clone()
};
tree.set_folder_meta("/", Some(mt.clone()), version);
}
} else {
let xml_mt = if zip_has_encrypted_package {
tree.root_entry_media_type("encrypted-package")
.unwrap_or("")
} else {
tree.root_meta().media_type.as_deref().unwrap_or("")
};
if xml_mt != mt.as_str() {
return Err(DetectError::Inconsistent(format!(
"mimetype conflicts with manifest.xml, \"{}\" vs. \"{}\"",
elide(xml_mt),
elide(mt)
)));
}
}
}
let root = tree.root_meta();
let has_unexpected_streams = tree.has_unexpected_odf12_streams(zip_has_encrypted_package);
let odf12_fatal = has_unexpected_streams && version_ge_12(root.version.as_deref());
Ok(Classification {
mode,
package_encrypted,
has_non_encrypted_entries,
odf_version: root.version.clone(),
zip_has_encrypted_package,
media_type: root.media_type.clone(),
common,
encrypted_entries,
has_unexpected_streams,
odf12_fatal,
pgp_keys,
})
}
fn check_stored_data_descriptors(
members: &[ZipMember],
class: &Classification,
) -> Result<(), DetectError> {
let encrypted: HashSet<&str> = class
.encrypted_entries
.iter()
.map(|e| e.path.as_str())
.collect();
for member in members {
if member.stored && member.data_descriptor {
let collapsed = collapse_slashes(&member.name);
if !encrypted.contains(member.name.as_str()) && !encrypted.contains(collapsed.as_str())
{
return Err(DetectError::Zip(
"entry STORED with data descriptor but not encrypted".into(),
));
}
}
}
Ok(())
}
fn elide(s: &str) -> String {
if s.len() <= DIAGNOSTIC_ELISION {
return s.to_string();
}
let cut = s
.char_indices()
.map(|(i, _)| i)
.take_while(|&i| i <= DIAGNOSTIC_ELISION)
.last()
.unwrap_or(0);
format!("{}… [+{} bytes elided]", &s[..cut], s.len() - cut)
}
fn short_name(path: &str) -> &str {
path.rsplit('/')
.next()
.filter(|s| !s.is_empty())
.unwrap_or(path)
}
fn accept_row(bag: &PropertyBag, key_info: bool, path: String) -> Option<EntryEncryption> {
if key_info {
if let Some(row) = pgp_entry(bag, &path) {
return Some(row);
}
}
password_entry(bag, &path)
}
fn checksum_present_or_unneeded(bag: &PropertyBag, cipher: Cipher) -> bool {
cipher == Cipher::AesGcmW3c || (bag.digest.is_some() && bag.digest_alg.is_some())
}
fn pgp_entry(bag: &PropertyBag, path: &str) -> Option<EntryEncryption> {
if bag.kdf != Some(KdfId::PgpRsaOaepMgf1p) {
return None;
}
let cipher = bag.enc_alg?;
let size = bag.size?;
let iv = bag.iv.clone()?;
if !checksum_present_or_unneeded(bag, cipher) {
return None;
}
Some(EntryEncryption {
path: path.to_string(),
cipher,
kdf: Kdf::PgpRsaOaepMgf1p,
start_key: StartKeyAlg::Sha256,
checksum: checksum_of(bag),
size,
iv,
derived_key_len: uris::default_derived_key_size(cipher),
})
}
fn password_entry(bag: &PropertyBag, path: &str) -> Option<EntryEncryption> {
let cipher = bag.enc_alg?;
let size = bag.size?;
let iv = bag.iv.clone()?;
let salt = bag.salt.clone()?;
let kdf = match bag.kdf {
Some(KdfId::Pbkdf2) => Kdf::Pbkdf2 {
iterations: bag.iteration_count.unwrap_or(0),
salt,
},
Some(KdfId::Argon2id) => {
let (t, m, p) = bag.argon2_args?;
Kdf::Argon2id { t, m, p, salt }
}
_ => return None,
};
if !checksum_present_or_unneeded(bag, cipher) {
return None;
}
Some(EntryEncryption {
path: path.to_string(),
cipher,
kdf,
start_key: bag.start_key_alg.unwrap_or(StartKeyAlg::Sha1),
checksum: checksum_of(bag),
size,
iv,
derived_key_len: bag.derived_key_size.unwrap_or(16),
})
}
fn checksum_of(bag: &PropertyBag) -> Checksum {
match (bag.digest_alg, bag.digest.as_ref()) {
(Some(ChecksumAlg::Sha1_1K), Some(d)) => Checksum::Sha1_1K(d.clone()),
(Some(ChecksumAlg::Sha256_1K), Some(d)) => Checksum::Sha256_1K(d.clone()),
_ => Checksum::None,
}
}
#[cfg(test)]
#[path = "classify_tests.rs"]
mod tests;