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 ¶ms.meta.salt,
250 ¶ms.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}