use std::io::Read;
use pbkdf2::pbkdf2_hmac;
use secure_gate::{RevealSecret, RevealSecretMut};
use sha1::Sha1;
use zip::ZipArchive;
use quick_xml::events::{BytesStart, Event};
use quick_xml::{Reader, Writer};
fn is_manifest_size_attr(key: &[u8]) -> bool {
key.ends_with(b":size") || key == b"size"
}
use crate::bad_parameter::{wide, BadParameter, ManifestField, MemberFault, Primitive};
use crate::classify::{member_matches_path, zip_entry_name};
use crate::kdf::KdfError;
use crate::limits::{
AES_BLOCK_LEN, AES_CBC_IV_LEN, AES_GCM_IV_LEN, AES_GCM_TAG_LEN, ARGON2_MAX_M_COST_KIB_READ,
ARGON2_MAX_P_COST_READ, ARGON2_MAX_T_COST_READ, BLOWFISH_IV_LEN, DERIVED_KEY_MAX_LEN,
DERIVED_KEY_MIN_LEN, INFLATE_CEILING, MAX_ENCRYPTED_ENTRIES, MAX_OUTPUT_BYTES, PBKDF2_MAX_ITER,
PBKDF2_MIN_ITER,
};
use crate::sensitive::{DerivedKey, PasswordDigest};
use crate::types::{Cipher, EntryEncryption, Kdf, Mode};
use crate::zip_err;
use crate::DetectError;
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum DecryptError {
#[error("classification failed: {0}")]
Classify(#[from] DetectError),
#[error("package is not encrypted")]
NotEncrypted,
#[error("password is empty")]
EmptyPassword,
#[error("PGP-encrypted packages are not supported")]
UnsupportedPgp,
#[error("LibreOffice would refuse this package: unexpected ODF 1.2 streams")]
Odf12Fatal,
#[error("wrong password")]
WrongPassword,
#[error("invalid encryption parameters: {0}")]
BadParameters(crate::BadParameter),
#[error("internal invariant violated: {0}")]
Internal(String),
#[error("host could not allocate {requested_bytes} bytes for {site}")]
HostCannotAllocate {
site: AllocationSite,
requested_bytes: usize,
},
#[error("inflate failed: {0}")]
Inflate(String),
#[error("zip error: {0}")]
Zip(String),
#[error("decrypted output would exceed the {limit}-byte limit")]
OutputLimit {
limit: u64,
},
#[error("I/O failed: {0}")]
Io(#[source] std::io::Error),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum AllocationSite {
KeyDerivation,
DerivedKey,
MemberPlaintext,
PackagePlaintext,
CipherBuffer,
StreamBuffer,
KdfThread,
}
impl core::fmt::Display for AllocationSite {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str(match self {
Self::KeyDerivation => "key derivation",
Self::DerivedKey => "the derived-key buffer",
Self::MemberPlaintext => "a decrypted package member",
Self::PackagePlaintext => "the decrypted package",
Self::CipherBuffer => "a cipher buffer",
Self::StreamBuffer => "a streaming buffer",
Self::KdfThread => "an Argon2id lane thread's stack",
})
}
}
pub(crate) fn try_zeroed(n: usize, site: AllocationSite) -> Result<Vec<u8>, DecryptError> {
let mut v = Vec::new();
v.try_reserve_exact(n)
.map_err(|_| DecryptError::HostCannotAllocate {
site,
requested_bytes: n,
})?;
v.resize(n, 0);
Ok(v)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct DecryptLimits {
pub argon2_max_t: u32,
pub argon2_max_m_kib: u32,
pub argon2_max_p: u32,
pub pbkdf2_max_iter: u32,
pub max_output_bytes: u64,
}
impl Default for DecryptLimits {
fn default() -> Self {
Self {
argon2_max_t: ARGON2_MAX_T_COST_READ,
argon2_max_m_kib: ARGON2_MAX_M_COST_KIB_READ,
argon2_max_p: ARGON2_MAX_P_COST_READ,
pbkdf2_max_iter: PBKDF2_MAX_ITER,
max_output_bytes: MAX_OUTPUT_BYTES,
}
}
}
impl DecryptLimits {
pub const PERMISSIVE: Self = Self {
argon2_max_t: i32::MAX as u32,
argon2_max_m_kib: i32::MAX as u32,
argon2_max_p: i32::MAX as u32,
pbkdf2_max_iter: i32::MAX as u32,
max_output_bytes: u64::MAX,
};
#[must_use]
pub fn with_argon2_max_t(mut self, t: u32) -> Self {
self.argon2_max_t = t;
self
}
#[must_use]
pub fn with_argon2_max_m_kib(mut self, m_kib: u32) -> Self {
self.argon2_max_m_kib = m_kib;
self
}
#[must_use]
pub fn with_argon2_max_p(mut self, p: u32) -> Self {
self.argon2_max_p = p;
self
}
#[must_use]
pub fn with_pbkdf2_max_iter(mut self, iter: u32) -> Self {
self.pbkdf2_max_iter = iter;
self
}
#[must_use]
pub fn with_max_output_bytes(mut self, bytes: u64) -> Self {
self.max_output_bytes = bytes;
self
}
}
pub fn decrypt(bytes: &[u8], password: &str) -> Result<Vec<u8>, DecryptError> {
decrypt_with_limits(bytes, password, DecryptLimits::default())
}
pub fn decrypt_with_limits(
bytes: &[u8],
password: &str,
limits: DecryptLimits,
) -> Result<Vec<u8>, DecryptError> {
crate::decrypt_stream::decrypt_slice(bytes, password, &limits)
}
pub(crate) fn screen_class(
class: &crate::Classification,
limits: &DecryptLimits,
) -> Result<(), DecryptError> {
if class.mode == Mode::Plain {
return Err(DecryptError::NotEncrypted);
}
if class.odf12_fatal {
return Err(DecryptError::Odf12Fatal);
}
if class
.encrypted_entries
.iter()
.any(|e| matches!(e.kdf, Kdf::PgpRsaOaepMgf1p))
{
return Err(DecryptError::UnsupportedPgp);
}
ensure_encrypted_entry_count(class.encrypted_entries.len(), MAX_ENCRYPTED_ENTRIES)?;
screen_output_limit(class, limits.max_output_bytes)
}
fn screen_output_limit(class: &crate::Classification, limit: u64) -> Result<(), DecryptError> {
let declared = |row: &EntryEncryption| u64::try_from(row.size).unwrap_or(0);
let total = match class.mode {
Mode::Wholesome => class.wholesome_row().map_or(0, declared),
_ => class
.encrypted_entries
.iter()
.fold(0u64, |sum, row| sum.saturating_add(declared(row))),
};
if total > limit {
return Err(DecryptError::OutputLimit { limit });
}
Ok(())
}
fn ensure_encrypted_entry_count(n: usize, cap: usize) -> Result<(), DecryptError> {
if n > cap {
return Err(DecryptError::BadParameters(BadParameter::OutOfRange {
field: ManifestField::EncryptedEntries,
got: wide(n),
min: 0,
max: wide(cap),
}));
}
Ok(())
}
pub(crate) fn member_for_archive<R: Read + std::io::Seek>(
archive: &mut ZipArchive<R>,
path: &str,
missing: impl FnOnce() -> DecryptError,
) -> Result<(usize, String), DecryptError> {
for i in 0..archive.len() {
let file = archive
.by_index(i)
.map_err(|e| DecryptError::Zip(zip_err::message(&e)))?;
let name = zip_entry_name(file.name_raw());
if member_matches_path(&name, path) {
return Ok((i, name));
}
}
Err(missing())
}
pub(crate) fn no_member(row: usize) -> impl FnOnce() -> DecryptError {
move || DecryptError::BadParameters(BadParameter::NoMember { row })
}
pub(crate) fn wholesome_row(
class: &crate::Classification,
) -> Result<(usize, &EntryEncryption), DecryptError> {
class
.encrypted_entries
.iter()
.enumerate()
.find(|(_, e)| class.mode == Mode::Wholesome && e.path == "encrypted-package")
.ok_or_else(|| {
DecryptError::Internal(
"a wholesome classification without its encrypted-package row".into(),
)
})
}
fn kdf_error(e: KdfError) -> DecryptError {
match e {
KdfError::Params(b) => DecryptError::BadParameters(b),
KdfError::Internal(s) => DecryptError::Internal(s.into()),
KdfError::HostCannotAllocate { requested_bytes } => DecryptError::HostCannotAllocate {
site: AllocationSite::KeyDerivation,
requested_bytes,
},
KdfError::HostCannotSpawn { requested_bytes } => DecryptError::HostCannotAllocate {
site: AllocationSite::KdfThread,
requested_bytes,
},
}
}
pub(crate) fn derive_key(
row: &EntryEncryption,
sk: PasswordDigest,
limits: &DecryptLimits,
) -> Result<DerivedKey, DecryptError> {
let n = row.derived_key_len;
if !(DERIVED_KEY_MIN_LEN..=DERIVED_KEY_MAX_LEN).contains(&n) {
return Err(DecryptError::Internal(
"derive_key reached with a derived key length screen_shape refuses".into(),
));
}
let n = n as usize;
let mut derived = DerivedKey::new(try_zeroed(n, AllocationSite::DerivedKey)?);
sk.with_secret(|sk_bytes| {
derived.with_secret_mut(|derived_bytes| -> Result<(), DecryptError> {
match &row.kdf {
Kdf::Pbkdf2 { iterations, salt } => {
let out_of_range = |got: i64| {
DecryptError::BadParameters(BadParameter::OutOfRange {
field: ManifestField::IterationCount,
got,
min: PBKDF2_MIN_ITER.into(),
max: limits.pbkdf2_max_iter.into(),
})
};
let iters = u32::try_from(*iterations)
.map_err(|_| out_of_range((*iterations).into()))?;
if !(PBKDF2_MIN_ITER..=limits.pbkdf2_max_iter).contains(&iters) {
return Err(out_of_range(iters.into()));
}
pbkdf2_hmac::<Sha1>(sk_bytes, salt, iters, derived_bytes);
Ok(())
}
Kdf::Argon2id { t, m, p, salt } => {
crate::kdf::derive_argon2id(sk_bytes, salt, *t, *m, *p, limits, derived_bytes)
.map_err(kdf_error)
}
Kdf::PgpRsaOaepMgf1p => Err(DecryptError::Internal(
"PGP row reached derive_key; decrypt screens PGP before deriving".into(),
)),
}
})
})?;
Ok(derived)
}
fn cipher_accepts_key_len(cipher: Cipher, n: i32) -> bool {
match cipher {
Cipher::AesGcmW3c | Cipher::AesCbcW3c => matches!(n, 16 | 24 | 32),
Cipher::BlowfishCfb8 => (4..=56).contains(&n),
}
}
#[cfg(test)]
fn screen_before_deriving(row: &EntryEncryption, blob: &[u8]) -> Result<(), DecryptError> {
let head = &blob[..blob.len().min(AES_GCM_IV_LEN)];
screen_shape(row, blob.len() as u64, head)
}
pub(crate) fn screen_shape(
row: &EntryEncryption,
len: u64,
head: &[u8],
) -> Result<(), DecryptError> {
if !cipher_accepts_key_len(row.cipher, row.derived_key_len) {
return Err(DecryptError::BadParameters(
BadParameter::KeySizeForCipher {
got: row.derived_key_len,
cipher: row.cipher,
},
));
}
let iv_len = |by: Primitive, want: usize| {
if row.iv.len() == want {
Ok(())
} else {
Err(DecryptError::BadParameters(BadParameter::CipherRejects {
field: ManifestField::IvLen,
by,
got: wide(row.iv.len()),
min: wide(want),
max: wide(want),
}))
}
};
let member = |fault| Err(DecryptError::BadParameters(BadParameter::Member(fault)));
match row.cipher {
Cipher::AesGcmW3c => {
iv_len(Primitive::AesGcm, AES_GCM_IV_LEN)?;
if len < (AES_GCM_IV_LEN + AES_GCM_TAG_LEN) as u64 || head.len() < AES_GCM_IV_LEN {
return member(MemberFault::ShorterThanIvAndTag);
}
if head[..AES_GCM_IV_LEN] != row.iv[..] {
return member(MemberFault::IvMismatch);
}
}
Cipher::AesCbcW3c => {
iv_len(Primitive::AesCbc, AES_CBC_IV_LEN)?;
if len == 0 || !len.is_multiple_of(AES_BLOCK_LEN as u64) {
return member(MemberFault::NotBlockMultiple);
}
}
Cipher::BlowfishCfb8 => iv_len(Primitive::Blowfish, BLOWFISH_IV_LEN)?,
}
Ok(())
}
pub(crate) fn inflated_len(size: i64) -> Result<usize, DecryptError> {
if !(0..=INFLATE_CEILING as i64).contains(&size) {
return Err(DecryptError::BadParameters(BadParameter::OutOfRange {
field: ManifestField::Size,
got: size,
min: 0,
max: wide(INFLATE_CEILING),
}));
}
Ok(size as usize)
}
fn without_size(e: &BytesStart<'_>) -> BytesStart<'static> {
let name = String::from_utf8_lossy(e.name().as_ref()).into_owned();
let mut out = BytesStart::new(name);
let strip_size = e.local_name().as_ref() == b"file-entry";
for attr in e.attributes().flatten() {
if strip_size && is_manifest_size_attr(attr.key.as_ref()) {
continue;
}
out.push_attribute((attr.key.as_ref(), attr.value.as_ref()));
}
out.into_owned()
}
pub(crate) fn strip_manifest(xml: &[u8]) -> Result<Vec<u8>, DecryptError> {
let mut reader = Reader::from_reader(xml);
reader.config_mut().trim_text(false);
let mut writer = Writer::new(Vec::new());
let mut buf = Vec::new();
let mut skip_depth = 0u32;
loop {
buf.clear();
match reader.read_event_into(&mut buf) {
Ok(Event::Eof) => break,
Ok(Event::Start(e)) => {
if skip_depth > 0 {
skip_depth += 1;
continue;
}
if e.local_name().as_ref() == b"encryption-data" {
skip_depth = 1;
continue;
}
writer
.write_event(Event::Start(without_size(&e)))
.map_err(|e| DecryptError::Internal(format!("manifest XML write: {e}")))?;
}
Ok(Event::End(e)) => {
if skip_depth > 0 {
skip_depth -= 1;
continue;
}
writer
.write_event(Event::End(e.into_owned()))
.map_err(|e| DecryptError::Internal(format!("manifest XML write: {e}")))?;
}
Ok(Event::Empty(e)) => {
if skip_depth > 0 {
continue;
}
if e.local_name().as_ref() == b"encryption-data" {
continue;
}
writer
.write_event(Event::Empty(without_size(&e)))
.map_err(|e| DecryptError::Internal(format!("manifest XML write: {e}")))?;
}
Ok(other) => {
if skip_depth > 0 {
continue;
}
writer
.write_event(other)
.map_err(|e| DecryptError::Internal(format!("manifest XML write: {e}")))?;
}
Err(e) => return Err(DecryptError::Zip(e.to_string())),
}
}
Ok(writer.into_inner())
}
#[cfg(test)]
pub(crate) fn classification_metadata_unchanged(
before: &crate::Classification,
after: &crate::Classification,
) -> bool {
before.odf_version == after.odf_version
&& before.media_type == after.media_type
&& before.zip_has_encrypted_package == after.zip_has_encrypted_package
}
#[cfg(test)]
#[path = "decrypt_tests.rs"]
mod tests;