use std::io::{self, Read, Seek, SeekFrom, Write};
use secure_gate::{RevealSecret, RevealSecretMut};
use zip::ZipArchive;
use crate::classify::{classify_latched, open_archive};
use crate::decrypt::{
derive_key, member_for_archive, no_member, screen_class, screen_shape, AllocationSite,
DecryptError, DecryptLimits,
};
use crate::io_latch::{Latch, Latched};
use crate::limits::{AES_GCM_IV_LEN, AES_GCM_TAG_LEN};
use crate::sensitive::DerivedKey;
use crate::stream::{
chunk_buffer, gcm_verify, ChunkBuffer, Fault, GcmDecryptReader, GcmStream, InflateReader, CHUNK,
};
use crate::types::{EntryEncryption, StartKeyAlg};
use crate::zip_err;
use crate::zip_stream::{deflate_bound, SeekableZipSink, ZipStreamWriter};
use crate::Mode;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum IntegrityOutcome {
Verified,
PasswordCheckOnly,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct DecryptOutcome {
pub integrity: IntegrityOutcome,
}
pub fn decrypt_to<R: Read + Seek, W: Write>(
reader: R,
writer: W,
password: &str,
) -> Result<DecryptOutcome, DecryptError> {
decrypt_with_limits_to(reader, writer, password, DecryptLimits::default())
}
pub fn decrypt_with_limits_to<R: Read + Seek, W: Write>(
reader: R,
mut writer: W,
password: &str,
limits: DecryptLimits,
) -> Result<DecryptOutcome, DecryptError> {
if password.is_empty() {
return Err(DecryptError::EmptyPassword);
}
let latch = Latch::default();
let mut src = Latched::new(reader, &latch);
let result = run(&mut src, &mut writer, password, &limits);
match latch.take() {
Some(err) => Err(DecryptError::Io(err)),
None => result,
}
}
fn run<R: Read + Seek, W: Write>(
src: &mut R,
writer: &mut W,
password: &str,
limits: &DecryptLimits,
) -> Result<DecryptOutcome, DecryptError> {
let class = classify_latched(&mut *src)?;
screen_class(&class, limits)?;
src.seek(SeekFrom::Start(0)).map_err(DecryptError::Io)?;
let mut archive =
open_archive(&mut *src).map_err(|e| DecryptError::Zip(zip_err::message(&e)))?;
match class.mode {
Mode::Wholesome => {
let row = crate::decrypt::wholesome_row(&class)?;
wholesome(&mut archive, row, writer, password, limits, Sizes::Streamed)?;
Ok(DecryptOutcome {
integrity: IntegrityOutcome::Verified,
})
}
_ => {
let mut zip = ZipStreamWriter::new(writer);
let outcome = crate::decrypt_entries::per_entry(
&mut archive,
&class,
&mut zip,
password,
limits,
Sizes::Streamed,
)?;
zip.finish()
.map_err(crate::decrypt_entries::zip_stream_error(limits))?;
Ok(outcome)
}
}
}
pub(crate) fn decrypt_slice(
bytes: &[u8],
password: &str,
limits: &DecryptLimits,
) -> Result<Vec<u8>, DecryptError> {
if password.is_empty() {
return Err(DecryptError::EmptyPassword);
}
let class = crate::classify::classify(bytes)?;
screen_class(&class, limits)?;
let mut archive = open_archive(io::Cursor::new(bytes))
.map_err(|e| DecryptError::Zip(zip_err::message(&e)))?;
let mut out;
let len = match class.mode {
Mode::Wholesome => {
let row = crate::decrypt::wholesome_row(&class)?;
let n = crate::decrypt::inflated_len(row.1.size)?;
out = crate::decrypt::try_zeroed(n, AllocationSite::PackagePlaintext)?;
let mut slot = SliceWriter::new(&mut out[..]);
wholesome(
&mut archive,
row,
&mut slot,
password,
limits,
Sizes::WholeBuffer,
)
.map_err(ours)?;
slot.len
}
_ => {
let bound = rebuild_bound(&mut archive, &class)?;
out = crate::decrypt::try_zeroed(bound, AllocationSite::PackagePlaintext)?;
let mut slot = SliceWriter::new(&mut out[..]);
let mut zip = SeekableZipSink::new(&mut slot);
crate::decrypt_entries::per_entry(
&mut archive,
&class,
&mut zip,
password,
limits,
Sizes::WholeBuffer,
)
.map_err(ours)?;
zip.finish()
.map_err(crate::decrypt_entries::zip_stream_error(limits))
.map_err(ours)?;
slot.len
}
};
out.truncate(len);
Ok(out)
}
struct SliceWriter<'a> {
buf: &'a mut [u8],
pos: usize,
len: usize,
}
impl<'a> SliceWriter<'a> {
fn new(buf: &'a mut [u8]) -> Self {
Self {
buf,
pos: 0,
len: 0,
}
}
}
impl Write for SliceWriter<'_> {
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
let end = self
.pos
.checked_add(data.len())
.filter(|&e| e <= self.buf.len())
.ok_or_else(|| io::Error::new(io::ErrorKind::WriteZero, "output bound exceeded"))?;
self.buf[self.pos..end].copy_from_slice(data);
self.pos = end;
self.len = self.len.max(end);
Ok(data.len())
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
impl Seek for SliceWriter<'_> {
fn seek(&mut self, to: SeekFrom) -> io::Result<u64> {
let base = match to {
SeekFrom::Start(n) => Some(n),
SeekFrom::End(d) => (self.len as u64).checked_add_signed(d),
SeekFrom::Current(d) => (self.pos as u64).checked_add_signed(d),
};
self.pos = base
.and_then(|n| usize::try_from(n).ok())
.filter(|&n| n <= self.buf.len())
.ok_or_else(|| {
io::Error::new(io::ErrorKind::InvalidInput, "seek outside the output")
})?;
Ok(self.pos as u64)
}
}
fn ours(e: DecryptError) -> DecryptError {
match e {
DecryptError::Io(e) => DecryptError::Internal(format!("output buffer: {e}")),
other => other,
}
}
fn rebuild_bound<R: Read + Seek>(
archive: &mut ZipArchive<R>,
class: &crate::Classification,
) -> Result<usize, DecryptError> {
const PER_MEMBER: u64 = 30 + 46 + 2 * 64 + 1024;
let ceiling = crate::limits::INFLATE_CEILING as u64;
let mut bound = 22u64 + 1024;
for i in 0..archive.len() {
let f = archive
.by_index_raw(i)
.map_err(|e| DecryptError::Zip(zip_err::message(&e)))?;
let body = f.size().max(f.compressed_size()).min(ceiling);
bound += PER_MEMBER + 2 * f.name_raw().len() as u64 + deflate_bound(body);
}
for row in &class.encrypted_entries {
let declared = u64::try_from(row.size).unwrap_or(0).min(ceiling);
bound += deflate_bound(declared);
}
usize::try_from(bound).map_err(|_| DecryptError::HostCannotAllocate {
site: AllocationSite::PackagePlaintext,
requested_bytes: usize::MAX,
})
}
pub(crate) fn declared_size(size: i64) -> Result<u64, DecryptError> {
u64::try_from(size).map_err(|_| {
DecryptError::BadParameters(crate::BadParameter::OutOfRange {
field: crate::ManifestField::Size,
got: size,
min: 0,
max: i64::MAX,
})
})
}
#[derive(Clone, Copy)]
pub(crate) enum Sizes {
Streamed,
WholeBuffer,
}
impl Sizes {
pub(crate) fn declared(self, size: i64) -> Result<u64, DecryptError> {
match self {
Sizes::Streamed => declared_size(size),
Sizes::WholeBuffer => crate::decrypt::inflated_len(size).map(|n| n as u64),
}
}
}
pub(crate) fn find_key(
row: &EntryEncryption,
password: &str,
limits: &DecryptLimits,
mut accepts: impl FnMut(&[u8]) -> Result<bool, DecryptError>,
) -> Result<DerivedKey, DecryptError> {
let mut attempt = |sk| -> Result<Option<DerivedKey>, DecryptError> {
let key = derive_key(row, sk, limits)?;
let ok = key.with_secret(|k| accepts(k))?;
Ok(ok.then_some(key))
};
if let Some(key) = attempt(crate::kdf::start_key(password, row.start_key))? {
return Ok(key);
}
if row.start_key == StartKeyAlg::Sha1 {
for rung in crate::kdf::SHA1_LADDER {
if let Some(key) = attempt(crate::kdf::legacy_start_key(password, rung))? {
return Ok(key);
}
}
}
Err(DecryptError::WrongPassword)
}
pub(crate) fn member_shape<R: Read + Seek>(
archive: &mut ZipArchive<R>,
index: usize,
) -> Result<(u64, Vec<u8>), DecryptError> {
let mut file = archive
.by_index(index)
.map_err(|e| DecryptError::Zip(zip_err::message(&e)))?;
let len = file.size();
let mut head = [0u8; AES_GCM_IV_LEN];
let n = read_full(&mut file, &mut head).map_err(read_error)?;
Ok((len, head[..n].to_vec()))
}
fn wholesome<R: Read + Seek, W: Write>(
archive: &mut ZipArchive<R>,
(row_index, row): (usize, &EntryEncryption),
writer: &mut W,
password: &str,
limits: &DecryptLimits,
sizes: Sizes,
) -> Result<(), DecryptError> {
let expected = sizes.declared(row.size)?;
let (index, _) = member_for_archive(archive, &row.path, no_member(row_index))?;
let (len, head) = member_shape(archive, index)?;
screen_shape(row, len, &head)?;
gcm_member(archive, index, row, len, password, limits, |plain| {
copy_out(plain, writer, expected, limits)
})
}
pub(crate) fn gcm_member<R: Read + Seek>(
archive: &mut ZipArchive<R>,
index: usize,
row: &EntryEncryption,
len: u64,
password: &str,
limits: &DecryptLimits,
release: impl FnOnce(&mut dyn Read) -> Result<(), DecryptError>,
) -> Result<(), DecryptError> {
let ct_len = len - (AES_GCM_IV_LEN + AES_GCM_TAG_LEN) as u64;
let key = gcm_key(archive, index, row, len, password, limits)?;
let mut file = open_after_iv(archive, index)?;
key.with_secret(|k| -> Result<(), DecryptError> {
let gcm = GcmStream::new(k, &row.iv).ok_or_else(|| {
DecryptError::Internal("an AES-GCM key length screen_shape passed".into())
})?;
let mut plain = GcmDecryptReader::new(&mut file, gcm, ct_len);
release(&mut plain)?;
drain(&mut plain)
})?;
ensure_end(&mut file)
}
pub(crate) fn gcm_key<R: Read + Seek>(
archive: &mut ZipArchive<R>,
index: usize,
row: &EntryEncryption,
len: u64,
password: &str,
limits: &DecryptLimits,
) -> Result<DerivedKey, DecryptError> {
let ct_len = len - (AES_GCM_IV_LEN + AES_GCM_TAG_LEN) as u64;
find_key(row, password, limits, |k| {
let mut file = open_after_iv(archive, index)?;
let ok = gcm_verify(k, &row.iv, &mut file, ct_len).map_err(read_error)?;
ensure_end(&mut file)?;
Ok(ok)
})
}
pub(crate) fn open_after_iv<R: Read + Seek>(
archive: &mut ZipArchive<R>,
index: usize,
) -> Result<zip::read::ZipFile<'_, R>, DecryptError> {
let mut file = archive
.by_index(index)
.map_err(|e| DecryptError::Zip(zip_err::message(&e)))?;
let mut iv = [0u8; AES_GCM_IV_LEN];
if read_full(&mut file, &mut iv).map_err(read_error)? != AES_GCM_IV_LEN {
return Err(DecryptError::BadParameters(crate::BadParameter::Member(
crate::MemberFault::ShorterThanIvAndTag,
)));
}
Ok(file)
}
fn ensure_end<R: Read>(file: &mut R) -> Result<(), DecryptError> {
let mut one = [0u8; 1];
match read_full(file, &mut one).map_err(read_error)? {
0 => Ok(()),
_ => Err(DecryptError::BadParameters(crate::BadParameter::Member(
crate::MemberFault::LongerThanHeader,
))),
}
}
pub(crate) fn copy_out<W: Write + ?Sized>(
deflated: &mut dyn Read,
writer: &mut W,
expected: u64,
limits: &DecryptLimits,
) -> Result<(), DecryptError> {
let mut inflate = InflateReader::new(deflated, expected, limits.max_output_bytes)
.map_err(fault_error(limits))?;
let mut buf = buffer()?;
loop {
let n = buf
.with_secret_mut(|b| inflate.read(b))
.map_err(|e| read_error_with(e, limits))?;
if n == 0 {
return Ok(());
}
buf.with_secret(|b| writer.write_all(&b[..n]))
.map_err(DecryptError::Io)?;
}
}
fn drain(r: &mut dyn Read) -> Result<(), DecryptError> {
let mut buf = buffer()?;
while buf.with_secret_mut(|b| r.read(b)).map_err(read_error)? > 0 {}
Ok(())
}
pub(crate) fn buffer() -> Result<ChunkBuffer, DecryptError> {
chunk_buffer(CHUNK).map_err(|_| DecryptError::HostCannotAllocate {
site: AllocationSite::StreamBuffer,
requested_bytes: CHUNK,
})
}
pub(crate) fn read_full<R: Read + ?Sized>(r: &mut R, buf: &mut [u8]) -> io::Result<usize> {
let mut n = 0;
while n < buf.len() {
match r.read(&mut buf[n..]) {
Ok(0) => break,
Ok(k) => n += k,
Err(e) if e.kind() == io::ErrorKind::Interrupted => {}
Err(e) => return Err(e),
}
}
Ok(n)
}
pub(crate) fn read_error(e: io::Error) -> DecryptError {
read_error_with(e, &DecryptLimits::default())
}
fn read_error_with(e: io::Error, limits: &DecryptLimits) -> DecryptError {
match Fault::take(e) {
Ok(fault) => fault_error(limits)(fault),
Err(e) => DecryptError::Zip(e.to_string()),
}
}
pub(crate) fn fault_error(limits: &DecryptLimits) -> impl Fn(Fault) -> DecryptError + '_ {
move |fault| match fault {
Fault::WrongPassword => DecryptError::WrongPassword,
Fault::Changed => DecryptError::Io(io::Error::new(
io::ErrorKind::InvalidData,
"the input changed between the verify and release passes",
)),
Fault::BadParameters(b) => DecryptError::BadParameters(b),
Fault::Internal(s) => DecryptError::Internal(s.to_string()),
Fault::Inflate(s) => DecryptError::Inflate(s),
Fault::OutputLimit => DecryptError::OutputLimit {
limit: limits.max_output_bytes,
},
Fault::Alloc(n) => DecryptError::HostCannotAllocate {
site: AllocationSite::StreamBuffer,
requested_bytes: n,
},
Fault::Deflate(s) => DecryptError::Internal(format!("deflate failed: {s}")),
}
}
#[cfg(test)]
#[path = "decrypt_stream_tests.rs"]
mod tests;