Skip to main content

functora_core/
package.rs

1use crate::Error;
2use crate::crypto::{CipherType, Kdf, STREAM_CHUNK, STREAM_TAG, StreamParts, stream_spans};
3use crate::progress::{Job, yield_to_paint};
4use crate::worker::Reporter;
5use crate::zip::{CancelToken, ZIP_CHUNK, check_cancel, zip_entries};
6use serde::{Deserialize, Serialize};
7use std::io::{Read, Seek, Write};
8use std::path::PathBuf;
9use std::sync::Arc;
10use tap::prelude::*;
11use zip::CompressionMethod;
12
13pub const METADATA_ENTRY: &str = "metadata.json";
14pub const PAYLOAD_ENTRY: &str = "payload.cpt";
15
16#[must_use]
17pub fn aad(prefix: &[u8], cipher: CipherType, kdf: Kdf) -> Vec<u8> {
18    prefix
19        .iter()
20        .chain(&[cipher as u8, kdf as u8])
21        .copied()
22        .collect()
23}
24
25#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
26pub struct ArchiveMetadata {
27    pub cipher: Option<CipherType>,
28    pub kdf: Kdf,
29    pub nonce: Vec<u8>,
30    pub salt: Vec<u8>,
31}
32
33#[derive(Debug, Clone, PartialEq)]
34pub enum ArchiveSource {
35    Bytes(Vec<u8>),
36    Path(PathBuf),
37}
38
39impl ArchiveSource {
40    pub fn into_bytes(self) -> Result<Vec<u8>, Error> {
41        match self {
42            Self::Bytes(bytes) => Ok(bytes),
43            Self::Path(path) => Ok(std::fs::read(path)?),
44        }
45    }
46}
47
48#[derive(Debug, Clone, Copy)]
49pub struct PackageStages<S> {
50    pub zip: S,
51    pub encrypt: S,
52    pub decrypt: S,
53}
54
55impl<S> PackageStages<S> {
56    pub const fn new(zip: S, encrypt: S, decrypt: S) -> Self {
57        Self {
58            zip,
59            encrypt,
60            decrypt,
61        }
62    }
63}
64
65fn stored_opts() -> zip::write::FileOptions<'static, ()> {
66    zip::write::FileOptions::default().compression_method(CompressionMethod::Stored)
67}
68
69fn write_package_entries(
70    zip: &mut zip::ZipWriter<std::io::Cursor<&mut Vec<u8>>>,
71    meta: &ArchiveMetadata,
72) -> Result<(), Error> {
73    zip.start_file(METADATA_ENTRY, stored_opts())?;
74    zip.write_all(&serde_json::to_vec(meta)?)?;
75    zip.start_file(PAYLOAD_ENTRY, stored_opts())?;
76    Ok(())
77}
78
79pub async fn package_report<S>(
80    entries: Vec<(String, Arc<[u8]>)>,
81    password: &str,
82    cipher: Option<CipherType>,
83    prefix: &'static [u8],
84    stages: PackageStages<S>,
85    report: &mut Reporter<S>,
86    cancel: Option<&CancelToken>,
87) -> Result<Vec<u8>, Error>
88where
89    S: Copy + Send + Sync + 'static,
90{
91    let total = entries.iter().map(|(_, d)| d.len() as u64).sum::<u64>();
92    let mut inner = Vec::new();
93    {
94        let mut zip = zip::ZipWriter::new(std::io::Cursor::new(&mut inner));
95        let mut done = 0u64;
96        zip_entries(
97            &mut zip, &entries, stages.zip, report, &mut done, total, cancel,
98        )
99        .await?;
100        let _ = zip.finish()?;
101    }
102    match cipher {
103        Some(cipher_sel) => {
104            package_with_encryption(&inner, password, cipher_sel, prefix, stages, report, cancel)
105                .await
106        }
107        None => package_plain(&inner, stages, report, cancel).await,
108    }
109}
110
111async fn package_with_encryption<S>(
112    inner: &[u8],
113    password: &str,
114    cipher: CipherType,
115    prefix: &'static [u8],
116    stages: PackageStages<S>,
117    report: &mut Reporter<S>,
118    cancel: Option<&CancelToken>,
119) -> Result<Vec<u8>, Error>
120where
121    S: Copy + Send + Sync + 'static,
122{
123    let parts = StreamParts::derive(password, cipher, &aad(prefix, cipher, Kdf::Argon2id))?;
124    let meta = ArchiveMetadata {
125        cipher: Some(cipher),
126        kdf: Kdf::Argon2id,
127        nonce: parts.nonce().to_vec(),
128        salt: parts.salt().to_vec(),
129    };
130    let mut pkg = Vec::new();
131    {
132        let mut zip = zip::ZipWriter::new(std::io::Cursor::new(&mut pkg));
133        write_package_entries(&mut zip, &meta)?;
134        for span in stream_spans(inner.len(), STREAM_CHUNK) {
135            check_cancel(cancel)?;
136            let (position, kind, offset, end) = span?;
137            zip.write_all(&parts.encrypt_chunk(position, kind, &inner[offset..end])?)?;
138            report(Job {
139                stage: stages.encrypt,
140                done: end as u64,
141                total: inner.len() as u64,
142                name: None,
143            });
144            yield_to_paint().await;
145        }
146        let _ = zip.finish()?;
147    }
148    Ok(pkg)
149}
150
151async fn package_plain<S>(
152    inner: &[u8],
153    stages: PackageStages<S>,
154    report: &mut Reporter<S>,
155    cancel: Option<&CancelToken>,
156) -> Result<Vec<u8>, Error>
157where
158    S: Copy + Send + Sync + 'static,
159{
160    let meta = ArchiveMetadata {
161        cipher: None,
162        kdf: Kdf::Argon2id,
163        nonce: Vec::new(),
164        salt: Vec::new(),
165    };
166    let mut pkg = Vec::new();
167    {
168        let mut zip = zip::ZipWriter::new(std::io::Cursor::new(&mut pkg));
169        write_package_entries(&mut zip, &meta)?;
170        let mut done = 0u64;
171        for chunk in inner.chunks(ZIP_CHUNK) {
172            check_cancel(cancel)?;
173            zip.write_all(chunk)?;
174            done += chunk.len() as u64;
175            report(Job {
176                stage: stages.zip,
177                done,
178                total: inner.len() as u64,
179                name: None,
180            });
181            yield_to_paint().await;
182        }
183        let _ = zip.finish()?;
184    }
185    Ok(pkg)
186}
187
188fn read_entry<R: Read + Seek>(
189    archive: &mut zip::ZipArchive<R>,
190    name: &str,
191) -> Result<Vec<u8>, Error> {
192    let mut file = archive.by_name(name)?;
193    let capacity = usize::try_from(file.size()).map_err(|e| Error::Convert {
194        context: "entry size too large",
195        source: e,
196    })?;
197    let mut data = Vec::with_capacity(capacity);
198    let _ = file.read_to_end(&mut data)?;
199    Ok(data)
200}
201
202fn metadata_from_reader<R: Read + Seek>(reader: R) -> Result<ArchiveMetadata, Error> {
203    let mut archive = zip::ZipArchive::new(reader)?;
204    let json = read_entry(&mut archive, METADATA_ENTRY)?;
205    serde_json::from_slice::<ArchiveMetadata>(&json)?.pipe(Ok)
206}
207
208pub fn read_metadata(source: &ArchiveSource) -> Result<ArchiveMetadata, Error> {
209    match source {
210        ArchiveSource::Bytes(bytes) => metadata_from_reader(std::io::Cursor::new(bytes.as_slice())),
211        ArchiveSource::Path(path) => metadata_from_reader(std::fs::File::open(path)?),
212    }
213}
214
215fn package_from_reader<R: Read + Seek>(reader: R) -> Result<(ArchiveMetadata, Vec<u8>), Error> {
216    let mut archive = zip::ZipArchive::new(reader)?;
217    let meta: ArchiveMetadata = serde_json::from_slice(&read_entry(&mut archive, METADATA_ENTRY)?)?;
218    let payload = read_entry(&mut archive, PAYLOAD_ENTRY)?;
219    (meta, payload).pipe(Ok)
220}
221
222fn read_package(source: &ArchiveSource) -> Result<(ArchiveMetadata, Vec<u8>), Error> {
223    match source {
224        ArchiveSource::Bytes(bytes) => package_from_reader(std::io::Cursor::new(bytes.as_slice())),
225        ArchiveSource::Path(path) => package_from_reader(std::fs::File::open(path)?),
226    }
227}
228
229struct UnsealParams<'a> {
230    meta: &'a ArchiveMetadata,
231    password: &'a str,
232    cipher: CipherType,
233    prefix: &'static [u8],
234}
235
236async fn unseal_report<S>(
237    params: UnsealParams<'_>,
238    payload: Vec<u8>,
239    stages: PackageStages<S>,
240    report: &mut Reporter<S>,
241    cancel: Option<&CancelToken>,
242) -> Result<Vec<u8>, Error>
243where
244    S: Copy + Send + Sync + 'static,
245{
246    let parts = StreamParts::recover(
247        params.password,
248        params.cipher,
249        &params.meta.salt,
250        &params.meta.nonce,
251        &aad(params.prefix, params.cipher, params.meta.kdf),
252    )?;
253    let total = payload.len();
254    let mut out = Vec::with_capacity(payload.len());
255    for span in stream_spans(total, STREAM_CHUNK + STREAM_TAG) {
256        check_cancel(cancel)?;
257        let (position, kind, offset, end) = span?;
258        out.extend_from_slice(&parts.decrypt_chunk(position, kind, &payload[offset..end])?);
259        report(Job {
260            stage: stages.decrypt,
261            done: end as u64,
262            total: total as u64,
263            name: None,
264        });
265        yield_to_paint().await;
266    }
267    Ok(out)
268}
269
270pub async fn extract_package_report<S>(
271    source: ArchiveSource,
272    password: &str,
273    prefix: &'static [u8],
274    stages: PackageStages<S>,
275    report: &mut Reporter<S>,
276    cancel: Option<&CancelToken>,
277) -> Result<Vec<u8>, Error>
278where
279    S: Copy + Send + Sync + 'static,
280{
281    let (meta, payload) = read_package(&source)?;
282    match meta.cipher {
283        Some(cipher) => {
284            unseal_report(
285                UnsealParams {
286                    meta: &meta,
287                    password,
288                    cipher,
289                    prefix,
290                },
291                payload,
292                stages,
293                report,
294                cancel,
295            )
296            .await
297        }
298        None => Ok(payload),
299    }
300}