use std::io::Read;
use quick_xml::events::{BytesDecl, BytesEnd, BytesStart, Event};
use quick_xml::Writer;
use secure_gate::{RevealSecret, RevealSecretMut};
use zip::ZipArchive;
use crate::limits::{
AES_GCM_IV_LEN, ARGON2_MAX_M_COST_KIB_WRITE, ARGON2_MAX_T_COST_WRITE, ARGON2_MIN_M_COST_KIB,
ARGON2_MIN_P_COST, ARGON2_MIN_T_COST, DEFLATE_CEILING, MIMETYPE_CEILING,
};
use crate::sensitive::DerivedKey;
use crate::types::{Mode, StartKeyAlg};
use crate::uris;
use crate::DetectError;
pub(crate) struct Profile {
argon2_t: i32,
argon2_m_kib: i32,
argon2_p: i32,
derived_key_len: usize,
pub(crate) salt_len: usize,
pub(crate) iv_len: usize,
odf_version: &'static str,
}
pub(crate) const WHOLESOME: Profile = Profile {
argon2_t: 3,
argon2_m_kib: 65536,
argon2_p: 4,
derived_key_len: 32,
salt_len: 16,
iv_len: 12,
odf_version: "1.4",
};
const _: () = assert!(WHOLESOME.argon2_m_kib >= 8 * WHOLESOME.argon2_p);
const _: () = assert!(WHOLESOME.salt_len >= 8);
const _: () = assert!(WHOLESOME.derived_key_len == 32);
const _: () = assert!(WHOLESOME.iv_len == AES_GCM_IV_LEN);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum Argon2Axis {
T,
MKib,
P,
}
impl core::fmt::Display for Argon2Axis {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str(match self {
Self::T => "t",
Self::MKib => "m",
Self::P => "p",
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
#[non_exhaustive]
pub enum ParamsReason {
#[error("{axis} = {got} is outside {min}..={max}, the range this crate acts on")]
OutOfRange {
axis: Argon2Axis,
got: i32,
min: u32,
max: u32,
},
#[error("{axis} = {got} is outside {min}..={max}, which argon2 itself requires")]
CipherRejects {
axis: Argon2Axis,
got: i32,
min: u32,
max: u32,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Argon2Params {
t: i32,
m_kib: i32,
p: i32,
}
impl Argon2Params {
pub const LIBREOFFICE_DEFAULT: Self = Self {
t: WHOLESOME.argon2_t,
m_kib: WHOLESOME.argon2_m_kib,
p: WHOLESOME.argon2_p,
};
pub fn new(t: i32, m_kib: i32, p: i32) -> Result<Self, EncryptError> {
let ours = |axis, got, min, max| {
EncryptError::Params(ParamsReason::OutOfRange {
axis,
got,
min,
max,
})
};
if !(ARGON2_MIN_T_COST..=ARGON2_MAX_T_COST_WRITE).contains(&u32::try_from(t).unwrap_or(0)) {
return Err(ours(
Argon2Axis::T,
t,
ARGON2_MIN_T_COST,
ARGON2_MAX_T_COST_WRITE,
));
}
if !(ARGON2_MIN_M_COST_KIB..=ARGON2_MAX_M_COST_KIB_WRITE)
.contains(&u32::try_from(m_kib).unwrap_or(0))
{
return Err(ours(
Argon2Axis::MKib,
m_kib,
ARGON2_MIN_M_COST_KIB,
ARGON2_MAX_M_COST_KIB_WRITE,
));
}
if !(ARGON2_MIN_P_COST..=argon2::Params::MAX_P_COST)
.contains(&u32::try_from(p).unwrap_or(0))
{
return Err(EncryptError::Params(ParamsReason::CipherRejects {
axis: Argon2Axis::P,
got: p,
min: ARGON2_MIN_P_COST,
max: argon2::Params::MAX_P_COST,
}));
}
if m_kib < 8 * p {
return Err(EncryptError::Params(ParamsReason::CipherRejects {
axis: Argon2Axis::MKib,
got: m_kib,
min: u32::try_from(8 * p).unwrap_or(u32::MAX),
max: ARGON2_MAX_M_COST_KIB_WRITE,
}));
}
Ok(Self { t, m_kib, p })
}
#[must_use]
pub fn t(&self) -> i32 {
self.t
}
#[must_use]
pub fn m_kib(&self) -> i32 {
self.m_kib
}
#[must_use]
pub fn p(&self) -> i32 {
self.p
}
#[must_use]
pub fn is_weaker_than_libreoffice(&self) -> bool {
let d = Self::LIBREOFFICE_DEFAULT;
self.t < d.t || self.m_kib < d.m_kib || self.p < d.p
}
}
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
pub enum EncryptError {
#[error("classification failed: {0}")]
Classify(#[from] DetectError),
#[error("package is already encrypted")]
AlreadyEncrypted,
#[error(
"package has encrypted entries but no latch row: LibreOffice never prompts for its password"
)]
PartiallyEncrypted,
#[error("LibreOffice would refuse this package: unexpected ODF 1.2 streams")]
Odf12Fatal,
#[error("password is empty")]
EmptyPassword,
#[error("random number generation failed: {0}")]
Random(String),
#[error("invalid Argon2 parameters: {0}")]
Params(ParamsReason),
#[error("host could not allocate {requested_bytes} bytes for key derivation")]
HostCannotAllocate {
requested_bytes: usize,
},
#[error("deflate failed: {0}")]
Deflate(String),
#[error("unusable mimetype member: {0}")]
Mimetype(String),
#[error("zip error: {0}")]
Zip(String),
#[error("internal invariant violated: {0}")]
Internal(String),
#[error("I/O failed: {0}")]
Io(#[source] std::io::Error),
}
pub fn encrypt(bytes: &[u8], password: &str) -> Result<Vec<u8>, EncryptError> {
encrypt_with_params(bytes, password, Argon2Params::LIBREOFFICE_DEFAULT)
}
pub fn encrypt_with_params(
bytes: &[u8],
password: &str,
params: Argon2Params,
) -> Result<Vec<u8>, EncryptError> {
crate::encrypt_stream::encrypt_slice(bytes, password, params, DEFLATE_CEILING as u64)
}
pub(crate) fn derive_write_key(
password: &str,
salt: &[u8],
params: Argon2Params,
) -> Result<DerivedKey, EncryptError> {
let start_key = crate::kdf::start_key(password, StartKeyAlg::Sha256);
let mut derived_key = DerivedKey::new(vec![0u8; WHOLESOME.derived_key_len]);
start_key.with_secret(|sk| {
derived_key.with_secret_mut(|key| {
crate::kdf::derive_argon2id(
sk,
salt,
params.t,
params.m_kib,
params.p,
&crate::DecryptLimits::PERMISSIVE
.with_argon2_max_t(ARGON2_MAX_T_COST_WRITE)
.with_argon2_max_m_kib(ARGON2_MAX_M_COST_KIB_WRITE),
key,
)
.map_err(
|e| match e {
crate::kdf::KdfError::Params(b) => EncryptError::Internal(b.to_string()),
crate::kdf::KdfError::Internal(s) => EncryptError::Internal(s.into()),
crate::kdf::KdfError::HostCannotAllocate { requested_bytes }
| crate::kdf::KdfError::HostCannotSpawn { requested_bytes } => {
EncryptError::HostCannotAllocate { requested_bytes }
}
},
)
})
})?;
Ok(derived_key)
}
pub(crate) fn screen_input(class: &crate::Classification) -> Result<(), EncryptError> {
if class.mode != Mode::Plain {
return Err(if class.package_encrypted {
EncryptError::AlreadyEncrypted
} else {
EncryptError::PartiallyEncrypted
});
}
if class.odf12_fatal {
return Err(EncryptError::Odf12Fatal);
}
Ok(())
}
pub(crate) fn random_bytes(len: usize) -> Result<Vec<u8>, EncryptError> {
let mut buf = vec![0u8; len];
getrandom::fill(&mut buf).map_err(|e| EncryptError::Random(e.to_string()))?;
Ok(buf)
}
pub(crate) fn resolve_mimetype<R: Read + std::io::Seek>(
archive: &mut ZipArchive<R>,
classify_media_type: Option<&str>,
) -> Result<Option<String>, EncryptError> {
if let Some(raw) = read_input_mimetype_member(archive)? {
return Ok(Some(validate_media_type(raw)?));
}
Ok(classify_media_type.map(str::to_owned))
}
fn validate_media_type(raw: Vec<u8>) -> Result<String, EncryptError> {
let text = String::from_utf8(raw)
.map_err(|e| EncryptError::Mimetype(format!("not valid UTF-8: {e}")))?;
if let Some(c) = text.chars().find(|&c| !is_xml_char(c)) {
return Err(EncryptError::Mimetype(format!(
"contains U+{:04X}, not an XML 1.0 Char",
c as u32
)));
}
if let Some(c) = text.chars().find(|&c| matches!(c, '\t' | '\n' | '\r')) {
return Err(EncryptError::Mimetype(format!(
"contains U+{:04X}, which XML attribute-value normalization would \
turn into a space, making the manifest attribute disagree with the \
verbatim mimetype member",
c as u32
)));
}
Ok(text)
}
fn is_xml_char(c: char) -> bool {
matches!(c, '\t' | '\n' | '\r' | ' '..='\u{D7FF}' | '\u{E000}'..='\u{FFFD}' | '\u{10000}'..='\u{10FFFF}')
}
fn read_input_mimetype_member<R: Read + std::io::Seek>(
archive: &mut ZipArchive<R>,
) -> Result<Option<Vec<u8>>, EncryptError> {
let Ok(mut file) = archive.by_name("mimetype") else {
return Ok(None);
};
let mut buf = Vec::new();
file.by_ref()
.take(MIMETYPE_CEILING as u64 + 1)
.read_to_end(&mut buf)
.map_err(|e| EncryptError::Zip(e.to_string()))?;
if buf.len() > MIMETYPE_CEILING {
return Err(EncryptError::Mimetype(format!(
"member exceeds ceiling {MIMETYPE_CEILING}, which is all classify itself read"
)));
}
Ok(Some(buf))
}
pub(crate) fn build_manifest(
size: i64,
iv: &[u8],
salt: &[u8],
media_type: Option<&str>,
params: Argon2Params,
) -> Result<Vec<u8>, EncryptError> {
let mut root = BytesStart::new(uris::ELEMENT_MANIFEST);
root.push_attribute(("xmlns:manifest", uris::MANIFEST_NS_OASIS));
root.push_attribute(("xmlns:loext", uris::MANIFEST_NS_LOEXT));
root.push_attribute((uris::ATTR_VERSION, WHOLESOME.odf_version));
let size_str = size.to_string();
let mut file_entry = BytesStart::new(uris::ELEMENT_FILE_ENTRY);
file_entry.push_attribute((uris::ATTR_FULL_PATH, "encrypted-package"));
file_entry.push_attribute((uris::ATTR_SIZE, size_str.as_str()));
if let Some(mt) = media_type {
file_entry.push_attribute((uris::ATTR_MEDIA_TYPE, mt));
}
let iv_b64 = crate::manifest::encode_b64(iv);
let mut algorithm = BytesStart::new(uris::ELEMENT_ALGORITHM);
algorithm.push_attribute((uris::ATTR_ALGORITHM_NAME, uris::AESGCM256_URL));
algorithm.push_attribute((uris::ATTR_IV, iv_b64.as_str()));
let key_size = WHOLESOME.derived_key_len.to_string();
let mut start_key_gen = BytesStart::new(uris::ELEMENT_START_KEY_GENERATION);
start_key_gen.push_attribute((uris::ATTR_START_KEY_NAME, uris::SHA256_URL));
start_key_gen.push_attribute((uris::ATTR_KEY_SIZE, key_size.as_str()));
let (t, m, p) = (
params.t.to_string(),
params.m_kib.to_string(),
params.p.to_string(),
);
let salt_b64 = crate::manifest::encode_b64(salt);
let mut key_derivation = BytesStart::new(uris::ELEMENT_KEY_DERIVATION);
key_derivation.push_attribute((uris::ATTR_KEY_DERIVATION_NAME, uris::ARGON2ID_URL_LO));
key_derivation.push_attribute((uris::ATTR_ARGON2_T_LO, t.as_str()));
key_derivation.push_attribute((uris::ATTR_ARGON2_M_LO, m.as_str()));
key_derivation.push_attribute((uris::ATTR_ARGON2_P_LO, p.as_str()));
key_derivation.push_attribute((uris::ATTR_SALT, salt_b64.as_str()));
key_derivation.push_attribute((uris::ATTR_KEY_SIZE, key_size.as_str()));
let events = [
Event::Decl(BytesDecl::new("1.0", Some("UTF-8"), None)),
Event::Start(root),
Event::Start(file_entry),
Event::Start(BytesStart::new(uris::ELEMENT_ENCRYPTION_DATA)),
Event::Empty(algorithm),
Event::Empty(start_key_gen),
Event::Empty(key_derivation),
Event::End(BytesEnd::new(uris::ELEMENT_ENCRYPTION_DATA)),
Event::End(BytesEnd::new(uris::ELEMENT_FILE_ENTRY)),
Event::End(BytesEnd::new(uris::ELEMENT_MANIFEST)),
];
let mut writer = Writer::new(Vec::new());
for event in events {
writer
.write_event(event)
.map_err(|e| EncryptError::Internal(format!("manifest XML write: {e}")))?;
}
Ok(writer.into_inner())
}
#[cfg(test)]
#[path = "encrypt_tests.rs"]
mod tests;