1use crate::writer::ByteWriter;
17
18mod matrix;
19
20pub use matrix::matrix;
21
22#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
24pub enum TestCodec {
25 #[default]
27 None,
28 Lzma,
30 Lz4,
32 Lz4Hc,
34 Raw(u8),
36}
37
38impl TestCodec {
39 #[must_use]
41 pub fn id(self) -> u8 {
42 match self {
43 Self::None => 0,
44 Self::Lzma => 1,
45 Self::Lz4 => 2,
46 Self::Lz4Hc => 3,
47 Self::Raw(n) => n,
48 }
49 }
50}
51
52#[derive(Clone, Debug, Default, PartialEq, Eq)]
55pub struct BlockOverride {
56 pub block: usize,
58 pub codec: Option<TestCodec>,
60 pub uncompressed: Option<u32>,
64 pub compressed: Option<u32>,
66}
67
68#[derive(Clone, Debug, Default, PartialEq, Eq)]
70pub struct EntrySpec {
71 pub name: Vec<u8>,
73 pub data: Vec<u8>,
75 pub flags: u32,
77}
78
79#[derive(Clone, Debug, PartialEq, Eq)]
81pub struct BundleSpec {
82 pub format: u32,
84 pub version_player: Vec<u8>,
86 pub version_engine: Vec<u8>,
88 pub info_codec: TestCodec,
90 pub data_codec: TestCodec,
92 pub block_size: usize,
94 pub info_at_end: bool,
96 pub entries: Vec<EntrySpec>,
98 pub extra_flags: u32,
101 pub block_overrides: Vec<BlockOverride>,
103 pub truncate_to: Option<usize>,
105 pub encrypted: bool,
112}
113
114impl Default for BundleSpec {
115 fn default() -> Self {
116 Self {
117 format: 7,
118 version_player: b"5.x.x".to_vec(),
119 version_engine: b"2022.3.0f1".to_vec(),
120 info_codec: TestCodec::Lz4,
121 data_codec: TestCodec::Lz4,
122 block_size: 128 << 10,
123 info_at_end: false,
124 entries: Vec::new(),
125 extra_flags: 0,
126 block_overrides: Vec::new(),
127 truncate_to: None,
128 encrypted: false,
129 }
130 }
131}
132
133#[must_use]
137pub fn compress(codec: TestCodec, data: &[u8]) -> Vec<u8> {
138 match codec {
139 TestCodec::None | TestCodec::Raw(_) => data.to_vec(),
140 TestCodec::Lz4 | TestCodec::Lz4Hc => lz4_flex::block::compress(data),
141 TestCodec::Lzma => lzma(data),
142 }
143}
144
145pub const LZMA_DICT: u32 = 1 << 19;
147
148thread_local! {
149 static LZMA_MEMO: std::cell::RefCell<std::collections::HashMap<Vec<u8>, Vec<u8>>> =
154 std::cell::RefCell::new(std::collections::HashMap::new());
155}
156
157fn lzma(data: &[u8]) -> Vec<u8> {
161 let mut out = ByteWriter::le();
163 out.u8(0x5D).u32(LZMA_DICT);
164 let mut out = out.into_inner();
165 if let Some(hit) = LZMA_MEMO.with(|m| m.borrow().get(data).cloned()) {
166 out.extend_from_slice(&hit);
167 return out;
168 }
169 let stream = lzma_encode(data);
170 LZMA_MEMO.with(|m| {
171 let mut m = m.borrow_mut();
172 if m.len() >= 4096 {
174 m.clear();
175 }
176 m.insert(data.to_vec(), stream.clone());
177 });
178 out.extend_from_slice(&stream);
179 out
180}
181
182fn lzma_encode(data: &[u8]) -> Vec<u8> {
184 use liblzma::stream::{Action, Filters, LzmaOptions, Status, Stream};
185 let mut opts = LzmaOptions::new_preset(1).unwrap_or_else(|_| LzmaOptions::new());
186 opts.dict_size(LZMA_DICT)
187 .literal_context_bits(3)
188 .literal_position_bits(0)
189 .position_bits(2);
190 let mut filters = Filters::new();
191 filters.lzma1(&opts);
192 let Ok(mut stream) = Stream::new_raw_encoder(&filters) else {
193 return Vec::new();
194 };
195 let mut buf = vec![0u8; data.len() + data.len() / 2 + 1024];
196 loop {
197 let (read, written) = (stream.total_in(), stream.total_out());
198 let input = data.get(as_usize(read)..).unwrap_or_default();
199 let window = buf.get_mut(as_usize(written)..).unwrap_or_default();
200 match stream.process(input, window, Action::Finish) {
201 Ok(Status::StreamEnd) | Err(_) => break,
202 Ok(_) if window_full(&stream, buf.len()) => buf.resize(buf.len() * 2, 0),
203 Ok(_) => {}
204 }
205 }
206 buf.truncate(as_usize(stream.total_out()));
207 buf
208}
209
210fn window_full(stream: &liblzma::stream::Stream, len: usize) -> bool {
211 as_usize(stream.total_out()) >= len
212}
213
214fn as_usize(n: u64) -> usize {
215 usize::try_from(n).unwrap_or(usize::MAX)
216}
217
218fn engine_triple(engine: &[u8]) -> Option<(u32, u32, u32)> {
220 let s = std::str::from_utf8(engine).ok()?;
221 let mut parts = s.splitn(3, '.');
222 let major = parts.next()?.parse().ok()?;
223 let minor = parts.next()?.parse().ok()?;
224 let rest = parts.next()?;
225 let digits: String = rest.chars().take_while(char::is_ascii_digit).collect();
226 Some((major, minor, digits.parse().ok()?))
227}
228
229fn new_flags(engine: &[u8]) -> bool {
232 let Some(v) = engine_triple(engine) else {
233 return false;
234 };
235 !(v < (2020, 0, 0)
236 || (v.0 == 2020 && v < (2020, 3, 34))
237 || (v.0 == 2021 && v < (2021, 3, 2))
238 || (v.0 == 2022 && v < (2022, 1, 1)))
239}
240
241fn aligned(format: u32, engine: &[u8]) -> bool {
243 format >= 7 || engine_triple(engine).is_some_and(|v| v.0 == 2019 && v >= (2019, 4, 15))
244}
245
246#[must_use]
248pub fn build(spec: &BundleSpec) -> Vec<u8> {
249 build_with_signature(spec, b"UnityFS")
250}
251
252#[must_use]
257pub fn build_with_signature(spec: &BundleSpec, signature: &[u8]) -> Vec<u8> {
258 build_with_encoder(spec, signature, compress)
259}
260
261#[must_use]
265pub fn build_with_encoder(
266 spec: &BundleSpec,
267 signature: &[u8],
268 encode: impl Fn(TestCodec, &[u8]) -> Vec<u8>,
269) -> Vec<u8> {
270 let mut data = Vec::new();
272 let mut directory = ByteWriter::be();
273 directory.i32(i32::try_from(spec.entries.len()).unwrap_or(i32::MAX));
274 for e in &spec.entries {
275 directory
276 .i64(i64::try_from(data.len()).unwrap_or(i64::MAX))
277 .i64(i64::try_from(e.data.len()).unwrap_or(i64::MAX))
278 .u32(e.flags)
279 .cstr(&e.name);
280 data.extend_from_slice(&e.data);
281 }
282
283 let size = spec.block_size.max(1);
285 let mut stored = Vec::new();
286 let mut rows = ByteWriter::be();
287 let chunks: Vec<&[u8]> = data.chunks(size).collect();
288 let count = chunks.len().max(
289 spec.block_overrides
290 .iter()
291 .map(|o| o.block + 1)
292 .max()
293 .unwrap_or(0),
294 );
295 rows.bytes(&[0; 16]);
296 rows.i32(i32::try_from(count).unwrap_or(i32::MAX));
297 for i in 0..count {
298 let chunk = chunks.get(i).copied().unwrap_or_default();
299 let over = spec.block_overrides.iter().find(|o| o.block == i);
300 let codec = over.and_then(|o| o.codec).unwrap_or(spec.data_codec);
301 let bytes = encode(codec, chunk);
302 let uncompressed = over
303 .and_then(|o| o.uncompressed)
304 .unwrap_or_else(|| u32::try_from(chunk.len()).unwrap_or(u32::MAX));
305 let compressed = over
306 .and_then(|o| o.compressed)
307 .unwrap_or_else(|| u32::try_from(bytes.len()).unwrap_or(u32::MAX));
308 rows.u32(uncompressed)
309 .u32(compressed)
310 .u16(u16::from(codec.id()));
311 stored.extend_from_slice(&bytes);
312 }
313 rows.bytes(directory.as_slice());
314 let info = rows.into_inner();
315 let info_stored = encode(spec.info_codec, &info);
316
317 let mut flags = u32::from(spec.info_codec.id()) | 0x40 | spec.extra_flags;
318 if spec.info_at_end {
319 flags |= 0x80;
320 }
321 if spec.encrypted {
322 flags |= if new_flags(&spec.version_engine) {
323 0x1000
324 } else {
325 0x200
326 };
327 }
328
329 let mut w = ByteWriter::be();
330 w.cstr(signature)
331 .u32(spec.format)
332 .cstr(&spec.version_player)
333 .cstr(&spec.version_engine);
334 let size_at = w.len();
335 w.i64(0)
336 .u32(u32::try_from(info_stored.len()).unwrap_or(u32::MAX))
337 .u32(u32::try_from(info.len()).unwrap_or(u32::MAX))
338 .u32(flags);
339 if signature != b"UnityFS" {
340 w.u8(0);
341 }
342 if spec.encrypted {
343 w.u32(0).bytes(&[0; 2 * (16 + 16 + 1)]);
344 }
345 if aligned(spec.format, &spec.version_engine) {
346 w.align(16);
347 }
348 let pad = flags & 0x200 != 0 && new_flags(&spec.version_engine);
349 if !spec.info_at_end {
350 w.bytes(&info_stored);
351 }
352 if pad {
353 w.align(16);
354 }
355 w.bytes(&stored);
356 if spec.info_at_end {
357 w.bytes(&info_stored);
358 }
359 let mut file = w.into_inner();
360 let mut total = ByteWriter::be();
362 total.i64(i64::try_from(file.len()).unwrap_or(i64::MAX));
363 if let Some(at) = file.get_mut(size_at..size_at + 8) {
364 at.copy_from_slice(total.as_slice());
365 }
366 if let Some(n) = spec.truncate_to {
367 file.truncate(n);
368 }
369 file
370}
371
372#[cfg(test)]
373mod tests;